GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/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" /* for DOSish file names */
42#include "gdb-stabs.h"
43#include "gdbsupport/gdb_obstack.h"
44#include "completer.h"
45#include "bcache.h"
46#include "hashtab.h"
47#include "readline/tilde.h"
48#include "block.h"
49#include "observable.h"
50#include "exec.h"
51#include "parser-defs.h"
52#include "varobj.h"
53#include "elf-bfd.h"
54#include "solib.h"
55#include "remote.h"
56#include "stack.h"
57#include "gdb_bfd.h"
58#include "cli/cli-utils.h"
59#include "gdbsupport/byte-vector.h"
60#include "gdbsupport/pathstuff.h"
61#include "gdbsupport/selftest.h"
62#include "cli/cli-style.h"
63#include "gdbsupport/forward-scope-exit.h"
64#include "gdbsupport/buildargv.h"
65
66#include <sys/types.h>
67#include <fcntl.h>
68#include <sys/stat.h>
69#include <ctype.h>
70#include <chrono>
71#include <algorithm>
72
73int (*deprecated_ui_load_progress_hook) (const char *section,
74 unsigned long num);
75void (*deprecated_show_load_progress) (const char *section,
76 unsigned long section_sent,
77 unsigned long section_size,
78 unsigned long total_sent,
79 unsigned long total_size);
80void (*deprecated_pre_add_symbol_hook) (const char *);
82
84 = FORWARD_SCOPE_EXIT (clear_symtab_users);
85
86/* Global variables owned by this file. */
87
88/* See symfile.h. */
89
91
92/* See symfile.h. */
93
95
96/* Functions this file defines. */
97
98static void symbol_file_add_main_1 (const char *args, symfile_add_flags add_flags,
99 objfile_flags flags, CORE_ADDR reloff);
100
101static const struct sym_fns *find_sym_fns (bfd *);
102
103static void overlay_invalidate_all (void);
104
105static void simple_free_overlay_table (void);
106
107static void read_target_long_array (CORE_ADDR, unsigned int *, int, int,
108 enum bfd_endian);
109
110static int simple_read_overlay_table (void);
111
112static int simple_overlay_update_1 (struct obj_section *);
113
114static void symfile_find_segment_sections (struct objfile *objfile);
115
116/* List of all available sym_fns. On gdb startup, each object file reader
117 calls add_symtab_fns() to register information on each format it is
118 prepared to read. */
119
121{
122 registered_sym_fns (bfd_flavour sym_flavour_, const struct sym_fns *sym_fns_)
123 : sym_flavour (sym_flavour_), sym_fns (sym_fns_)
124 {}
125
126 /* BFD flavour that we handle. */
127 enum bfd_flavour sym_flavour;
128
129 /* The "vtable" of symbol functions. */
130 const struct sym_fns *sym_fns;
131};
132
133static std::vector<registered_sym_fns> symtab_fns;
134
135/* Values for "set print symbol-loading". */
136
137const char print_symbol_loading_off[] = "off";
138const char print_symbol_loading_brief[] = "brief";
139const char print_symbol_loading_full[] = "full";
140static const char *print_symbol_loading_enums[] =
141{
145 NULL
146};
148
149/* See symfile.h. */
150
151bool auto_solib_add = true;
152
153
154/* Return non-zero if symbol-loading messages should be printed.
155 FROM_TTY is the standard from_tty argument to gdb commands.
156 If EXEC is non-zero the messages are for the executable.
157 Otherwise, messages are for shared libraries.
158 If FULL is non-zero then the caller is printing a detailed message.
159 E.g., the message includes the shared library name.
160 Otherwise, the caller is printing a brief "summary" message. */
161
162int
163print_symbol_loading_p (int from_tty, int exec, int full)
164{
165 if (!from_tty && !info_verbose)
166 return 0;
167
168 if (exec)
169 {
170 /* We don't check FULL for executables, there are few such
171 messages, therefore brief == full. */
173 }
174 if (full)
177}
178
179/* True if we are reading a symbol table. */
180
182
183/* Increment currently_reading_symtab and return a cleanup that can be
184 used to decrement it. */
185
186scoped_restore_tmpl<int>
188{
189 gdb_assert (currently_reading_symtab >= 0);
190 return make_scoped_restore (&currently_reading_symtab,
192}
193
194/* Remember the lowest-addressed loadable section we've seen.
195
196 In case of equal vmas, the section with the largest size becomes the
197 lowest-addressed loadable section.
198
199 If the vmas and sizes are equal, the last section is considered the
200 lowest-addressed loadable section. */
201
202static void
203find_lowest_section (asection *sect, asection **lowest)
204{
205 if (0 == (bfd_section_flags (sect) & (SEC_ALLOC | SEC_LOAD)))
206 return;
207 if (!*lowest)
208 *lowest = sect; /* First loadable section */
209 else if (bfd_section_vma (*lowest) > bfd_section_vma (sect))
210 *lowest = sect; /* A lower loadable section */
211 else if (bfd_section_vma (*lowest) == bfd_section_vma (sect)
212 && (bfd_section_size (*lowest) <= bfd_section_size (sect)))
213 *lowest = sect;
214}
215
216/* Build (allocate and populate) a section_addr_info struct from
217 an existing section table. */
218
221{
223
224 for (const target_section &stp : table)
225 {
226 struct bfd_section *asect = stp.the_bfd_section;
227 bfd *abfd = asect->owner;
228
229 if (bfd_section_flags (asect) & (SEC_ALLOC | SEC_LOAD)
230 && sap.size () < table.size ())
231 sap.emplace_back (stp.addr,
232 bfd_section_name (asect),
233 gdb_bfd_section_index (abfd, asect));
234 }
235
236 return sap;
237}
238
239/* Create a section_addr_info from section offsets in ABFD. */
240
243{
244 struct bfd_section *sec;
245
247 for (sec = abfd->sections; sec != NULL; sec = sec->next)
248 if (bfd_section_flags (sec) & (SEC_ALLOC | SEC_LOAD))
249 sap.emplace_back (bfd_section_vma (sec),
250 bfd_section_name (sec),
251 gdb_bfd_section_index (abfd, sec));
252
253 return sap;
254}
255
256/* Create a section_addr_info from section offsets in OBJFILE. */
257
260{
261 int i;
262
263 /* Before reread_symbols gets rewritten it is not safe to call:
264 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
265 */
268 for (i = 0; i < sap.size (); i++)
269 {
270 int sectindex = sap[i].sectindex;
271
272 sap[i].addr += objfile->section_offsets[sectindex];
273 }
274 return sap;
275}
276
277/* Initialize OBJFILE's sect_index_* members. */
278
279static void
281{
282 asection *sect;
283 int i;
284
285 sect = bfd_get_section_by_name (objfile->obfd.get (), ".text");
286 if (sect)
287 objfile->sect_index_text = sect->index;
288
289 sect = bfd_get_section_by_name (objfile->obfd.get (), ".data");
290 if (sect)
291 objfile->sect_index_data = sect->index;
292
293 sect = bfd_get_section_by_name (objfile->obfd.get (), ".bss");
294 if (sect)
295 objfile->sect_index_bss = sect->index;
296
297 sect = bfd_get_section_by_name (objfile->obfd.get (), ".rodata");
298 if (sect)
299 objfile->sect_index_rodata = sect->index;
300
301 /* This is where things get really weird... We MUST have valid
302 indices for the various sect_index_* members or gdb will abort.
303 So if for example, there is no ".text" section, we have to
304 accomodate that. First, check for a file with the standard
305 one or two segments. */
306
308
309 /* Except when explicitly adding symbol files at some address,
310 section_offsets contains nothing but zeros, so it doesn't matter
311 which slot in section_offsets the individual sect_index_* members
312 index into. So if they are all zero, it is safe to just point
313 all the currently uninitialized indices to the first slot. But
314 beware: if this is the main executable, it may be relocated
315 later, e.g. by the remote qOffsets packet, and then this will
316 be wrong! That's why we try segments first. */
317
318 for (i = 0; i < objfile->section_offsets.size (); i++)
319 {
320 if (objfile->section_offsets[i] != 0)
321 {
322 break;
323 }
324 }
325 if (i == objfile->section_offsets.size ())
326 {
327 if (objfile->sect_index_text == -1)
329 if (objfile->sect_index_data == -1)
331 if (objfile->sect_index_bss == -1)
333 if (objfile->sect_index_rodata == -1)
335 }
336}
337
338/* Find a unique offset to use for loadable section SECT if
339 the user did not provide an offset. */
340
341static void
342place_section (bfd *abfd, asection *sect, section_offsets &offsets,
343 CORE_ADDR &lowest)
344{
345 CORE_ADDR start_addr;
346 int done;
347 ULONGEST align = ((ULONGEST) 1) << bfd_section_alignment (sect);
348
349 /* We are only interested in allocated sections. */
350 if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
351 return;
352
353 /* If the user specified an offset, honor it. */
354 if (offsets[gdb_bfd_section_index (abfd, sect)] != 0)
355 return;
356
357 /* Otherwise, let's try to find a place for the section. */
358 start_addr = (lowest + align - 1) & -align;
359
360 do {
361 asection *cur_sec;
362
363 done = 1;
364
365 for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
366 {
367 int indx = cur_sec->index;
368
369 /* We don't need to compare against ourself. */
370 if (cur_sec == sect)
371 continue;
372
373 /* We can only conflict with allocated sections. */
374 if ((bfd_section_flags (cur_sec) & SEC_ALLOC) == 0)
375 continue;
376
377 /* If the section offset is 0, either the section has not been placed
378 yet, or it was the lowest section placed (in which case LOWEST
379 will be past its end). */
380 if (offsets[indx] == 0)
381 continue;
382
383 /* If this section would overlap us, then we must move up. */
384 if (start_addr + bfd_section_size (sect) > offsets[indx]
385 && start_addr < offsets[indx] + bfd_section_size (cur_sec))
386 {
387 start_addr = offsets[indx] + bfd_section_size (cur_sec);
388 start_addr = (start_addr + align - 1) & -align;
389 done = 0;
390 break;
391 }
392
393 /* Otherwise, we appear to be OK. So far. */
394 }
395 }
396 while (!done);
397
398 offsets[gdb_bfd_section_index (abfd, sect)] = start_addr;
399 lowest = start_addr + bfd_section_size (sect);
400}
401
402/* Store section_addr_info as prepared (made relative and with SECTINDEX
403 filled-in) by addr_info_make_relative into SECTION_OFFSETS. */
404
405void
407 const section_addr_info &addrs)
408{
409 int i;
410
411 section_offsets.assign (section_offsets.size (), 0);
412
413 /* Now calculate offsets for section that were specified by the caller. */
414 for (i = 0; i < addrs.size (); i++)
415 {
416 const struct other_sections *osp;
417
418 osp = &addrs[i];
419 if (osp->sectindex == -1)
420 continue;
421
422 /* Record all sections in offsets. */
423 /* The section_offsets in the objfile are here filled in using
424 the BFD index. */
425 section_offsets[osp->sectindex] = osp->addr;
426 }
427}
428
429/* Transform section name S for a name comparison. prelink can split section
430 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
431 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
432 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
433 (`.sbss') section has invalid (increased) virtual address. */
434
435static const char *
436addr_section_name (const char *s)
437{
438 if (strcmp (s, ".dynbss") == 0)
439 return ".bss";
440 if (strcmp (s, ".sdynbss") == 0)
441 return ".sbss";
442
443 return s;
444}
445
446/* std::sort comparator for addrs_section_sort. Sort entries in
447 ascending order by their (name, sectindex) pair. sectindex makes
448 the sort by name stable. */
449
450static bool
452 const struct other_sections *b)
453{
454 int retval;
455
456 retval = strcmp (addr_section_name (a->name.c_str ()),
457 addr_section_name (b->name.c_str ()));
458 if (retval != 0)
459 return retval < 0;
460
461 return a->sectindex < b->sectindex;
462}
463
464/* Provide sorted array of pointers to sections of ADDRS. */
465
466static std::vector<const struct other_sections *>
468{
469 int i;
470
471 std::vector<const struct other_sections *> array (addrs.size ());
472 for (i = 0; i < addrs.size (); i++)
473 array[i] = &addrs[i];
474
475 std::sort (array.begin (), array.end (), addrs_section_compar);
476
477 return array;
478}
479
480/* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
481 also SECTINDEXes specific to ABFD there. This function can be used to
482 rebase ADDRS to start referencing different BFD than before. */
483
484void
486{
487 asection *lower_sect;
488 CORE_ADDR lower_offset;
489 int i;
490
491 /* Find lowest loadable section to be used as starting point for
492 contiguous sections. */
493 lower_sect = NULL;
494 for (asection *iter : gdb_bfd_sections (abfd))
495 find_lowest_section (iter, &lower_sect);
496 if (lower_sect == NULL)
497 {
498 warning (_("no loadable sections found in added symbol-file %s"),
499 bfd_get_filename (abfd));
500 lower_offset = 0;
501 }
502 else
503 lower_offset = bfd_section_vma (lower_sect);
504
505 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
506 in ABFD. Section names are not unique - there can be multiple sections of
507 the same name. Also the sections of the same name do not have to be
508 adjacent to each other. Some sections may be present only in one of the
509 files. Even sections present in both files do not have to be in the same
510 order.
511
512 Use stable sort by name for the sections in both files. Then linearly
513 scan both lists matching as most of the entries as possible. */
514
515 std::vector<const struct other_sections *> addrs_sorted
516 = addrs_section_sort (*addrs);
517
519 std::vector<const struct other_sections *> abfd_addrs_sorted
520 = addrs_section_sort (abfd_addrs);
521
522 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
523 ABFD_ADDRS_SORTED. */
524
525 std::vector<const struct other_sections *>
526 addrs_to_abfd_addrs (addrs->size (), nullptr);
527
528 std::vector<const struct other_sections *>::iterator abfd_sorted_iter
529 = abfd_addrs_sorted.begin ();
530 for (const other_sections *sect : addrs_sorted)
531 {
532 const char *sect_name = addr_section_name (sect->name.c_str ());
533
534 while (abfd_sorted_iter != abfd_addrs_sorted.end ()
535 && strcmp (addr_section_name ((*abfd_sorted_iter)->name.c_str ()),
536 sect_name) < 0)
537 abfd_sorted_iter++;
538
539 if (abfd_sorted_iter != abfd_addrs_sorted.end ()
540 && strcmp (addr_section_name ((*abfd_sorted_iter)->name.c_str ()),
541 sect_name) == 0)
542 {
543 int index_in_addrs;
544
545 /* Make the found item directly addressable from ADDRS. */
546 index_in_addrs = sect - addrs->data ();
547 gdb_assert (addrs_to_abfd_addrs[index_in_addrs] == NULL);
548 addrs_to_abfd_addrs[index_in_addrs] = *abfd_sorted_iter;
549
550 /* Never use the same ABFD entry twice. */
551 abfd_sorted_iter++;
552 }
553 }
554
555 /* Calculate offsets for the loadable sections.
556 FIXME! Sections must be in order of increasing loadable section
557 so that contiguous sections can use the lower-offset!!!
558
559 Adjust offsets if the segments are not contiguous.
560 If the section is contiguous, its offset should be set to
561 the offset of the highest loadable section lower than it
562 (the loadable section directly below it in memory).
563 this_offset = lower_offset = lower_addr - lower_orig_addr */
564
565 for (i = 0; i < addrs->size (); i++)
566 {
567 const struct other_sections *sect = addrs_to_abfd_addrs[i];
568
569 if (sect)
570 {
571 /* This is the index used by BFD. */
572 (*addrs)[i].sectindex = sect->sectindex;
573
574 if ((*addrs)[i].addr != 0)
575 {
576 (*addrs)[i].addr -= sect->addr;
577 lower_offset = (*addrs)[i].addr;
578 }
579 else
580 (*addrs)[i].addr = lower_offset;
581 }
582 else
583 {
584 /* addr_section_name transformation is not used for SECT_NAME. */
585 const std::string &sect_name = (*addrs)[i].name;
586
587 /* This section does not exist in ABFD, which is normally
588 unexpected and we want to issue a warning.
589
590 However, the ELF prelinker does create a few sections which are
591 marked in the main executable as loadable (they are loaded in
592 memory from the DYNAMIC segment) and yet are not present in
593 separate debug info files. This is fine, and should not cause
594 a warning. Shared libraries contain just the section
595 ".gnu.liblist" but it is not marked as loadable there. There is
596 no other way to identify them than by their name as the sections
597 created by prelink have no special flags.
598
599 For the sections `.bss' and `.sbss' see addr_section_name. */
600
601 if (!(sect_name == ".gnu.liblist"
602 || sect_name == ".gnu.conflict"
603 || (sect_name == ".bss"
604 && i > 0
605 && (*addrs)[i - 1].name == ".dynbss"
606 && addrs_to_abfd_addrs[i - 1] != NULL)
607 || (sect_name == ".sbss"
608 && i > 0
609 && (*addrs)[i - 1].name == ".sdynbss"
610 && addrs_to_abfd_addrs[i - 1] != NULL)))
611 warning (_("section %s not found in %s"), sect_name.c_str (),
612 bfd_get_filename (abfd));
613
614 (*addrs)[i].addr = 0;
615 (*addrs)[i].sectindex = -1;
616 }
617 }
618}
619
620/* Parse the user's idea of an offset for dynamic linking, into our idea
621 of how to represent it for fast symbol reading. This is the default
622 version of the sym_fns.sym_offsets function for symbol readers that
623 don't need to do anything special. It allocates a section_offsets table
624 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
625
626void
628 const section_addr_info &addrs)
629{
632
633 /* For relocatable files, all loadable sections will start at zero.
634 The zero is meaningless, so try to pick arbitrary addresses such
635 that no loadable sections overlap. This algorithm is quadratic,
636 but the number of sections in a single object file is generally
637 small. */
638 if ((bfd_get_file_flags (objfile->obfd.get ()) & (EXEC_P | DYNAMIC)) == 0)
639 {
640 bfd *abfd = objfile->obfd.get ();
641 asection *cur_sec;
642
643 for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
644 /* We do not expect this to happen; just skip this step if the
645 relocatable file has a section with an assigned VMA. */
646 if (bfd_section_vma (cur_sec) != 0)
647 break;
648
649 if (cur_sec == NULL)
650 {
652
653 /* Pick non-overlapping offsets for sections the user did not
654 place explicitly. */
655 CORE_ADDR lowest = 0;
656 for (asection *sect : gdb_bfd_sections (objfile->obfd.get ()))
658 lowest);
659
660 /* Correctly filling in the section offsets is not quite
661 enough. Relocatable files have two properties that
662 (most) shared objects do not:
663
664 - Their debug information will contain relocations. Some
665 shared libraries do also, but many do not, so this can not
666 be assumed.
667
668 - If there are multiple code sections they will be loaded
669 at different relative addresses in memory than they are
670 in the objfile, since all sections in the file will start
671 at address zero.
672
673 Because GDB has very limited ability to map from an
674 address in debug info to the correct code section,
675 it relies on adding SECT_OFF_TEXT to things which might be
676 code. If we clear all the section offsets, and set the
677 section VMAs instead, then symfile_relocate_debug_section
678 will return meaningful debug information pointing at the
679 correct sections.
680
681 GDB has too many different data structures for section
682 addresses - a bfd, objfile, and so_list all have section
683 tables, as does exec_ops. Some of these could probably
684 be eliminated. */
685
686 for (cur_sec = abfd->sections; cur_sec != NULL;
687 cur_sec = cur_sec->next)
688 {
689 if ((bfd_section_flags (cur_sec) & SEC_ALLOC) == 0)
690 continue;
691
692 bfd_set_section_vma (cur_sec, offsets[cur_sec->index]);
693 exec_set_section_address (bfd_get_filename (abfd),
694 cur_sec->index,
695 offsets[cur_sec->index]);
696 offsets[cur_sec->index] = 0;
697 }
698 }
699 }
700
701 /* Remember the bfd indexes for the .text, .data, .bss and
702 .rodata sections. */
704}
705
706/* Divide the file into segments, which are individual relocatable units.
707 This is the default version of the sym_fns.sym_segments function for
708 symbol readers that do not have an explicit representation of segments.
709 It assumes that object files do not have segments, and fully linked
710 files have a single segment. */
711
714{
715 int num_sections, i;
716 asection *sect;
717 CORE_ADDR low, high;
718
719 /* Relocatable files contain enough information to position each
720 loadable section independently; they should not be relocated
721 in segments. */
722 if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) == 0)
723 return NULL;
724
725 /* Make sure there is at least one loadable section in the file. */
726 for (sect = abfd->sections; sect != NULL; sect = sect->next)
727 {
728 if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
729 continue;
730
731 break;
732 }
733 if (sect == NULL)
734 return NULL;
735
736 low = bfd_section_vma (sect);
737 high = low + bfd_section_size (sect);
738
740
741 num_sections = bfd_count_sections (abfd);
742
743 /* All elements are initialized to 0 (map to no segment). */
744 data->segment_info.resize (num_sections);
745
746 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
747 {
748 CORE_ADDR vma;
749
750 if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
751 continue;
752
753 vma = bfd_section_vma (sect);
754 if (vma < low)
755 low = vma;
756 if (vma + bfd_section_size (sect) > high)
757 high = vma + bfd_section_size (sect);
758
759 data->segment_info[i] = 1;
760 }
761
762 data->segments.emplace_back (low, high - low);
763
764 return data;
765}
766
767/* This is a convenience function to call sym_read for OBJFILE and
768 possibly force the partial symbols to be read. */
769
770static void
771read_symbols (struct objfile *objfile, symfile_add_flags add_flags)
772{
773 (*objfile->sf->sym_read) (objfile, add_flags);
775
776 /* find_separate_debug_file_in_section should be called only if there is
777 single binary with no existing separate debug info file. */
781 {
783
784 if (abfd != NULL)
785 {
786 /* find_separate_debug_file_in_section uses the same filename for the
787 virtual section-as-bfd like the bfd filename containing the
788 section. Therefore use also non-canonical name form for the same
789 file containing the section. */
790 symbol_file_add_separate (abfd, bfd_get_filename (abfd.get ()),
791 add_flags | SYMFILE_NOT_FILENAME, objfile);
792 }
793 }
794 if ((add_flags & SYMFILE_NO_READ) == 0)
796}
797
798/* Initialize entry point information for this objfile. */
799
800static void
802{
803 struct entry_info *ei = &objfile->per_bfd->ei;
804
805 if (ei->initialized)
806 return;
807 ei->initialized = 1;
808
809 /* Save startup file's range of PC addresses to help blockframe.c
810 decide where the bottom of the stack is. */
811
812 if (bfd_get_file_flags (objfile->obfd.get ()) & EXEC_P)
813 {
814 /* Executable file -- record its entry point so we'll recognize
815 the startup file because it contains the entry point. */
816 ei->entry_point = bfd_get_start_address (objfile->obfd.get ());
817 ei->entry_point_p = 1;
818 }
819 else if (bfd_get_file_flags (objfile->obfd.get ()) & DYNAMIC
820 && bfd_get_start_address (objfile->obfd.get ()) != 0)
821 {
822 /* Some shared libraries may have entry points set and be
823 runnable. There's no clear way to indicate this, so just check
824 for values other than zero. */
825 ei->entry_point = bfd_get_start_address (objfile->obfd.get ());
826 ei->entry_point_p = 1;
827 }
828 else
829 {
830 /* Examination of non-executable.o files. Short-circuit this stuff. */
831 ei->entry_point_p = 0;
832 }
833
834 if (ei->entry_point_p)
835 {
836 struct obj_section *osect;
837 CORE_ADDR entry_point = ei->entry_point;
838 int found;
839
840 /* Make certain that the address points at real code, and not a
841 function descriptor. */
843 (objfile->arch (), entry_point, current_inferior ()->top_target ());
844
845 /* Remove any ISA markers, so that this matches entries in the
846 symbol table. */
847 ei->entry_point
848 = gdbarch_addr_bits_remove (objfile->arch (), entry_point);
849
850 found = 0;
852 {
853 struct bfd_section *sect = osect->the_bfd_section;
854
855 if (entry_point >= bfd_section_vma (sect)
856 && entry_point < (bfd_section_vma (sect)
857 + bfd_section_size (sect)))
858 {
860 = gdb_bfd_section_index (objfile->obfd.get (), sect);
861 found = 1;
862 break;
863 }
864 }
865
866 if (!found)
868 }
869}
870
871/* Process a symbol file, as either the main file or as a dynamically
872 loaded file.
873
874 This function does not set the OBJFILE's entry-point info.
875
876 OBJFILE is where the symbols are to be read from.
877
878 ADDRS is the list of section load addresses. If the user has given
879 an 'add-symbol-file' command, then this is the list of offsets and
880 addresses he or she provided as arguments to the command; or, if
881 we're handling a shared library, these are the actual addresses the
882 sections are loaded at, according to the inferior's dynamic linker
883 (as gleaned by GDB's shared library code). We convert each address
884 into an offset from the section VMA's as it appears in the object
885 file, and then call the file's sym_offsets function to convert this
886 into a format-specific offset table --- a `section_offsets'.
887 The sectindex field is used to control the ordering of sections
888 with the same name. Upon return, it is updated to contain the
889 corresponding BFD section index, or -1 if the section was not found.
890
891 ADD_FLAGS encodes verbosity level, whether this is main symbol or
892 an extra symbol file such as dynamically loaded code, and whether
893 breakpoint reset should be deferred. */
894
895static void
897 section_addr_info *addrs,
898 symfile_add_flags add_flags)
899{
900 section_addr_info local_addr;
901 const int mainline = add_flags & SYMFILE_MAINLINE;
902
904 objfile->qf.clear ();
905
906 if (objfile->sf == NULL)
907 {
908 /* No symbols to load, but we still need to make sure
909 that the section_offsets table is allocated. */
910 int num_sections = gdb_bfd_count_sections (objfile->obfd.get ());
911
912 objfile->section_offsets.assign (num_sections, 0);
913 return;
914 }
915
916 /* Make sure that partially constructed symbol tables will be cleaned up
917 if an error occurs during symbol reading. */
918 gdb::optional<clear_symtab_users_cleanup> defer_clear_users;
919
920 objfile_up objfile_holder (objfile);
921
922 /* If ADDRS is NULL, put together a dummy address list.
923 We now establish the convention that an addr of zero means
924 no load address was specified. */
925 if (! addrs)
926 addrs = &local_addr;
927
928 if (mainline)
929 {
930 /* We will modify the main symbol table, make sure that all its users
931 will be cleaned up if an error occurs during symbol reading. */
932 defer_clear_users.emplace ((symfile_add_flag) 0);
933
934 /* Since no error yet, throw away the old symbol table. */
935
937 {
939 gdb_assert (current_program_space->symfile_object_file == NULL);
940 }
941
942 /* Currently we keep symbols from the add-symbol-file command.
943 If the user wants to get rid of them, they should do "symbol-file"
944 without arguments first. Not sure this is the best behavior
945 (PR 2207). */
946
948 }
949
950 /* Convert addr into an offset rather than an absolute address.
951 We find the lowest address of a loaded segment in the objfile,
952 and assume that <addr> is where that got loaded.
953
954 We no longer warn if the lowest section is not a text segment (as
955 happens for the PA64 port. */
956 if (addrs->size () > 0)
957 addr_info_make_relative (addrs, objfile->obfd.get ());
958
959 /* Initialize symbol reading routines for this objfile, allow complaints to
960 appear for this new file, and record how verbose to be, then do the
961 initial symbol reading for this file. */
962
963 (*objfile->sf->sym_init) (objfile);
965
966 (*objfile->sf->sym_offsets) (objfile, *addrs);
967
968 read_symbols (objfile, add_flags);
969
970 /* Discard cleanups as symbol reading was successful. */
971
972 objfile_holder.release ();
973 if (defer_clear_users)
974 defer_clear_users->release ();
975}
976
977/* Same as syms_from_objfile_1, but also initializes the objfile
978 entry-point info. */
979
980static void
982 section_addr_info *addrs,
983 symfile_add_flags add_flags)
984{
985 syms_from_objfile_1 (objfile, addrs, add_flags);
987}
988
989/* Perform required actions after either reading in the initial
990 symbols for a new objfile, or mapping in the symbols from a reusable
991 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
992
993static void
994finish_new_objfile (struct objfile *objfile, symfile_add_flags add_flags)
995{
996 /* If this is the main symbol file we have to clean up all users of the
997 old main symbol file. Otherwise it is sufficient to fixup all the
998 breakpoints that may have been redefined by this symbol file. */
999 if (add_flags & SYMFILE_MAINLINE)
1000 {
1001 /* OK, make it the "real" symbol file. */
1003
1004 clear_symtab_users (add_flags);
1005 }
1006 else if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
1007 {
1009 }
1010
1011 /* We're done reading the symbol file; finish off complaints. */
1013}
1014
1015/* Process a symbol file, as either the main file or as a dynamically
1016 loaded file.
1017
1018 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1019 A new reference is acquired by this function.
1020
1021 For NAME description see the objfile constructor.
1022
1023 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1024 extra, such as dynamically loaded code, and what to do with breakpoints.
1025
1026 ADDRS is as described for syms_from_objfile_1, above.
1027 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1028
1029 PARENT is the original objfile if ABFD is a separate debug info file.
1030 Otherwise PARENT is NULL.
1031
1032 Upon success, returns a pointer to the objfile that was added.
1033 Upon failure, jumps back to command level (never returns). */
1034
1035static struct objfile *
1037 symfile_add_flags add_flags,
1038 section_addr_info *addrs,
1039 objfile_flags flags, struct objfile *parent)
1040{
1041 struct objfile *objfile;
1042 const int from_tty = add_flags & SYMFILE_VERBOSE;
1043 const int mainline = add_flags & SYMFILE_MAINLINE;
1044 const int always_confirm = add_flags & SYMFILE_ALWAYS_CONFIRM;
1045 const int should_print = (print_symbol_loading_p (from_tty, mainline, 1)
1047 || (add_flags & SYMFILE_NO_READ) == 0));
1048
1050 {
1052 add_flags &= ~SYMFILE_NO_READ;
1053 }
1054 else if (readnever_symbol_files
1055 || (parent != NULL && (parent->flags & OBJF_READNEVER)))
1056 {
1058 add_flags |= SYMFILE_NO_READ;
1059 }
1060 if ((add_flags & SYMFILE_NOT_FILENAME) != 0)
1062
1063 /* Give user a chance to burp if ALWAYS_CONFIRM or we'd be
1064 interactively wiping out any existing symbols. */
1065
1066 if (from_tty
1067 && (always_confirm
1069 && mainline))
1070 && !query (_("Load new symbol table from \"%s\"? "), name))
1071 error (_("Not confirmed."));
1072
1073 if (mainline)
1075 objfile = objfile::make (abfd, name, flags, parent);
1076
1077 /* We either created a new mapped symbol table, mapped an existing
1078 symbol table file which has not had initial symbol reading
1079 performed, or need to read an unmapped symbol table. */
1080 if (should_print)
1081 {
1084 else
1085 gdb_printf (_("Reading symbols from %ps...\n"),
1087 }
1088 syms_from_objfile (objfile, addrs, add_flags);
1089
1090 /* We now have at least a partial symbol table. Check to see if the
1091 user requested that all symbols be read on initial access via either
1092 the gdb startup command line or on a per symbol file basis. Expand
1093 all partial symbol tables for this objfile if so. */
1094
1095 if ((flags & OBJF_READNOW))
1096 {
1097 if (should_print)
1098 gdb_printf (_("Expanding full symbols from %ps...\n"),
1100
1102 }
1103
1104 /* Note that we only print a message if we have no symbols and have
1105 no separate debug file. If there is a separate debug file which
1106 does not have symbols, we'll have emitted this message for that
1107 file, and so printing it twice is just redundant. */
1108 if (should_print && !objfile_has_symbols (objfile)
1109 && objfile->separate_debug_objfile == nullptr)
1110 gdb_printf (_("(No debugging symbols found in %ps)\n"),
1112
1113 if (should_print)
1114 {
1117 }
1118
1119 /* We print some messages regardless of whether 'from_tty ||
1120 info_verbose' is true, so make sure they go out at the right
1121 time. */
1123
1124 if (objfile->sf == NULL)
1125 {
1127 return objfile; /* No symbols. */
1128 }
1129
1130 finish_new_objfile (objfile, add_flags);
1131
1133
1134 bfd_cache_close_all ();
1135 return (objfile);
1136}
1137
1138/* Add BFD as a separate debug file for OBJFILE. For NAME description
1139 see the objfile constructor. */
1140
1141void
1143 symfile_add_flags symfile_flags,
1144 struct objfile *objfile)
1145{
1146 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1147 because sections of BFD may not match sections of OBJFILE and because
1148 vma may have been modified by tools such as prelink. */
1150
1152 (bfd, name, symfile_flags, &sap,
1155 objfile);
1156}
1157
1158/* Process the symbol file ABFD, as either the main file or as a
1159 dynamically loaded file.
1160 See symbol_file_add_with_addrs's comments for details. */
1161
1162struct objfile *
1164 symfile_add_flags add_flags,
1165 section_addr_info *addrs,
1166 objfile_flags flags, struct objfile *parent)
1167{
1168 return symbol_file_add_with_addrs (abfd, name, add_flags, addrs, flags,
1169 parent);
1170}
1171
1172/* Process a symbol file, as either the main file or as a dynamically
1173 loaded file. See symbol_file_add_with_addrs's comments for details. */
1174
1175struct objfile *
1176symbol_file_add (const char *name, symfile_add_flags add_flags,
1177 section_addr_info *addrs, objfile_flags flags)
1178{
1180
1181 return symbol_file_add_from_bfd (bfd, name, add_flags, addrs,
1182 flags, NULL);
1183}
1184
1185/* Call symbol_file_add() with default values and update whatever is
1186 affected by the loading of a new main().
1187 Used when the file is supplied in the gdb command line
1188 and by some targets with special loading requirements.
1189 The auxiliary function, symbol_file_add_main_1(), has the flags
1190 argument for the switches that can only be specified in the symbol_file
1191 command itself. */
1192
1193void
1194symbol_file_add_main (const char *args, symfile_add_flags add_flags)
1195{
1196 symbol_file_add_main_1 (args, add_flags, 0, 0);
1197}
1198
1199static void
1200symbol_file_add_main_1 (const char *args, symfile_add_flags add_flags,
1201 objfile_flags flags, CORE_ADDR reloff)
1202{
1204
1205 struct objfile *objfile = symbol_file_add (args, add_flags, NULL, flags);
1206 if (reloff != 0)
1207 objfile_rebase (objfile, reloff);
1208
1209 /* Getting new symbols may change our opinion about
1210 what is frameless. */
1212
1213 if ((add_flags & SYMFILE_NO_READ) == 0)
1215}
1216
1217void
1218symbol_file_clear (int from_tty)
1219{
1221 && from_tty
1223 ? !query (_("Discard symbol table from `%s'? "),
1225 : !query (_("Discard symbol table? "))))
1226 error (_("Not confirmed."));
1227
1228 /* solib descriptors may have handles to objfiles. Wipe them before their
1229 objfiles get stale by free_all_objfiles. */
1230 no_shared_libraries (NULL, from_tty);
1231
1233
1235
1236 gdb_assert (current_program_space->symfile_object_file == NULL);
1237 if (from_tty)
1238 gdb_printf (_("No symbol file now.\n"));
1239}
1240
1241/* See symfile.h. */
1242
1244
1245static int
1246separate_debug_file_exists (const std::string &name, unsigned long crc,
1247 struct objfile *parent_objfile)
1248{
1249 unsigned long file_crc;
1250 int file_crc_p;
1251 struct stat parent_stat, abfd_stat;
1252 int verified_as_different;
1253
1254 /* Find a separate debug info file as if symbols would be present in
1255 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1256 section can contain just the basename of PARENT_OBJFILE without any
1257 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1258 the separate debug infos with the same basename can exist. */
1259
1260 if (filename_cmp (name.c_str (), objfile_name (parent_objfile)) == 0)
1261 return 0;
1262
1264 {
1265 gdb_printf (gdb_stdlog, _(" Trying %s..."), name.c_str ());
1267 }
1268
1269 gdb_bfd_ref_ptr abfd (gdb_bfd_open (name.c_str (), gnutarget));
1270
1271 if (abfd == NULL)
1272 {
1274 gdb_printf (gdb_stdlog, _(" no, unable to open.\n"));
1275
1276 return 0;
1277 }
1278
1279 /* Verify symlinks were not the cause of filename_cmp name difference above.
1280
1281 Some operating systems, e.g. Windows, do not provide a meaningful
1282 st_ino; they always set it to zero. (Windows does provide a
1283 meaningful st_dev.) Files accessed from gdbservers that do not
1284 support the vFile:fstat packet will also have st_ino set to zero.
1285 Do not indicate a duplicate library in either case. While there
1286 is no guarantee that a system that provides meaningful inode
1287 numbers will never set st_ino to zero, this is merely an
1288 optimization, so we do not need to worry about false negatives. */
1289
1290 if (bfd_stat (abfd.get (), &abfd_stat) == 0
1291 && abfd_stat.st_ino != 0
1292 && bfd_stat (parent_objfile->obfd.get (), &parent_stat) == 0)
1293 {
1294 if (abfd_stat.st_dev == parent_stat.st_dev
1295 && abfd_stat.st_ino == parent_stat.st_ino)
1296 {
1299 _(" no, same file as the objfile.\n"));
1300
1301 return 0;
1302 }
1303 verified_as_different = 1;
1304 }
1305 else
1306 verified_as_different = 0;
1307
1308 file_crc_p = gdb_bfd_crc (abfd.get (), &file_crc);
1309
1310 if (!file_crc_p)
1311 {
1313 gdb_printf (gdb_stdlog, _(" no, error computing CRC.\n"));
1314
1315 return 0;
1316 }
1317
1318 if (crc != file_crc)
1319 {
1320 unsigned long parent_crc;
1321
1322 /* If the files could not be verified as different with
1323 bfd_stat then we need to calculate the parent's CRC
1324 to verify whether the files are different or not. */
1325
1326 if (!verified_as_different)
1327 {
1328 if (!gdb_bfd_crc (parent_objfile->obfd.get (), &parent_crc))
1329 {
1332 _(" no, error computing CRC.\n"));
1333
1334 return 0;
1335 }
1336 }
1337
1338 if (verified_as_different || parent_crc != file_crc)
1339 warning (_("the debug information found in \"%s\""
1340 " does not match \"%s\" (CRC mismatch).\n"),
1341 name.c_str (), objfile_name (parent_objfile));
1342
1344 gdb_printf (gdb_stdlog, _(" no, CRC doesn't match.\n"));
1345
1346 return 0;
1347 }
1348
1350 gdb_printf (gdb_stdlog, _(" yes!\n"));
1351
1352 return 1;
1353}
1354
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
1378static std::string
1380 const char *canon_dir,
1381 const char *debuglink,
1382 unsigned long crc32, struct objfile *objfile)
1383{
1386 _("\nLooking for separate debug info (debug link) for "
1387 "%s\n"), objfile_name (objfile));
1388
1389 /* First try in the same directory as the original file. */
1390 std::string debugfile = dir;
1391 debugfile += debuglink;
1392
1393 if (separate_debug_file_exists (debugfile, crc32, objfile))
1394 return debugfile;
1395
1396 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1397 debugfile = dir;
1398 debugfile += DEBUG_SUBDIRECTORY;
1399 debugfile += "/";
1400 debugfile += debuglink;
1401
1402 if (separate_debug_file_exists (debugfile, crc32, objfile))
1403 return debugfile;
1404
1405 /* Then try in the global debugfile directories.
1406
1407 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1408 cause "/..." lookups. */
1409
1410 bool target_prefix = startswith (dir, "target:");
1411 const char *dir_notarget = target_prefix ? dir + strlen ("target:") : dir;
1412 std::vector<gdb::unique_xmalloc_ptr<char>> debugdir_vec
1413 = dirnames_to_char_ptr_vec (debug_file_directory.c_str ());
1414 gdb::unique_xmalloc_ptr<char> canon_sysroot
1415 = gdb_realpath (gdb_sysroot.c_str ());
1416
1417 /* MS-Windows/MS-DOS don't allow colons in file names; we must
1418 convert the drive letter into a one-letter directory, so that the
1419 file name resulting from splicing below will be valid.
1420
1421 FIXME: The below only works when GDB runs on MS-Windows/MS-DOS.
1422 There are various remote-debugging scenarios where such a
1423 transformation of the drive letter might be required when GDB runs
1424 on a Posix host, see
1425
1426 https://sourceware.org/ml/gdb-patches/2019-04/msg00605.html
1427
1428 If some of those scenarios need to be supported, we will need to
1429 use a different condition for HAS_DRIVE_SPEC and a different macro
1430 instead of STRIP_DRIVE_SPEC, which work on Posix systems as well. */
1431 std::string drive;
1432 if (HAS_DRIVE_SPEC (dir_notarget))
1433 {
1434 drive = dir_notarget[0];
1435 dir_notarget = STRIP_DRIVE_SPEC (dir_notarget);
1436 }
1437
1438 for (const gdb::unique_xmalloc_ptr<char> &debugdir : debugdir_vec)
1439 {
1440 debugfile = target_prefix ? "target:" : "";
1441 debugfile += debugdir;
1442 debugfile += "/";
1443 debugfile += drive;
1444 debugfile += dir_notarget;
1445 debugfile += debuglink;
1446
1447 if (separate_debug_file_exists (debugfile, crc32, objfile))
1448 return debugfile;
1449
1450 const char *base_path = NULL;
1451 if (canon_dir != NULL)
1452 {
1453 if (canon_sysroot.get () != NULL)
1454 base_path = child_path (canon_sysroot.get (), canon_dir);
1455 else
1456 base_path = child_path (gdb_sysroot.c_str (), canon_dir);
1457 }
1458 if (base_path != NULL)
1459 {
1460 /* If the file is in the sysroot, try using its base path in
1461 the global debugfile directory. */
1462 debugfile = target_prefix ? "target:" : "";
1463 debugfile += debugdir;
1464 debugfile += "/";
1465 debugfile += base_path;
1466 debugfile += "/";
1467 debugfile += debuglink;
1468
1469 if (separate_debug_file_exists (debugfile, crc32, objfile))
1470 return debugfile;
1471
1472 /* If the file is in the sysroot, try using its base path in
1473 the sysroot's global debugfile directory. */
1474 debugfile = target_prefix ? "target:" : "";
1475 debugfile += gdb_sysroot;
1476 debugfile += debugdir;
1477 debugfile += "/";
1478 debugfile += base_path;
1479 debugfile += "/";
1480 debugfile += debuglink;
1481
1482 if (separate_debug_file_exists (debugfile, crc32, objfile))
1483 return debugfile;
1484 }
1485
1486 }
1487
1488 return std::string ();
1489}
1490
1491/* Modify PATH to contain only "[/]directory/" part of PATH.
1492 If there were no directory separators in PATH, PATH will be empty
1493 string on return. */
1494
1495static void
1497{
1498 int i;
1499
1500 /* Strip off the final filename part, leaving the directory name,
1501 followed by a slash. The directory can be relative or absolute. */
1502 for (i = strlen(path) - 1; i >= 0; i--)
1503 if (IS_DIR_SEPARATOR (path[i]))
1504 break;
1505
1506 /* If I is -1 then no directory is present there and DIR will be "". */
1507 path[i + 1] = '\0';
1508}
1509
1510/* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1511 Returns pathname, or an empty string. */
1512
1513std::string
1515{
1516 unsigned long crc32;
1517
1518 gdb::unique_xmalloc_ptr<char> debuglink
1519 (bfd_get_debug_link_info (objfile->obfd.get (), &crc32));
1520
1521 if (debuglink == NULL)
1522 {
1523 /* There's no separate debug info, hence there's no way we could
1524 load it => no warning. */
1525 return std::string ();
1526 }
1527
1528 std::string dir = objfile_name (objfile);
1530 gdb::unique_xmalloc_ptr<char> canon_dir (lrealpath (dir.c_str ()));
1531
1532 std::string debugfile
1533 = find_separate_debug_file (dir.c_str (), canon_dir.get (),
1534 debuglink.get (), crc32, objfile);
1535
1536 if (debugfile.empty ())
1537 {
1538 /* For PR gdb/9538, try again with realpath (if different from the
1539 original). */
1540
1541 struct stat st_buf;
1542
1543 if (lstat (objfile_name (objfile), &st_buf) == 0
1544 && S_ISLNK (st_buf.st_mode))
1545 {
1546 gdb::unique_xmalloc_ptr<char> symlink_dir
1547 (lrealpath (objfile_name (objfile)));
1548 if (symlink_dir != NULL)
1549 {
1550 terminate_after_last_dir_separator (symlink_dir.get ());
1551 if (dir != symlink_dir.get ())
1552 {
1553 /* Different directory, so try using it. */
1554 debugfile = find_separate_debug_file (symlink_dir.get (),
1555 symlink_dir.get (),
1556 debuglink.get (),
1557 crc32,
1558 objfile);
1559 }
1560 }
1561 }
1562 }
1563
1564 return debugfile;
1565}
1566
1567/* Make sure that OBJF_{READNOW,READNEVER} are not set
1568 simultaneously. */
1569
1570static void
1572{
1573 if ((flags & OBJF_READNOW) && (flags & OBJF_READNEVER))
1574 error (_("-readnow and -readnever cannot be used simultaneously"));
1575}
1576
1577/* This is the symbol-file command. Read the file, analyze its
1578 symbols, and add a struct symtab to a symtab list. The syntax of
1579 the command is rather bizarre:
1580
1581 1. The function buildargv implements various quoting conventions
1582 which are undocumented and have little or nothing in common with
1583 the way things are quoted (or not quoted) elsewhere in GDB.
1584
1585 2. Options are used, which are not generally used in GDB (perhaps
1586 "set mapped on", "set readnow on" would be better)
1587
1588 3. The order of options matters, which is contrary to GNU
1589 conventions (because it is confusing and inconvenient). */
1590
1591void
1592symbol_file_command (const char *args, int from_tty)
1593{
1594 dont_repeat ();
1595
1596 if (args == NULL)
1597 {
1598 symbol_file_clear (from_tty);
1599 }
1600 else
1601 {
1602 objfile_flags flags = OBJF_USERLOADED;
1603 symfile_add_flags add_flags = 0;
1604 char *name = NULL;
1605 bool stop_processing_options = false;
1606 CORE_ADDR offset = 0;
1607 int idx;
1608 char *arg;
1609
1610 if (from_tty)
1611 add_flags |= SYMFILE_VERBOSE;
1612
1613 gdb_argv built_argv (args);
1614 for (arg = built_argv[0], idx = 0; arg != NULL; arg = built_argv[++idx])
1615 {
1616 if (stop_processing_options || *arg != '-')
1617 {
1618 if (name == NULL)
1619 name = arg;
1620 else
1621 error (_("Unrecognized argument \"%s\""), arg);
1622 }
1623 else if (strcmp (arg, "-readnow") == 0)
1625 else if (strcmp (arg, "-readnever") == 0)
1627 else if (strcmp (arg, "-o") == 0)
1628 {
1629 arg = built_argv[++idx];
1630 if (arg == NULL)
1631 error (_("Missing argument to -o"));
1632
1633 offset = parse_and_eval_address (arg);
1634 }
1635 else if (strcmp (arg, "--") == 0)
1636 stop_processing_options = true;
1637 else
1638 error (_("Unrecognized argument \"%s\""), arg);
1639 }
1640
1641 if (name == NULL)
1642 error (_("no symbol file name was specified"));
1643
1645
1646 /* Set SYMFILE_DEFER_BP_RESET because the proper displacement for a PIE
1647 (Position Independent Executable) main symbol file will only be
1648 computed by the solib_create_inferior_hook below. Without it,
1649 breakpoint_re_set would fail to insert the breakpoints with the zero
1650 displacement. */
1651 add_flags |= SYMFILE_DEFER_BP_RESET;
1652
1653 symbol_file_add_main_1 (name, add_flags, flags, offset);
1654
1655 solib_create_inferior_hook (from_tty);
1656
1657 /* Now it's safe to re-add the breakpoints. */
1659
1660 /* Also, it's safe to re-add varobjs. */
1661 varobj_re_set ();
1662 }
1663}
1664
1665/* Set the initial language. */
1666
1667void
1669{
1671 return;
1672 enum language lang = main_language ();
1673 /* Make C the default language. */
1674 enum language default_lang = language_c;
1675
1676 if (lang == language_unknown)
1677 {
1678 const char *name = main_name ();
1679 struct symbol *sym
1680 = lookup_symbol_in_language (name, NULL, VAR_DOMAIN, default_lang,
1681 NULL).symbol;
1682
1683 if (sym != NULL)
1684 lang = sym->language ();
1685 }
1686
1687 if (lang == language_unknown)
1688 {
1689 lang = default_lang;
1690 }
1691
1692 set_language (lang);
1693 expected_language = current_language; /* Don't warn the user. */
1694}
1695
1696/* Open the file specified by NAME and hand it off to BFD for
1697 preliminary analysis. Return a newly initialized bfd *, which
1698 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1699 absolute). In case of trouble, error() is called. */
1700
1703{
1704 int desc = -1;
1705
1706 gdb::unique_xmalloc_ptr<char> absolute_name;
1707 if (!is_target_filename (name))
1708 {
1709 gdb::unique_xmalloc_ptr<char> expanded_name (tilde_expand (name));
1710
1711 /* Look down path for it, allocate 2nd new malloc'd copy. */
1712 desc = openp (getenv ("PATH"),
1714 expanded_name.get (), O_RDONLY | O_BINARY, &absolute_name);
1715#if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1716 if (desc < 0)
1717 {
1718 char *exename = (char *) alloca (strlen (expanded_name.get ()) + 5);
1719
1720 strcat (strcpy (exename, expanded_name.get ()), ".exe");
1721 desc = openp (getenv ("PATH"),
1723 exename, O_RDONLY | O_BINARY, &absolute_name);
1724 }
1725#endif
1726 if (desc < 0)
1727 perror_with_name (expanded_name.get ());
1728
1729 name = absolute_name.get ();
1730 }
1731
1732 gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (name, gnutarget, desc));
1733 if (sym_bfd == NULL)
1734 error (_("`%s': can't open to read symbols: %s."), name,
1735 bfd_errmsg (bfd_get_error ()));
1736
1737 if (!gdb_bfd_has_target_filename (sym_bfd.get ()))
1738 bfd_set_cacheable (sym_bfd.get (), 1);
1739
1740 if (!bfd_check_format (sym_bfd.get (), bfd_object))
1741 error (_("`%s': can't read symbols: %s."), name,
1742 bfd_errmsg (bfd_get_error ()));
1743
1744 return sym_bfd;
1745}
1746
1747/* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1748 the section was not found. */
1749
1750int
1751get_section_index (struct objfile *objfile, const char *section_name)
1752{
1753 asection *sect = bfd_get_section_by_name (objfile->obfd.get (), section_name);
1754
1755 if (sect)
1756 return sect->index;
1757 else
1758 return -1;
1759}
1760
1761/* Link SF into the global symtab_fns list.
1762 FLAVOUR is the file format that SF handles.
1763 Called on startup by the _initialize routine in each object file format
1764 reader, to register information about each format the reader is prepared
1765 to handle. */
1766
1767void
1768add_symtab_fns (enum bfd_flavour flavour, const struct sym_fns *sf)
1769{
1770 symtab_fns.emplace_back (flavour, sf);
1771}
1772
1773/* Initialize OBJFILE to read symbols from its associated BFD. It
1774 either returns or calls error(). The result is an initialized
1775 struct sym_fns in the objfile structure, that contains cached
1776 information about the symbol file. */
1777
1778static const struct sym_fns *
1779find_sym_fns (bfd *abfd)
1780{
1781 enum bfd_flavour our_flavour = bfd_get_flavour (abfd);
1782
1783 if (our_flavour == bfd_target_srec_flavour
1784 || our_flavour == bfd_target_ihex_flavour
1785 || our_flavour == bfd_target_tekhex_flavour)
1786 return NULL; /* No symbols. */
1787
1788 for (const registered_sym_fns &rsf : symtab_fns)
1789 if (our_flavour == rsf.sym_flavour)
1790 return rsf.sym_fns;
1791
1792 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1793 bfd_get_target (abfd));
1794}
1795
1796
1797/* This function runs the load command of our current target. */
1798
1799static void
1800load_command (const char *arg, int from_tty)
1801{
1802 dont_repeat ();
1803
1804 /* The user might be reloading because the binary has changed. Take
1805 this opportunity to check. */
1807 reread_symbols (from_tty);
1808
1809 std::string temp;
1810 if (arg == NULL)
1811 {
1812 const char *parg, *prev;
1813
1814 arg = get_exec_file (1);
1815
1816 /* We may need to quote this string so buildargv can pull it
1817 apart. */
1818 prev = parg = arg;
1819 while ((parg = strpbrk (parg, "\\\"'\t ")))
1820 {
1821 temp.append (prev, parg - prev);
1822 prev = parg++;
1823 temp.push_back ('\\');
1824 }
1825 /* If we have not copied anything yet, then we didn't see a
1826 character to quote, and we can just leave ARG unchanged. */
1827 if (!temp.empty ())
1828 {
1829 temp.append (prev);
1830 arg = temp.c_str ();
1831 }
1832 }
1833
1834 target_load (arg, from_tty);
1835
1836 /* After re-loading the executable, we don't really know which
1837 overlays are mapped any more. */
1839}
1840
1841/* This version of "load" should be usable for any target. Currently
1842 it is just used for remote targets, not inftarg.c or core files,
1843 on the theory that only in that case is it useful.
1844
1845 Avoiding xmodem and the like seems like a win (a) because we don't have
1846 to worry about finding it, and (b) On VMS, fork() is very slow and so
1847 we don't want to run a subprocess. On the other hand, I'm not sure how
1848 performance compares. */
1849
1850static int validate_download = 0;
1851
1852/* Opaque data for load_progress. */
1854{
1855 /* Cumulative data. */
1856 unsigned long write_count = 0;
1857 unsigned long data_count = 0;
1858 bfd_size_type total_size = 0;
1859};
1860
1861/* Opaque data for load_progress for a single section. */
1863{
1865 const char *section_name_, ULONGEST section_size_,
1866 CORE_ADDR lma_, gdb_byte *buffer_)
1867 : cumulative (cumulative_), section_name (section_name_),
1868 section_size (section_size_), lma (lma_), buffer (buffer_)
1869 {}
1870
1872
1873 /* Per-section data. */
1874 const char *section_name;
1875 ULONGEST section_sent = 0;
1877 CORE_ADDR lma;
1878 gdb_byte *buffer;
1879};
1880
1881/* Opaque data for load_section_callback. */
1883{
1885 : progress_data (progress_data_)
1886 {}
1887
1889 {
1890 for (auto &&request : requests)
1891 {
1892 xfree (request.data);
1893 delete ((load_progress_section_data *) request.baton);
1894 }
1895 }
1896
1897 CORE_ADDR load_offset = 0;
1899 std::vector<struct memory_write_request> requests;
1900};
1901
1902/* Target write callback routine for progress reporting. */
1903
1904static void
1905load_progress (ULONGEST bytes, void *untyped_arg)
1906{
1907 struct load_progress_section_data *args
1908 = (struct load_progress_section_data *) untyped_arg;
1909 struct load_progress_data *totals;
1910
1911 if (args == NULL)
1912 /* Writing padding data. No easy way to get at the cumulative
1913 stats, so just ignore this. */
1914 return;
1915
1916 totals = args->cumulative;
1917
1918 if (bytes == 0 && args->section_sent == 0)
1919 {
1920 /* The write is just starting. Let the user know we've started
1921 this section. */
1922 current_uiout->message ("Loading section %s, size %s lma %s\n",
1923 args->section_name,
1924 hex_string (args->section_size),
1925 paddress (target_gdbarch (), args->lma));
1926 return;
1927 }
1928
1930 {
1931 /* Broken memories and broken monitors manifest themselves here
1932 when bring new computers to life. This doubles already slow
1933 downloads. */
1934 /* NOTE: cagney/1999-10-18: A more efficient implementation
1935 might add a verify_memory() method to the target vector and
1936 then use that. remote.c could implement that method using
1937 the ``qCRC'' packet. */
1938 gdb::byte_vector check (bytes);
1939
1940 if (target_read_memory (args->lma, check.data (), bytes) != 0)
1941 error (_("Download verify read failed at %s"),
1942 paddress (target_gdbarch (), args->lma));
1943 if (memcmp (args->buffer, check.data (), bytes) != 0)
1944 error (_("Download verify compare failed at %s"),
1945 paddress (target_gdbarch (), args->lma));
1946 }
1947 totals->data_count += bytes;
1948 args->lma += bytes;
1949 args->buffer += bytes;
1950 totals->write_count += 1;
1951 args->section_sent += bytes;
1952 if (check_quit_flag ()
1954 && deprecated_ui_load_progress_hook (args->section_name,
1955 args->section_sent)))
1956 error (_("Canceled the download"));
1957
1959 deprecated_show_load_progress (args->section_name,
1960 args->section_sent,
1961 args->section_size,
1962 totals->data_count,
1963 totals->total_size);
1964}
1965
1966/* Service function for generic_load. */
1967
1968static void
1969load_one_section (bfd *abfd, asection *asec,
1970 struct load_section_data *args)
1971{
1972 bfd_size_type size = bfd_section_size (asec);
1973 const char *sect_name = bfd_section_name (asec);
1974
1975 if ((bfd_section_flags (asec) & SEC_LOAD) == 0)
1976 return;
1977
1978 if (size == 0)
1979 return;
1980
1981 ULONGEST begin = bfd_section_lma (asec) + args->load_offset;
1982 ULONGEST end = begin + size;
1983 gdb_byte *buffer = (gdb_byte *) xmalloc (size);
1984 bfd_get_section_contents (abfd, asec, buffer, 0, size);
1985
1986 load_progress_section_data *section_data
1987 = new load_progress_section_data (args->progress_data, sect_name, size,
1988 begin, buffer);
1989
1990 args->requests.emplace_back (begin, end, buffer, section_data);
1991}
1992
1993static void print_transfer_performance (struct ui_file *stream,
1994 unsigned long data_count,
1995 unsigned long write_count,
1996 std::chrono::steady_clock::duration d);
1997
1998/* See symfile.h. */
1999
2000void
2001generic_load (const char *args, int from_tty)
2002{
2003 struct load_progress_data total_progress;
2004 struct load_section_data cbdata (&total_progress);
2005 struct ui_out *uiout = current_uiout;
2006
2007 if (args == NULL)
2008 error_no_arg (_("file to load"));
2009
2010 gdb_argv argv (args);
2011
2012 gdb::unique_xmalloc_ptr<char> filename (tilde_expand (argv[0]));
2013
2014 if (argv[1] != NULL)
2015 {
2016 const char *endptr;
2017
2018 cbdata.load_offset = strtoulst (argv[1], &endptr, 0);
2019
2020 /* If the last word was not a valid number then
2021 treat it as a file name with spaces in. */
2022 if (argv[1] == endptr)
2023 error (_("Invalid download offset:%s."), argv[1]);
2024
2025 if (argv[2] != NULL)
2026 error (_("Too many parameters."));
2027 }
2028
2029 /* Open the file for loading. */
2030 gdb_bfd_ref_ptr loadfile_bfd (gdb_bfd_open (filename.get (), gnutarget));
2031 if (loadfile_bfd == NULL)
2032 perror_with_name (filename.get ());
2033
2034 if (!bfd_check_format (loadfile_bfd.get (), bfd_object))
2035 {
2036 error (_("\"%s\" is not an object file: %s"), filename.get (),
2037 bfd_errmsg (bfd_get_error ()));
2038 }
2039
2040 for (asection *asec : gdb_bfd_sections (loadfile_bfd))
2041 total_progress.total_size += bfd_section_size (asec);
2042
2043 for (asection *asec : gdb_bfd_sections (loadfile_bfd))
2044 load_one_section (loadfile_bfd.get (), asec, &cbdata);
2045
2046 using namespace std::chrono;
2047
2048 steady_clock::time_point start_time = steady_clock::now ();
2049
2051 load_progress) != 0)
2052 error (_("Load failed"));
2053
2054 steady_clock::time_point end_time = steady_clock::now ();
2055
2056 CORE_ADDR entry = bfd_get_start_address (loadfile_bfd.get ());
2057 entry = gdbarch_addr_bits_remove (target_gdbarch (), entry);
2058 uiout->text ("Start address ");
2059 uiout->field_core_addr ("address", target_gdbarch (), entry);
2060 uiout->text (", load size ");
2061 uiout->field_unsigned ("load-size", total_progress.data_count);
2062 uiout->text ("\n");
2064
2065 /* Reset breakpoints, now that we have changed the load image. For
2066 instance, breakpoints may have been set (or reset, by
2067 post_create_inferior) while connected to the target but before we
2068 loaded the program. In that case, the prologue analyzer could
2069 have read instructions from the target to find the right
2070 breakpoint locations. Loading has changed the contents of that
2071 memory. */
2072
2074
2076 total_progress.write_count,
2077 end_time - start_time);
2078}
2079
2080/* Report on STREAM the performance of a memory transfer operation,
2081 such as 'load'. DATA_COUNT is the number of bytes transferred.
2082 WRITE_COUNT is the number of separate write operations, or 0, if
2083 that information is not available. TIME is how long the operation
2084 lasted. */
2085
2086static void
2088 unsigned long data_count,
2089 unsigned long write_count,
2090 std::chrono::steady_clock::duration time)
2091{
2092 using namespace std::chrono;
2093 struct ui_out *uiout = current_uiout;
2094
2095 milliseconds ms = duration_cast<milliseconds> (time);
2096
2097 uiout->text ("Transfer rate: ");
2098 if (ms.count () > 0)
2099 {
2100 unsigned long rate = ((ULONGEST) data_count * 1000) / ms.count ();
2101
2102 if (uiout->is_mi_like_p ())
2103 {
2104 uiout->field_unsigned ("transfer-rate", rate * 8);
2105 uiout->text (" bits/sec");
2106 }
2107 else if (rate < 1024)
2108 {
2109 uiout->field_unsigned ("transfer-rate", rate);
2110 uiout->text (" bytes/sec");
2111 }
2112 else
2113 {
2114 uiout->field_unsigned ("transfer-rate", rate / 1024);
2115 uiout->text (" KB/sec");
2116 }
2117 }
2118 else
2119 {
2120 uiout->field_unsigned ("transferred-bits", (data_count * 8));
2121 uiout->text (" bits in <1 sec");
2122 }
2123 if (write_count > 0)
2124 {
2125 uiout->text (", ");
2126 uiout->field_unsigned ("write-rate", data_count / write_count);
2127 uiout->text (" bytes/write");
2128 }
2129 uiout->text (".\n");
2130}
2131
2132/* Add an OFFSET to the start address of each section in OBJF, except
2133 sections that were specified in ADDRS. */
2134
2135static void
2137 const section_addr_info &addrs,
2138 CORE_ADDR offset)
2139{
2140 /* Add OFFSET to all sections by default. */
2141 section_offsets offsets (objf->section_offsets.size (), offset);
2142
2143 /* Create sorted lists of all sections in ADDRS as well as all
2144 sections in OBJF. */
2145
2146 std::vector<const struct other_sections *> addrs_sorted
2147 = addrs_section_sort (addrs);
2148
2149 section_addr_info objf_addrs
2151 std::vector<const struct other_sections *> objf_addrs_sorted
2152 = addrs_section_sort (objf_addrs);
2153
2154 /* Walk the BFD section list, and if a matching section is found in
2155 ADDRS_SORTED_LIST, set its offset to zero to keep its address
2156 unchanged.
2157
2158 Note that both lists may contain multiple sections with the same
2159 name, and then the sections from ADDRS are matched in BFD order
2160 (thanks to sectindex). */
2161
2162 std::vector<const struct other_sections *>::iterator addrs_sorted_iter
2163 = addrs_sorted.begin ();
2164 for (const other_sections *objf_sect : objf_addrs_sorted)
2165 {
2166 const char *objf_name = addr_section_name (objf_sect->name.c_str ());
2167 int cmp = -1;
2168
2169 while (cmp < 0 && addrs_sorted_iter != addrs_sorted.end ())
2170 {
2171 const struct other_sections *sect = *addrs_sorted_iter;
2172 const char *sect_name = addr_section_name (sect->name.c_str ());
2173 cmp = strcmp (sect_name, objf_name);
2174 if (cmp <= 0)
2175 ++addrs_sorted_iter;
2176 }
2177
2178 if (cmp == 0)
2179 offsets[objf_sect->sectindex] = 0;
2180 }
2181
2182 /* Apply the new section offsets. */
2183 objfile_relocate (objf, offsets);
2184}
2185
2186/* This function allows the addition of incrementally linked object files.
2187 It does not modify any state in the target, only in the debugger. */
2188
2189static void
2190add_symbol_file_command (const char *args, int from_tty)
2191{
2192 struct gdbarch *gdbarch = get_current_arch ();
2193 gdb::unique_xmalloc_ptr<char> filename;
2194 char *arg;
2195 int argcnt = 0;
2196 struct objfile *objf;
2197 objfile_flags flags = OBJF_USERLOADED | OBJF_SHARED;
2198 symfile_add_flags add_flags = 0;
2199
2200 if (from_tty)
2201 add_flags |= SYMFILE_VERBOSE;
2202
2203 struct sect_opt
2204 {
2205 const char *name;
2206 const char *value;
2207 };
2208
2209 std::vector<sect_opt> sect_opts = { { ".text", NULL } };
2210 bool stop_processing_options = false;
2211 CORE_ADDR offset = 0;
2212
2213 dont_repeat ();
2214
2215 if (args == NULL)
2216 error (_("add-symbol-file takes a file name and an address"));
2217
2218 bool seen_addr = false;
2219 bool seen_offset = false;
2220 gdb_argv argv (args);
2221
2222 for (arg = argv[0], argcnt = 0; arg != NULL; arg = argv[++argcnt])
2223 {
2224 if (stop_processing_options || *arg != '-')
2225 {
2226 if (filename == NULL)
2227 {
2228 /* First non-option argument is always the filename. */
2229 filename.reset (tilde_expand (arg));
2230 }
2231 else if (!seen_addr)
2232 {
2233 /* The second non-option argument is always the text
2234 address at which to load the program. */
2235 sect_opts[0].value = arg;
2236 seen_addr = true;
2237 }
2238 else
2239 error (_("Unrecognized argument \"%s\""), arg);
2240 }
2241 else if (strcmp (arg, "-readnow") == 0)
2243 else if (strcmp (arg, "-readnever") == 0)
2245 else if (strcmp (arg, "-s") == 0)
2246 {
2247 if (argv[argcnt + 1] == NULL)
2248 error (_("Missing section name after \"-s\""));
2249 else if (argv[argcnt + 2] == NULL)
2250 error (_("Missing section address after \"-s\""));
2251
2252 sect_opt sect = { argv[argcnt + 1], argv[argcnt + 2] };
2253
2254 sect_opts.push_back (sect);
2255 argcnt += 2;
2256 }
2257 else if (strcmp (arg, "-o") == 0)
2258 {
2259 arg = argv[++argcnt];
2260 if (arg == NULL)
2261 error (_("Missing argument to -o"));
2262
2263 offset = parse_and_eval_address (arg);
2264 seen_offset = true;
2265 }
2266 else if (strcmp (arg, "--") == 0)
2267 stop_processing_options = true;
2268 else
2269 error (_("Unrecognized argument \"%s\""), arg);
2270 }
2271
2272 if (filename == NULL)
2273 error (_("You must provide a filename to be loaded."));
2274
2276
2277 /* Print the prompt for the query below. And save the arguments into
2278 a sect_addr_info structure to be passed around to other
2279 functions. We have to split this up into separate print
2280 statements because hex_string returns a local static
2281 string. */
2282
2283 gdb_printf (_("add symbol table from file \"%s\""),
2284 filename.get ());
2285 section_addr_info section_addrs;
2286 std::vector<sect_opt>::const_iterator it = sect_opts.begin ();
2287 if (!seen_addr)
2288 ++it;
2289 for (; it != sect_opts.end (); ++it)
2290 {
2291 CORE_ADDR addr;
2292 const char *val = it->value;
2293 const char *sec = it->name;
2294
2295 if (section_addrs.empty ())
2296 gdb_printf (_(" at\n"));
2297 addr = parse_and_eval_address (val);
2298
2299 /* Here we store the section offsets in the order they were
2300 entered on the command line. Every array element is
2301 assigned an ascending section index to preserve the above
2302 order over an unstable sorting algorithm. This dummy
2303 index is not used for any other purpose.
2304 */
2305 section_addrs.emplace_back (addr, sec, section_addrs.size ());
2306 gdb_printf ("\t%s_addr = %s\n", sec,
2307 paddress (gdbarch, addr));
2308
2309 /* The object's sections are initialized when a
2310 call is made to build_objfile_section_table (objfile).
2311 This happens in reread_symbols.
2312 At this point, we don't know what file type this is,
2313 so we can't determine what section names are valid. */
2314 }
2315 if (seen_offset)
2316 gdb_printf (_("%s offset by %s\n"),
2317 (section_addrs.empty ()
2318 ? _(" with all sections")
2319 : _("with other sections")),
2320 paddress (gdbarch, offset));
2321 else if (section_addrs.empty ())
2322 gdb_printf ("\n");
2323
2324 if (from_tty && (!query ("%s", "")))
2325 error (_("Not confirmed."));
2326
2327 objf = symbol_file_add (filename.get (), add_flags, &section_addrs,
2328 flags);
2329 if (!objfile_has_symbols (objf) && objf->per_bfd->minimal_symbol_count <= 0)
2330 warning (_("newly-added symbol file \"%s\" does not provide any symbols"),
2331 filename.get ());
2332
2333 if (seen_offset)
2334 set_objfile_default_section_offset (objf, section_addrs, offset);
2335
2337
2338 /* Getting new symbols may change our opinion about what is
2339 frameless. */
2341}
2342
2343
2344/* This function removes a symbol file that was added via add-symbol-file. */
2345
2346static void
2347remove_symbol_file_command (const char *args, int from_tty)
2348{
2349 struct objfile *objf = NULL;
2350 struct program_space *pspace = current_program_space;
2351
2352 dont_repeat ();
2353
2354 if (args == NULL)
2355 error (_("remove-symbol-file: no symbol file provided"));
2356
2357 gdb_argv argv (args);
2358
2359 if (strcmp (argv[0], "-a") == 0)
2360 {
2361 /* Interpret the next argument as an address. */
2362 CORE_ADDR addr;
2363
2364 if (argv[1] == NULL)
2365 error (_("Missing address argument"));
2366
2367 if (argv[2] != NULL)
2368 error (_("Junk after %s"), argv[1]);
2369
2370 addr = parse_and_eval_address (argv[1]);
2371
2373 {
2374 if ((objfile->flags & OBJF_USERLOADED) != 0
2375 && (objfile->flags & OBJF_SHARED) != 0
2376 && objfile->pspace == pspace
2377 && is_addr_in_objfile (addr, objfile))
2378 {
2379 objf = objfile;
2380 break;
2381 }
2382 }
2383 }
2384 else if (argv[0] != NULL)
2385 {
2386 /* Interpret the current argument as a file name. */
2387
2388 if (argv[1] != NULL)
2389 error (_("Junk after %s"), argv[0]);
2390
2391 gdb::unique_xmalloc_ptr<char> filename (tilde_expand (argv[0]));
2392
2394 {
2395 if ((objfile->flags & OBJF_USERLOADED) != 0
2396 && (objfile->flags & OBJF_SHARED) != 0
2397 && objfile->pspace == pspace
2398 && filename_cmp (filename.get (), objfile_name (objfile)) == 0)
2399 {
2400 objf = objfile;
2401 break;
2402 }
2403 }
2404 }
2405
2406 if (objf == NULL)
2407 error (_("No symbol file found"));
2408
2409 if (from_tty
2410 && !query (_("Remove symbol table from file \"%s\"? "),
2411 objfile_name (objf)))
2412 error (_("Not confirmed."));
2413
2414 objf->unlink ();
2416}
2417
2418/* Re-read symbols if a symbol-file has changed. */
2419
2420void
2421reread_symbols (int from_tty)
2422{
2423 long new_modtime;
2424 struct stat new_statbuf;
2425 int res;
2426 std::vector<struct objfile *> new_objfiles;
2427
2429 {
2430 if (objfile->obfd.get () == NULL)
2431 continue;
2432
2433 /* Separate debug objfiles are handled in the main objfile. */
2435 continue;
2436
2437 /* If this object is from an archive (what you usually create with
2438 `ar', often called a `static library' on most systems, though
2439 a `shared library' on AIX is also an archive), then you should
2440 stat on the archive name, not member name. */
2441 if (objfile->obfd->my_archive)
2442 res = stat (bfd_get_filename (objfile->obfd->my_archive), &new_statbuf);
2443 else
2444 res = stat (objfile_name (objfile), &new_statbuf);
2445 if (res != 0)
2446 {
2447 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2448 gdb_printf (_("`%s' has disappeared; keeping its symbols.\n"),
2450 continue;
2451 }
2452 new_modtime = new_statbuf.st_mtime;
2453 if (new_modtime != objfile->mtime)
2454 {
2455 gdb_printf (_("`%s' has changed; re-reading symbols.\n"),
2457
2458 /* There are various functions like symbol_file_add,
2459 symfile_bfd_open, syms_from_objfile, etc., which might
2460 appear to do what we want. But they have various other
2461 effects which we *don't* want. So we just do stuff
2462 ourselves. We don't worry about mapped files (for one thing,
2463 any mapped file will be out of date). */
2464
2465 /* If we get an error, blow away this objfile (not sure if
2466 that is the correct response for things like shared
2467 libraries). */
2468 objfile_up objfile_holder (objfile);
2469
2470 /* We need to do this whenever any symbols go away. */
2471 clear_symtab_users_cleanup defer_clear_users (0);
2472
2473 if (current_program_space->exec_bfd () != NULL
2474 && filename_cmp (bfd_get_filename (objfile->obfd.get ()),
2475 bfd_get_filename (current_program_space->exec_bfd ())) == 0)
2476 {
2477 /* Reload EXEC_BFD without asking anything. */
2478
2479 exec_file_attach (bfd_get_filename (objfile->obfd.get ()), 0);
2480 }
2481
2482 /* Keep the calls order approx. the same as in free_objfile. */
2483
2484 /* Free the separate debug objfiles. It will be
2485 automatically recreated by sym_read. */
2487
2488 /* Clear the stale source cache. */
2490
2491 /* Remove any references to this objfile in the global
2492 value lists. */
2494
2495 /* Nuke all the state that we will re-read. Much of the following
2496 code which sets things to NULL really is necessary to tell
2497 other parts of GDB that there is nothing currently there.
2498
2499 Try to keep the freeing order compatible with free_objfile. */
2500
2501 if (objfile->sf != NULL)
2502 {
2504 }
2505
2507
2508 /* Clean up any state BFD has sitting around. */
2509 {
2511 const char *obfd_filename;
2512
2513 obfd_filename = bfd_get_filename (objfile->obfd.get ());
2514 /* Open the new BFD before freeing the old one, so that
2515 the filename remains live. */
2516 gdb_bfd_ref_ptr temp (gdb_bfd_open (obfd_filename, gnutarget));
2517 objfile->obfd = std::move (temp);
2518 if (objfile->obfd == NULL)
2519 error (_("Can't open %s to read symbols."), obfd_filename);
2520 }
2521
2522 std::string original_name = objfile->original_name;
2523
2524 /* bfd_openr sets cacheable to true, which is what we want. */
2525 if (!bfd_check_format (objfile->obfd.get (), bfd_object))
2526 error (_("Can't read symbols from %s: %s."), objfile_name (objfile),
2527 bfd_errmsg (bfd_get_error ()));
2528
2529 /* NB: after this call to obstack_free, objfiles_changed
2530 will need to be called (see discussion below). */
2531 obstack_free (&objfile->objfile_obstack, 0);
2532 objfile->sections = NULL;
2533 objfile->section_offsets.clear ();
2534 objfile->sect_index_bss = -1;
2538 objfile->compunit_symtabs = NULL;
2539 objfile->template_symbols = NULL;
2540 objfile->static_links.reset (nullptr);
2541
2542 /* obstack_init also initializes the obstack so it is
2543 empty. We could use obstack_specify_allocation but
2544 gdb_obstack.h specifies the alloc/dealloc functions. */
2545 obstack_init (&objfile->objfile_obstack);
2546
2547 /* set_objfile_per_bfd potentially allocates the per-bfd
2548 data on the objfile's obstack (if sharing data across
2549 multiple users is not possible), so it's important to
2550 do it *after* the obstack has been initialized. */
2552
2554 = obstack_strdup (&objfile->objfile_obstack, original_name);
2555
2556 /* Reset the sym_fns pointer. The ELF reader can change it
2557 based on whether .gdb_index is present, and we need it to
2558 start over. PR symtab/15885 */
2560 objfile->qf.clear ();
2561
2563
2564 /* What the hell is sym_new_init for, anyway? The concept of
2565 distinguishing between the main file and additional files
2566 in this way seems rather dubious. */
2568 {
2570 }
2571
2572 (*objfile->sf->sym_init) (objfile);
2574
2575 objfile->flags &= ~OBJF_PSYMTABS_READ;
2576
2577 /* We are about to read new symbols and potentially also
2578 DWARF information. Some targets may want to pass addresses
2579 read from DWARF DIE's through an adjustment function before
2580 saving them, like MIPS, which may call into
2581 "find_pc_section". When called, that function will make
2582 use of per-objfile program space data.
2583
2584 Since we discarded our section information above, we have
2585 dangling pointers in the per-objfile program space data
2586 structure. Force GDB to update the section mapping
2587 information by letting it know the objfile has changed,
2588 making the dangling pointers point to correct data
2589 again. */
2590
2592
2593 /* Recompute section offsets and section indices. */
2594 objfile->sf->sym_offsets (objfile, {});
2595
2596 read_symbols (objfile, 0);
2597
2598 if ((objfile->flags & OBJF_READNOW))
2599 {
2600 const int mainline = objfile->flags & OBJF_MAINLINE;
2601 const int should_print = (print_symbol_loading_p (from_tty, mainline, 1)
2603 if (should_print)
2604 gdb_printf (_("Expanding full symbols from %ps...\n"),
2607
2609 }
2610
2612 {
2613 gdb_stdout->wrap_here (0);
2614 gdb_printf (_("(no debugging symbols found)\n"));
2615 gdb_stdout->wrap_here (0);
2616 }
2617
2618 /* We're done reading the symbol file; finish off complaints. */
2620
2621 /* Getting new symbols may change our opinion about what is
2622 frameless. */
2623
2625
2626 /* Discard cleanups as symbol reading was successful. */
2627 objfile_holder.release ();
2628 defer_clear_users.release ();
2629
2630 /* If the mtime has changed between the time we set new_modtime
2631 and now, we *want* this to be out of date, so don't call stat
2632 again now. */
2633 objfile->mtime = new_modtime;
2635
2636 new_objfiles.push_back (objfile);
2637 }
2638 }
2639
2640 if (!new_objfiles.empty ())
2641 {
2643
2644 /* The registry for each objfile was cleared and
2645 gdb::observers::new_objfile.notify (NULL) has been called by
2646 clear_symtab_users above. Notify the new files now. */
2647 for (auto iter : new_objfiles)
2648 gdb::observers::new_objfile.notify (iter);
2649
2650 /* At least one objfile has changed, so we can consider that
2651 the executable we're debugging has changed too. */
2653 }
2654}
2655
2656
2658{
2659 filename_language (const std::string &ext_, enum language lang_)
2660 : ext (ext_), lang (lang_)
2661 {}
2662
2663 std::string ext;
2665};
2666
2667static std::vector<filename_language> filename_language_table;
2668
2669/* See symfile.h. */
2670
2671void
2672add_filename_language (const char *ext, enum language lang)
2673{
2674 gdb_assert (ext != nullptr);
2675 filename_language_table.emplace_back (ext, lang);
2676}
2677
2678static std::string ext_args;
2679static void
2680show_ext_args (struct ui_file *file, int from_tty,
2681 struct cmd_list_element *c, const char *value)
2682{
2683 gdb_printf (file,
2684 _("Mapping between filename extension "
2685 "and source language is \"%s\".\n"),
2686 value);
2687}
2688
2689static void
2690set_ext_lang_command (const char *args,
2691 int from_tty, struct cmd_list_element *e)
2692{
2693 const char *begin = ext_args.c_str ();
2694 const char *end = ext_args.c_str ();
2695
2696 /* First arg is filename extension, starting with '.' */
2697 if (*end != '.')
2698 error (_("'%s': Filename extension must begin with '.'"), ext_args.c_str ());
2699
2700 /* Find end of first arg. */
2701 while (*end != '\0' && !isspace (*end))
2702 end++;
2703
2704 if (*end == '\0')
2705 error (_("'%s': two arguments required -- "
2706 "filename extension and language"),
2707 ext_args.c_str ());
2708
2709 /* Extract first arg, the extension. */
2710 std::string extension = ext_args.substr (0, end - begin);
2711
2712 /* Find beginning of second arg, which should be a source language. */
2713 begin = skip_spaces (end);
2714
2715 if (*begin == '\0')
2716 error (_("'%s': two arguments required -- "
2717 "filename extension and language"),
2718 ext_args.c_str ());
2719
2720 /* Lookup the language from among those we know. */
2721 language lang = language_enum (begin);
2722
2723 auto it = filename_language_table.begin ();
2724 /* Now lookup the filename extension: do we already know it? */
2725 for (; it != filename_language_table.end (); it++)
2726 {
2727 if (it->ext == extension)
2728 break;
2729 }
2730
2731 if (it == filename_language_table.end ())
2732 {
2733 /* New file extension. */
2734 add_filename_language (extension.data (), lang);
2735 }
2736 else
2737 {
2738 /* Redefining a previously known filename extension. */
2739
2740 /* if (from_tty) */
2741 /* query ("Really make files of type %s '%s'?", */
2742 /* ext_args, language_str (lang)); */
2743
2744 it->lang = lang;
2745 }
2746}
2747
2748static void
2749info_ext_lang_command (const char *args, int from_tty)
2750{
2751 gdb_printf (_("Filename extensions and the languages they represent:"));
2752 gdb_printf ("\n\n");
2753 for (const filename_language &entry : filename_language_table)
2754 gdb_printf ("\t%s\t- %s\n", entry.ext.c_str (),
2755 language_str (entry.lang));
2756}
2757
2758enum language
2759deduce_language_from_filename (const char *filename)
2760{
2761 const char *cp;
2762
2763 if (filename != NULL)
2764 if ((cp = strrchr (filename, '.')) != NULL)
2765 {
2766 for (const filename_language &entry : filename_language_table)
2767 if (entry.ext == cp)
2768 return entry.lang;
2769 }
2770
2771 return language_unknown;
2772}
2773
2774/* Allocate and initialize a new symbol table.
2775 CUST is from the result of allocate_compunit_symtab. */
2776
2777struct symtab *
2778allocate_symtab (struct compunit_symtab *cust, const char *filename,
2779 const char *filename_for_id)
2780{
2781 struct objfile *objfile = cust->objfile ();
2782 struct symtab *symtab
2783 = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symtab);
2784
2787 symtab->fullname = NULL;
2789
2790 /* This can be very verbose with lots of headers.
2791 Only print at higher debug levels. */
2792 if (symtab_create_debug >= 2)
2793 {
2794 /* Be a bit clever with debugging messages, and don't print objfile
2795 every time, only when it changes. */
2796 static std::string last_objfile_name;
2797 const char *this_objfile_name = objfile_name (objfile);
2798
2799 if (last_objfile_name.empty () || last_objfile_name != this_objfile_name)
2800 {
2801 last_objfile_name = this_objfile_name;
2802
2804 ("creating one or more symtabs for objfile %s", this_objfile_name);
2805 }
2806
2807 symtab_create_debug_printf_v ("created symtab %s for module %s",
2808 host_address_to_string (symtab), filename);
2809 }
2810
2811 /* Add it to CUST's list of symtabs. */
2812 cust->add_filetab (symtab);
2813
2814 /* Backlink to the containing compunit symtab. */
2815 symtab->set_compunit (cust);
2816
2817 return symtab;
2818}
2819
2820/* Allocate and initialize a new compunit.
2821 NAME is the name of the main source file, if there is one, or some
2822 descriptive text if there are no source files. */
2823
2824struct compunit_symtab *
2826{
2827 struct compunit_symtab *cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2828 struct compunit_symtab);
2829 const char *saved_name;
2830
2831 cu->set_objfile (objfile);
2832
2833 /* The name we record here is only for display/debugging purposes.
2834 Just save the basename to avoid path issues (too long for display,
2835 relative vs absolute, etc.). */
2836 saved_name = lbasename (name);
2837 cu->name = obstack_strdup (&objfile->objfile_obstack, saved_name);
2838
2839 cu->set_debugformat ("unknown");
2840
2841 symtab_create_debug_printf_v ("created compunit symtab %s for %s",
2842 host_address_to_string (cu),
2843 cu->name);
2844
2845 return cu;
2846}
2847
2848/* Hook CU to the objfile it comes from. */
2849
2850void
2852{
2853 cu->next = cu->objfile ()->compunit_symtabs;
2854 cu->objfile ()->compunit_symtabs = cu;
2855}
2856
2857
2858/* Reset all data structures in gdb which may contain references to
2859 symbol table data. */
2860
2861void
2862clear_symtab_users (symfile_add_flags add_flags)
2863{
2864 /* Someday, we should do better than this, by only blowing away
2865 the things that really need to be blown. */
2866
2867 /* Clear the "current" symtab first, because it is no longer valid.
2868 breakpoint_re_set may try to access the current symtab. */
2870
2871 clear_displays ();
2874 gdb::observers::new_objfile.notify (NULL);
2875
2876 /* Now that the various caches have been cleared, we can re_set
2877 our breakpoints without risking it using stale data. */
2878 if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
2880}
2881
2882/* OVERLAYS:
2883 The following code implements an abstraction for debugging overlay sections.
2884
2885 The target model is as follows:
2886 1) The gnu linker will permit multiple sections to be mapped into the
2887 same VMA, each with its own unique LMA (or load address).
2888 2) It is assumed that some runtime mechanism exists for mapping the
2889 sections, one by one, from the load address into the VMA address.
2890 3) This code provides a mechanism for gdb to keep track of which
2891 sections should be considered to be mapped from the VMA to the LMA.
2892 This information is used for symbol lookup, and memory read/write.
2893 For instance, if a section has been mapped then its contents
2894 should be read from the VMA, otherwise from the LMA.
2895
2896 Two levels of debugger support for overlays are available. One is
2897 "manual", in which the debugger relies on the user to tell it which
2898 overlays are currently mapped. This level of support is
2899 implemented entirely in the core debugger, and the information about
2900 whether a section is mapped is kept in the objfile->obj_section table.
2901
2902 The second level of support is "automatic", and is only available if
2903 the target-specific code provides functionality to read the target's
2904 overlay mapping table, and translate its contents for the debugger
2905 (by updating the mapped state information in the obj_section tables).
2906
2907 The interface is as follows:
2908 User commands:
2909 overlay map <name> -- tell gdb to consider this section mapped
2910 overlay unmap <name> -- tell gdb to consider this section unmapped
2911 overlay list -- list the sections that GDB thinks are mapped
2912 overlay read-target -- get the target's state of what's mapped
2913 overlay off/manual/auto -- set overlay debugging state
2914 Functional interface:
2915 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2916 section, return that section.
2917 find_pc_overlay(pc): find any overlay section that contains
2918 the pc, either in its VMA or its LMA
2919 section_is_mapped(sect): true if overlay is marked as mapped
2920 section_is_overlay(sect): true if section's VMA != LMA
2921 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2922 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2923 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2924 overlay_mapped_address(...): map an address from section's LMA to VMA
2925 overlay_unmapped_address(...): map an address from section's VMA to LMA
2926 symbol_overlayed_address(...): Return a "current" address for symbol:
2927 either in VMA or LMA depending on whether
2928 the symbol's section is currently mapped. */
2929
2930/* Overlay debugging state: */
2931
2933int overlay_cache_invalid = 0; /* True if need to refresh mapped state. */
2934
2935/* Function: section_is_overlay (SECTION)
2936 Returns true if SECTION has VMA not equal to LMA, ie.
2937 SECTION is loaded at an address different from where it will "run". */
2938
2939int
2941{
2942 if (overlay_debugging && section)
2943 {
2944 asection *bfd_section = section->the_bfd_section;
2945
2946 if (bfd_section_lma (bfd_section) != 0
2947 && bfd_section_lma (bfd_section) != bfd_section_vma (bfd_section))
2948 return 1;
2949 }
2950
2951 return 0;
2952}
2953
2954/* Function: overlay_invalidate_all (void)
2955 Invalidate the mapped state of all overlay sections (mark it as stale). */
2956
2957static void
2959{
2960 struct obj_section *sect;
2961
2964 if (section_is_overlay (sect))
2965 sect->ovly_mapped = -1;
2966}
2967
2968/* Function: section_is_mapped (SECTION)
2969 Returns true if section is an overlay, and is currently mapped.
2970
2971 Access to the ovly_mapped flag is restricted to this function, so
2972 that we can do automatic update. If the global flag
2973 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2974 overlay_invalidate_all. If the mapped state of the particular
2975 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2976
2977int
2979{
2980 struct gdbarch *gdbarch;
2981
2982 if (osect == 0 || !section_is_overlay (osect))
2983 return 0;
2984
2985 switch (overlay_debugging)
2986 {
2987 default:
2988 case ovly_off:
2989 return 0; /* overlay debugging off */
2990 case ovly_auto: /* overlay debugging automatic */
2991 /* Unles there is a gdbarch_overlay_update function,
2992 there's really nothing useful to do here (can't really go auto). */
2993 gdbarch = osect->objfile->arch ();
2995 {
2997 {
3000 }
3001 if (osect->ovly_mapped == -1)
3003 }
3004 /* fall thru */
3005 case ovly_on: /* overlay debugging manual */
3006 return osect->ovly_mapped == 1;
3007 }
3008}
3009
3010/* Function: pc_in_unmapped_range
3011 If PC falls into the lma range of SECTION, return true, else false. */
3012
3013CORE_ADDR
3014pc_in_unmapped_range (CORE_ADDR pc, struct obj_section *section)
3015{
3016 if (section_is_overlay (section))
3017 {
3018 asection *bfd_section = section->the_bfd_section;
3019
3020 /* We assume the LMA is relocated by the same offset as the VMA. */
3021 bfd_vma size = bfd_section_size (bfd_section);
3022 CORE_ADDR offset = section->offset ();
3023
3024 if (bfd_section_lma (bfd_section) + offset <= pc
3025 && pc < bfd_section_lma (bfd_section) + offset + size)
3026 return 1;
3027 }
3028
3029 return 0;
3030}
3031
3032/* Function: pc_in_mapped_range
3033 If PC falls into the vma range of SECTION, return true, else false. */
3034
3035CORE_ADDR
3036pc_in_mapped_range (CORE_ADDR pc, struct obj_section *section)
3037{
3038 if (section_is_overlay (section))
3039 {
3040 if (section->addr () <= pc
3041 && pc < section->endaddr ())
3042 return 1;
3043 }
3044
3045 return 0;
3046}
3047
3048/* Return true if the mapped ranges of sections A and B overlap, false
3049 otherwise. */
3050
3051static int
3053{
3054 CORE_ADDR a_start = a->addr ();
3055 CORE_ADDR a_end = a->endaddr ();
3056 CORE_ADDR b_start = b->addr ();
3057 CORE_ADDR b_end = b->endaddr ();
3058
3059 return (a_start < b_end && b_start < a_end);
3060}
3061
3062/* Function: overlay_unmapped_address (PC, SECTION)
3063 Returns the address corresponding to PC in the unmapped (load) range.
3064 May be the same as PC. */
3065
3066CORE_ADDR
3067overlay_unmapped_address (CORE_ADDR pc, struct obj_section *section)
3068{
3069 if (section_is_overlay (section) && pc_in_mapped_range (pc, section))
3070 {
3071 asection *bfd_section = section->the_bfd_section;
3072
3073 return (pc + bfd_section_lma (bfd_section)
3074 - bfd_section_vma (bfd_section));
3075 }
3076
3077 return pc;
3078}
3079
3080/* Function: overlay_mapped_address (PC, SECTION)
3081 Returns the address corresponding to PC in the mapped (runtime) range.
3082 May be the same as PC. */
3083
3084CORE_ADDR
3085overlay_mapped_address (CORE_ADDR pc, struct obj_section *section)
3086{
3087 if (section_is_overlay (section) && pc_in_unmapped_range (pc, section))
3088 {
3089 asection *bfd_section = section->the_bfd_section;
3090
3091 return (pc + bfd_section_vma (bfd_section)
3092 - bfd_section_lma (bfd_section));
3093 }
3094
3095 return pc;
3096}
3097
3098/* Function: symbol_overlayed_address
3099 Return one of two addresses (relative to the VMA or to the LMA),
3100 depending on whether the section is mapped or not. */
3101
3102CORE_ADDR
3103symbol_overlayed_address (CORE_ADDR address, struct obj_section *section)
3104{
3106 {
3107 /* If the symbol has no section, just return its regular address. */
3108 if (section == 0)
3109 return address;
3110 /* If the symbol's section is not an overlay, just return its
3111 address. */
3112 if (!section_is_overlay (section))
3113 return address;
3114 /* If the symbol's section is mapped, just return its address. */
3115 if (section_is_mapped (section))
3116 return address;
3117 /*
3118 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3119 * then return its LOADED address rather than its vma address!!
3120 */
3121 return overlay_unmapped_address (address, section);
3122 }
3123 return address;
3124}
3125
3126/* Function: find_pc_overlay (PC)
3127 Return the best-match overlay section for PC:
3128 If PC matches a mapped overlay section's VMA, return that section.
3129 Else if PC matches an unmapped section's VMA, return that section.
3130 Else if PC matches an unmapped section's LMA, return that section. */
3131
3132struct obj_section *
3133find_pc_overlay (CORE_ADDR pc)
3134{
3135 struct obj_section *osect, *best_match = NULL;
3136
3138 {
3141 if (section_is_overlay (osect))
3142 {
3143 if (pc_in_mapped_range (pc, osect))
3144 {
3145 if (section_is_mapped (osect))
3146 return osect;
3147 else
3148 best_match = osect;
3149 }
3150 else if (pc_in_unmapped_range (pc, osect))
3151 best_match = osect;
3152 }
3153 }
3154 return best_match;
3155}
3156
3157/* Function: find_pc_mapped_section (PC)
3158 If PC falls into the VMA address range of an overlay section that is
3159 currently marked as MAPPED, return that section. Else return NULL. */
3160
3161struct obj_section *
3163{
3164 struct obj_section *osect;
3165
3167 {
3170 if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect))
3171 return osect;
3172 }
3173
3174 return NULL;
3175}
3176
3177/* Function: list_overlays_command
3178 Print a list of mapped sections and their PC ranges. */
3179
3180static void
3181list_overlays_command (const char *args, int from_tty)
3182{
3183 int nmapped = 0;
3184 struct obj_section *osect;
3185
3187 {
3190 if (section_is_mapped (osect))
3191 {
3192 struct gdbarch *gdbarch = objfile->arch ();
3193 const char *name;
3194 bfd_vma lma, vma;
3195 int size;
3196
3197 vma = bfd_section_vma (osect->the_bfd_section);
3198 lma = bfd_section_lma (osect->the_bfd_section);
3199 size = bfd_section_size (osect->the_bfd_section);
3200 name = bfd_section_name (osect->the_bfd_section);
3201
3202 gdb_printf ("Section %s, loaded at ", name);
3203 gdb_puts (paddress (gdbarch, lma));
3204 gdb_puts (" - ");
3205 gdb_puts (paddress (gdbarch, lma + size));
3206 gdb_printf (", mapped at ");
3207 gdb_puts (paddress (gdbarch, vma));
3208 gdb_puts (" - ");
3209 gdb_puts (paddress (gdbarch, vma + size));
3210 gdb_puts ("\n");
3211
3212 nmapped++;
3213 }
3214 }
3215 if (nmapped == 0)
3216 gdb_printf (_("No sections are mapped.\n"));
3217}
3218
3219/* Function: map_overlay_command
3220 Mark the named section as mapped (ie. residing at its VMA address). */
3221
3222static void
3223map_overlay_command (const char *args, int from_tty)
3224{
3225 struct obj_section *sec, *sec2;
3226
3227 if (!overlay_debugging)
3228 error (_("Overlay debugging not enabled. Use "
3229 "either the 'overlay auto' or\n"
3230 "the 'overlay manual' command."));
3231
3232 if (args == 0 || *args == 0)
3233 error (_("Argument required: name of an overlay section"));
3234
3235 /* First, find a section matching the user supplied argument. */
3236 for (objfile *obj_file : current_program_space->objfiles ())
3237 ALL_OBJFILE_OSECTIONS (obj_file, sec)
3238 if (!strcmp (bfd_section_name (sec->the_bfd_section), args))
3239 {
3240 /* Now, check to see if the section is an overlay. */
3241 if (!section_is_overlay (sec))
3242 continue; /* not an overlay section */
3243
3244 /* Mark the overlay as "mapped". */
3245 sec->ovly_mapped = 1;
3246
3247 /* Next, make a pass and unmap any sections that are
3248 overlapped by this new section: */
3249 for (objfile *objfile2 : current_program_space->objfiles ())
3250 ALL_OBJFILE_OSECTIONS (objfile2, sec2)
3251 if (sec2->ovly_mapped && sec != sec2 && sections_overlap (sec,
3252 sec2))
3253 {
3254 if (info_verbose)
3255 gdb_printf (_("Note: section %s unmapped by overlap\n"),
3256 bfd_section_name (sec2->the_bfd_section));
3257 sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2. */
3258 }
3259 return;
3260 }
3261 error (_("No overlay section called %s"), args);
3262}
3263
3264/* Function: unmap_overlay_command
3265 Mark the overlay section as unmapped
3266 (ie. resident in its LMA address range, rather than the VMA range). */
3267
3268static void
3269unmap_overlay_command (const char *args, int from_tty)
3270{
3271 struct obj_section *sec = NULL;
3272
3273 if (!overlay_debugging)
3274 error (_("Overlay debugging not enabled. "
3275 "Use either the 'overlay auto' or\n"
3276 "the 'overlay manual' command."));
3277
3278 if (args == 0 || *args == 0)
3279 error (_("Argument required: name of an overlay section"));
3280
3281 /* First, find a section matching the user supplied argument. */
3284 if (!strcmp (bfd_section_name (sec->the_bfd_section), args))
3285 {
3286 if (!sec->ovly_mapped)
3287 error (_("Section %s is not mapped"), args);
3288 sec->ovly_mapped = 0;
3289 return;
3290 }
3291 error (_("No overlay section called %s"), args);
3292}
3293
3294/* Function: overlay_auto_command
3295 A utility command to turn on overlay debugging.
3296 Possibly this should be done via a set/show command. */
3297
3298static void
3299overlay_auto_command (const char *args, int from_tty)
3300{
3303 if (info_verbose)
3304 gdb_printf (_("Automatic overlay debugging enabled."));
3305}
3306
3307/* Function: overlay_manual_command
3308 A utility command to turn on overlay debugging.
3309 Possibly this should be done via a set/show command. */
3310
3311static void
3312overlay_manual_command (const char *args, int from_tty)
3313{
3316 if (info_verbose)
3317 gdb_printf (_("Overlay debugging enabled."));
3318}
3319
3320/* Function: overlay_off_command
3321 A utility command to turn on overlay debugging.
3322 Possibly this should be done via a set/show command. */
3323
3324static void
3325overlay_off_command (const char *args, int from_tty)
3326{
3329 if (info_verbose)
3330 gdb_printf (_("Overlay debugging disabled."));
3331}
3332
3333static void
3334overlay_load_command (const char *args, int from_tty)
3335{
3336 struct gdbarch *gdbarch = get_current_arch ();
3337
3340 else
3341 error (_("This target does not know how to read its overlay state."));
3342}
3343
3344/* Command list chain containing all defined "overlay" subcommands. */
3346
3347/* Target Overlays for the "Simplest" overlay manager:
3348
3349 This is GDB's default target overlay layer. It works with the
3350 minimal overlay manager supplied as an example by Cygnus. The
3351 entry point is via a function pointer "gdbarch_overlay_update",
3352 so targets that use a different runtime overlay manager can
3353 substitute their own overlay_update function and take over the
3354 function pointer.
3355
3356 The overlay_update function pokes around in the target's data structures
3357 to see what overlays are mapped, and updates GDB's overlay mapping with
3358 this information.
3359
3360 In this simple implementation, the target data structures are as follows:
3361 unsigned _novlys; /# number of overlay sections #/
3362 unsigned _ovly_table[_novlys][4] = {
3363 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3364 {..., ..., ..., ...},
3365 }
3366 unsigned _novly_regions; /# number of overlay regions #/
3367 unsigned _ovly_region_table[_novly_regions][3] = {
3368 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3369 {..., ..., ...},
3370 }
3371 These functions will attempt to update GDB's mappedness state in the
3372 symbol section table, based on the target's mappedness state.
3373
3374 To do this, we keep a cached copy of the target's _ovly_table, and
3375 attempt to detect when the cached copy is invalidated. The main
3376 entry point is "simple_overlay_update(SECT), which looks up SECT in
3377 the cached table and re-reads only the entry for that section from
3378 the target (whenever possible). */
3379
3380/* Cached, dynamically allocated copies of the target data structures: */
3381static unsigned (*cache_ovly_table)[4] = 0;
3382static unsigned cache_novlys = 0;
3383static CORE_ADDR cache_ovly_table_base = 0;
3385 {
3388
3389/* Throw away the cached copy of _ovly_table. */
3390
3391static void
3393{
3395 cache_novlys = 0;
3396 cache_ovly_table = NULL;
3398}
3399
3400/* Read an array of ints of size SIZE from the target into a local buffer.
3401 Convert to host order. int LEN is number of ints. */
3402
3403static void
3404read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr,
3405 int len, int size, enum bfd_endian byte_order)
3406{
3407 /* FIXME (alloca): Not safe if array is very large. */
3408 gdb_byte *buf = (gdb_byte *) alloca (len * size);
3409 int i;
3410
3411 read_memory (memaddr, buf, len * size);
3412 for (i = 0; i < len; i++)
3413 myaddr[i] = extract_unsigned_integer (size * i + buf, size, byte_order);
3414}
3415
3416/* Find and grab a copy of the target _ovly_table
3417 (and _novlys, which is needed for the table's size). */
3418
3419static int
3421{
3422 struct bound_minimal_symbol novlys_msym;
3423 struct bound_minimal_symbol ovly_table_msym;
3424 struct gdbarch *gdbarch;
3425 int word_size;
3426 enum bfd_endian byte_order;
3427
3429 novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL);
3430 if (! novlys_msym.minsym)
3431 {
3432 error (_("Error reading inferior's overlay table: "
3433 "couldn't find `_novlys' variable\n"
3434 "in inferior. Use `overlay manual' mode."));
3435 return 0;
3436 }
3437
3438 ovly_table_msym = lookup_bound_minimal_symbol ("_ovly_table");
3439 if (! ovly_table_msym.minsym)
3440 {
3441 error (_("Error reading inferior's overlay table: couldn't find "
3442 "`_ovly_table' array\n"
3443 "in inferior. Use `overlay manual' mode."));
3444 return 0;
3445 }
3446
3447 gdbarch = ovly_table_msym.objfile->arch ();
3448 word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3449 byte_order = gdbarch_byte_order (gdbarch);
3450
3452 4, byte_order);
3454 = (unsigned int (*)[4]) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
3455 cache_ovly_table_base = ovly_table_msym.value_address ();
3457 (unsigned int *) cache_ovly_table,
3458 cache_novlys * 4, word_size, byte_order);
3459
3460 return 1; /* SUCCESS */
3461}
3462
3463/* Function: simple_overlay_update_1
3464 A helper function for simple_overlay_update. Assuming a cached copy
3465 of _ovly_table exists, look through it to find an entry whose vma,
3466 lma and size match those of OSECT. Re-read the entry and make sure
3467 it still matches OSECT (else the table may no longer be valid).
3468 Set OSECT's mapped state to match the entry. Return: 1 for
3469 success, 0 for failure. */
3470
3471static int
3473{
3474 int i;
3475 asection *bsect = osect->the_bfd_section;
3476 struct gdbarch *gdbarch = osect->objfile->arch ();
3477 int word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
3478 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3479
3480 for (i = 0; i < cache_novlys; i++)
3481 if (cache_ovly_table[i][VMA] == bfd_section_vma (bsect)
3482 && cache_ovly_table[i][LMA] == bfd_section_lma (bsect))
3483 {
3485 (unsigned int *) cache_ovly_table[i],
3486 4, word_size, byte_order);
3487 if (cache_ovly_table[i][VMA] == bfd_section_vma (bsect)
3488 && cache_ovly_table[i][LMA] == bfd_section_lma (bsect))
3489 {
3490 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3491 return 1;
3492 }
3493 else /* Warning! Warning! Target's ovly table has changed! */
3494 return 0;
3495 }
3496 return 0;
3497}
3498
3499/* Function: simple_overlay_update
3500 If OSECT is NULL, then update all sections' mapped state
3501 (after re-reading the entire target _ovly_table).
3502 If OSECT is non-NULL, then try to find a matching entry in the
3503 cached ovly_table and update only OSECT's mapped state.
3504 If a cached entry can't be found or the cache isn't valid, then
3505 re-read the entire cache, and go ahead and update all sections. */
3506
3507void
3509{
3510 /* Were we given an osect to look up? NULL means do all of them. */
3511 if (osect)
3512 /* Have we got a cached copy of the target's overlay table? */
3513 if (cache_ovly_table != NULL)
3514 {
3515 /* Does its cached location match what's currently in the
3516 symtab? */
3518 = lookup_minimal_symbol ("_ovly_table", NULL, NULL);
3519
3520 if (minsym.minsym == NULL)
3521 error (_("Error reading inferior's overlay table: couldn't "
3522 "find `_ovly_table' array\n"
3523 "in inferior. Use `overlay manual' mode."));
3524
3526 /* Then go ahead and try to look up this single section in
3527 the cache. */
3528 if (simple_overlay_update_1 (osect))
3529 /* Found it! We're done. */
3530 return;
3531 }
3532
3533 /* Cached table no good: need to read the entire table anew.
3534 Or else we want all the sections, in which case it's actually
3535 more efficient to read the whole table in one block anyway. */
3536
3538 return;
3539
3540 /* Now may as well update all sections, even if only one was requested. */
3543 if (section_is_overlay (osect))
3544 {
3545 int i;
3546 asection *bsect = osect->the_bfd_section;
3547
3548 for (i = 0; i < cache_novlys; i++)
3549 if (cache_ovly_table[i][VMA] == bfd_section_vma (bsect)
3550 && cache_ovly_table[i][LMA] == bfd_section_lma (bsect))
3551 { /* obj_section matches i'th entry in ovly_table. */
3552 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3553 break; /* finished with inner for loop: break out. */
3554 }
3555 }
3556}
3557
3558/* Default implementation for sym_relocate. */
3559
3560bfd_byte *
3561default_symfile_relocate (struct objfile *objfile, asection *sectp,
3562 bfd_byte *buf)
3563{
3564 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3565 DWO file. */
3566 bfd *abfd = sectp->owner;
3567
3568 /* We're only interested in sections with relocation
3569 information. */
3570 if ((sectp->flags & SEC_RELOC) == 0)
3571 return NULL;
3572
3573 /* We will handle section offsets properly elsewhere, so relocate as if
3574 all sections begin at 0. */
3575 for (asection *sect : gdb_bfd_sections (abfd))
3576 {
3577 sect->output_section = sect;
3578 sect->output_offset = 0;
3579 }
3580
3581 return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
3582}
3583
3584/* Relocate the contents of a debug section SECTP in ABFD. The
3585 contents are stored in BUF if it is non-NULL, or returned in a
3586 malloc'd buffer otherwise.
3587
3588 For some platforms and debug info formats, shared libraries contain
3589 relocations against the debug sections (particularly for DWARF-2;
3590 one affected platform is PowerPC GNU/Linux, although it depends on
3591 the version of the linker in use). Also, ELF object files naturally
3592 have unresolved relocations for their debug sections. We need to apply
3593 the relocations in order to get the locations of symbols correct.
3594 Another example that may require relocation processing, is the
3595 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3596 debug section. */
3597
3598bfd_byte *
3600 asection *sectp, bfd_byte *buf)
3601{
3602 gdb_assert (objfile->sf->sym_relocate);
3603
3604 return (*objfile->sf->sym_relocate) (objfile, sectp, buf);
3605}
3606
3609{
3610 const struct sym_fns *sf = find_sym_fns (abfd);
3611
3612 if (sf == NULL)
3613 return NULL;
3614
3615 return sf->sym_segments (abfd);
3616}
3617
3618/* Given:
3619 - DATA, containing segment addresses from the object file ABFD, and
3620 the mapping from ABFD's sections onto the segments that own them,
3621 and
3622 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3623 segment addresses reported by the target,
3624 store the appropriate offsets for each section in OFFSETS.
3625
3626 If there are fewer entries in SEGMENT_BASES than there are segments
3627 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3628
3629 If there are more entries, then ignore the extra. The target may
3630 not be able to distinguish between an empty data segment and a
3631 missing data segment; a missing text segment is less plausible. */
3632
3633int
3635 const struct symfile_segment_data *data,
3636 section_offsets &offsets,
3637 int num_segment_bases,
3638 const CORE_ADDR *segment_bases)
3639{
3640 int i;
3641 asection *sect;
3642
3643 /* It doesn't make sense to call this function unless you have some
3644 segment base addresses. */
3645 gdb_assert (num_segment_bases > 0);
3646
3647 /* If we do not have segment mappings for the object file, we
3648 can not relocate it by segments. */
3649 gdb_assert (data != NULL);
3650 gdb_assert (data->segments.size () > 0);
3651
3652 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
3653 {
3654 int which = data->segment_info[i];
3655
3656 gdb_assert (0 <= which && which <= data->segments.size ());
3657
3658 /* Don't bother computing offsets for sections that aren't
3659 loaded as part of any segment. */
3660 if (! which)
3661 continue;
3662
3663 /* Use the last SEGMENT_BASES entry as the address of any extra
3664 segments mentioned in DATA->segment_info. */
3665 if (which > num_segment_bases)
3666 which = num_segment_bases;
3667
3668 offsets[i] = segment_bases[which - 1] - data->segments[which - 1].base;
3669 }
3670
3671 return 1;
3672}
3673
3674static void
3676{
3677 bfd *abfd = objfile->obfd.get ();
3678 int i;
3679 asection *sect;
3680
3682 if (data == NULL)
3683 return;
3684
3685 if (data->segments.size () != 1 && data->segments.size () != 2)
3686 return;
3687
3688 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
3689 {
3690 int which = data->segment_info[i];
3691
3692 if (which == 1)
3693 {
3694 if (objfile->sect_index_text == -1)
3695 objfile->sect_index_text = sect->index;
3696
3697 if (objfile->sect_index_rodata == -1)
3698 objfile->sect_index_rodata = sect->index;
3699 }
3700 else if (which == 2)
3701 {
3702 if (objfile->sect_index_data == -1)
3703 objfile->sect_index_data = sect->index;
3704
3705 if (objfile->sect_index_bss == -1)
3706 objfile->sect_index_bss = sect->index;
3707 }
3708 }
3709}
3710
3711/* Listen for free_objfile events. */
3712
3713static void
3715{
3716 /* Remove the target sections owned by this objfile. */
3717 if (objfile != NULL)
3719}
3720
3721/* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3722 Expand all symtabs that match the specified criteria.
3723 See quick_symbol_functions.expand_symtabs_matching for details. */
3724
3725bool
3727 (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
3728 const lookup_name_info &lookup_name,
3729 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
3730 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
3731 block_search_flags search_flags,
3732 enum search_domain kind)
3733{
3735 if (!objfile->expand_symtabs_matching (file_matcher,
3736 &lookup_name,
3737 symbol_matcher,
3738 expansion_notify,
3739 search_flags,
3741 kind))
3742 return false;
3743 return true;
3744}
3745
3746/* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3747 Map function FUN over every file.
3748 See quick_symbol_functions.map_symbol_filenames for details. */
3749
3750void
3751map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun,
3752 bool need_fullname)
3753{
3755 objfile->map_symbol_filenames (fun, need_fullname);
3756}
3757
3758#if GDB_SELF_TEST
3759
3760namespace selftests {
3761namespace filename_language {
3762
3763static void test_filename_language ()
3764{
3765 /* This test messes up the filename_language_table global. */
3766 scoped_restore restore_flt = make_scoped_restore (&filename_language_table);
3767
3768 /* Test deducing an unknown extension. */
3769 language lang = deduce_language_from_filename ("myfile.blah");
3770 SELF_CHECK (lang == language_unknown);
3771
3772 /* Test deducing a known extension. */
3773 lang = deduce_language_from_filename ("myfile.c");
3774 SELF_CHECK (lang == language_c);
3775
3776 /* Test adding a new extension using the internal API. */
3778 lang = deduce_language_from_filename ("myfile.blah");
3779 SELF_CHECK (lang == language_pascal);
3780}
3781
3782static void
3783test_set_ext_lang_command ()
3784{
3785 /* This test messes up the filename_language_table global. */
3786 scoped_restore restore_flt = make_scoped_restore (&filename_language_table);
3787
3788 /* Confirm that the .hello extension is not known. */
3789 language lang = deduce_language_from_filename ("cake.hello");
3790 SELF_CHECK (lang == language_unknown);
3791
3792 /* Test adding a new extension using the CLI command. */
3793 ext_args = ".hello rust";
3794 set_ext_lang_command (NULL, 1, NULL);
3795
3796 lang = deduce_language_from_filename ("cake.hello");
3797 SELF_CHECK (lang == language_rust);
3798
3799 /* Test overriding an existing extension using the CLI command. */
3800 int size_before = filename_language_table.size ();
3801 ext_args = ".hello pascal";
3802 set_ext_lang_command (NULL, 1, NULL);
3803 int size_after = filename_language_table.size ();
3804
3805 lang = deduce_language_from_filename ("cake.hello");
3806 SELF_CHECK (lang == language_pascal);
3807 SELF_CHECK (size_before == size_after);
3808}
3809
3810} /* namespace filename_language */
3811} /* namespace selftests */
3812
3813#endif /* GDB_SELF_TEST */
3814
3815void _initialize_symfile ();
3816void
3818{
3819 struct cmd_list_element *c;
3820
3822
3823#define READNOW_READNEVER_HELP \
3824 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3825immediately. This makes the command slower, but may make future operations\n\
3826faster.\n\
3827The '-readnever' option will prevent GDB from reading the symbol file's\n\
3828symbolic debug information."
3829
3830 c = add_cmd ("symbol-file", class_files, symbol_file_command, _("\
3831Load symbol table from executable file FILE.\n\
3832Usage: symbol-file [-readnow | -readnever] [-o OFF] FILE\n\
3833OFF is an optional offset which is added to each section address.\n\
3834The `file' command can also load symbol tables, as well as setting the file\n\
3835to execute.\n" READNOW_READNEVER_HELP), &cmdlist);
3837
3838 c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command, _("\
3839Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3840Usage: add-symbol-file FILE [-readnow | -readnever] [-o OFF] [ADDR] \
3841[-s SECT-NAME SECT-ADDR]...\n\
3842ADDR is the starting address of the file's text.\n\
3843Each '-s' argument provides a section name and address, and\n\
3844should be specified if the data and bss segments are not contiguous\n\
3845with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n\
3846OFF is an optional offset which is added to the default load addresses\n\
3847of all sections for which no other address was specified.\n"
3849 &cmdlist);
3851
3852 c = add_cmd ("remove-symbol-file", class_files,
3854Remove a symbol file added via the add-symbol-file command.\n\
3855Usage: remove-symbol-file FILENAME\n\
3856 remove-symbol-file -a ADDRESS\n\
3857The file to remove can be identified by its filename or by an address\n\
3858that lies within the boundaries of this symbol file in memory."),
3859 &cmdlist);
3860
3861 c = add_cmd ("load", class_files, load_command, _("\
3862Dynamically load FILE into the running program.\n\
3863FILE symbols are recorded for access from GDB.\n\
3864Usage: load [FILE] [OFFSET]\n\
3865An optional load OFFSET may also be given as a literal address.\n\
3866When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3867on its own."), &cmdlist);
3869
3870 cmd_list_element *overlay_cmd
3871 = add_basic_prefix_cmd ("overlay", class_support,
3872 _("Commands for debugging overlays."), &overlaylist,
3873 0, &cmdlist);
3874
3875 add_com_alias ("ovly", overlay_cmd, class_support, 1);
3876 add_com_alias ("ov", overlay_cmd, class_support, 1);
3877
3878 add_cmd ("map-overlay", class_support, map_overlay_command,
3879 _("Assert that an overlay section is mapped."), &overlaylist);
3880
3881 add_cmd ("unmap-overlay", class_support, unmap_overlay_command,
3882 _("Assert that an overlay section is unmapped."), &overlaylist);
3883
3884 add_cmd ("list-overlays", class_support, list_overlays_command,
3885 _("List mappings of overlay sections."), &overlaylist);
3886
3888 _("Enable overlay debugging."), &overlaylist);
3890 _("Disable overlay debugging."), &overlaylist);
3892 _("Enable automatic overlay debugging."), &overlaylist);
3894 _("Read the overlay mapping state from the target."), &overlaylist);
3895
3896 /* Filename extension to source language lookup table: */
3897 add_setshow_string_noescape_cmd ("extension-language", class_files,
3898 &ext_args, _("\
3899Set mapping between filename extension and source language."), _("\
3900Show mapping between filename extension and source language."), _("\
3901Usage: set extension-language .foo bar"),
3904 &setlist, &showlist);
3905
3906 add_info ("extensions", info_ext_lang_command,
3907 _("All filename extensions associated with a source language."));
3908
3909 add_setshow_optional_filename_cmd ("debug-file-directory", class_support,
3911Set the directories where separate debug symbols are searched for."), _("\
3912Show the directories where separate debug symbols are searched for."), _("\
3913Separate debug symbols are first searched for in the same\n\
3914directory as the binary, then in the `" DEBUG_SUBDIRECTORY "' subdirectory,\n\
3915and lastly at the path of the directory of the binary with\n\
3916each global debug-file-directory component prepended."),
3917 NULL,
3919 &setlist, &showlist);
3920
3921 add_setshow_enum_cmd ("symbol-loading", no_class,
3923 _("\
3924Set printing of symbol loading messages."), _("\
3925Show printing of symbol loading messages."), _("\
3926off == turn all messages off\n\
3927brief == print messages for the executable,\n\
3928 and brief messages for shared libraries\n\
3929full == print messages for the executable,\n\
3930 and messages for each shared library."),
3931 NULL,
3932 NULL,
3934
3935 add_setshow_boolean_cmd ("separate-debug-file", no_class,
3937Set printing of separate debug info file search debug."), _("\
3938Show printing of separate debug info file search debug."), _("\
3939When on, GDB prints the searched locations while looking for separate debug \
3940info files."), NULL, NULL, &setdebuglist, &showdebuglist);
3941
3942#if GDB_SELF_TEST
3943 selftests::register_test
3944 ("filename_language", selftests::filename_language::test_filename_language);
3945 selftests::register_test
3946 ("set_ext_lang_command",
3947 selftests::filename_language::test_set_ext_lang_command);
3948#endif
3949}
const char *const name
Definition: aarch64-tdep.c:67
void * xmalloc(YYSIZE_T)
void xfree(void *)
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:846
struct gdbarch * target_gdbarch(void)
Definition: arch-utils.c:1453
void clear_pc_function_cache(void)
Definition: blockframe.c:201
void breakpoint_re_set(void)
Definition: breakpoint.c:12917
void disable_overlay_breakpoints(void)
Definition: breakpoint.c:7653
void enable_overlay_breakpoints(void)
Definition: breakpoint.c:7641
void clear_displays(void)
Definition: printcmd.c:2002
ui_file_style style() const
Definition: cli-style.c:169
symfile_add_flags symfile_flags
Definition: inferior.h:609
void clear_registry()
Definition: registry.h:168
Definition: ui-out.h:160
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:125
struct cmd_list_element * showprintlist
Definition: cli-cmds.c:161
void error_no_arg(const char *why)
Definition: cli-cmds.c:204
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:85
struct cmd_list_element * setprintlist
Definition: cli-cmds.c:159
struct cmd_list_element * setlist
Definition: cli-cmds.c:117
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:165
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:163
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)
Definition: cli-decode.c:1323
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)
Definition: cli-decode.c:934
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:618
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:739
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:883
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)
Definition: cli-decode.c:1294
cli_style_option file_name_style
void dont_repeat()
Definition: top.c:809
@ 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:105
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:237
const char * get_exec_file(int err)
Definition: corefile.c:149
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:295
const char * gnutarget
Definition: corefile.c:394
int check_quit_flag(void)
Definition: extension.c:805
#define O_BINARY
Definition: defs.h:116
bool info_verbose
Definition: top.c:2022
language
Definition: defs.h:211
@ language_unknown
Definition: defs.h:212
@ language_pascal
Definition: defs.h:222
@ language_rust
Definition: defs.h:224
@ language_c
Definition: defs.h:214
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition: defs.h:526
std::string gdb_sysroot
Definition: main.c:63
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:1023
void exec_file_attach(const char *filename, int from_tty)
Definition: exec.c:365
void reinit_frame_cache(void)
Definition: frame.c:2006
int gdb_bfd_crc(struct bfd *abfd, unsigned long *crc_out)
Definition: gdb_bfd.c:858
int gdb_bfd_section_index(bfd *abfd, asection *section)
Definition: gdb_bfd.c:980
int gdb_bfd_has_target_filename(struct bfd *abfd)
Definition: gdb_bfd.c:215
int gdb_bfd_count_sections(bfd *abfd)
Definition: gdb_bfd.c:998
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:491
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
Definition: gdb_bfd.h:78
static gdb_bfd_section_range gdb_bfd_sections(bfd *abfd)
Definition: gdb_bfd.h:222
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1370
bfd * obfd
Definition: gdbarch-gen.h:894
bool gdbarch_overlay_update_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4183
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:3087
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1440
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:3070
void gdbarch_overlay_update(struct gdbarch *gdbarch, struct obj_section *osect)
Definition: gdbarch.c:4190
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:1862
size_t size
Definition: go32-nat.c:241
struct inferior * current_inferior(void)
Definition: inferior.c:54
enum language language_enum(const char *str)
Definition: language.c:427
const char * language_str(enum language lang)
Definition: language.c:452
const struct language_defn * current_language
Definition: language.c:83
enum language set_language(enum language lang)
Definition: language.c:361
const struct language_defn * expected_language
Definition: language.c:89
language_mode
Definition: language.h:700
@ language_mode_manual
Definition: language.h:701
static void validate_readnow_readnever()
Definition: main.c:546
gdb_bfd_ref_ptr find_separate_debug_file_in_section(struct objfile *objfile)
Definition: minidebug.c:263
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 executable_changed
observable< struct objfile * > new_objfile
@ OBJF_USERLOADED
Definition: objfile-flags.h:53
@ OBJF_READNEVER
Definition: objfile-flags.h:70
@ OBJF_SHARED
Definition: objfile-flags.h:42
@ OBJF_NOT_FILENAME
Definition: objfile-flags.h:66
@ OBJF_MAINLINE
Definition: objfile-flags.h:61
@ OBJF_REORDERED
Definition: objfile-flags.h:36
@ OBJF_READNOW
Definition: objfile-flags.h:45
void objfiles_changed(void)
Definition: objfiles.c:1235
int objfile_has_symbols(struct objfile *objfile)
Definition: objfiles.c:789
void objfile_relocate(struct objfile *objfile, const section_offsets &new_offsets)
Definition: objfiles.c:716
bool is_addr_in_objfile(CORE_ADDR addr, const struct objfile *objfile)
Definition: objfiles.c:1253
void objfile_rebase(struct objfile *objfile, CORE_ADDR slide)
Definition: objfiles.c:765
int have_partial_symbols(void)
Definition: objfiles.c:803
void free_objfile_separate_debug(struct objfile *objfile)
Definition: objfiles.c:479
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1308
int have_full_symbols(void)
Definition: objfiles.c:818
void build_objfile_section_table(struct objfile *objfile)
Definition: objfiles.c:280
void set_objfile_per_bfd(struct objfile *objfile)
Definition: objfiles.c:121
void objfile_set_sym_fns(struct objfile *objfile, const struct sym_fns *sf)
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:148
std::unique_ptr< objfile, objfile_deleter > objfile_up
Definition: objfiles.h:801
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:130
struct program_space * current_program_space
Definition: progspace.c:39
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: regcache.c:1368
struct regcache * get_current_regcache(void)
Definition: regcache.c:426
int rate
Definition: ser-unix.c:242
void solib_create_inferior_hook(int from_tty)
Definition: solib.c:1245
void no_shared_libraries(const char *ignored, int from_tty)
Definition: solib.c:1277
int openp(const char *path, openp_flags opts, const char *string, int mode, gdb::unique_xmalloc_ptr< char > *filename_opened)
Definition: source.c:805
void clear_current_source_symtab_and_line(void)
Definition: source.c:301
void forget_cached_source_info(void)
Definition: source.c:444
@ OPF_TRY_CWD_FIRST
Definition: source.h:30
@ OPF_RETURN_REALPATH
Definition: source.h:32
void clear_last_displayed_sal(void)
Definition: stack.c:1210
struct symbol * symbol
Definition: symtab.h:1494
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:1847
const char * name
Definition: symtab.h:1855
void add_filetab(symtab *filetab)
Definition: symtab.h:1729
void set_objfile(struct objfile *objfile)
Definition: symtab.h:1719
void set_debugformat(const char *debugformat)
Definition: symtab.h:1748
struct objfile * objfile() const
Definition: symtab.h:1714
CORE_ADDR entry_point
Definition: objfiles.h:118
unsigned initialized
Definition: objfiles.h:127
int the_bfd_section_index
Definition: objfiles.h:121
unsigned entry_point_p
Definition: objfiles.h:124
std::string ext
Definition: symfile.c:2663
enum language lang
Definition: symfile.c:2664
filename_language(const std::string &ext_, enum language lang_)
Definition: symfile.c:2659
enum language language() const
Definition: symtab.h:501
unsigned long data_count
Definition: symfile.c:1857
unsigned long write_count
Definition: symfile.c:1856
bfd_size_type total_size
Definition: symfile.c:1858
load_progress_section_data(load_progress_data *cumulative_, const char *section_name_, ULONGEST section_size_, CORE_ADDR lma_, gdb_byte *buffer_)
Definition: symfile.c:1864
struct load_progress_data * cumulative
Definition: symfile.c:1871
const char * section_name
Definition: symfile.c:1874
CORE_ADDR load_offset
Definition: symfile.c:1897
load_section_data(load_progress_data *progress_data_)
Definition: symfile.c:1884
struct load_progress_data * progress_data
Definition: symfile.c:1898
std::vector< struct memory_write_request > requests
Definition: symfile.c:1899
CORE_ADDR value_address(objfile *objfile) const
Definition: symtab.c:421
CORE_ADDR addr() const
Definition: objfiles.h:822
CORE_ADDR endaddr() const
Definition: objfiles.h:829
struct objfile * objfile
Definition: objfiles.h:838
int ovly_mapped
Definition: objfiles.h:841
CORE_ADDR offset() const
Definition: objfiles.h:810
struct bfd_section * the_bfd_section
Definition: objfiles.h:835
const char * original_name
Definition: objfiles.h:631
int sect_index_rodata
Definition: objfiles.h:714
const struct sym_fns * sf
Definition: objfiles.h:681
struct compunit_symtab * compunit_symtabs
Definition: objfiles.h:646
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:743
struct program_space * pspace
Definition: objfiles.h:641
struct objfile * separate_debug_objfile
Definition: objfiles.h:738
registry< objfile > registry_fields
Definition: objfiles.h:689
int sect_index_bss
Definition: objfiles.h:713
int sect_index_data
Definition: objfiles.h:712
struct gdbarch * arch() const
Definition: objfiles.h:482
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:657
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:451
htab_up static_links
Definition: objfiles.h:772
struct obj_section * sections
Definition: objfiles.h:725
gdb_bfd_ref_ptr obfd
Definition: objfiles.h:653
void expand_all_symtabs()
void require_partial_symbols(bool verbose)
const char * intern(const char *str)
Definition: objfiles.h:469
objfile_flags flags
Definition: objfiles.h:637
int sect_index_text
Definition: objfiles.h:711
auto_obstack objfile_obstack
Definition: objfiles.h:673
std::forward_list< quick_symbol_functions_up > qf
Definition: objfiles.h:685
struct symbol * template_symbols
Definition: objfiles.h:759
::section_offsets section_offsets
Definition: objfiles.h:699
void map_symbol_filenames(gdb::function_view< symbol_filename_ftype > fun, bool need_fullname)
void unlink()
Definition: objfiles.c:470
bool has_partial_symbols()
Definition: symfile-debug.c:77
long mtime
Definition: objfiles.h:668
int sectindex
Definition: symfile.h:64
std::string name
Definition: symfile.h:59
CORE_ADDR addr
Definition: symfile.h:58
void remove_target_sections(void *owner)
Definition: exec.c:647
void add_target_sections(void *owner, const target_section_table &sections)
Definition: exec.c:593
objfiles_range objfiles()
Definition: progspace.h:209
bfd * exec_bfd() const
Definition: progspace.h:264
struct objfile * symfile_object_file
Definition: progspace.h:353
void free_all_objfiles()
Definition: progspace.c:128
registered_sym_fns(bfd_flavour sym_flavour_, const struct sym_fns *sym_fns_)
Definition: symfile.c:122
const struct sym_fns * sym_fns
Definition: symfile.c:130
enum bfd_flavour sym_flavour
Definition: symfile.c:127
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:1661
char * fullname
Definition: symtab.h:1670
void set_language(enum language language)
Definition: symtab.h:1628
const char * filename
Definition: symtab.h:1651
void set_compunit(struct compunit_symtab *compunit)
Definition: symtab.h:1608
Definition: value.c:181
symfile_add_flag
@ SYMFILE_NO_READ
@ SYMFILE_MAINLINE
@ SYMFILE_NOT_FILENAME
@ SYMFILE_VERBOSE
@ SYMFILE_DEFER_BP_RESET
@ SYMFILE_ALWAYS_CONFIRM
static void add_symbol_file_command(const char *args, int from_tty)
Definition: symfile.c:2190
gdb_bfd_ref_ptr symfile_bfd_open(const char *name)
Definition: symfile.c:1702
static std::vector< registered_sym_fns > symtab_fns
Definition: symfile.c:133
bool separate_debug_file_debug
Definition: symfile.c:1243
void add_filename_language(const char *ext, enum language lang)
Definition: symfile.c:2672
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3133
enum language deduce_language_from_filename(const char *filename)
Definition: symfile.c:2759
static void map_overlay_command(const char *args, int from_tty)
Definition: symfile.c:3223
static CORE_ADDR cache_ovly_table_base
Definition: symfile.c:3383
void(* deprecated_post_add_symbol_hook)(void)
Definition: symfile.c:81
static void overlay_manual_command(const char *args, int from_tty)
Definition: symfile.c:3312
static void find_lowest_section(asection *sect, asection **lowest)
Definition: symfile.c:203
static void remove_symbol_file_command(const char *args, int from_tty)
Definition: symfile.c:2347
static const struct sym_fns * find_sym_fns(bfd *)
Definition: symfile.c:1779
bfd_byte * symfile_relocate_debug_section(struct objfile *objfile, asection *sectp, bfd_byte *buf)
Definition: symfile.c:3599
static void place_section(bfd *abfd, asection *sect, section_offsets &offsets, CORE_ADDR &lowest)
Definition: symfile.c:342
static void list_overlays_command(const char *args, int from_tty)
Definition: symfile.c:3181
void add_symtab_fns(enum bfd_flavour flavour, const struct sym_fns *sf)
Definition: symfile.c:1768
int get_section_index(struct objfile *objfile, const char *section_name)
Definition: symfile.c:1751
CORE_ADDR overlay_unmapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3067
section_addr_info build_section_addr_info_from_objfile(const struct objfile *objfile)
Definition: symfile.c:259
std::string debug_file_directory
Definition: symfile.c:1355
int section_is_mapped(struct obj_section *osect)
Definition: symfile.c:2978
ovly_index
Definition: symfile.c:3385
@ OSIZE
Definition: symfile.c:3386
@ VMA
Definition: symfile.c:3386
@ MAPPED
Definition: symfile.c:3386
@ LMA
Definition: symfile.c:3386
static const char * print_symbol_loading_enums[]
Definition: symfile.c:140
static void finish_new_objfile(struct objfile *objfile, symfile_add_flags add_flags)
Definition: symfile.c:994
void symbol_file_clear(int from_tty)
Definition: symfile.c:1218
void add_compunit_symtab_to_objfile(struct compunit_symtab *cu)
Definition: symfile.c:2851
void _initialize_symfile()
Definition: symfile.c:3817
static std::vector< const struct other_sections * > addrs_section_sort(const section_addr_info &addrs)
Definition: symfile.c:467
bool auto_solib_add
Definition: symfile.c:151
static section_addr_info build_section_addr_info_from_bfd(bfd *abfd)
Definition: symfile.c:242
void symbol_file_command(const char *args, int from_tty)
Definition: symfile.c:1592
int readnow_symbol_files
Definition: symfile.c:90
static void symfile_free_objfile(struct objfile *objfile)
Definition: symfile.c:3714
const char print_symbol_loading_brief[]
Definition: symfile.c:138
static void load_one_section(bfd *abfd, asection *asec, struct load_section_data *args)
Definition: symfile.c:1969
static void overlay_load_command(const char *args, int from_tty)
Definition: symfile.c:3334
CORE_ADDR pc_in_mapped_range(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3036
static int simple_read_overlay_table(void)
Definition: symfile.c:3420
static void terminate_after_last_dir_separator(char *path)
Definition: symfile.c:1496
static std::string find_separate_debug_file(const char *dir, const char *canon_dir, const char *debuglink, unsigned long crc32, struct objfile *objfile)
Definition: symfile.c:1379
static const char * addr_section_name(const char *s)
Definition: symfile.c:436
static void overlay_off_command(const char *args, int from_tty)
Definition: symfile.c:3325
void reread_symbols(int from_tty)
Definition: symfile.c:2421
#define DEBUG_SUBDIRECTORY
Definition: symfile.c:1367
void symbol_file_add_main(const char *args, symfile_add_flags add_flags)
Definition: symfile.c:1194
void set_initial_language(void)
Definition: symfile.c:1668
section_addr_info build_section_addr_info_from_section_table(const target_section_table &table)
Definition: symfile.c:220
static void symbol_file_add_main_1(const char *args, symfile_add_flags add_flags, objfile_flags flags, CORE_ADDR reloff)
Definition: symfile.c:1200
CORE_ADDR overlay_mapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3085
static void show_debug_file_directory(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: symfile.c:1357
void default_symfile_offsets(struct objfile *objfile, const section_addr_info &addrs)
Definition: symfile.c:627
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:1036
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:2087
struct obj_section * find_pc_mapped_section(CORE_ADDR pc)
Definition: symfile.c:3162
int print_symbol_loading_p(int from_tty, int exec, int full)
Definition: symfile.c:163
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:3727
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:75
struct symtab * allocate_symtab(struct compunit_symtab *cust, const char *filename, const char *filename_for_id)
Definition: symfile.c:2778
static void simple_free_overlay_table(void)
Definition: symfile.c:3392
const char print_symbol_loading_off[]
Definition: symfile.c:137
int readnever_symbol_files
Definition: symfile.c:94
void generic_load(const char *args, int from_tty)
Definition: symfile.c:2001
static unsigned(* cache_ovly_table)[4]
Definition: symfile.c:3381
void addr_info_make_relative(section_addr_info *addrs, bfd *abfd)
Definition: symfile.c:485
CORE_ADDR pc_in_unmapped_range(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3014
struct compunit_symtab * allocate_compunit_symtab(struct objfile *objfile, const char *name)
Definition: symfile.c:2825
int(* deprecated_ui_load_progress_hook)(const char *section, unsigned long num)
Definition: symfile.c:73
int overlay_cache_invalid
Definition: symfile.c:2933
static void init_entry_point_info(struct objfile *objfile)
Definition: symfile.c:801
static const char * print_symbol_loading
Definition: symfile.c:147
static void overlay_auto_command(const char *args, int from_tty)
Definition: symfile.c:3299
FORWARD_SCOPE_EXIT(clear_symtab_users) clear_symtab_users_cleanup
Definition: symfile.c:84
symfile_segment_data_up get_symfile_segment_data(bfd *abfd)
Definition: symfile.c:3608
void relative_addr_info_to_section_offsets(section_offsets &section_offsets, const section_addr_info &addrs)
Definition: symfile.c:406
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:3634
symfile_segment_data_up default_symfile_segments(bfd *abfd)
Definition: symfile.c:713
static void load_progress(ULONGEST bytes, void *untyped_arg)
Definition: symfile.c:1905
static int simple_overlay_update_1(struct obj_section *)
Definition: symfile.c:3472
void simple_overlay_update(struct obj_section *osect)
Definition: symfile.c:3508
static bool addrs_section_compar(const struct other_sections *a, const struct other_sections *b)
Definition: symfile.c:451
static std::vector< filename_language > filename_language_table
Definition: symfile.c:2667
void(* deprecated_pre_add_symbol_hook)(const char *)
Definition: symfile.c:80
static std::string ext_args
Definition: symfile.c:2678
static void show_ext_args(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: symfile.c:2680
static void set_ext_lang_command(const char *args, int from_tty, struct cmd_list_element *e)
Definition: symfile.c:2690
void map_symbol_filenames(gdb::function_view< symbol_filename_ftype > fun, bool need_fullname)
Definition: symfile.c:3751
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:1142
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:1163
static void set_objfile_default_section_offset(struct objfile *objf, const section_addr_info &addrs, CORE_ADDR offset)
Definition: symfile.c:2136
static int separate_debug_file_exists(const std::string &name, unsigned long crc, struct objfile *parent_objfile)
Definition: symfile.c:1246
int section_is_overlay(struct obj_section *section)
Definition: symfile.c:2940
struct objfile * symbol_file_add(const char *name, symfile_add_flags add_flags, section_addr_info *addrs, objfile_flags flags)
Definition: symfile.c:1176
static unsigned cache_novlys
Definition: symfile.c:3382
static void read_symbols(struct objfile *objfile, symfile_add_flags add_flags)
Definition: symfile.c:771
enum overlay_debugging_state overlay_debugging
Definition: symfile.c:2932
std::string find_separate_debug_file_by_debuglink(struct objfile *objfile)
Definition: symfile.c:1514
static void info_ext_lang_command(const char *args, int from_tty)
Definition: symfile.c:2749
static void init_objfile_sect_indices(struct objfile *objfile)
Definition: symfile.c:280
#define READNOW_READNEVER_HELP
static int validate_download
Definition: symfile.c:1850
static struct cmd_list_element * overlaylist
Definition: symfile.c:3345
static void symfile_find_segment_sections(struct objfile *objfile)
Definition: symfile.c:3675
static void read_target_long_array(CORE_ADDR, unsigned int *, int, int, enum bfd_endian)
Definition: symfile.c:3404
int currently_reading_symtab
Definition: symfile.c:181
static void syms_from_objfile_1(struct objfile *objfile, section_addr_info *addrs, symfile_add_flags add_flags)
Definition: symfile.c:896
const char print_symbol_loading_full[]
Definition: symfile.c:139
CORE_ADDR symbol_overlayed_address(CORE_ADDR address, struct obj_section *section)
Definition: symfile.c:3103
static int sections_overlap(struct obj_section *a, struct obj_section *b)
Definition: symfile.c:3052
static void load_command(const char *arg, int from_tty)
Definition: symfile.c:1800
void clear_symtab_users(symfile_add_flags add_flags)
Definition: symfile.c:2862
scoped_restore_tmpl< int > increment_reading_symtab(void)
Definition: symfile.c:187
bfd_byte * default_symfile_relocate(struct objfile *objfile, asection *sectp, bfd_byte *buf)
Definition: symfile.c:3561
static void unmap_overlay_command(const char *args, int from_tty)
Definition: symfile.c:3269
static void overlay_invalidate_all(void)
Definition: symfile.c:2958
static void syms_from_objfile(struct objfile *objfile, section_addr_info *addrs, symfile_add_flags add_flags)
Definition: symfile.c:981
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:278
@ ovly_auto
Definition: symfile.h:281
@ ovly_on
Definition: symfile.h:280
@ ovly_off
Definition: symfile.h:279
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:1949
const char * main_name()
Definition: symtab.c:6309
enum language main_language(void)
Definition: symtab.c:6323
unsigned int symtab_create_debug
Definition: symtab.c:257
search_domain
Definition: symtab.h:916
#define symtab_create_debug_printf_v(fmt,...)
Definition: symtab.h:2623
@ VAR_DOMAIN
Definition: symtab.h:881
@ UNDEF_DOMAIN
Definition: symtab.h:876
std::vector< CORE_ADDR > section_offsets
Definition: symtab.h:1595
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:1771
void target_load(const char *arg, int from_tty)
Definition: target.c:923
@ 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
void perror_with_name(const char *string)
Definition: utils.c:643
int query(const char *ctlstr,...)
Definition: utils.c:1010
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:3114
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition: utils.c:1865
void gdb_flush(struct ui_file *stream)
Definition: utils.c:1477
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1788
#define gdb_stdlog
Definition: utils.h:196
#define gdb_stdout
Definition: utils.h:188
void preserve_values(struct objfile *objfile)
Definition: value.c:2676
void varobj_re_set(void)
Definition: varobj.c:2383
static void check(BOOL ok, const char *file, int line)
Definition: windows-nat.c:392