GDB (xrefs)
Loading...
Searching...
No Matches
symfile.c
Go to the documentation of this file.
1/* Generic symbol file reading for the GNU debugger, GDB.
2
3 Copyright (C) 1990-2023 Free Software Foundation, Inc.
4
5 Contributed by Cygnus Support, using pieces from other GDB modules.
6
7 This file is part of GDB.
8
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.
13
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.
18
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/>. */
21
22#include "defs.h"
23#include "arch-utils.h"
24#include "bfdlink.h"
25#include "symtab.h"
26#include "gdbtypes.h"
27#include "gdbcore.h"
28#include "frame.h"
29#include "target.h"
30#include "value.h"
31#include "symfile.h"
32#include "objfiles.h"
33#include "source.h"
34#include "gdbcmd.h"
35#include "breakpoint.h"
36#include "language.h"
37#include "complaints.h"
38#include "demangle.h"
39#include "inferior.h"
40#include "regcache.h"
41#include "filenames.h"
42#include "gdbsupport/gdb_obstack.h"
43#include "completer.h"
44#include "bcache.h"
45#include "hashtab.h"
46#include "readline/tilde.h"
47#include "block.h"
48#include "observable.h"
49#include "exec.h"
50#include "parser-defs.h"
51#include "varobj.h"
52#include "elf-bfd.h"
53#include "solib.h"
54#include "remote.h"
55#include "stack.h"
56#include "gdb_bfd.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"
64
65#include <sys/types.h>
66#include <fcntl.h>
67#include <sys/stat.h>
68#include <ctype.h>
69#include <chrono>
70#include <algorithm>
71
72int (*deprecated_ui_load_progress_hook) (const char *section,
73 unsigned long num);
74void (*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);
79void (*deprecated_pre_add_symbol_hook) (const char *);
81
83 = FORWARD_SCOPE_EXIT (clear_symtab_users);
84
85/* Global variables owned by this file. */
86
87/* See symfile.h. */
90
91/* See symfile.h. */
94
95/* Functions this file defines. */
96
97static void symbol_file_add_main_1 (const char *args, symfile_add_flags add_flags,
98 objfile_flags flags, CORE_ADDR reloff);
99
100static const struct sym_fns *find_sym_fns (bfd *);
101
102static void overlay_invalidate_all (void);
103
104static void simple_free_overlay_table (void);
105
106static void read_target_long_array (CORE_ADDR, unsigned int *, int, int,
107 enum bfd_endian);
108
109static int simple_read_overlay_table (void);
110
111static int simple_overlay_update_1 (struct obj_section *);
112
113static void symfile_find_segment_sections (struct objfile *objfile);
114
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
117 prepared to read. */
121 registered_sym_fns (bfd_flavour sym_flavour_, const struct sym_fns *sym_fns_)
122 : sym_flavour (sym_flavour_), sym_fns (sym_fns_)
123 {}
124
125 /* BFD flavour that we handle. */
126 enum bfd_flavour sym_flavour;
127
128 /* The "vtable" of symbol functions. */
129 const struct sym_fns *sym_fns;
130};
132static std::vector<registered_sym_fns> symtab_fns;
133
134/* Values for "set print symbol-loading". */
136const char print_symbol_loading_off[] = "off";
137const char print_symbol_loading_brief[] = "brief";
147
148/* See symfile.h. */
150bool auto_solib_add = true;
151
152
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. */
160
161int
162print_symbol_loading_p (int from_tty, int exec, int full)
163{
164 if (!from_tty && !info_verbose)
165 return 0;
166
167 if (exec)
168 {
169 /* We don't check FULL for executables, there are few such
170 messages, therefore brief == full. */
172 }
173 if (full)
176}
177
178/* True if we are reading a symbol table. */
181
182/* Increment currently_reading_symtab and return a cleanup that can be
183 used to decrement it. */
184
185scoped_restore_tmpl<int>
187{
188 gdb_assert (currently_reading_symtab >= 0);
189 return make_scoped_restore (&currently_reading_symtab,
191}
192
193/* Remember the lowest-addressed loadable section we've seen.
194
195 In case of equal vmas, the section with the largest size becomes the
196 lowest-addressed loadable section.
197
198 If the vmas and sizes are equal, the last section is considered the
199 lowest-addressed loadable section. */
200
201static void
202find_lowest_section (asection *sect, asection **lowest)
203{
204 if (0 == (bfd_section_flags (sect) & (SEC_ALLOC | SEC_LOAD)))
205 return;
206 if (!*lowest)
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)))
212 *lowest = sect;
213}
214
215/* Build (allocate and populate) a section_addr_info struct from
216 an existing section table. */
217
220{
222
223 for (const target_section &stp : table)
224 {
225 struct bfd_section *asect = stp.the_bfd_section;
226 bfd *abfd = asect->owner;
227
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));
233 }
234
235 return sap;
236}
237
238/* Create a section_addr_info from section offsets in ABFD. */
239
242{
243 struct bfd_section *sec;
244
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));
251
252 return sap;
253}
254
255/* Create a section_addr_info from section offsets in OBJFILE. */
256
259{
260 int i;
261
262 /* Before reread_symbols gets rewritten it is not safe to call:
263 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
264 */
267 for (i = 0; i < sap.size (); i++)
268 {
269 int sectindex = sap[i].sectindex;
270
271 sap[i].addr += objfile->section_offsets[sectindex];
272 }
273 return sap;
274}
275
276/* Initialize OBJFILE's sect_index_* members. */
277
278static void
280{
281 asection *sect;
282 int i;
283
284 sect = bfd_get_section_by_name (objfile->obfd.get (), ".text");
285 if (sect)
286 objfile->sect_index_text = sect->index;
287
288 sect = bfd_get_section_by_name (objfile->obfd.get (), ".data");
289 if (sect)
290 objfile->sect_index_data = sect->index;
291
292 sect = bfd_get_section_by_name (objfile->obfd.get (), ".bss");
293 if (sect)
294 objfile->sect_index_bss = sect->index;
295
296 sect = bfd_get_section_by_name (objfile->obfd.get (), ".rodata");
297 if (sect)
298 objfile->sect_index_rodata = sect->index;
299
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. */
305
307
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. */
316
317 for (i = 0; i < objfile->section_offsets.size (); i++)
318 {
319 if (objfile->section_offsets[i] != 0)
320 {
321 break;
322 }
323 }
324 if (i == objfile->section_offsets.size ())
325 {
326 if (objfile->sect_index_text == -1)
328 if (objfile->sect_index_data == -1)
330 if (objfile->sect_index_bss == -1)
332 if (objfile->sect_index_rodata == -1)
334 }
335}
336
337/* Find a unique offset to use for loadable section SECT if
338 the user did not provide an offset. */
339
340static void
341place_section (bfd *abfd, asection *sect, section_offsets &offsets,
342 CORE_ADDR &lowest)
343{
344 CORE_ADDR start_addr;
345 int done;
346 ULONGEST align = ((ULONGEST) 1) << bfd_section_alignment (sect);
347
348 /* We are only interested in allocated sections. */
349 if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
350 return;
351
352 /* If the user specified an offset, honor it. */
353 if (offsets[gdb_bfd_section_index (abfd, sect)] != 0)
354 return;
355
356 /* Otherwise, let's try to find a place for the section. */
357 start_addr = (lowest + align - 1) & -align;
358
359 do {
360 asection *cur_sec;
361
362 done = 1;
363
364 for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
365 {
366 int indx = cur_sec->index;
367
368 /* We don't need to compare against ourself. */
369 if (cur_sec == sect)
370 continue;
371
372 /* We can only conflict with allocated sections. */
373 if ((bfd_section_flags (cur_sec) & SEC_ALLOC) == 0)
374 continue;
375
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)
380 continue;
381
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))
385 {
386 start_addr = offsets[indx] + bfd_section_size (cur_sec);
387 start_addr = (start_addr + align - 1) & -align;
388 done = 0;
389 break;
390 }
391
392 /* Otherwise, we appear to be OK. So far. */
393 }
394 }
395 while (!done);
396
397 offsets[gdb_bfd_section_index (abfd, sect)] = start_addr;
398 lowest = start_addr + bfd_section_size (sect);
399}
400
401/* Store section_addr_info as prepared (made relative and with SECTINDEX
402 filled-in) by addr_info_make_relative into SECTION_OFFSETS. */
403
404void
406 const section_addr_info &addrs)
407{
408 int i;
409
410 section_offsets.assign (section_offsets.size (), 0);
411
412 /* Now calculate offsets for section that were specified by the caller. */
413 for (i = 0; i < addrs.size (); i++)
414 {
415 const struct other_sections *osp;
416
417 osp = &addrs[i];
418 if (osp->sectindex == -1)
419 continue;
420
421 /* Record all sections in offsets. */
422 /* The section_offsets in the objfile are here filled in using
423 the BFD index. */
424 section_offsets[osp->sectindex] = osp->addr;
425 }
426}
427
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. */
433
434static const char *
435addr_section_name (const char *s)
436{
437 if (strcmp (s, ".dynbss") == 0)
438 return ".bss";
439 if (strcmp (s, ".sdynbss") == 0)
440 return ".sbss";
441
442 return s;
443}
444
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. */
448
449static bool
450addrs_section_compar (const struct other_sections *a,
451 const struct other_sections *b)
452{
453 int retval;
454
455 retval = strcmp (addr_section_name (a->name.c_str ()),
456 addr_section_name (b->name.c_str ()));
457 if (retval != 0)
458 return retval < 0;
459
460 return a->sectindex < b->sectindex;
461}
462
463/* Provide sorted array of pointers to sections of ADDRS. */
464
465static std::vector<const struct other_sections *>
467{
468 int i;
469
470 std::vector<const struct other_sections *> array (addrs.size ());
471 for (i = 0; i < addrs.size (); i++)
472 array[i] = &addrs[i];
473
474 std::sort (array.begin (), array.end (), addrs_section_compar);
475
476 return array;
477}
478
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. */
482
483void
485{
486 asection *lower_sect;
487 CORE_ADDR lower_offset;
488 int i;
489
490 /* Find lowest loadable section to be used as starting point for
491 contiguous sections. */
492 lower_sect = NULL;
493 for (asection *iter : gdb_bfd_sections (abfd))
494 find_lowest_section (iter, &lower_sect);
495 if (lower_sect == NULL)
496 {
497 warning (_("no loadable sections found in added symbol-file %s"),
498 bfd_get_filename (abfd));
499 lower_offset = 0;
500 }
501 else
502 lower_offset = bfd_section_vma (lower_sect);
503
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
509 order.
510
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. */
513
514 std::vector<const struct other_sections *> addrs_sorted
515 = addrs_section_sort (*addrs);
516
518 std::vector<const struct other_sections *> abfd_addrs_sorted
519 = addrs_section_sort (abfd_addrs);
520
521 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
522 ABFD_ADDRS_SORTED. */
523
524 std::vector<const struct other_sections *>
525 addrs_to_abfd_addrs (addrs->size (), nullptr);
526
527 std::vector<const struct other_sections *>::iterator abfd_sorted_iter
528 = abfd_addrs_sorted.begin ();
529 for (const other_sections *sect : addrs_sorted)
530 {
531 const char *sect_name = addr_section_name (sect->name.c_str ());
532
533 while (abfd_sorted_iter != abfd_addrs_sorted.end ()
534 && strcmp (addr_section_name ((*abfd_sorted_iter)->name.c_str ()),
535 sect_name) < 0)
536 abfd_sorted_iter++;
537
538 if (abfd_sorted_iter != abfd_addrs_sorted.end ()
539 && strcmp (addr_section_name ((*abfd_sorted_iter)->name.c_str ()),
540 sect_name) == 0)
541 {
542 int index_in_addrs;
543
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;
548
549 /* Never use the same ABFD entry twice. */
550 abfd_sorted_iter++;
551 }
552 }
553
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!!!
557
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 */
563
564 for (i = 0; i < addrs->size (); i++)
565 {
566 const struct other_sections *sect = addrs_to_abfd_addrs[i];
567
568 if (sect)
569 {
570 /* This is the index used by BFD. */
571 (*addrs)[i].sectindex = sect->sectindex;
572
573 if ((*addrs)[i].addr != 0)
574 {
575 (*addrs)[i].addr -= sect->addr;
576 lower_offset = (*addrs)[i].addr;
577 }
578 else
579 (*addrs)[i].addr = lower_offset;
580 }
581 else
582 {
583 /* addr_section_name transformation is not used for SECT_NAME. */
584 const std::string &sect_name = (*addrs)[i].name;
585
586 /* This section does not exist in ABFD, which is normally
587 unexpected and we want to issue a warning.
588
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.
597
598 For the sections `.bss' and `.sbss' see addr_section_name. */
599
600 if (!(sect_name == ".gnu.liblist"
601 || sect_name == ".gnu.conflict"
602 || (sect_name == ".bss"
603 && i > 0
604 && (*addrs)[i - 1].name == ".dynbss"
605 && addrs_to_abfd_addrs[i - 1] != NULL)
606 || (sect_name == ".sbss"
607 && i > 0
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));
612
613 (*addrs)[i].addr = 0;
614 (*addrs)[i].sectindex = -1;
615 }
616 }
617}
618
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. */
624
625void
627 const section_addr_info &addrs)
628{
631
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
636 small. */
637 if ((bfd_get_file_flags (objfile->obfd.get ()) & (EXEC_P | DYNAMIC)) == 0)
638 {
639 bfd *abfd = objfile->obfd.get ();
640 asection *cur_sec;
641
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)
646 break;
647
648 if (cur_sec == NULL)
649 {
651
652 /* Pick non-overlapping offsets for sections the user did not
653 place explicitly. */
654 CORE_ADDR lowest = 0;
655 for (asection *sect : gdb_bfd_sections (objfile->obfd.get ()))
657 lowest);
658
659 /* Correctly filling in the section offsets is not quite
660 enough. Relocatable files have two properties that
661 (most) shared objects do not:
662
663 - Their debug information will contain relocations. Some
664 shared libraries do also, but many do not, so this can not
665 be assumed.
666
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
670 at address zero.
671
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
678 correct sections.
679
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
683 be eliminated. */
684
685 for (cur_sec = abfd->sections; cur_sec != NULL;
686 cur_sec = cur_sec->next)
687 {
688 if ((bfd_section_flags (cur_sec) & SEC_ALLOC) == 0)
689 continue;
690
691 bfd_set_section_vma (cur_sec, offsets[cur_sec->index]);
692 exec_set_section_address (bfd_get_filename (abfd),
693 cur_sec->index,
694 offsets[cur_sec->index]);
695 offsets[cur_sec->index] = 0;
696 }
697 }
698 }
699
700 /* Remember the bfd indexes for the .text, .data, .bss and
701 .rodata sections. */
703}
704
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. */
710
712default_symfile_segments (bfd *abfd)
713{
714 int num_sections, i;
715 asection *sect;
716 CORE_ADDR low, high;
717
718 /* Relocatable files contain enough information to position each
719 loadable section independently; they should not be relocated
720 in segments. */
721 if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) == 0)
722 return NULL;
723
724 /* Make sure there is at least one loadable section in the file. */
725 for (sect = abfd->sections; sect != NULL; sect = sect->next)
726 {
727 if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
728 continue;
729
730 break;
731 }
732 if (sect == NULL)
733 return NULL;
734
735 low = bfd_section_vma (sect);
736 high = low + bfd_section_size (sect);
737
739
740 num_sections = bfd_count_sections (abfd);
741
742 /* All elements are initialized to 0 (map to no segment). */
743 data->segment_info.resize (num_sections);
744
745 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
746 {
747 CORE_ADDR vma;
748
749 if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
750 continue;
751
752 vma = bfd_section_vma (sect);
753 if (vma < low)
754 low = vma;
755 if (vma + bfd_section_size (sect) > high)
756 high = vma + bfd_section_size (sect);
757
758 data->segment_info[i] = 1;
759 }
760
761 data->segments.emplace_back (low, high - low);
762
763 return data;
764}
765
766/* This is a convenience function to call sym_read for OBJFILE and
767 possibly force the partial symbols to be read. */
768
769static void
770read_symbols (struct objfile *objfile, symfile_add_flags add_flags)
771{
772 (*objfile->sf->sym_read) (objfile, add_flags);
774
775 /* find_separate_debug_file_in_section should be called only if there is
776 single binary with no existing separate debug info file. */
780 {
782
783 if (abfd != NULL)
784 {
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);
791 }
792 }
793 if ((add_flags & SYMFILE_NO_READ) == 0)
795}
796
797/* Initialize entry point information for this objfile. */
798
799static void
801{
802 struct entry_info *ei = &objfile->per_bfd->ei;
803
804 if (ei->initialized)
805 return;
806 ei->initialized = 1;
807
808 /* Save startup file's range of PC addresses to help blockframe.c
809 decide where the bottom of the stack is. */
810
811 if (bfd_get_file_flags (objfile->obfd.get ()) & EXEC_P)
812 {
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;
817 }
818 else if (bfd_get_file_flags (objfile->obfd.get ()) & DYNAMIC
819 && bfd_get_start_address (objfile->obfd.get ()) != 0)
820 {
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;
826 }
827 else
828 {
829 /* Examination of non-executable.o files. Short-circuit this stuff. */
830 ei->entry_point_p = 0;
831 }
832
833 if (ei->entry_point_p)
834 {
835 CORE_ADDR entry_point = ei->entry_point;
836 int found;
837
838 /* Make certain that the address points at real code, and not a
839 function descriptor. */
841 (objfile->arch (), entry_point, current_inferior ()->top_target ());
842
843 /* Remove any ISA markers, so that this matches entries in the
844 symbol table. */
845 ei->entry_point
847
848 found = 0;
849 for (obj_section *osect : objfile->sections ())
850 {
851 struct bfd_section *sect = osect->the_bfd_section;
852
853 if (entry_point >= bfd_section_vma (sect)
854 && entry_point < (bfd_section_vma (sect)
855 + bfd_section_size (sect)))
856 {
858 = gdb_bfd_section_index (objfile->obfd.get (), sect);
859 found = 1;
860 break;
861 }
862 }
863
864 if (!found)
866 }
867}
868
869/* Process a symbol file, as either the main file or as a dynamically
870 loaded file.
871
872 This function does not set the OBJFILE's entry-point info.
873
874 OBJFILE is where the symbols are to be read from.
875
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.
888
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. */
892
893static void
895 section_addr_info *addrs,
896 symfile_add_flags add_flags)
897{
898 section_addr_info local_addr;
899 const int mainline = add_flags & SYMFILE_MAINLINE;
900
902 objfile->qf.clear ();
903
904 if (objfile->sf == NULL)
905 {
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 ());
909
910 objfile->section_offsets.assign (num_sections, 0);
911 return;
912 }
913
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;
917
918 objfile_up objfile_holder (objfile);
919
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. */
923 if (! addrs)
924 addrs = &local_addr;
925
926 if (mainline)
927 {
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);
931
932 /* Since no error yet, throw away the old symbol table. */
933
935 {
937 gdb_assert (current_program_space->symfile_object_file == NULL);
938 }
939
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
943 (PR 2207). */
944
946 }
947
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.
951
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 ());
956
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. */
960
961 (*objfile->sf->sym_init) (objfile);
963
964 (*objfile->sf->sym_offsets) (objfile, *addrs);
965
966 read_symbols (objfile, add_flags);
967
968 /* Discard cleanups as symbol reading was successful. */
969
970 objfile_holder.release ();
971 if (defer_clear_users)
972 defer_clear_users->release ();
973}
974
975/* Same as syms_from_objfile_1, but also initializes the objfile
976 entry-point info. */
977
978static void
980 section_addr_info *addrs,
981 symfile_add_flags add_flags)
982{
983 syms_from_objfile_1 (objfile, addrs, add_flags);
985}
986
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. */
990
991static void
992finish_new_objfile (struct objfile *objfile, symfile_add_flags add_flags)
993{
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)
998 {
999 /* OK, make it the "real" symbol file. */
1001
1002 clear_symtab_users (add_flags);
1003 }
1004 else if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
1005 {
1007 }
1008
1009 /* We're done reading the symbol file; finish off complaints. */
1011}
1012
1013/* Process a symbol file, as either the main file or as a dynamically
1014 loaded file.
1015
1016 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1017 A new reference is acquired by this function.
1018
1019 For NAME description see the objfile constructor.
1020
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.
1023
1024 ADDRS is as described for syms_from_objfile_1, above.
1025 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1026
1027 PARENT is the original objfile if ABFD is a separate debug info file.
1028 Otherwise PARENT is NULL.
1029
1030 Upon success, returns a pointer to the objfile that was added.
1031 Upon failure, jumps back to command level (never returns). */
1032
1033static struct objfile *
1034symbol_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)
1038{
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)
1045 || (add_flags & SYMFILE_NO_READ) == 0));
1046
1048 {
1050 add_flags &= ~SYMFILE_NO_READ;
1051 }
1052 else if (readnever_symbol_files
1053 || (parent != NULL && (parent->flags & OBJF_READNEVER)))
1054 {
1056 add_flags |= SYMFILE_NO_READ;
1057 }
1058 if ((add_flags & SYMFILE_NOT_FILENAME) != 0)
1060
1061 /* Give user a chance to burp if ALWAYS_CONFIRM or we'd be
1062 interactively wiping out any existing symbols. */
1063
1064 if (from_tty
1065 && (always_confirm
1067 && mainline))
1068 && !query (_("Load new symbol table from \"%s\"? "), name))
1069 error (_("Not confirmed."));
1070
1071 if (mainline)
1073 objfile = objfile::make (abfd, name, flags, parent);
1074
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. */
1078 if (should_print)
1079 {
1082 else
1083 gdb_printf (_("Reading symbols from %ps...\n"),
1085 }
1086 syms_from_objfile (objfile, addrs, add_flags);
1087
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. */
1092
1093 if ((flags & OBJF_READNOW))
1094 {
1095 if (should_print)
1096 gdb_printf (_("Expanding full symbols from %ps...\n"),
1098
1100 }
1101
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"),
1110
1111 if (should_print)
1112 {
1115 }
1116
1117 /* We print some messages regardless of whether 'from_tty ||
1118 info_verbose' is true, so make sure they go out at the right
1119 time. */
1121
1122 if (objfile->sf != nullptr)
1123 finish_new_objfile (objfile, add_flags);
1124
1126
1127 bfd_cache_close_all ();
1128 return objfile;
1129}
1130
1131/* Add BFD as a separate debug file for OBJFILE. For NAME description
1132 see the objfile constructor. */
1133
1134void
1135symbol_file_add_separate (const gdb_bfd_ref_ptr &bfd, const char *name,
1136 symfile_add_flags symfile_flags,
1137 struct objfile *objfile)
1138{
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. */
1143
1145 (bfd, name, symfile_flags, &sap,
1148 objfile);
1149}
1150
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. */
1154
1155struct objfile *
1156symbol_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)
1160{
1161 return symbol_file_add_with_addrs (abfd, name, add_flags, addrs, flags,
1162 parent);
1163}
1164
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. */
1167
1168struct objfile *
1169symbol_file_add (const char *name, symfile_add_flags add_flags,
1170 section_addr_info *addrs, objfile_flags flags)
1171{
1173
1174 return symbol_file_add_from_bfd (bfd, name, add_flags, addrs,
1175 flags, NULL);
1176}
1177
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
1184 command itself. */
1185
1186void
1187symbol_file_add_main (const char *args, symfile_add_flags add_flags)
1188{
1189 symbol_file_add_main_1 (args, add_flags, 0, 0);
1190}
1191
1192static void
1193symbol_file_add_main_1 (const char *args, symfile_add_flags add_flags,
1194 objfile_flags flags, CORE_ADDR reloff)
1195{
1197
1198 struct objfile *objfile = symbol_file_add (args, add_flags, NULL, flags);
1199 if (reloff != 0)
1200 objfile_rebase (objfile, reloff);
1201
1202 /* Getting new symbols may change our opinion about
1203 what is frameless. */
1205
1206 if ((add_flags & SYMFILE_NO_READ) == 0)
1208}
1209
1210void
1211symbol_file_clear (int from_tty)
1212{
1214 && from_tty
1216 ? !query (_("Discard symbol table from `%s'? "),
1218 : !query (_("Discard symbol table? "))))
1219 error (_("Not confirmed."));
1220
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);
1224
1226
1228
1229 gdb_assert (current_program_space->symfile_object_file == NULL);
1230 if (from_tty)
1231 gdb_printf (_("No symbol file now.\n"));
1232}
1233
1234/* See symfile.h. */
1236bool separate_debug_file_debug = false;
1237
1238static int
1239separate_debug_file_exists (const std::string &name, unsigned long crc,
1240 struct objfile *parent_objfile,
1241 deferred_warnings *warnings)
1242{
1243 unsigned long file_crc;
1244 int file_crc_p;
1245 struct stat parent_stat, abfd_stat;
1246 int verified_as_different;
1247
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. */
1253
1254 if (filename_cmp (name.c_str (), objfile_name (parent_objfile)) == 0)
1255 return 0;
1256
1258 {
1259 gdb_printf (gdb_stdlog, _(" Trying %s..."), name.c_str ());
1261 }
1262
1263 gdb_bfd_ref_ptr abfd (gdb_bfd_open (name.c_str (), gnutarget));
1264
1265 if (abfd == NULL)
1266 {
1268 gdb_printf (gdb_stdlog, _(" no, unable to open.\n"));
1269
1270 return 0;
1271 }
1272
1273 /* Verify symlinks were not the cause of filename_cmp name difference above.
1274
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. */
1283
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)
1287 {
1288 if (abfd_stat.st_dev == parent_stat.st_dev
1289 && abfd_stat.st_ino == parent_stat.st_ino)
1290 {
1293 _(" no, same file as the objfile.\n"));
1294
1295 return 0;
1296 }
1297 verified_as_different = 1;
1298 }
1299 else
1300 verified_as_different = 0;
1301
1302 file_crc_p = gdb_bfd_crc (abfd.get (), &file_crc);
1303
1304 if (!file_crc_p)
1305 {
1307 gdb_printf (gdb_stdlog, _(" no, error computing CRC.\n"));
1308
1309 return 0;
1310 }
1311
1312 if (crc != file_crc)
1313 {
1314 unsigned long parent_crc;
1315
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. */
1319
1320 if (!verified_as_different)
1321 {
1322 if (!gdb_bfd_crc (parent_objfile->obfd.get (), &parent_crc))
1323 {
1326 _(" no, error computing CRC.\n"));
1327
1328 return 0;
1329 }
1330 }
1331
1332 if (verified_as_different || parent_crc != file_crc)
1333 {
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)."),
1341 name.c_str ()),
1343 objfile_name (parent_objfile)));
1344 }
1345
1346 return 0;
1347 }
1348
1350 gdb_printf (gdb_stdlog, _(" yes!\n"));
1351
1352 return 1;
1353}
1355std::string debug_file_directory;
1356static void
1357show_debug_file_directory (struct ui_file *file, int from_tty,
1358 struct cmd_list_element *c, const char *value)
1359{
1360 gdb_printf (file,
1361 _("The directory where separate debug "
1362 "symbols are searched for is \"%s\".\n"),
1363 value);
1364}
1365
1366#if ! defined (DEBUG_SUBDIRECTORY)
1367#define DEBUG_SUBDIRECTORY ".debug"
1368#endif
1369
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
1376 string.
1377
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
1382 will be printed. */
1383
1384static std::string
1385find_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)
1390{
1393 _("\nLooking for separate debug info (debug link) for "
1394 "%s\n"), objfile_name (objfile));
1395
1396 /* First try in the same directory as the original file. */
1397 std::string debugfile = dir;
1398 debugfile += debuglink;
1399
1400 if (separate_debug_file_exists (debugfile, crc32, objfile, warnings))
1401 return debugfile;
1402
1403 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1404 debugfile = dir;
1405 debugfile += DEBUG_SUBDIRECTORY;
1406 debugfile += "/";
1407 debugfile += debuglink;
1408
1409 if (separate_debug_file_exists (debugfile, crc32, objfile, warnings))
1410 return debugfile;
1411
1412 /* Then try in the global debugfile directories.
1413
1414 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1415 cause "/..." lookups. */
1416
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 ());
1423
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.
1427
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
1432
1433 https://sourceware.org/ml/gdb-patches/2019-04/msg00605.html
1434
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. */
1438 std::string drive;
1439 if (HAS_DRIVE_SPEC (dir_notarget))
1440 {
1441 drive = dir_notarget[0];
1442 dir_notarget = STRIP_DRIVE_SPEC (dir_notarget);
1443 }
1444
1445 for (const gdb::unique_xmalloc_ptr<char> &debugdir : debugdir_vec)
1446 {
1447 debugfile = target_prefix ? "target:" : "";
1448 debugfile += debugdir;
1449 debugfile += "/";
1450 debugfile += drive;
1451 debugfile += dir_notarget;
1452 debugfile += debuglink;
1453
1454 if (separate_debug_file_exists (debugfile, crc32, objfile, warnings))
1455 return debugfile;
1456
1457 const char *base_path = NULL;
1458 if (canon_dir != NULL)
1459 {
1460 if (canon_sysroot.get () != NULL)
1461 base_path = child_path (canon_sysroot.get (), canon_dir);
1462 else
1463 base_path = child_path (gdb_sysroot.c_str (), canon_dir);
1464 }
1465 if (base_path != NULL)
1466 {
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;
1471 debugfile += "/";
1472 debugfile += base_path;
1473 debugfile += "/";
1474 debugfile += debuglink;
1475
1476 if (separate_debug_file_exists (debugfile, crc32, objfile, warnings))
1477 return debugfile;
1478
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:")
1486 {
1487 debugfile = target_prefix ? "target:" : "";
1488 if (startswith (gdb_sysroot, "target:"))
1489 {
1490 std::string root = gdb_sysroot.substr (strlen ("target:"));
1491 gdb_assert (!root.empty ());
1492 debugfile += root;
1493 }
1494 else
1495 debugfile += gdb_sysroot;
1496 debugfile += debugdir;
1497 debugfile += "/";
1498 debugfile += base_path;
1499 debugfile += "/";
1500 debugfile += debuglink;
1501
1502 if (separate_debug_file_exists (debugfile, crc32, objfile,
1503 warnings))
1504 return debugfile;
1505 }
1506 }
1507 }
1508
1509 return std::string ();
1510}
1511
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. */
1515
1516static void
1518{
1519 int i;
1520
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]))
1525 break;
1526
1527 /* If I is -1 then no directory is present there and DIR will be "". */
1528 path[i + 1] = '\0';
1529}
1530
1531/* See symtab.h. */
1532
1533std::string
1535 (struct objfile *objfile, deferred_warnings *warnings)
1536{
1537 uint32_t crc32;
1538
1539 gdb::unique_xmalloc_ptr<char> debuglink
1540 (bfd_get_debug_link_info (objfile->obfd.get (), &crc32));
1541
1542 if (debuglink == NULL)
1543 {
1544 /* There's no separate debug info, hence there's no way we could
1545 load it => no warning. */
1546 return std::string ();
1547 }
1548
1549 std::string dir = objfile_name (objfile);
1551 gdb::unique_xmalloc_ptr<char> canon_dir (lrealpath (dir.c_str ()));
1552
1553 std::string debugfile
1554 = find_separate_debug_file (dir.c_str (), canon_dir.get (),
1555 debuglink.get (), crc32, objfile,
1556 warnings);
1557
1558 if (debugfile.empty ())
1559 {
1560 /* For PR gdb/9538, try again with realpath (if different from the
1561 original). */
1562
1563 struct stat st_buf;
1564
1565 if (lstat (objfile_name (objfile), &st_buf) == 0
1566 && S_ISLNK (st_buf.st_mode))
1567 {
1568 gdb::unique_xmalloc_ptr<char> symlink_dir
1569 (lrealpath (objfile_name (objfile)));
1570 if (symlink_dir != NULL)
1571 {
1572 terminate_after_last_dir_separator (symlink_dir.get ());
1573 if (dir != symlink_dir.get ())
1574 {
1575 /* Different directory, so try using it. */
1576 debugfile = find_separate_debug_file (symlink_dir.get (),
1577 symlink_dir.get (),
1578 debuglink.get (),
1579 crc32,
1580 objfile,
1581 warnings);
1582 }
1583 }
1584 }
1585 }
1586
1587 return debugfile;
1588}
1589
1590/* Make sure that OBJF_{READNOW,READNEVER} are not set
1591 simultaneously. */
1592
1593static void
1594validate_readnow_readnever (objfile_flags flags)
1595{
1596 if ((flags & OBJF_READNOW) && (flags & OBJF_READNEVER))
1597 error (_("-readnow and -readnever cannot be used simultaneously"));
1598}
1599
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:
1603
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.
1607
1608 2. Options are used, which are not generally used in GDB (perhaps
1609 "set mapped on", "set readnow on" would be better)
1610
1611 3. The order of options matters, which is contrary to GNU
1612 conventions (because it is confusing and inconvenient). */
1613
1614void
1615symbol_file_command (const char *args, int from_tty)
1616{
1617 dont_repeat ();
1618
1619 if (args == NULL)
1620 {
1621 symbol_file_clear (from_tty);
1622 }
1623 else
1624 {
1625 objfile_flags flags = OBJF_USERLOADED;
1626 symfile_add_flags add_flags = 0;
1627 char *name = NULL;
1628 bool stop_processing_options = false;
1629 CORE_ADDR offset = 0;
1630 int idx;
1631 char *arg;
1632
1633 if (from_tty)
1634 add_flags |= SYMFILE_VERBOSE;
1635
1636 gdb_argv built_argv (args);
1637 for (arg = built_argv[0], idx = 0; arg != NULL; arg = built_argv[++idx])
1638 {
1639 if (stop_processing_options || *arg != '-')
1640 {
1641 if (name == NULL)
1642 name = arg;
1643 else
1644 error (_("Unrecognized argument \"%s\""), arg);
1645 }
1646 else if (strcmp (arg, "-readnow") == 0)
1648 else if (strcmp (arg, "-readnever") == 0)
1650 else if (strcmp (arg, "-o") == 0)
1651 {
1652 arg = built_argv[++idx];
1653 if (arg == NULL)
1654 error (_("Missing argument to -o"));
1655
1656 offset = parse_and_eval_address (arg);
1657 }
1658 else if (strcmp (arg, "--") == 0)
1659 stop_processing_options = true;
1660 else
1661 error (_("Unrecognized argument \"%s\""), arg);
1662 }
1663
1664 if (name == NULL)
1665 error (_("no symbol file name was specified"));
1666
1668
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
1673 displacement. */
1674 add_flags |= SYMFILE_DEFER_BP_RESET;
1675
1676 symbol_file_add_main_1 (name, add_flags, flags, offset);
1677
1678 solib_create_inferior_hook (from_tty);
1679
1680 /* Now it's safe to re-add the breakpoints. */
1682
1683 /* Also, it's safe to re-add varobjs. */
1684 varobj_re_set ();
1685 }
1686}
1687
1688/* Set the initial language. */
1689
1690void
1692{
1694 return;
1695 enum language lang = main_language ();
1696 /* Make C the default language. */
1697 enum language default_lang = language_c;
1698
1699 if (lang == language_unknown)
1700 {
1701 const char *name = main_name ();
1702 struct symbol *sym
1703 = lookup_symbol_in_language (name, NULL, VAR_DOMAIN, default_lang,
1704 NULL).symbol;
1705
1706 if (sym != NULL)
1707 lang = sym->language ();
1708 }
1709
1710 if (lang == language_unknown)
1711 {
1712 lang = default_lang;
1713 }
1714
1715 set_language (lang);
1716 expected_language = current_language; /* Don't warn the user. */
1717}
1718
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. */
1723
1725symfile_bfd_open (const char *name)
1726{
1727 int desc = -1;
1728
1729 gdb::unique_xmalloc_ptr<char> absolute_name;
1730 if (!is_target_filename (name))
1731 {
1732 gdb::unique_xmalloc_ptr<char> expanded_name (tilde_expand (name));
1733
1734 /* Look down path for it, allocate 2nd new malloc'd copy. */
1735 desc = openp (getenv ("PATH"),
1737 expanded_name.get (), O_RDONLY | O_BINARY, &absolute_name);
1738#if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1739 if (desc < 0)
1740 {
1741 char *exename = (char *) alloca (strlen (expanded_name.get ()) + 5);
1742
1743 strcat (strcpy (exename, expanded_name.get ()), ".exe");
1744 desc = openp (getenv ("PATH"),
1746 exename, O_RDONLY | O_BINARY, &absolute_name);
1747 }
1748#endif
1749 if (desc < 0)
1750 perror_with_name (expanded_name.get ());
1751
1752 name = absolute_name.get ();
1753 }
1754
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 ()));
1759
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 ()));
1763
1764 return sym_bfd;
1765}
1766
1767/* See symfile.h. */
1768
1770symfile_bfd_open_no_error (const char *name) noexcept
1771{
1772 try
1773 {
1774 return symfile_bfd_open (name);
1775 }
1776 catch (const gdb_exception_error &err)
1777 {
1778 warning ("%s", err.what ());
1779 }
1780
1781 return nullptr;
1782}
1783
1784/* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1785 the section was not found. */
1786
1788get_section_index (struct objfile *objfile, const char *section_name)
1789{
1790 asection *sect = bfd_get_section_by_name (objfile->obfd.get (), section_name);
1791
1792 if (sect)
1793 return sect->index;
1794 else
1795 return -1;
1796}
1797
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
1802 to handle. */
1803
1804void
1805add_symtab_fns (enum bfd_flavour flavour, const struct sym_fns *sf)
1806{
1807 symtab_fns.emplace_back (flavour, sf);
1808}
1809
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. */
1814
1815static const struct sym_fns *
1816find_sym_fns (bfd *abfd)
1817{
1818 enum bfd_flavour our_flavour = bfd_get_flavour (abfd);
1819
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. */
1824
1825 for (const registered_sym_fns &rsf : symtab_fns)
1826 if (our_flavour == rsf.sym_flavour)
1827 return rsf.sym_fns;
1828
1829 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1830 bfd_get_target (abfd));
1831}
1832
1833
1834/* This function runs the load command of our current target. */
1835
1836static void
1837load_command (const char *arg, int from_tty)
1838{
1839 dont_repeat ();
1840
1841 /* The user might be reloading because the binary has changed. Take
1842 this opportunity to check. */
1844 reread_symbols (from_tty);
1845
1846 std::string temp;
1847 if (arg == NULL)
1848 {
1849 const char *parg, *prev;
1850
1851 arg = get_exec_file (1);
1852
1853 /* We may need to quote this string so buildargv can pull it
1854 apart. */
1855 prev = parg = arg;
1856 while ((parg = strpbrk (parg, "\\\"'\t ")))
1857 {
1858 temp.append (prev, parg - prev);
1859 prev = parg++;
1860 temp.push_back ('\\');
1861 }
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. */
1864 if (!temp.empty ())
1865 {
1866 temp.append (prev);
1867 arg = temp.c_str ();
1868 }
1869 }
1870
1871 target_load (arg, from_tty);
1872
1873 /* After re-loading the executable, we don't really know which
1874 overlays are mapped any more. */
1876}
1877
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.
1881
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. */
1887static int validate_download = 0;
1888
1889/* Opaque data for load_progress. */
1890struct load_progress_data
1891{
1892 /* Cumulative data. */
1893 unsigned long write_count = 0;
1894 unsigned long data_count = 0;
1895 bfd_size_type total_size = 0;
1896};
1897
1898/* Opaque data for load_progress for a single section. */
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_)
1906 {}
1909
1910 /* Per-section data. */
1911 const char *section_name;
1912 ULONGEST section_sent = 0;
1914 CORE_ADDR lma;
1915 gdb_byte *buffer;
1916};
1917
1918/* Opaque data for load_section_callback. */
1919struct load_section_data
1921 load_section_data (load_progress_data *progress_data_)
1922 : progress_data (progress_data_)
1923 {}
1926 {
1927 for (auto &&request : requests)
1928 {
1929 xfree (request.data);
1930 delete ((load_progress_section_data *) request.baton);
1931 }
1932 }
1934 CORE_ADDR load_offset = 0;
1936 std::vector<struct memory_write_request> requests;
1937};
1938
1939/* Target write callback routine for progress reporting. */
1940
1941static void
1942load_progress (ULONGEST bytes, void *untyped_arg)
1943{
1944 struct load_progress_section_data *args
1945 = (struct load_progress_section_data *) untyped_arg;
1946 struct load_progress_data *totals;
1947
1948 if (args == NULL)
1949 /* Writing padding data. No easy way to get at the cumulative
1950 stats, so just ignore this. */
1951 return;
1952
1953 totals = args->cumulative;
1954
1955 if (bytes == 0 && args->section_sent == 0)
1956 {
1957 /* The write is just starting. Let the user know we've started
1958 this section. */
1959 current_uiout->message ("Loading section %s, size %s lma %s\n",
1960 args->section_name,
1961 hex_string (args->section_size),
1962 paddress (target_gdbarch (), args->lma));
1963 return;
1964 }
1965
1967 {
1968 /* Broken memories and broken monitors manifest themselves here
1969 when bring new computers to life. This doubles already slow
1970 downloads. */
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);
1976
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));
1983 }
1984 totals->data_count += bytes;
1985 args->lma += bytes;
1986 args->buffer += bytes;
1987 totals->write_count += 1;
1988 args->section_sent += bytes;
1989 if (check_quit_flag ()
1991 && deprecated_ui_load_progress_hook (args->section_name,
1992 args->section_sent)))
1993 error (_("Canceled the download"));
1994
1996 deprecated_show_load_progress (args->section_name,
1997 args->section_sent,
1998 args->section_size,
1999 totals->data_count,
2000 totals->total_size);
2001}
2002
2003/* Service function for generic_load. */
2004
2005static void
2006load_one_section (bfd *abfd, asection *asec,
2007 struct load_section_data *args)
2008{
2009 bfd_size_type size = bfd_section_size (asec);
2010 const char *sect_name = bfd_section_name (asec);
2011
2012 if ((bfd_section_flags (asec) & SEC_LOAD) == 0)
2013 return;
2014
2015 if (size == 0)
2016 return;
2017
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);
2022
2023 load_progress_section_data *section_data
2024 = new load_progress_section_data (args->progress_data, sect_name, size,
2025 begin, buffer);
2026
2027 args->requests.emplace_back (begin, end, buffer, section_data);
2028}
2029
2030static 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);
2034
2035/* See symfile.h. */
2036
2037void
2038generic_load (const char *args, int from_tty)
2039{
2040 struct load_progress_data total_progress;
2041 struct load_section_data cbdata (&total_progress);
2042 struct ui_out *uiout = current_uiout;
2043
2044 if (args == NULL)
2045 error_no_arg (_("file to load"));
2046
2047 gdb_argv argv (args);
2048
2049 gdb::unique_xmalloc_ptr<char> filename (tilde_expand (argv[0]));
2050
2051 if (argv[1] != NULL)
2052 {
2053 const char *endptr;
2054
2055 cbdata.load_offset = strtoulst (argv[1], &endptr, 0);
2056
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]);
2061
2062 if (argv[2] != NULL)
2063 error (_("Too many parameters."));
2064 }
2065
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 ());
2070
2071 if (!bfd_check_format (loadfile_bfd.get (), bfd_object))
2072 {
2073 error (_("\"%s\" is not an object file: %s"), filename.get (),
2074 bfd_errmsg (bfd_get_error ()));
2075 }
2076
2077 for (asection *asec : gdb_bfd_sections (loadfile_bfd))
2078 total_progress.total_size += bfd_section_size (asec);
2079
2080 for (asection *asec : gdb_bfd_sections (loadfile_bfd))
2081 load_one_section (loadfile_bfd.get (), asec, &cbdata);
2082
2083 using namespace std::chrono;
2084
2085 steady_clock::time_point start_time = steady_clock::now ();
2086
2088 load_progress) != 0)
2089 error (_("Load failed"));
2090
2091 steady_clock::time_point end_time = steady_clock::now ();
2092
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);
2099 uiout->text ("\n");
2101
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
2108 memory. */
2109
2111
2113 total_progress.write_count,
2114 end_time - start_time);
2115}
2116
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
2121 lasted. */
2122
2123static void
2124print_transfer_performance (struct ui_file *stream,
2125 unsigned long data_count,
2126 unsigned long write_count,
2127 std::chrono::steady_clock::duration time)
2128{
2129 using namespace std::chrono;
2130 struct ui_out *uiout = current_uiout;
2131
2132 milliseconds ms = duration_cast<milliseconds> (time);
2133
2134 uiout->text ("Transfer rate: ");
2135 if (ms.count () > 0)
2136 {
2137 unsigned long rate = ((ULONGEST) data_count * 1000) / ms.count ();
2138
2139 if (uiout->is_mi_like_p ())
2140 {
2141 uiout->field_unsigned ("transfer-rate", rate * 8);
2142 uiout->text (" bits/sec");
2143 }
2144 else if (rate < 1024)
2145 {
2146 uiout->field_unsigned ("transfer-rate", rate);
2147 uiout->text (" bytes/sec");
2148 }
2149 else
2150 {
2151 uiout->field_unsigned ("transfer-rate", rate / 1024);
2152 uiout->text (" KB/sec");
2153 }
2154 }
2155 else
2156 {
2157 uiout->field_unsigned ("transferred-bits", (data_count * 8));
2158 uiout->text (" bits in <1 sec");
2159 }
2160 if (write_count > 0)
2161 {
2162 uiout->text (", ");
2163 uiout->field_unsigned ("write-rate", data_count / write_count);
2164 uiout->text (" bytes/write");
2165 }
2166 uiout->text (".\n");
2167}
2168
2169/* Add an OFFSET to the start address of each section in OBJF, except
2170 sections that were specified in ADDRS. */
2171
2172static void
2174 const section_addr_info &addrs,
2175 CORE_ADDR offset)
2176{
2177 /* Add OFFSET to all sections by default. */
2178 section_offsets offsets (objf->section_offsets.size (), offset);
2179
2180 /* Create sorted lists of all sections in ADDRS as well as all
2181 sections in OBJF. */
2182
2183 std::vector<const struct other_sections *> addrs_sorted
2184 = addrs_section_sort (addrs);
2185
2186 section_addr_info objf_addrs
2188 std::vector<const struct other_sections *> objf_addrs_sorted
2189 = addrs_section_sort (objf_addrs);
2190
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
2193 unchanged.
2194
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). */
2198
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)
2202 {
2203 const char *objf_name = addr_section_name (objf_sect->name.c_str ());
2204 int cmp = -1;
2205
2206 while (cmp < 0 && addrs_sorted_iter != addrs_sorted.end ())
2207 {
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);
2211 if (cmp <= 0)
2212 ++addrs_sorted_iter;
2213 }
2214
2215 if (cmp == 0)
2216 offsets[objf_sect->sectindex] = 0;
2217 }
2218
2219 /* Apply the new section offsets. */
2220 objfile_relocate (objf, offsets);
2221}
2222
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. */
2225
2226static void
2227add_symbol_file_command (const char *args, int from_tty)
2228{
2229 struct gdbarch *gdbarch = get_current_arch ();
2230 gdb::unique_xmalloc_ptr<char> filename;
2231 char *arg;
2232 int argcnt = 0;
2233 struct objfile *objf;
2234 objfile_flags flags = OBJF_USERLOADED | OBJF_SHARED;
2235 symfile_add_flags add_flags = 0;
2236
2237 if (from_tty)
2238 add_flags |= SYMFILE_VERBOSE;
2239
2240 struct sect_opt
2241 {
2242 const char *name;
2243 const char *value;
2244 };
2245
2246 std::vector<sect_opt> sect_opts = { { ".text", NULL } };
2247 bool stop_processing_options = false;
2248 CORE_ADDR offset = 0;
2249
2250 dont_repeat ();
2251
2252 if (args == NULL)
2253 error (_("add-symbol-file takes a file name and an address"));
2254
2255 bool seen_addr = false;
2256 bool seen_offset = false;
2257 gdb_argv argv (args);
2258
2259 for (arg = argv[0], argcnt = 0; arg != NULL; arg = argv[++argcnt])
2260 {
2261 if (stop_processing_options || *arg != '-')
2262 {
2263 if (filename == NULL)
2264 {
2265 /* First non-option argument is always the filename. */
2266 filename.reset (tilde_expand (arg));
2267 }
2268 else if (!seen_addr)
2269 {
2270 /* The second non-option argument is always the text
2271 address at which to load the program. */
2272 sect_opts[0].value = arg;
2273 seen_addr = true;
2274 }
2275 else
2276 error (_("Unrecognized argument \"%s\""), arg);
2277 }
2278 else if (strcmp (arg, "-readnow") == 0)
2280 else if (strcmp (arg, "-readnever") == 0)
2282 else if (strcmp (arg, "-s") == 0)
2283 {
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\""));
2288
2289 sect_opt sect = { argv[argcnt + 1], argv[argcnt + 2] };
2290
2291 sect_opts.push_back (sect);
2292 argcnt += 2;
2293 }
2294 else if (strcmp (arg, "-o") == 0)
2295 {
2296 arg = argv[++argcnt];
2297 if (arg == NULL)
2298 error (_("Missing argument to -o"));
2299
2300 offset = parse_and_eval_address (arg);
2301 seen_offset = true;
2302 }
2303 else if (strcmp (arg, "--") == 0)
2304 stop_processing_options = true;
2305 else
2306 error (_("Unrecognized argument \"%s\""), arg);
2307 }
2308
2309 if (filename == NULL)
2310 error (_("You must provide a filename to be loaded."));
2311
2313
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
2318 string. */
2319
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 ();
2324 if (!seen_addr)
2325 ++it;
2326 for (; it != sect_opts.end (); ++it)
2327 {
2328 CORE_ADDR addr;
2329 const char *val = it->value;
2330 const char *sec = it->name;
2331
2332 if (section_addrs.empty ())
2333 gdb_printf (_(" at\n"));
2334 addr = parse_and_eval_address (val);
2335
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.
2341 */
2342 section_addrs.emplace_back (addr, sec, section_addrs.size ());
2343 gdb_printf ("\t%s_addr = %s\n", sec,
2344 paddress (gdbarch, addr));
2345
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. */
2351 }
2352 if (seen_offset)
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 ())
2359 gdb_printf ("\n");
2360
2361 if (from_tty && (!query ("%s", "")))
2362 error (_("Not confirmed."));
2363
2364 objf = symbol_file_add (filename.get (), add_flags, &section_addrs,
2365 flags);
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 ()));
2369
2370 if (seen_offset)
2371 set_objfile_default_section_offset (objf, section_addrs, offset);
2372
2374
2375 /* Getting new symbols may change our opinion about what is
2376 frameless. */
2378}
2379
2380
2381/* This function removes a symbol file that was added via add-symbol-file. */
2382
2383static void
2384remove_symbol_file_command (const char *args, int from_tty)
2385{
2386 struct objfile *objf = NULL;
2387 struct program_space *pspace = current_program_space;
2388
2389 dont_repeat ();
2390
2391 if (args == NULL)
2392 error (_("remove-symbol-file: no symbol file provided"));
2393
2394 gdb_argv argv (args);
2395
2396 if (strcmp (argv[0], "-a") == 0)
2397 {
2398 /* Interpret the next argument as an address. */
2399 CORE_ADDR addr;
2400
2401 if (argv[1] == NULL)
2402 error (_("Missing address argument"));
2403
2404 if (argv[2] != NULL)
2405 error (_("Junk after %s"), argv[1]);
2406
2407 addr = parse_and_eval_address (argv[1]);
2408
2410 {
2411 if ((objfile->flags & OBJF_USERLOADED) != 0
2412 && (objfile->flags & OBJF_SHARED) != 0
2413 && objfile->pspace == pspace
2414 && is_addr_in_objfile (addr, objfile))
2415 {
2416 objf = objfile;
2417 break;
2418 }
2419 }
2420 }
2421 else if (argv[0] != NULL)
2422 {
2423 /* Interpret the current argument as a file name. */
2424
2425 if (argv[1] != NULL)
2426 error (_("Junk after %s"), argv[0]);
2427
2428 gdb::unique_xmalloc_ptr<char> filename (tilde_expand (argv[0]));
2429
2431 {
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)
2436 {
2437 objf = objfile;
2438 break;
2439 }
2440 }
2441 }
2442
2443 if (objf == NULL)
2444 error (_("No symbol file found"));
2445
2446 if (from_tty
2447 && !query (_("Remove symbol table from file \"%s\"? "),
2448 objfile_name (objf)))
2449 error (_("Not confirmed."));
2450
2451 objf->unlink ();
2453}
2454
2455/* Re-read symbols if a symbol-file has changed. */
2456
2457void
2458reread_symbols (int from_tty)
2459{
2460 std::vector<struct objfile *> new_objfiles;
2461
2462 /* Check to see if the executable has changed, and if so reopen it. The
2463 executable might not be in the list of objfiles (if the user set
2464 different values for 'exec-file' and 'symbol-file'), and even if it
2465 is, then we use a separate timestamp (within the program_space) to
2466 indicate when the executable was last reloaded. */
2468
2470 {
2471 if (objfile->obfd.get () == NULL)
2472 continue;
2473
2474 /* Separate debug objfiles are handled in the main objfile. */
2476 continue;
2477
2478 /* When a in-memory BFD is initially created, it's mtime (as
2479 returned by bfd_get_mtime) is the creation time of the BFD.
2480 However, we call bfd_stat here as we want to see if the
2481 underlying file has changed, and in this case an in-memory BFD
2482 will return an st_mtime of zero, so it appears that the in-memory
2483 file has changed, which isn't what we want here -- this code is
2484 about reloading BFDs that changed on disk.
2485
2486 Just skip any in-memory BFD. */
2487 if (objfile->obfd.get ()->flags & BFD_IN_MEMORY)
2488 continue;
2489
2490 struct stat new_statbuf;
2491 int res = bfd_stat (objfile->obfd.get (), &new_statbuf);
2492 if (res != 0)
2493 {
2494 /* If this object is from an archive (what you usually create
2495 with `ar', often called a `static library' on most systems,
2496 though a `shared library' on AIX is also an archive), then you
2497 should stat on the archive name, not member name. */
2498 const char *filename;
2499 if (objfile->obfd->my_archive)
2500 filename = bfd_get_filename (objfile->obfd->my_archive);
2501 else
2502 filename = objfile_name (objfile);
2503
2504 warning (_("`%ps' has disappeared; keeping its symbols."),
2505 styled_string (file_name_style.style (), filename));
2506 continue;
2507 }
2508 time_t new_modtime = new_statbuf.st_mtime;
2509 if (new_modtime != objfile->mtime)
2510 {
2511 gdb_printf (_("`%ps' has changed; re-reading symbols.\n"),
2514
2515 /* There are various functions like symbol_file_add,
2516 symfile_bfd_open, syms_from_objfile, etc., which might
2517 appear to do what we want. But they have various other
2518 effects which we *don't* want. So we just do stuff
2519 ourselves. We don't worry about mapped files (for one thing,
2520 any mapped file will be out of date). */
2521
2522 /* If we get an error, blow away this objfile (not sure if
2523 that is the correct response for things like shared
2524 libraries). */
2525 objfile_up objfile_holder (objfile);
2526
2527 /* We need to do this whenever any symbols go away. */
2528 clear_symtab_users_cleanup defer_clear_users (0);
2529
2530 /* Keep the calls order approx. the same as in free_objfile. */
2531
2532 /* Free the separate debug objfiles. It will be
2533 automatically recreated by sym_read. */
2535
2536 /* Clear the stale source cache. */
2538
2539 /* Remove any references to this objfile in the global
2540 value lists. */
2542
2543 /* Nuke all the state that we will re-read. Much of the following
2544 code which sets things to NULL really is necessary to tell
2545 other parts of GDB that there is nothing currently there.
2546
2547 Try to keep the freeing order compatible with free_objfile. */
2548
2549 if (objfile->sf != NULL)
2550 {
2552 }
2553
2555
2556 /* Clean up any state BFD has sitting around. */
2557 {
2559 const char *obfd_filename;
2560
2561 obfd_filename = bfd_get_filename (objfile->obfd.get ());
2562 /* Open the new BFD before freeing the old one, so that
2563 the filename remains live. */
2564 gdb_bfd_ref_ptr temp (gdb_bfd_open (obfd_filename, gnutarget));
2565 objfile->obfd = std::move (temp);
2566 if (objfile->obfd == NULL)
2567 error (_("Can't open %s to read symbols."), obfd_filename);
2568 }
2569
2570 std::string original_name = objfile->original_name;
2571
2572 /* bfd_openr sets cacheable to true, which is what we want. */
2573 if (!bfd_check_format (objfile->obfd.get (), bfd_object))
2574 error (_("Can't read symbols from %s: %s."), objfile_name (objfile),
2575 bfd_errmsg (bfd_get_error ()));
2576
2577 /* NB: after this call to obstack_free, objfiles_changed
2578 will need to be called (see discussion below). */
2579 obstack_free (&objfile->objfile_obstack, 0);
2580 objfile->sections_start = NULL;
2581 objfile->section_offsets.clear ();
2582 objfile->sect_index_bss = -1;
2586 objfile->compunit_symtabs = NULL;
2587 objfile->template_symbols = NULL;
2588 objfile->static_links.reset (nullptr);
2589
2590 /* obstack_init also initializes the obstack so it is
2591 empty. We could use obstack_specify_allocation but
2592 gdb_obstack.h specifies the alloc/dealloc functions. */
2593 obstack_init (&objfile->objfile_obstack);
2594
2595 /* set_objfile_per_bfd potentially allocates the per-bfd
2596 data on the objfile's obstack (if sharing data across
2597 multiple users is not possible), so it's important to
2598 do it *after* the obstack has been initialized. */
2600
2602 = obstack_strdup (&objfile->objfile_obstack, original_name);
2603
2604 /* Reset the sym_fns pointer. The ELF reader can change it
2605 based on whether .gdb_index is present, and we need it to
2606 start over. PR symtab/15885 */
2608 objfile->qf.clear ();
2609
2611
2612 /* What the hell is sym_new_init for, anyway? The concept of
2613 distinguishing between the main file and additional files
2614 in this way seems rather dubious. */
2616 {
2618 }
2619
2620 (*objfile->sf->sym_init) (objfile);
2622
2623 objfile->flags &= ~OBJF_PSYMTABS_READ;
2624
2625 /* We are about to read new symbols and potentially also
2626 DWARF information. Some targets may want to pass addresses
2627 read from DWARF DIE's through an adjustment function before
2628 saving them, like MIPS, which may call into
2629 "find_pc_section". When called, that function will make
2630 use of per-objfile program space data.
2631
2632 Since we discarded our section information above, we have
2633 dangling pointers in the per-objfile program space data
2634 structure. Force GDB to update the section mapping
2635 information by letting it know the objfile has changed,
2636 making the dangling pointers point to correct data
2637 again. */
2638
2640
2641 /* Recompute section offsets and section indices. */
2642 objfile->sf->sym_offsets (objfile, {});
2643
2644 read_symbols (objfile, 0);
2645
2646 if ((objfile->flags & OBJF_READNOW))
2647 {
2648 const int mainline = objfile->flags & OBJF_MAINLINE;
2649 const int should_print = (print_symbol_loading_p (from_tty, mainline, 1)
2651 if (should_print)
2652 gdb_printf (_("Expanding full symbols from %ps...\n"),
2655
2657 }
2658
2660 {
2661 gdb_stdout->wrap_here (0);
2662 gdb_printf (_("(no debugging symbols found)\n"));
2663 gdb_stdout->wrap_here (0);
2664 }
2665
2666 /* We're done reading the symbol file; finish off complaints. */
2668
2669 /* Getting new symbols may change our opinion about what is
2670 frameless. */
2671
2673
2674 /* Discard cleanups as symbol reading was successful. */
2675 objfile_holder.release ();
2676 defer_clear_users.release ();
2677
2678 /* If the mtime has changed between the time we set new_modtime
2679 and now, we *want* this to be out of date, so don't call stat
2680 again now. */
2681 objfile->mtime = new_modtime;
2683
2684 new_objfiles.push_back (objfile);
2685 }
2686 }
2687
2688 if (!new_objfiles.empty ())
2689 {
2691
2692 /* The registry for each objfile was cleared and
2693 gdb::observers::new_objfile.notify (NULL) has been called by
2694 clear_symtab_users above. Notify the new files now. */
2695 for (auto iter : new_objfiles)
2697 }
2698}
2699
2701struct filename_language
2703 filename_language (const std::string &ext_, enum language lang_)
2704 : ext (ext_), lang (lang_)
2705 {}
2707 std::string ext;
2708 enum language lang;
2709};
2711static std::vector<filename_language> filename_language_table;
2712
2713/* See symfile.h. */
2714
2715void
2716add_filename_language (const char *ext, enum language lang)
2717{
2718 gdb_assert (ext != nullptr);
2719 filename_language_table.emplace_back (ext, lang);
2720}
2722static std::string ext_args;
2723static void
2724show_ext_args (struct ui_file *file, int from_tty,
2725 struct cmd_list_element *c, const char *value)
2726{
2727 gdb_printf (file,
2728 _("Mapping between filename extension "
2729 "and source language is \"%s\".\n"),
2730 value);
2731}
2732
2733static void
2734set_ext_lang_command (const char *args,
2735 int from_tty, struct cmd_list_element *e)
2736{
2737 const char *begin = ext_args.c_str ();
2738 const char *end = ext_args.c_str ();
2739
2740 /* First arg is filename extension, starting with '.' */
2741 if (*end != '.')
2742 error (_("'%s': Filename extension must begin with '.'"), ext_args.c_str ());
2743
2744 /* Find end of first arg. */
2745 while (*end != '\0' && !isspace (*end))
2746 end++;
2747
2748 if (*end == '\0')
2749 error (_("'%s': two arguments required -- "
2750 "filename extension and language"),
2751 ext_args.c_str ());
2752
2753 /* Extract first arg, the extension. */
2754 std::string extension = ext_args.substr (0, end - begin);
2755
2756 /* Find beginning of second arg, which should be a source language. */
2757 begin = skip_spaces (end);
2758
2759 if (*begin == '\0')
2760 error (_("'%s': two arguments required -- "
2761 "filename extension and language"),
2762 ext_args.c_str ());
2763
2764 /* Lookup the language from among those we know. */
2765 language lang = language_enum (begin);
2766
2767 auto it = filename_language_table.begin ();
2768 /* Now lookup the filename extension: do we already know it? */
2769 for (; it != filename_language_table.end (); it++)
2770 {
2771 if (it->ext == extension)
2772 break;
2773 }
2774
2775 if (it == filename_language_table.end ())
2776 {
2777 /* New file extension. */
2778 add_filename_language (extension.data (), lang);
2779 }
2780 else
2781 {
2782 /* Redefining a previously known filename extension. */
2783
2784 /* if (from_tty) */
2785 /* query ("Really make files of type %s '%s'?", */
2786 /* ext_args, language_str (lang)); */
2787
2788 it->lang = lang;
2789 }
2790}
2791
2792static void
2793info_ext_lang_command (const char *args, int from_tty)
2794{
2795 gdb_printf (_("Filename extensions and the languages they represent:"));
2796 gdb_printf ("\n\n");
2797 for (const filename_language &entry : filename_language_table)
2798 gdb_printf ("\t%s\t- %s\n", entry.ext.c_str (),
2799 language_str (entry.lang));
2800}
2801
2803deduce_language_from_filename (const char *filename)
2804{
2805 const char *cp;
2806
2807 if (filename != NULL)
2808 if ((cp = strrchr (filename, '.')) != NULL)
2809 {
2810 for (const filename_language &entry : filename_language_table)
2811 if (entry.ext == cp)
2812 return entry.lang;
2813 }
2814
2815 return language_unknown;
2816}
2817
2818/* Allocate and initialize a new symbol table.
2819 CUST is from the result of allocate_compunit_symtab. */
2820
2821struct symtab *
2822allocate_symtab (struct compunit_symtab *cust, const char *filename,
2823 const char *filename_for_id)
2824{
2825 struct objfile *objfile = cust->objfile ();
2826 struct symtab *symtab
2827 = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symtab);
2828
2831 symtab->fullname = NULL;
2833
2834 /* This can be very verbose with lots of headers.
2835 Only print at higher debug levels. */
2836 if (symtab_create_debug >= 2)
2837 {
2838 /* Be a bit clever with debugging messages, and don't print objfile
2839 every time, only when it changes. */
2840 static std::string last_objfile_name;
2841 const char *this_objfile_name = objfile_name (objfile);
2842
2843 if (last_objfile_name.empty () || last_objfile_name != this_objfile_name)
2844 {
2845 last_objfile_name = this_objfile_name;
2846
2848 ("creating one or more symtabs for objfile %s", this_objfile_name);
2849 }
2850
2851 symtab_create_debug_printf_v ("created symtab %s for module %s",
2852 host_address_to_string (symtab), filename);
2853 }
2854
2855 /* Add it to CUST's list of symtabs. */
2856 cust->add_filetab (symtab);
2857
2858 /* Backlink to the containing compunit symtab. */
2859 symtab->set_compunit (cust);
2860
2861 return symtab;
2862}
2863
2864/* Allocate and initialize a new compunit.
2865 NAME is the name of the main source file, if there is one, or some
2866 descriptive text if there are no source files. */
2867
2869allocate_compunit_symtab (struct objfile *objfile, const char *name)
2870{
2871 struct compunit_symtab *cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2872 struct compunit_symtab);
2873 const char *saved_name;
2874
2875 cu->set_objfile (objfile);
2876
2877 /* The name we record here is only for display/debugging purposes.
2878 Just save the basename to avoid path issues (too long for display,
2879 relative vs absolute, etc.). */
2880 saved_name = lbasename (name);
2881 cu->name = obstack_strdup (&objfile->objfile_obstack, saved_name);
2882
2883 cu->set_debugformat ("unknown");
2884
2885 symtab_create_debug_printf_v ("created compunit symtab %s for %s",
2886 host_address_to_string (cu),
2887 cu->name);
2888
2889 return cu;
2890}
2891
2892/* Hook CU to the objfile it comes from. */
2893
2894void
2896{
2897 cu->next = cu->objfile ()->compunit_symtabs;
2898 cu->objfile ()->compunit_symtabs = cu;
2899}
2900
2901
2902/* Reset all data structures in gdb which may contain references to
2903 symbol table data. */
2904
2905void
2906clear_symtab_users (symfile_add_flags add_flags)
2907{
2908 /* Someday, we should do better than this, by only blowing away
2909 the things that really need to be blown. */
2910
2911 /* Clear the "current" symtab first, because it is no longer valid.
2912 breakpoint_re_set may try to access the current symtab. */
2914
2915 clear_displays ();
2919
2920 /* Now that the various caches have been cleared, we can re_set
2921 our breakpoints without risking it using stale data. */
2922 if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
2924}
2925
2926/* OVERLAYS:
2927 The following code implements an abstraction for debugging overlay sections.
2928
2929 The target model is as follows:
2930 1) The gnu linker will permit multiple sections to be mapped into the
2931 same VMA, each with its own unique LMA (or load address).
2932 2) It is assumed that some runtime mechanism exists for mapping the
2933 sections, one by one, from the load address into the VMA address.
2934 3) This code provides a mechanism for gdb to keep track of which
2935 sections should be considered to be mapped from the VMA to the LMA.
2936 This information is used for symbol lookup, and memory read/write.
2937 For instance, if a section has been mapped then its contents
2938 should be read from the VMA, otherwise from the LMA.
2939
2940 Two levels of debugger support for overlays are available. One is
2941 "manual", in which the debugger relies on the user to tell it which
2942 overlays are currently mapped. This level of support is
2943 implemented entirely in the core debugger, and the information about
2944 whether a section is mapped is kept in the objfile->obj_section table.
2945
2946 The second level of support is "automatic", and is only available if
2947 the target-specific code provides functionality to read the target's
2948 overlay mapping table, and translate its contents for the debugger
2949 (by updating the mapped state information in the obj_section tables).
2950
2951 The interface is as follows:
2952 User commands:
2953 overlay map <name> -- tell gdb to consider this section mapped
2954 overlay unmap <name> -- tell gdb to consider this section unmapped
2955 overlay list -- list the sections that GDB thinks are mapped
2956 overlay read-target -- get the target's state of what's mapped
2957 overlay off/manual/auto -- set overlay debugging state
2958 Functional interface:
2959 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2960 section, return that section.
2961 find_pc_overlay(pc): find any overlay section that contains
2962 the pc, either in its VMA or its LMA
2963 section_is_mapped(sect): true if overlay is marked as mapped
2964 section_is_overlay(sect): true if section's VMA != LMA
2965 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2966 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2967 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2968 overlay_mapped_address(...): map an address from section's LMA to VMA
2969 overlay_unmapped_address(...): map an address from section's VMA to LMA
2970 symbol_overlayed_address(...): Return a "current" address for symbol:
2971 either in VMA or LMA depending on whether
2972 the symbol's section is currently mapped. */
2973
2974/* Overlay debugging state: */
2977int overlay_cache_invalid = 0; /* True if need to refresh mapped state. */
2978
2979/* Function: section_is_overlay (SECTION)
2980 Returns true if SECTION has VMA not equal to LMA, ie.
2981 SECTION is loaded at an address different from where it will "run". */
2982
2984section_is_overlay (struct obj_section *section)
2985{
2986 if (overlay_debugging && section)
2987 {
2988 asection *bfd_section = section->the_bfd_section;
2989
2990 if (bfd_section_lma (bfd_section) != 0
2991 && bfd_section_lma (bfd_section) != bfd_section_vma (bfd_section))
2992 return 1;
2993 }
2994
2995 return 0;
2996}
2997
2998/* Function: overlay_invalidate_all (void)
2999 Invalidate the mapped state of all overlay sections (mark it as stale). */
3000
3001static void
3003{
3005 for (obj_section *sect : objfile->sections ())
3006 if (section_is_overlay (sect))
3007 sect->ovly_mapped = -1;
3008}
3009
3010/* Function: section_is_mapped (SECTION)
3011 Returns true if section is an overlay, and is currently mapped.
3012
3013 Access to the ovly_mapped flag is restricted to this function, so
3014 that we can do automatic update. If the global flag
3015 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3016 overlay_invalidate_all. If the mapped state of the particular
3017 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3018
3020section_is_mapped (struct obj_section *osect)
3021{
3022 struct gdbarch *gdbarch;
3023
3024 if (osect == 0 || !section_is_overlay (osect))
3025 return 0;
3026
3027 switch (overlay_debugging)
3028 {
3029 default:
3030 case ovly_off:
3031 return 0; /* overlay debugging off */
3032 case ovly_auto: /* overlay debugging automatic */
3033 /* Unles there is a gdbarch_overlay_update function,
3034 there's really nothing useful to do here (can't really go auto). */
3035 gdbarch = osect->objfile->arch ();
3037 {
3039 {
3042 }
3043 if (osect->ovly_mapped == -1)
3045 }
3046 /* fall thru */
3047 case ovly_on: /* overlay debugging manual */
3048 return osect->ovly_mapped == 1;
3049 }
3050}
3051
3052/* Function: pc_in_unmapped_range
3053 If PC falls into the lma range of SECTION, return true, else false. */
3054
3055bool
3056pc_in_unmapped_range (CORE_ADDR pc, struct obj_section *section)
3057{
3058 if (section_is_overlay (section))
3059 {
3060 asection *bfd_section = section->the_bfd_section;
3061
3062 /* We assume the LMA is relocated by the same offset as the VMA. */
3063 bfd_vma size = bfd_section_size (bfd_section);
3064 CORE_ADDR offset = section->offset ();
3065
3066 if (bfd_section_lma (bfd_section) + offset <= pc
3067 && pc < bfd_section_lma (bfd_section) + offset + size)
3068 return true;
3069 }
3070
3071 return false;
3072}
3073
3074/* Function: pc_in_mapped_range
3075 If PC falls into the vma range of SECTION, return true, else false. */
3076
3077bool
3078pc_in_mapped_range (CORE_ADDR pc, struct obj_section *section)
3079{
3080 if (section_is_overlay (section))
3081 {
3082 if (section->addr () <= pc
3083 && pc < section->endaddr ())
3084 return true;
3085 }
3086
3087 return false;
3088}
3089
3090/* Return true if the mapped ranges of sections A and B overlap, false
3091 otherwise. */
3092
3093static int
3094sections_overlap (struct obj_section *a, struct obj_section *b)
3095{
3096 CORE_ADDR a_start = a->addr ();
3097 CORE_ADDR a_end = a->endaddr ();
3098 CORE_ADDR b_start = b->addr ();
3099 CORE_ADDR b_end = b->endaddr ();
3100
3101 return (a_start < b_end && b_start < a_end);
3102}
3103
3104/* Function: overlay_unmapped_address (PC, SECTION)
3105 Returns the address corresponding to PC in the unmapped (load) range.
3106 May be the same as PC. */
3107
3108CORE_ADDR
3109overlay_unmapped_address (CORE_ADDR pc, struct obj_section *section)
3110{
3111 if (section_is_overlay (section) && pc_in_mapped_range (pc, section))
3112 {
3113 asection *bfd_section = section->the_bfd_section;
3114
3115 return (pc + bfd_section_lma (bfd_section)
3116 - bfd_section_vma (bfd_section));
3117 }
3118
3119 return pc;
3120}
3121
3122/* Function: overlay_mapped_address (PC, SECTION)
3123 Returns the address corresponding to PC in the mapped (runtime) range.
3124 May be the same as PC. */
3125
3126CORE_ADDR
3127overlay_mapped_address (CORE_ADDR pc, struct obj_section *section)
3128{
3129 if (section_is_overlay (section) && pc_in_unmapped_range (pc, section))
3130 {
3131 asection *bfd_section = section->the_bfd_section;
3132
3133 return (pc + bfd_section_vma (bfd_section)
3134 - bfd_section_lma (bfd_section));
3135 }
3136
3137 return pc;
3138}
3139
3140/* Function: symbol_overlayed_address
3141 Return one of two addresses (relative to the VMA or to the LMA),
3142 depending on whether the section is mapped or not. */
3143
3144CORE_ADDR
3145symbol_overlayed_address (CORE_ADDR address, struct obj_section *section)
3146{
3148 {
3149 /* If the symbol has no section, just return its regular address. */
3150 if (section == 0)
3151 return address;
3152 /* If the symbol's section is not an overlay, just return its
3153 address. */
3154 if (!section_is_overlay (section))
3155 return address;
3156 /* If the symbol's section is mapped, just return its address. */
3157 if (section_is_mapped (section))
3158 return address;
3159 /*
3160 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3161 * then return its LOADED address rather than its vma address!!
3162 */
3163 return overlay_unmapped_address (address, section);
3164 }
3165 return address;
3166}
3167
3168/* Function: find_pc_overlay (PC)
3169 Return the best-match overlay section for PC:
3170 If PC matches a mapped overlay section's VMA, return that section.
3171 Else if PC matches an unmapped section's VMA, return that section.
3172 Else if PC matches an unmapped section's LMA, return that section. */
3173
3175find_pc_overlay (CORE_ADDR pc)
3176{
3177 struct obj_section *best_match = NULL;
3178
3180 {
3182 for (obj_section *osect : objfile->sections ())
3183 if (section_is_overlay (osect))
3184 {
3185 if (pc_in_mapped_range (pc, osect))
3186 {
3187 if (section_is_mapped (osect))
3188 return osect;
3189 else
3190 best_match = osect;
3191 }
3192 else if (pc_in_unmapped_range (pc, osect))
3193 best_match = osect;
3194 }
3195 }
3196 return best_match;
3197}
3198
3199/* Function: find_pc_mapped_section (PC)
3200 If PC falls into the VMA address range of an overlay section that is
3201 currently marked as MAPPED, return that section. Else return NULL. */
3202
3204find_pc_mapped_section (CORE_ADDR pc)
3205{
3207 {
3209 for (obj_section *osect : objfile->sections ())
3210 if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect))
3211 return osect;
3212 }
3213
3214 return NULL;
3215}
3216
3217/* Function: list_overlays_command
3218 Print a list of mapped sections and their PC ranges. */
3219
3220static void
3221list_overlays_command (const char *args, int from_tty)
3222{
3223 int nmapped = 0;
3224
3226 {
3228 for (obj_section *osect : objfile->sections ())
3229 if (section_is_mapped (osect))
3230 {
3231 struct gdbarch *gdbarch = objfile->arch ();
3232 const char *name;
3233 bfd_vma lma, vma;
3234 int size;
3235
3236 vma = bfd_section_vma (osect->the_bfd_section);
3237 lma = bfd_section_lma (osect->the_bfd_section);
3238 size = bfd_section_size (osect->the_bfd_section);
3239 name = bfd_section_name (osect->the_bfd_section);
3240
3241 gdb_printf ("Section %s, loaded at ", name);
3242 gdb_puts (paddress (gdbarch, lma));
3243 gdb_puts (" - ");
3244 gdb_puts (paddress (gdbarch, lma + size));
3245 gdb_printf (", mapped at ");
3246 gdb_puts (paddress (gdbarch, vma));
3247 gdb_puts (" - ");
3248 gdb_puts (paddress (gdbarch, vma + size));
3249 gdb_puts ("\n");
3250
3251 nmapped++;
3252 }
3253 }
3254 if (nmapped == 0)
3255 gdb_printf (_("No sections are mapped.\n"));
3256}
3257
3258/* Function: map_overlay_command
3259 Mark the named section as mapped (ie. residing at its VMA address). */
3260
3261static void
3262map_overlay_command (const char *args, int from_tty)
3263{
3264 if (!overlay_debugging)
3265 error (_("Overlay debugging not enabled. Use "
3266 "either the 'overlay auto' or\n"
3267 "the 'overlay manual' command."));
3268
3269 if (args == 0 || *args == 0)
3270 error (_("Argument required: name of an overlay section"));
3271
3272 /* First, find a section matching the user supplied argument. */
3273 for (objfile *obj_file : current_program_space->objfiles ())
3274 for (obj_section *sec : obj_file->sections ())
3275 if (!strcmp (bfd_section_name (sec->the_bfd_section), args))
3276 {
3277 /* Now, check to see if the section is an overlay. */
3278 if (!section_is_overlay (sec))
3279 continue; /* not an overlay section */
3280
3281 /* Mark the overlay as "mapped". */
3282 sec->ovly_mapped = 1;
3283
3284 /* Next, make a pass and unmap any sections that are
3285 overlapped by this new section: */
3286 for (objfile *objfile2 : current_program_space->objfiles ())
3287 for (obj_section *sec2 : objfile2->sections ())
3288 if (sec2->ovly_mapped && sec != sec2 && sections_overlap (sec,
3289 sec2))
3290 {
3291 if (info_verbose)
3292 gdb_printf (_("Note: section %s unmapped by overlap\n"),
3293 bfd_section_name (sec2->the_bfd_section));
3294 sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2. */
3295 }
3296 return;
3297 }
3298 error (_("No overlay section called %s"), args);
3299}
3300
3301/* Function: unmap_overlay_command
3302 Mark the overlay section as unmapped
3303 (ie. resident in its LMA address range, rather than the VMA range). */
3304
3305static void
3306unmap_overlay_command (const char *args, int from_tty)
3307{
3308 if (!overlay_debugging)
3309 error (_("Overlay debugging not enabled. "
3310 "Use either the 'overlay auto' or\n"
3311 "the 'overlay manual' command."));
3312
3313 if (args == 0 || *args == 0)
3314 error (_("Argument required: name of an overlay section"));
3315
3316 /* First, find a section matching the user supplied argument. */
3318 for (obj_section *sec : objfile->sections ())
3319 if (!strcmp (bfd_section_name (sec->the_bfd_section), args))
3320 {
3321 if (!sec->ovly_mapped)
3322 error (_("Section %s is not mapped"), args);
3323 sec->ovly_mapped = 0;
3324 return;
3325 }
3326 error (_("No overlay section called %s"), args);
3327}
3328
3329/* Function: overlay_auto_command
3330 A utility command to turn on overlay debugging.
3331 Possibly this should be done via a set/show command. */
3332
3333static void
3334overlay_auto_command (const char *args, int from_tty)
3335{
3338 if (info_verbose)
3339 gdb_printf (_("Automatic overlay debugging enabled."));
3340}
3341
3342/* Function: overlay_manual_command
3343 A utility command to turn on overlay debugging.
3344 Possibly this should be done via a set/show command. */
3345
3346static void
3347overlay_manual_command (const char *args, int from_tty)
3348{
3351 if (info_verbose)
3352 gdb_printf (_("Overlay debugging enabled."));
3353}
3354
3355/* Function: overlay_off_command
3356 A utility command to turn on overlay debugging.
3357 Possibly this should be done via a set/show command. */
3358
3359static void
3360overlay_off_command (const char *args, int from_tty)
3361{
3364 if (info_verbose)
3365 gdb_printf (_("Overlay debugging disabled."));
3366}
3367
3368static void
3369overlay_load_command (const char *args, int from_tty)
3370{
3371 struct gdbarch *gdbarch = get_current_arch ();
3372
3375 else
3376 error (_("This target does not know how to read its overlay state."));
3377}
3378
3379/* Command list chain containing all defined "overlay" subcommands. */
3380static struct cmd_list_element *overlaylist;
3381
3382/* Target Overlays for the "Simplest" overlay manager:
3383
3384 This is GDB's default target overlay layer. It works with the
3385 minimal overlay manager supplied as an example by Cygnus. The
3386 entry point is via a function pointer "gdbarch_overlay_update",
3387 so targets that use a different runtime overlay manager can
3388 substitute their own overlay_update function and take over the
3389 function pointer.
3390
3391 The overlay_update function pokes around in the target's data structures
3392 to see what overlays are mapped, and updates GDB's overlay mapping with
3393 this information.
3394
3395 In this simple implementation, the target data structures are as follows:
3396 unsigned _novlys; /# number of overlay sections #/
3397 unsigned _ovly_table[_novlys][4] = {
3398 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3399 {..., ..., ..., ...},
3400 }
3401 unsigned _novly_regions; /# number of overlay regions #/
3402 unsigned _ovly_region_table[_novly_regions][3] = {
3403 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3404 {..., ..., ...},
3405 }
3406 These functions will attempt to update GDB's mappedness state in the
3407 symbol section table, based on the target's mappedness state.
3408
3409 To do this, we keep a cached copy of the target's _ovly_table, and
3410 attempt to detect when the cached copy is invalidated. The main
3411 entry point is "simple_overlay_update(SECT), which looks up SECT in
3412 the cached table and re-reads only the entry for that section from
3413 the target (whenever possible). */
3414
3415/* Cached, dynamically allocated copies of the target data structures: */
3416static unsigned (*cache_ovly_table)[4] = 0;
3417static unsigned cache_novlys = 0;
3418static CORE_ADDR cache_ovly_table_base = 0;
3419enum ovly_index
3422 };
3423
3424/* Throw away the cached copy of _ovly_table. */
3425
3426static void
3428{
3430 cache_novlys = 0;
3431 cache_ovly_table = NULL;
3433}
3434
3435/* Read an array of ints of size SIZE from the target into a local buffer.
3436 Convert to host order. int LEN is number of ints. */
3437
3438static void
3439read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr,
3440 int len, int size, enum bfd_endian byte_order)
3441{
3442 /* FIXME (alloca): Not safe if array is very large. */
3443 gdb_byte *buf = (gdb_byte *) alloca (len * size);
3444 int i;
3445
3446 read_memory (memaddr, buf, len * size);
3447 for (i = 0; i < len; i++)
3448 myaddr[i] = extract_unsigned_integer (size * i + buf, size, byte_order);
3449}
3450
3451/* Find and grab a copy of the target _ovly_table
3452 (and _novlys, which is needed for the table's size). */
3453
3454static int
3456{
3457 struct bound_minimal_symbol novlys_msym;
3458 struct bound_minimal_symbol ovly_table_msym;
3459 struct gdbarch *gdbarch;
3460 int word_size;
3461 enum bfd_endian byte_order;
3462
3464 novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL);
3465 if (! novlys_msym.minsym)
3466 {
3467 error (_("Error reading inferior's overlay table: "
3468 "couldn't find `_novlys' variable\n"
3469 "in inferior. Use `overlay manual' mode."));
3470 return 0;
3471 }
3472
3473 ovly_table_msym = lookup_bound_minimal_symbol ("_ovly_table");
3474 if (! ovly_table_msym.minsym)
3475 {
3476 error (_("Error reading inferior's overlay table: couldn't find "
3477 "`_ovly_table' array\n"
3478 "in inferior. Use `overlay manual' mode."));
3479 return 0;
3480 }
3481
3482 gdbarch = ovly_table_msym.objfile->arch ();
3483 word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3484 byte_order = gdbarch_byte_order (gdbarch);
3485
3487 4, byte_order);
3489 = (unsigned int (*)[4]) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
3490 cache_ovly_table_base = ovly_table_msym.value_address ();
3492 (unsigned int *) cache_ovly_table,
3493 cache_novlys * 4, word_size, byte_order);
3494
3495 return 1; /* SUCCESS */
3496}
3497
3498/* Function: simple_overlay_update_1
3499 A helper function for simple_overlay_update. Assuming a cached copy
3500 of _ovly_table exists, look through it to find an entry whose vma,
3501 lma and size match those of OSECT. Re-read the entry and make sure
3502 it still matches OSECT (else the table may no longer be valid).
3503 Set OSECT's mapped state to match the entry. Return: 1 for
3504 success, 0 for failure. */
3505
3506static int
3508{
3509 int i;
3510 asection *bsect = osect->the_bfd_section;
3511 struct gdbarch *gdbarch = osect->objfile->arch ();
3512 int word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3513 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3514
3515 for (i = 0; i < cache_novlys; i++)
3516 if (cache_ovly_table[i][VMA] == bfd_section_vma (bsect)
3517 && cache_ovly_table[i][LMA] == bfd_section_lma (bsect))
3518 {
3520 (unsigned int *) cache_ovly_table[i],
3521 4, word_size, byte_order);
3522 if (cache_ovly_table[i][VMA] == bfd_section_vma (bsect)
3523 && cache_ovly_table[i][LMA] == bfd_section_lma (bsect))
3524 {
3525 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3526 return 1;
3527 }
3528 else /* Warning! Warning! Target's ovly table has changed! */
3529 return 0;
3530 }
3531 return 0;
3532}
3533
3534/* Function: simple_overlay_update
3535 If OSECT is NULL, then update all sections' mapped state
3536 (after re-reading the entire target _ovly_table).
3537 If OSECT is non-NULL, then try to find a matching entry in the
3538 cached ovly_table and update only OSECT's mapped state.
3539 If a cached entry can't be found or the cache isn't valid, then
3540 re-read the entire cache, and go ahead and update all sections. */
3541
3542void
3543simple_overlay_update (struct obj_section *osect)
3544{
3545 /* Were we given an osect to look up? NULL means do all of them. */
3546 if (osect)
3547 /* Have we got a cached copy of the target's overlay table? */
3548 if (cache_ovly_table != NULL)
3549 {
3550 /* Does its cached location match what's currently in the
3551 symtab? */
3553 = lookup_minimal_symbol ("_ovly_table", NULL, NULL);
3554
3555 if (minsym.minsym == NULL)
3556 error (_("Error reading inferior's overlay table: couldn't "
3557 "find `_ovly_table' array\n"
3558 "in inferior. Use `overlay manual' mode."));
3559
3561 /* Then go ahead and try to look up this single section in
3562 the cache. */
3563 if (simple_overlay_update_1 (osect))
3564 /* Found it! We're done. */
3565 return;
3566 }
3567
3568 /* Cached table no good: need to read the entire table anew.
3569 Or else we want all the sections, in which case it's actually
3570 more efficient to read the whole table in one block anyway. */
3571
3573 return;
3574
3575 /* Now may as well update all sections, even if only one was requested. */
3577 for (obj_section *sect : objfile->sections ())
3578 if (section_is_overlay (sect))
3579 {
3580 int i;
3581 asection *bsect = sect->the_bfd_section;
3582
3583 for (i = 0; i < cache_novlys; i++)
3584 if (cache_ovly_table[i][VMA] == bfd_section_vma (bsect)
3585 && cache_ovly_table[i][LMA] == bfd_section_lma (bsect))
3586 { /* obj_section matches i'th entry in ovly_table. */
3587 sect->ovly_mapped = cache_ovly_table[i][MAPPED];
3588 break; /* finished with inner for loop: break out. */
3589 }
3590 }
3591}
3592
3593/* Default implementation for sym_relocate. */
3594
3595bfd_byte *
3596default_symfile_relocate (struct objfile *objfile, asection *sectp,
3597 bfd_byte *buf)
3598{
3599 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3600 DWO file. */
3601 bfd *abfd = sectp->owner;
3602
3603 /* We're only interested in sections with relocation
3604 information. */
3605 if ((sectp->flags & SEC_RELOC) == 0)
3606 return NULL;
3607
3608 /* We will handle section offsets properly elsewhere, so relocate as if
3609 all sections begin at 0. */
3610 for (asection *sect : gdb_bfd_sections (abfd))
3611 {
3612 sect->output_section = sect;
3613 sect->output_offset = 0;
3614 }
3615
3616 return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
3617}
3618
3619/* Relocate the contents of a debug section SECTP in ABFD. The
3620 contents are stored in BUF if it is non-NULL, or returned in a
3621 malloc'd buffer otherwise.
3622
3623 For some platforms and debug info formats, shared libraries contain
3624 relocations against the debug sections (particularly for DWARF-2;
3625 one affected platform is PowerPC GNU/Linux, although it depends on
3626 the version of the linker in use). Also, ELF object files naturally
3627 have unresolved relocations for their debug sections. We need to apply
3628 the relocations in order to get the locations of symbols correct.
3629 Another example that may require relocation processing, is the
3630 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3631 debug section. */
3632
3633bfd_byte *
3635 asection *sectp, bfd_byte *buf)
3636{
3637 gdb_assert (objfile->sf->sym_relocate);
3638
3639 return (*objfile->sf->sym_relocate) (objfile, sectp, buf);
3640}
3641
3643get_symfile_segment_data (bfd *abfd)
3644{
3645 const struct sym_fns *sf = find_sym_fns (abfd);
3646
3647 if (sf == NULL)
3648 return NULL;
3649
3650 return sf->sym_segments (abfd);
3651}
3652
3653/* Given:
3654 - DATA, containing segment addresses from the object file ABFD, and
3655 the mapping from ABFD's sections onto the segments that own them,
3656 and
3657 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3658 segment addresses reported by the target,
3659 store the appropriate offsets for each section in OFFSETS.
3660
3661 If there are fewer entries in SEGMENT_BASES than there are segments
3662 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3663
3664 If there are more entries, then ignore the extra. The target may
3665 not be able to distinguish between an empty data segment and a
3666 missing data segment; a missing text segment is less plausible. */
3667
3670 const struct symfile_segment_data *data,
3671 section_offsets &offsets,
3672 int num_segment_bases,
3673 const CORE_ADDR *segment_bases)
3674{
3675 int i;
3676 asection *sect;
3677
3678 /* It doesn't make sense to call this function unless you have some
3679 segment base addresses. */
3680 gdb_assert (num_segment_bases > 0);
3681
3682 /* If we do not have segment mappings for the object file, we
3683 can not relocate it by segments. */
3684 gdb_assert (data != NULL);
3685 gdb_assert (data->segments.size () > 0);
3686
3687 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
3688 {
3689 int which = data->segment_info[i];
3690
3691 gdb_assert (0 <= which && which <= data->segments.size ());
3692
3693 /* Don't bother computing offsets for sections that aren't
3694 loaded as part of any segment. */
3695 if (! which)
3696 continue;
3697
3698 /* Use the last SEGMENT_BASES entry as the address of any extra
3699 segments mentioned in DATA->segment_info. */
3700 if (which > num_segment_bases)
3701 which = num_segment_bases;
3702
3703 offsets[i] = segment_bases[which - 1] - data->segments[which - 1].base;
3704 }
3705
3706 return 1;
3707}
3708
3709static void
3711{
3712 bfd *abfd = objfile->obfd.get ();
3713 int i;
3714 asection *sect;
3715
3717 if (data == NULL)
3718 return;
3719
3720 if (data->segments.size () != 1 && data->segments.size () != 2)
3721 return;
3722
3723 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
3724 {
3725 int which = data->segment_info[i];
3726
3727 if (which == 1)
3728 {
3729 if (objfile->sect_index_text == -1)
3730 objfile->sect_index_text = sect->index;
3731
3732 if (objfile->sect_index_rodata == -1)
3733 objfile->sect_index_rodata = sect->index;
3734 }
3735 else if (which == 2)
3736 {
3737 if (objfile->sect_index_data == -1)
3738 objfile->sect_index_data = sect->index;
3739
3740 if (objfile->sect_index_bss == -1)
3741 objfile->sect_index_bss = sect->index;
3742 }
3743 }
3744}
3745
3746/* Listen for free_objfile events. */
3747
3748static void
3750{
3751 /* Remove the target sections owned by this objfile. */
3753}
3754
3755/* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3756 Expand all symtabs that match the specified criteria.
3757 See quick_symbol_functions.expand_symtabs_matching for details. */
3758
3759bool
3761 (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
3762 const lookup_name_info &lookup_name,
3763 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
3764 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
3765 block_search_flags search_flags,
3766 enum search_domain kind)
3767{
3769 if (!objfile->expand_symtabs_matching (file_matcher,
3770 &lookup_name,
3771 symbol_matcher,
3772 expansion_notify,
3773 search_flags,
3775 kind))
3776 return false;
3777 return true;
3778}
3779
3780/* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3781 Map function FUN over every file.
3782 See quick_symbol_functions.map_symbol_filenames for details. */
3783
3784void
3785map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun,
3786 bool need_fullname)
3787{
3789 objfile->map_symbol_filenames (fun, need_fullname);
3790}
3791
3792#if GDB_SELF_TEST
3793
3794namespace selftests {
3795namespace filename_language {
3796
3797static void test_filename_language ()
3798{
3799 /* This test messes up the filename_language_table global. */
3800 scoped_restore restore_flt = make_scoped_restore (&filename_language_table);
3801
3802 /* Test deducing an unknown extension. */
3803 language lang = deduce_language_from_filename ("myfile.blah");
3804 SELF_CHECK (lang == language_unknown);
3805
3806 /* Test deducing a known extension. */
3807 lang = deduce_language_from_filename ("myfile.c");
3808 SELF_CHECK (lang == language_c);
3809
3810 /* Test adding a new extension using the internal API. */
3812 lang = deduce_language_from_filename ("myfile.blah");
3813 SELF_CHECK (lang == language_pascal);
3814}
3815
3816static void
3817test_set_ext_lang_command ()
3818{
3819 /* This test messes up the filename_language_table global. */
3820 scoped_restore restore_flt = make_scoped_restore (&filename_language_table);
3821
3822 /* Confirm that the .hello extension is not known. */
3823 language lang = deduce_language_from_filename ("cake.hello");
3824 SELF_CHECK (lang == language_unknown);
3825
3826 /* Test adding a new extension using the CLI command. */
3827 ext_args = ".hello rust";
3828 set_ext_lang_command (NULL, 1, NULL);
3829
3830 lang = deduce_language_from_filename ("cake.hello");
3831 SELF_CHECK (lang == language_rust);
3832
3833 /* Test overriding an existing extension using the CLI command. */
3834 int size_before = filename_language_table.size ();
3835 ext_args = ".hello pascal";
3836 set_ext_lang_command (NULL, 1, NULL);
3837 int size_after = filename_language_table.size ();
3838
3839 lang = deduce_language_from_filename ("cake.hello");
3840 SELF_CHECK (lang == language_pascal);
3841 SELF_CHECK (size_before == size_after);
3842}
3843
3844} /* namespace filename_language */
3845} /* namespace selftests */
3846
3847#endif /* GDB_SELF_TEST */
3848
3849void _initialize_symfile ();
3850void
3852{
3853 struct cmd_list_element *c;
3854
3856
3857#define READNOW_READNEVER_HELP \
3858 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3859immediately. This makes the command slower, but may make future operations\n\
3860faster.\n\
3861The '-readnever' option will prevent GDB from reading the symbol file's\n\
3862symbolic debug information."
3863
3864 c = add_cmd ("symbol-file", class_files, symbol_file_command, _("\
3865Load symbol table from executable file FILE.\n\
3866Usage: symbol-file [-readnow | -readnever] [-o OFF] FILE\n\
3867OFF is an optional offset which is added to each section address.\n\
3868The `file' command can also load symbol tables, as well as setting the file\n\
3869to execute.\n" READNOW_READNEVER_HELP), &cmdlist);
3871
3872 c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command, _("\
3873Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3874Usage: add-symbol-file FILE [-readnow | -readnever] [-o OFF] [ADDR] \
3875[-s SECT-NAME SECT-ADDR]...\n\
3876ADDR is the starting address of the file's text.\n\
3877Each '-s' argument provides a section name and address, and\n\
3878should be specified if the data and bss segments are not contiguous\n\
3879with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n\
3880OFF is an optional offset which is added to the default load addresses\n\
3881of all sections for which no other address was specified.\n"
3883 &cmdlist);
3885
3886 c = add_cmd ("remove-symbol-file", class_files,
3888Remove a symbol file added via the add-symbol-file command.\n\
3889Usage: remove-symbol-file FILENAME\n\
3890 remove-symbol-file -a ADDRESS\n\
3891The file to remove can be identified by its filename or by an address\n\
3892that lies within the boundaries of this symbol file in memory."),
3893 &cmdlist);
3894
3895 c = add_cmd ("load", class_files, load_command, _("\
3896Dynamically load FILE into the running program.\n\
3897FILE symbols are recorded for access from GDB.\n\
3898Usage: load [FILE] [OFFSET]\n\
3899An optional load OFFSET may also be given as a literal address.\n\
3900When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3901on its own."), &cmdlist);
3903
3904 cmd_list_element *overlay_cmd
3905 = add_basic_prefix_cmd ("overlay", class_support,
3906 _("Commands for debugging overlays."), &overlaylist,
3907 0, &cmdlist);
3908
3909 add_com_alias ("ovly", overlay_cmd, class_support, 1);
3910 add_com_alias ("ov", overlay_cmd, class_support, 1);
3911
3912 add_cmd ("map-overlay", class_support, map_overlay_command,
3913 _("Assert that an overlay section is mapped."), &overlaylist);
3914
3915 add_cmd ("unmap-overlay", class_support, unmap_overlay_command,
3916 _("Assert that an overlay section is unmapped."), &overlaylist);
3917
3918 add_cmd ("list-overlays", class_support, list_overlays_command,
3919 _("List mappings of overlay sections."), &overlaylist);
3920
3922 _("Enable overlay debugging."), &overlaylist);
3924 _("Disable overlay debugging."), &overlaylist);
3926 _("Enable automatic overlay debugging."), &overlaylist);
3928 _("Read the overlay mapping state from the target."), &overlaylist);
3929
3930 /* Filename extension to source language lookup table: */
3931 add_setshow_string_noescape_cmd ("extension-language", class_files,
3932 &ext_args, _("\
3933Set mapping between filename extension and source language."), _("\
3934Show mapping between filename extension and source language."), _("\
3935Usage: set extension-language .foo bar"),
3938 &setlist, &showlist);
3939
3940 add_info ("extensions", info_ext_lang_command,
3941 _("All filename extensions associated with a source language."));
3942
3943 add_setshow_optional_filename_cmd ("debug-file-directory", class_support,
3945Set the directories where separate debug symbols are searched for."), _("\
3946Show the directories where separate debug symbols are searched for."), _("\
3947Separate debug symbols are first searched for in the same\n\
3948directory as the binary, then in the `" DEBUG_SUBDIRECTORY "' subdirectory,\n\
3949and lastly at the path of the directory of the binary with\n\
3950each global debug-file-directory component prepended."),
3951 NULL,
3953 &setlist, &showlist);
3954
3955 add_setshow_enum_cmd ("symbol-loading", no_class,
3957 _("\
3958Set printing of symbol loading messages."), _("\
3959Show printing of symbol loading messages."), _("\
3960off == turn all messages off\n\
3961brief == print messages for the executable,\n\
3962 and brief messages for shared libraries\n\
3963full == print messages for the executable,\n\
3964 and messages for each shared library."),
3965 NULL,
3966 NULL,
3968
3969 add_setshow_boolean_cmd ("separate-debug-file", no_class,
3971Set printing of separate debug info file search debug."), _("\
3972Show printing of separate debug info file search debug."), _("\
3973When on, GDB prints the searched locations while looking for separate debug \
3974info files."), NULL, NULL, &setdebuglist, &showdebuglist);
3975
3976#if GDB_SELF_TEST
3977 selftests::register_test
3978 ("filename_language", selftests::filename_language::test_filename_language);
3979 selftests::register_test
3980 ("set_ext_lang_command",
3981 selftests::filename_language::test_set_ext_lang_command);
3982#endif
3983}
const char *const name
void * xmalloc(YYSIZE_T)
void xfree(void *)
struct gdbarch * get_current_arch(void)
Definition arch-utils.c:846
struct gdbarch * target_gdbarch(void)
void clear_pc_function_cache(void)
Definition blockframe.c:201
void breakpoint_re_set(void)
void disable_overlay_breakpoints(void)
void enable_overlay_breakpoints(void)
void clear_displays(void)
Definition printcmd.c:2023
ui_file_style style() const
Definition cli-style.c:169
symfile_add_flags symfile_flags
Definition inferior.h:644
void clear_registry()
Definition registry.h:168
void field_core_addr(const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition ui-out.c:478
void text(const char *string)
Definition ui-out.c:566
bool is_mi_like_p() const
Definition ui-out.c:810
void field_unsigned(const char *fldname, ULONGEST value)
Definition ui-out.c:464
struct cmd_list_element * showlist
Definition cli-cmds.c:127
struct cmd_list_element * showprintlist
Definition cli-cmds.c:163
void error_no_arg(const char *why)
Definition cli-cmds.c:206
struct cmd_list_element * cmdlist
Definition cli-cmds.c:87
struct cmd_list_element * setprintlist
Definition cli-cmds.c:161
struct cmd_list_element * setlist
Definition cli-cmds.c:119
struct cmd_list_element * showdebuglist
Definition cli-cmds.c:167
struct cmd_list_element * setdebuglist
Definition cli-cmds.c:165
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
cmd_list_element * add_com_alias(const char *name, cmd_list_element *target, command_class theclass, int abbrev_flag)
set_show_commands add_setshow_optional_filename_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition cli-decode.c:117
set_show_commands add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:688
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:809
set_show_commands add_setshow_string_noescape_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:953
struct cmd_list_element * add_basic_prefix_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition cli-decode.c:391
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
cli_style_option file_name_style
void dont_repeat()
Definition top.c:696
@ class_support
Definition command.h:58
@ class_files
Definition command.h:57
@ no_class
Definition command.h:53
void clear_complaints()
Definition complaints.c:74
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition completer.c:204
void reopen_exec_file(void)
Definition corefile.c:106
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition corefile.c:238
const char * get_exec_file(int err)
Definition corefile.c:150
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:296
const char * gnutarget
Definition corefile.c:405
int check_quit_flag(void)
Definition extension.c:857
#define O_BINARY
Definition defs.h:114
bool info_verbose
Definition top.c:1941
language
Definition defs.h:211
@ language_unknown
Definition defs.h:212
@ language_pascal
Definition defs.h:222
@ language_rust
Definition defs.h:215
@ language_c
Definition defs.h:213
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
std::string gdb_sysroot
Definition main.c:64
CORE_ADDR parse_and_eval_address(const char *exp)
Definition eval.c:52
void exec_set_section_address(const char *filename, int index, CORE_ADDR address)
Definition exec.c:1030
void reinit_frame_cache(void)
Definition frame.c:2107
int gdb_bfd_crc(struct bfd *abfd, unsigned long *crc_out)
Definition gdb_bfd.c:842
int gdb_bfd_section_index(bfd *abfd, asection *section)
Definition gdb_bfd.c:984
int gdb_bfd_count_sections(bfd *abfd)
Definition gdb_bfd.c:1002
int is_target_filename(const char *name)
Definition gdb_bfd.c:207
gdb_bfd_ref_ptr gdb_bfd_open(const char *name, const char *target, int fd, bool warn_if_slow)
Definition gdb_bfd.c:473
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
Definition gdb_bfd.h:79
static gdb_bfd_section_range gdb_bfd_sections(bfd *abfd)
Definition gdb_bfd.h:234
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
bfd * obfd
bool gdbarch_overlay_update_p(struct gdbarch *gdbarch)
Definition gdbarch.c:4283
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition gdbarch.c:3152
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1466
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition gdbarch.c:3135
void gdbarch_overlay_update(struct gdbarch *gdbarch, struct obj_section *osect)
Definition gdbarch.c:4290
mach_port_t notify
Definition gnu-nat.c:1778
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition gnu-nat.c:1789
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition gnu-nat.c:1861
size_t size
Definition go32-nat.c:239
struct inferior * current_inferior(void)
Definition inferior.c:55
enum language language_enum(const char *str)
Definition language.c:427
static void set_language(const char *language)
Definition language.c:140
const char * language_str(enum language lang)
Definition language.c:449
const struct language_defn * current_language
Definition language.c:82
const struct language_defn * expected_language
Definition language.c:88
language_mode
Definition language.h:717
@ language_mode_manual
Definition language.h:718
static void validate_readnow_readnever()
Definition main.c:550
gdb_bfd_ref_ptr find_separate_debug_file_in_section(struct objfile *objfile)
Definition minidebug.c:226
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
struct bound_minimal_symbol lookup_bound_minimal_symbol(const char *name)
Definition minsyms.c:481
observable< struct objfile * > free_objfile
observable< struct objfile * > new_objfile
observable< program_space * > all_objfiles_removed
@ OBJF_USERLOADED
@ OBJF_READNEVER
@ OBJF_SHARED
@ OBJF_NOT_FILENAME
@ OBJF_MAINLINE
@ OBJF_READNOW
void objfiles_changed(void)
Definition objfiles.c:1188
int objfile_has_symbols(struct objfile *objfile)
Definition objfiles.c:749
void objfile_relocate(struct objfile *objfile, const section_offsets &new_offsets)
Definition objfiles.c:676
bool is_addr_in_objfile(CORE_ADDR addr, const struct objfile *objfile)
Definition objfiles.c:1206
void objfile_rebase(struct objfile *objfile, CORE_ADDR slide)
Definition objfiles.c:725
int have_partial_symbols(void)
Definition objfiles.c:763
void free_objfile_separate_debug(struct objfile *objfile)
Definition objfiles.c:477
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1259
int have_full_symbols(void)
Definition objfiles.c:778
void build_objfile_section_table(struct objfile *objfile)
Definition objfiles.c:278
void set_objfile_per_bfd(struct objfile *objfile)
Definition objfiles.c:119
void objfile_set_sym_fns(struct objfile *objfile, const struct sym_fns *sf)
#define SECT_OFF_TEXT(objfile)
Definition objfiles.h:139
std::unique_ptr< objfile, objfile_deleter > objfile_up
Definition objfiles.h:899
struct program_space * current_program_space
Definition progspace.c:40
int value
Definition py-param.c:79
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition regcache.c:1377
struct regcache * get_current_regcache(void)
Definition regcache.c:429
int rate
Definition ser-unix.c:242
void solib_create_inferior_hook(int from_tty)
Definition solib.c:1252
void no_shared_libraries(const char *ignored, int from_tty)
Definition solib.c:1284
int openp(const char *path, openp_flags opts, const char *string, int mode, gdb::unique_xmalloc_ptr< char > *filename_opened)
Definition source.c:772
void clear_current_source_symtab_and_line(void)
Definition source.c:302
void forget_cached_source_info(void)
Definition source.c:417
@ OPF_TRY_CWD_FIRST
Definition source.h:30
@ OPF_RETURN_REALPATH
Definition source.h:32
void clear_last_displayed_sal(void)
Definition stack.c:1188
struct symbol * symbol
Definition symtab.h:1533
struct objfile * objfile
Definition minsyms.h:54
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
struct compunit_symtab * next
Definition symtab.h:1911
const char * name
Definition symtab.h:1919
void add_filetab(symtab *filetab)
Definition symtab.h:1803
void set_objfile(struct objfile *objfile)
Definition symtab.h:1793
void set_debugformat(const char *debugformat)
Definition symtab.h:1822
struct objfile * objfile() const
Definition symtab.h:1788
void warn(const char *format,...) ATTRIBUTE_PRINTF(2
CORE_ADDR entry_point
Definition objfiles.h:117
unsigned initialized
Definition objfiles.h:126
int the_bfd_section_index
Definition objfiles.h:120
unsigned entry_point_p
Definition objfiles.h:123
std::string ext
Definition symfile.c:2706
enum language lang
Definition symfile.c:2707
filename_language(const std::string &ext_, enum language lang_)
Definition symfile.c:2702
enum language language() const
Definition symtab.h:502
unsigned long data_count
Definition symfile.c:1893
unsigned long write_count
Definition symfile.c:1892
bfd_size_type total_size
Definition symfile.c:1894
load_progress_section_data(load_progress_data *cumulative_, const char *section_name_, ULONGEST section_size_, CORE_ADDR lma_, gdb_byte *buffer_)
Definition symfile.c:1900
struct load_progress_data * cumulative
Definition symfile.c:1907
const char * section_name
Definition symfile.c:1910
CORE_ADDR load_offset
Definition symfile.c:1933
load_section_data(load_progress_data *progress_data_)
Definition symfile.c:1920
struct load_progress_data * progress_data
Definition symfile.c:1934
std::vector< struct memory_write_request > requests
Definition symfile.c:1935
CORE_ADDR value_address(objfile *objfile) const
Definition symtab.c:439
CORE_ADDR addr() const
Definition objfiles.h:385
CORE_ADDR endaddr() const
Definition objfiles.h:392
struct objfile * objfile
Definition objfiles.h:401
int ovly_mapped
Definition objfiles.h:404
CORE_ADDR offset() const
Definition objfiles.h:903
struct bfd_section * the_bfd_section
Definition objfiles.h:398
struct obj_section * sections_start
Definition objfiles.h:812
const char * original_name
Definition objfiles.h:718
iterator_range< section_iterator > sections()
Definition objfiles.h:685
int sect_index_rodata
Definition objfiles.h:801
const struct sym_fns * sf
Definition objfiles.h:768
struct compunit_symtab * compunit_symtabs
Definition objfiles.h:733
struct objfile * separate_debug_objfile_backlink
Definition objfiles.h:830
struct program_space * pspace
Definition objfiles.h:728
struct objfile * separate_debug_objfile
Definition objfiles.h:825
registry< objfile > registry_fields
Definition objfiles.h:776
int sect_index_bss
Definition objfiles.h:800
int sect_index_data
Definition objfiles.h:799
struct gdbarch * arch() const
Definition objfiles.h:507
struct objfile_per_bfd_storage * per_bfd
Definition objfiles.h:744
bool expand_symtabs_matching(gdb::function_view< expand_symtabs_file_matcher_ftype > file_matcher, const lookup_name_info *lookup_name, gdb::function_view< expand_symtabs_symbol_matcher_ftype > symbol_matcher, gdb::function_view< expand_symtabs_exp_notify_ftype > expansion_notify, block_search_flags search_flags, domain_enum domain, enum search_domain kind)
static objfile * make(gdb_bfd_ref_ptr bfd_, const char *name_, objfile_flags flags_, objfile *parent=nullptr)
Definition objfiles.c:449
objfile(gdb_bfd_ref_ptr, const char *, objfile_flags)
Definition objfiles.c:313
htab_up static_links
Definition objfiles.h:859
gdb_bfd_ref_ptr obfd
Definition objfiles.h:740
void expand_all_symtabs()
void require_partial_symbols(bool verbose)
const char * intern(const char *str)
Definition objfiles.h:494
objfile_flags flags
Definition objfiles.h:724
int sect_index_text
Definition objfiles.h:798
auto_obstack objfile_obstack
Definition objfiles.h:760
std::forward_list< quick_symbol_functions_up > qf
Definition objfiles.h:772
struct symbol * template_symbols
Definition objfiles.h:846
::section_offsets section_offsets
Definition objfiles.h:786
void map_symbol_filenames(gdb::function_view< symbol_filename_ftype > fun, bool need_fullname)
void unlink()
Definition objfiles.c:468
bool has_partial_symbols()
long mtime
Definition objfiles.h:755
std::string name
Definition symfile.h:59
CORE_ADDR addr
Definition symfile.h:58
void remove_target_sections(void *owner)
Definition exec.c:654
void add_target_sections(void *owner, const target_section_table &sections)
Definition exec.c:602
objfiles_range objfiles()
Definition progspace.h:209
struct objfile * symfile_object_file
Definition progspace.h:357
void free_all_objfiles()
Definition progspace.c:131
registered_sym_fns(bfd_flavour sym_flavour_, const struct sym_fns *sym_fns_)
Definition symfile.c:120
const struct sym_fns * sym_fns
Definition symfile.c:128
enum bfd_flavour sym_flavour
Definition symfile.c:125
bfd_byte *(* sym_relocate)(struct objfile *, asection *sectp, bfd_byte *buf)
Definition symfile.h:171
void(* sym_read)(struct objfile *, symfile_add_flags)
Definition symfile.h:138
void(* sym_new_init)(struct objfile *)
Definition symfile.h:125
void(* sym_init)(struct objfile *)
Definition symfile.h:131
symfile_segment_data_up(* sym_segments)(bfd *abfd)
Definition symfile.h:159
void(* sym_offsets)(struct objfile *, const section_addr_info &)
Definition symfile.h:153
void(* sym_finish)(struct objfile *)
Definition symfile.h:144
const char * filename_for_id
Definition symtab.h:1735
char * fullname
Definition symtab.h:1744
void set_language(enum language language)
Definition symtab.h:1702
const char * filename
Definition symtab.h:1725
void set_compunit(struct compunit_symtab *compunit)
Definition symtab.h:1682
Definition value.h:130
symfile_add_flag
@ SYMFILE_NO_READ
@ SYMFILE_MAINLINE
@ SYMFILE_NOT_FILENAME
@ SYMFILE_VERBOSE
@ SYMFILE_DEFER_BP_RESET
@ SYMFILE_ALWAYS_CONFIRM
static int separate_debug_file_exists(const std::string &name, unsigned long crc, struct objfile *parent_objfile, deferred_warnings *warnings)
Definition symfile.c:1238
static void add_symbol_file_command(const char *args, int from_tty)
Definition symfile.c:2226
gdb_bfd_ref_ptr symfile_bfd_open(const char *name)
Definition symfile.c:1724
static std::vector< registered_sym_fns > symtab_fns
Definition symfile.c:131
bool separate_debug_file_debug
Definition symfile.c:1235
static std::string find_separate_debug_file(const char *dir, const char *canon_dir, const char *debuglink, unsigned long crc32, struct objfile *objfile, deferred_warnings *warnings)
Definition symfile.c:1384
void add_filename_language(const char *ext, enum language lang)
Definition symfile.c:2715
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition symfile.c:3174
enum language deduce_language_from_filename(const char *filename)
Definition symfile.c:2802
static void map_overlay_command(const char *args, int from_tty)
Definition symfile.c:3261
static CORE_ADDR cache_ovly_table_base
Definition symfile.c:3417
void(* deprecated_post_add_symbol_hook)(void)
Definition symfile.c:80
static void overlay_manual_command(const char *args, int from_tty)
Definition symfile.c:3346
static void find_lowest_section(asection *sect, asection **lowest)
Definition symfile.c:201
static void remove_symbol_file_command(const char *args, int from_tty)
Definition symfile.c:2383
static const struct sym_fns * find_sym_fns(bfd *)
Definition symfile.c:1815
bfd_byte * symfile_relocate_debug_section(struct objfile *objfile, asection *sectp, bfd_byte *buf)
Definition symfile.c:3633
static void place_section(bfd *abfd, asection *sect, section_offsets &offsets, CORE_ADDR &lowest)
Definition symfile.c:340
static void list_overlays_command(const char *args, int from_tty)
Definition symfile.c:3220
void add_symtab_fns(enum bfd_flavour flavour, const struct sym_fns *sf)
Definition symfile.c:1804
int get_section_index(struct objfile *objfile, const char *section_name)
Definition symfile.c:1787
CORE_ADDR overlay_unmapped_address(CORE_ADDR pc, struct obj_section *section)
Definition symfile.c:3108
section_addr_info build_section_addr_info_from_objfile(const struct objfile *objfile)
Definition symfile.c:257
std::string debug_file_directory
Definition symfile.c:1354
int section_is_mapped(struct obj_section *osect)
Definition symfile.c:3019
ovly_index
Definition symfile.c:3419
@ OSIZE
Definition symfile.c:3420
@ VMA
Definition symfile.c:3420
@ MAPPED
Definition symfile.c:3420
@ LMA
Definition symfile.c:3420
std::string find_separate_debug_file_by_debuglink(struct objfile *objfile, deferred_warnings *warnings)
Definition symfile.c:1534
static const char * print_symbol_loading_enums[]
Definition symfile.c:138
static void finish_new_objfile(struct objfile *objfile, symfile_add_flags add_flags)
Definition symfile.c:991
void symbol_file_clear(int from_tty)
Definition symfile.c:1210
void add_compunit_symtab_to_objfile(struct compunit_symtab *cu)
Definition symfile.c:2894
void _initialize_symfile()
Definition symfile.c:3850
static std::vector< const struct other_sections * > addrs_section_sort(const section_addr_info &addrs)
Definition symfile.c:465
bool auto_solib_add
Definition symfile.c:149
static section_addr_info build_section_addr_info_from_bfd(bfd *abfd)
Definition symfile.c:240
void symbol_file_command(const char *args, int from_tty)
Definition symfile.c:1614
int readnow_symbol_files
Definition symfile.c:88
static void symfile_free_objfile(struct objfile *objfile)
Definition symfile.c:3748
const char print_symbol_loading_brief[]
Definition symfile.c:136
static void load_one_section(bfd *abfd, asection *asec, struct load_section_data *args)
Definition symfile.c:2005
static void overlay_load_command(const char *args, int from_tty)
Definition symfile.c:3368
bool pc_in_unmapped_range(CORE_ADDR pc, struct obj_section *section)
Definition symfile.c:3055
static int simple_read_overlay_table(void)
Definition symfile.c:3454
static void terminate_after_last_dir_separator(char *path)
Definition symfile.c:1516
static const char * addr_section_name(const char *s)
Definition symfile.c:434
static void overlay_off_command(const char *args, int from_tty)
Definition symfile.c:3359
void reread_symbols(int from_tty)
Definition symfile.c:2457
#define DEBUG_SUBDIRECTORY
Definition symfile.c:1366
void symbol_file_add_main(const char *args, symfile_add_flags add_flags)
Definition symfile.c:1186
void set_initial_language(void)
Definition symfile.c:1690
section_addr_info build_section_addr_info_from_section_table(const target_section_table &table)
Definition symfile.c:218
static void symbol_file_add_main_1(const char *args, symfile_add_flags add_flags, objfile_flags flags, CORE_ADDR reloff)
Definition symfile.c:1192
CORE_ADDR overlay_mapped_address(CORE_ADDR pc, struct obj_section *section)
Definition symfile.c:3126
static void show_debug_file_directory(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition symfile.c:1356
void default_symfile_offsets(struct objfile *objfile, const section_addr_info &addrs)
Definition symfile.c:625
static struct objfile * symbol_file_add_with_addrs(const gdb_bfd_ref_ptr &abfd, const char *name, symfile_add_flags add_flags, section_addr_info *addrs, objfile_flags flags, struct objfile *parent)
Definition symfile.c:1033
static void print_transfer_performance(struct ui_file *stream, unsigned long data_count, unsigned long write_count, std::chrono::steady_clock::duration d)
Definition symfile.c:2123
struct obj_section * find_pc_mapped_section(CORE_ADDR pc)
Definition symfile.c:3203
int print_symbol_loading_p(int from_tty, int exec, int full)
Definition symfile.c:161
bool expand_symtabs_matching(gdb::function_view< expand_symtabs_file_matcher_ftype > file_matcher, const lookup_name_info &lookup_name, gdb::function_view< expand_symtabs_symbol_matcher_ftype > symbol_matcher, gdb::function_view< expand_symtabs_exp_notify_ftype > expansion_notify, block_search_flags search_flags, enum search_domain kind)
Definition symfile.c:3760
void(* deprecated_show_load_progress)(const char *section, unsigned long section_sent, unsigned long section_size, unsigned long total_sent, unsigned long total_size)
Definition symfile.c:74
struct symtab * allocate_symtab(struct compunit_symtab *cust, const char *filename, const char *filename_for_id)
Definition symfile.c:2821
static void simple_free_overlay_table(void)
Definition symfile.c:3426
const char print_symbol_loading_off[]
Definition symfile.c:135
int readnever_symbol_files
Definition symfile.c:92
void generic_load(const char *args, int from_tty)
Definition symfile.c:2037
static unsigned(* cache_ovly_table)[4]
Definition symfile.c:3415
void addr_info_make_relative(section_addr_info *addrs, bfd *abfd)
Definition symfile.c:483
struct compunit_symtab * allocate_compunit_symtab(struct objfile *objfile, const char *name)
Definition symfile.c:2868
int(* deprecated_ui_load_progress_hook)(const char *section, unsigned long num)
Definition symfile.c:72
int overlay_cache_invalid
Definition symfile.c:2976
static void init_entry_point_info(struct objfile *objfile)
Definition symfile.c:799
static const char * print_symbol_loading
Definition symfile.c:145
static void overlay_auto_command(const char *args, int from_tty)
Definition symfile.c:3333
FORWARD_SCOPE_EXIT(clear_symtab_users) clear_symtab_users_cleanup
Definition symfile.c:82
symfile_segment_data_up get_symfile_segment_data(bfd *abfd)
Definition symfile.c:3642
void relative_addr_info_to_section_offsets(section_offsets &section_offsets, const section_addr_info &addrs)
Definition symfile.c:404
int symfile_map_offsets_to_segments(bfd *abfd, const struct symfile_segment_data *data, section_offsets &offsets, int num_segment_bases, const CORE_ADDR *segment_bases)
Definition symfile.c:3668
symfile_segment_data_up default_symfile_segments(bfd *abfd)
Definition symfile.c:711
static void load_progress(ULONGEST bytes, void *untyped_arg)
Definition symfile.c:1941
static int simple_overlay_update_1(struct obj_section *)
Definition symfile.c:3506
void simple_overlay_update(struct obj_section *osect)
Definition symfile.c:3542
static bool addrs_section_compar(const struct other_sections *a, const struct other_sections *b)
Definition symfile.c:449
static std::vector< filename_language > filename_language_table
Definition symfile.c:2710
void(* deprecated_pre_add_symbol_hook)(const char *)
Definition symfile.c:79
static std::string ext_args
Definition symfile.c:2721
bool pc_in_mapped_range(CORE_ADDR pc, struct obj_section *section)
Definition symfile.c:3077
static void show_ext_args(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition symfile.c:2723
static void set_ext_lang_command(const char *args, int from_tty, struct cmd_list_element *e)
Definition symfile.c:2733
void map_symbol_filenames(gdb::function_view< symbol_filename_ftype > fun, bool need_fullname)
Definition symfile.c:3784
void symbol_file_add_separate(const gdb_bfd_ref_ptr &bfd, const char *name, symfile_add_flags symfile_flags, struct objfile *objfile)
Definition symfile.c:1134
struct objfile * symbol_file_add_from_bfd(const gdb_bfd_ref_ptr &abfd, const char *name, symfile_add_flags add_flags, section_addr_info *addrs, objfile_flags flags, struct objfile *parent)
Definition symfile.c:1155
gdb_bfd_ref_ptr symfile_bfd_open_no_error(const char *name) noexcept
Definition symfile.c:1769
static void set_objfile_default_section_offset(struct objfile *objf, const section_addr_info &addrs, CORE_ADDR offset)
Definition symfile.c:2172
int section_is_overlay(struct obj_section *section)
Definition symfile.c:2983
struct objfile * symbol_file_add(const char *name, symfile_add_flags add_flags, section_addr_info *addrs, objfile_flags flags)
Definition symfile.c:1168
static unsigned cache_novlys
Definition symfile.c:3416
static void read_symbols(struct objfile *objfile, symfile_add_flags add_flags)
Definition symfile.c:769
enum overlay_debugging_state overlay_debugging
Definition symfile.c:2975
static void info_ext_lang_command(const char *args, int from_tty)
Definition symfile.c:2792
static void init_objfile_sect_indices(struct objfile *objfile)
Definition symfile.c:278
#define READNOW_READNEVER_HELP
static int validate_download
Definition symfile.c:1886
static struct cmd_list_element * overlaylist
Definition symfile.c:3379
static void symfile_find_segment_sections(struct objfile *objfile)
Definition symfile.c:3709
static void read_target_long_array(CORE_ADDR, unsigned int *, int, int, enum bfd_endian)
Definition symfile.c:3438
int currently_reading_symtab
Definition symfile.c:179
static void syms_from_objfile_1(struct objfile *objfile, section_addr_info *addrs, symfile_add_flags add_flags)
Definition symfile.c:893
const char print_symbol_loading_full[]
Definition symfile.c:137
CORE_ADDR symbol_overlayed_address(CORE_ADDR address, struct obj_section *section)
Definition symfile.c:3144
static int sections_overlap(struct obj_section *a, struct obj_section *b)
Definition symfile.c:3093
static void load_command(const char *arg, int from_tty)
Definition symfile.c:1836
void clear_symtab_users(symfile_add_flags add_flags)
Definition symfile.c:2905
scoped_restore_tmpl< int > increment_reading_symtab(void)
Definition symfile.c:185
bfd_byte * default_symfile_relocate(struct objfile *objfile, asection *sectp, bfd_byte *buf)
Definition symfile.c:3595
static void unmap_overlay_command(const char *args, int from_tty)
Definition symfile.c:3305
static void overlay_invalidate_all(void)
Definition symfile.c:3001
static void syms_from_objfile(struct objfile *objfile, section_addr_info *addrs, symfile_add_flags add_flags)
Definition symfile.c:978
std::unique_ptr< symfile_segment_data > symfile_segment_data_up
Definition symfile.h:104
std::vector< other_sections > section_addr_info
Definition symfile.h:74
overlay_debugging_state
Definition symfile.h:293
@ ovly_auto
Definition symfile.h:296
@ ovly_on
Definition symfile.h:295
@ ovly_off
Definition symfile.h:294
struct block_symbol lookup_symbol_in_language(const char *name, const struct block *block, const domain_enum domain, enum language lang, struct field_of_this_result *is_a_field_of_this)
Definition symtab.c:1946
const char * main_name()
Definition symtab.c:6322
enum language main_language(void)
Definition symtab.c:6336
unsigned int symtab_create_debug
Definition symtab.c:254
search_domain
Definition symtab.h:945
#define symtab_create_debug_printf_v(fmt,...)
Definition symtab.h:2689
@ VAR_DOMAIN
Definition symtab.h:910
@ UNDEF_DOMAIN
Definition symtab.h:905
std::vector< CORE_ADDR > section_offsets
Definition symtab.h:1669
int target_write_memory_blocks(const std::vector< memory_write_request > &requests, enum flash_preserve_mode preserve_flash_p, void(*progress_cb)(ULONGEST, void *))
std::vector< target_section > target_section_table
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
void target_load(const char *arg, int from_tty)
Definition target.c:928
@ flash_discard
Definition target.h:1626
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
Definition ui-out.h:151
#define current_uiout
Definition ui-out.h:40
int query(const char *ctlstr,...)
Definition utils.c:943
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3166
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void gdb_flush(struct ui_file *stream)
Definition utils.c:1498
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1809
#define gdb_stdlog
Definition utils.h:190
#define gdb_stdout
Definition utils.h:182
void preserve_values(struct objfile *objfile)
Definition value.c:2441
void varobj_re_set(void)
Definition varobj.c:2358
static void check(BOOL ok, const char *file, int line)