1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990-2019 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
35 #include "breakpoint.h"
37 #include "complaints.h"
41 #include "filenames.h" /* for DOSish file names */
42 #include "gdb-stabs.h"
43 #include "gdb_obstack.h"
44 #include "completer.h"
47 #include "readline/readline.h"
49 #include "observable.h"
51 #include "parser-defs.h"
58 #include "cli/cli-utils.h"
59 #include "gdbsupport/byte-vector.h"
60 #include "gdbsupport/pathstuff.h"
61 #include "gdbsupport/selftest.h"
62 #include "cli/cli-style.h"
63 #include "gdbsupport/forward-scope-exit.h"
65 #include <sys/types.h>
74 int (*deprecated_ui_load_progress_hook
) (const char *section
,
76 void (*deprecated_show_load_progress
) (const char *section
,
77 unsigned long section_sent
,
78 unsigned long section_size
,
79 unsigned long total_sent
,
80 unsigned long total_size
);
81 void (*deprecated_pre_add_symbol_hook
) (const char *);
82 void (*deprecated_post_add_symbol_hook
) (void);
84 using clear_symtab_users_cleanup
85 = FORWARD_SCOPE_EXIT (clear_symtab_users
);
87 /* Global variables owned by this file. */
88 int readnow_symbol_files
; /* Read full symbols immediately. */
89 int readnever_symbol_files
; /* Never read full symbols. */
91 /* Functions this file defines. */
93 static void symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
94 objfile_flags flags
, CORE_ADDR reloff
);
96 static const struct sym_fns
*find_sym_fns (bfd
*);
98 static void overlay_invalidate_all (void);
100 static void simple_free_overlay_table (void);
102 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
105 static int simple_read_overlay_table (void);
107 static int simple_overlay_update_1 (struct obj_section
*);
109 static void symfile_find_segment_sections (struct objfile
*objfile
);
111 /* List of all available sym_fns. On gdb startup, each object file reader
112 calls add_symtab_fns() to register information on each format it is
115 struct registered_sym_fns
117 registered_sym_fns (bfd_flavour sym_flavour_
, const struct sym_fns
*sym_fns_
)
118 : sym_flavour (sym_flavour_
), sym_fns (sym_fns_
)
121 /* BFD flavour that we handle. */
122 enum bfd_flavour sym_flavour
;
124 /* The "vtable" of symbol functions. */
125 const struct sym_fns
*sym_fns
;
128 static std::vector
<registered_sym_fns
> symtab_fns
;
130 /* Values for "set print symbol-loading". */
132 const char print_symbol_loading_off
[] = "off";
133 const char print_symbol_loading_brief
[] = "brief";
134 const char print_symbol_loading_full
[] = "full";
135 static const char *print_symbol_loading_enums
[] =
137 print_symbol_loading_off
,
138 print_symbol_loading_brief
,
139 print_symbol_loading_full
,
142 static const char *print_symbol_loading
= print_symbol_loading_full
;
146 int auto_solib_add
= 1;
149 /* Return non-zero if symbol-loading messages should be printed.
150 FROM_TTY is the standard from_tty argument to gdb commands.
151 If EXEC is non-zero the messages are for the executable.
152 Otherwise, messages are for shared libraries.
153 If FULL is non-zero then the caller is printing a detailed message.
154 E.g., the message includes the shared library name.
155 Otherwise, the caller is printing a brief "summary" message. */
158 print_symbol_loading_p (int from_tty
, int exec
, int full
)
160 if (!from_tty
&& !info_verbose
)
165 /* We don't check FULL for executables, there are few such
166 messages, therefore brief == full. */
167 return print_symbol_loading
!= print_symbol_loading_off
;
170 return print_symbol_loading
== print_symbol_loading_full
;
171 return print_symbol_loading
== print_symbol_loading_brief
;
174 /* True if we are reading a symbol table. */
176 int currently_reading_symtab
= 0;
178 /* Increment currently_reading_symtab and return a cleanup that can be
179 used to decrement it. */
181 scoped_restore_tmpl
<int>
182 increment_reading_symtab (void)
184 gdb_assert (currently_reading_symtab
>= 0);
185 return make_scoped_restore (¤tly_reading_symtab
,
186 currently_reading_symtab
+ 1);
189 /* Remember the lowest-addressed loadable section we've seen.
190 This function is called via bfd_map_over_sections.
192 In case of equal vmas, the section with the largest size becomes the
193 lowest-addressed loadable section.
195 If the vmas and sizes are equal, the last section is considered the
196 lowest-addressed loadable section. */
199 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
201 asection
**lowest
= (asection
**) obj
;
203 if (0 == (bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
)))
206 *lowest
= sect
; /* First loadable section */
207 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
208 *lowest
= sect
; /* A lower loadable section */
209 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
210 && (bfd_section_size (abfd
, (*lowest
))
211 <= bfd_section_size (abfd
, sect
)))
215 /* Build (allocate and populate) a section_addr_info struct from
216 an existing section table. */
219 build_section_addr_info_from_section_table (const struct target_section
*start
,
220 const struct target_section
*end
)
222 const struct target_section
*stp
;
224 section_addr_info sap
;
226 for (stp
= start
; stp
!= end
; stp
++)
228 struct bfd_section
*asect
= stp
->the_bfd_section
;
229 bfd
*abfd
= asect
->owner
;
231 if (bfd_get_section_flags (abfd
, asect
) & (SEC_ALLOC
| SEC_LOAD
)
232 && sap
.size () < end
- start
)
233 sap
.emplace_back (stp
->addr
,
234 bfd_section_name (abfd
, asect
),
235 gdb_bfd_section_index (abfd
, asect
));
241 /* Create a section_addr_info from section offsets in ABFD. */
243 static section_addr_info
244 build_section_addr_info_from_bfd (bfd
*abfd
)
246 struct bfd_section
*sec
;
248 section_addr_info sap
;
249 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
250 if (bfd_get_section_flags (abfd
, sec
) & (SEC_ALLOC
| SEC_LOAD
))
251 sap
.emplace_back (bfd_get_section_vma (abfd
, sec
),
252 bfd_get_section_name (abfd
, sec
),
253 gdb_bfd_section_index (abfd
, sec
));
258 /* Create a section_addr_info from section offsets in OBJFILE. */
261 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
265 /* Before reread_symbols gets rewritten it is not safe to call:
266 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
268 section_addr_info sap
= build_section_addr_info_from_bfd (objfile
->obfd
);
269 for (i
= 0; i
< sap
.size (); i
++)
271 int sectindex
= sap
[i
].sectindex
;
273 sap
[i
].addr
+= objfile
->section_offsets
->offsets
[sectindex
];
278 /* Initialize OBJFILE's sect_index_* members. */
281 init_objfile_sect_indices (struct objfile
*objfile
)
286 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
288 objfile
->sect_index_text
= sect
->index
;
290 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
292 objfile
->sect_index_data
= sect
->index
;
294 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
296 objfile
->sect_index_bss
= sect
->index
;
298 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
300 objfile
->sect_index_rodata
= sect
->index
;
302 /* This is where things get really weird... We MUST have valid
303 indices for the various sect_index_* members or gdb will abort.
304 So if for example, there is no ".text" section, we have to
305 accomodate that. First, check for a file with the standard
306 one or two segments. */
308 symfile_find_segment_sections (objfile
);
310 /* Except when explicitly adding symbol files at some address,
311 section_offsets contains nothing but zeros, so it doesn't matter
312 which slot in section_offsets the individual sect_index_* members
313 index into. So if they are all zero, it is safe to just point
314 all the currently uninitialized indices to the first slot. But
315 beware: if this is the main executable, it may be relocated
316 later, e.g. by the remote qOffsets packet, and then this will
317 be wrong! That's why we try segments first. */
319 for (i
= 0; i
< objfile
->num_sections
; i
++)
321 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
326 if (i
== objfile
->num_sections
)
328 if (objfile
->sect_index_text
== -1)
329 objfile
->sect_index_text
= 0;
330 if (objfile
->sect_index_data
== -1)
331 objfile
->sect_index_data
= 0;
332 if (objfile
->sect_index_bss
== -1)
333 objfile
->sect_index_bss
= 0;
334 if (objfile
->sect_index_rodata
== -1)
335 objfile
->sect_index_rodata
= 0;
339 /* The arguments to place_section. */
341 struct place_section_arg
343 struct section_offsets
*offsets
;
347 /* Find a unique offset to use for loadable section SECT if
348 the user did not provide an offset. */
351 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
353 struct place_section_arg
*arg
= (struct place_section_arg
*) obj
;
354 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
356 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
358 /* We are only interested in allocated sections. */
359 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
362 /* If the user specified an offset, honor it. */
363 if (offsets
[gdb_bfd_section_index (abfd
, sect
)] != 0)
366 /* Otherwise, let's try to find a place for the section. */
367 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
374 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
376 int indx
= cur_sec
->index
;
378 /* We don't need to compare against ourself. */
382 /* We can only conflict with allocated sections. */
383 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
386 /* If the section offset is 0, either the section has not been placed
387 yet, or it was the lowest section placed (in which case LOWEST
388 will be past its end). */
389 if (offsets
[indx
] == 0)
392 /* If this section would overlap us, then we must move up. */
393 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
394 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
396 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
397 start_addr
= (start_addr
+ align
- 1) & -align
;
402 /* Otherwise, we appear to be OK. So far. */
407 offsets
[gdb_bfd_section_index (abfd
, sect
)] = start_addr
;
408 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
411 /* Store section_addr_info as prepared (made relative and with SECTINDEX
412 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
416 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
418 const section_addr_info
&addrs
)
422 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
424 /* Now calculate offsets for section that were specified by the caller. */
425 for (i
= 0; i
< addrs
.size (); i
++)
427 const struct other_sections
*osp
;
430 if (osp
->sectindex
== -1)
433 /* Record all sections in offsets. */
434 /* The section_offsets in the objfile are here filled in using
436 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
440 /* Transform section name S for a name comparison. prelink can split section
441 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
442 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
443 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
444 (`.sbss') section has invalid (increased) virtual address. */
447 addr_section_name (const char *s
)
449 if (strcmp (s
, ".dynbss") == 0)
451 if (strcmp (s
, ".sdynbss") == 0)
457 /* std::sort comparator for addrs_section_sort. Sort entries in
458 ascending order by their (name, sectindex) pair. sectindex makes
459 the sort by name stable. */
462 addrs_section_compar (const struct other_sections
*a
,
463 const struct other_sections
*b
)
467 retval
= strcmp (addr_section_name (a
->name
.c_str ()),
468 addr_section_name (b
->name
.c_str ()));
472 return a
->sectindex
< b
->sectindex
;
475 /* Provide sorted array of pointers to sections of ADDRS. */
477 static std::vector
<const struct other_sections
*>
478 addrs_section_sort (const section_addr_info
&addrs
)
482 std::vector
<const struct other_sections
*> array (addrs
.size ());
483 for (i
= 0; i
< addrs
.size (); i
++)
484 array
[i
] = &addrs
[i
];
486 std::sort (array
.begin (), array
.end (), addrs_section_compar
);
491 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
492 also SECTINDEXes specific to ABFD there. This function can be used to
493 rebase ADDRS to start referencing different BFD than before. */
496 addr_info_make_relative (section_addr_info
*addrs
, bfd
*abfd
)
498 asection
*lower_sect
;
499 CORE_ADDR lower_offset
;
502 /* Find lowest loadable section to be used as starting point for
503 continguous sections. */
505 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
506 if (lower_sect
== NULL
)
508 warning (_("no loadable sections found in added symbol-file %s"),
509 bfd_get_filename (abfd
));
513 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
515 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
516 in ABFD. Section names are not unique - there can be multiple sections of
517 the same name. Also the sections of the same name do not have to be
518 adjacent to each other. Some sections may be present only in one of the
519 files. Even sections present in both files do not have to be in the same
522 Use stable sort by name for the sections in both files. Then linearly
523 scan both lists matching as most of the entries as possible. */
525 std::vector
<const struct other_sections
*> addrs_sorted
526 = addrs_section_sort (*addrs
);
528 section_addr_info abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
529 std::vector
<const struct other_sections
*> abfd_addrs_sorted
530 = addrs_section_sort (abfd_addrs
);
532 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
533 ABFD_ADDRS_SORTED. */
535 std::vector
<const struct other_sections
*>
536 addrs_to_abfd_addrs (addrs
->size (), nullptr);
538 std::vector
<const struct other_sections
*>::iterator abfd_sorted_iter
539 = abfd_addrs_sorted
.begin ();
540 for (const other_sections
*sect
: addrs_sorted
)
542 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
544 while (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
545 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
549 if (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
550 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
555 /* Make the found item directly addressable from ADDRS. */
556 index_in_addrs
= sect
- addrs
->data ();
557 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
558 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_sorted_iter
;
560 /* Never use the same ABFD entry twice. */
565 /* Calculate offsets for the loadable sections.
566 FIXME! Sections must be in order of increasing loadable section
567 so that contiguous sections can use the lower-offset!!!
569 Adjust offsets if the segments are not contiguous.
570 If the section is contiguous, its offset should be set to
571 the offset of the highest loadable section lower than it
572 (the loadable section directly below it in memory).
573 this_offset = lower_offset = lower_addr - lower_orig_addr */
575 for (i
= 0; i
< addrs
->size (); i
++)
577 const struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
581 /* This is the index used by BFD. */
582 (*addrs
)[i
].sectindex
= sect
->sectindex
;
584 if ((*addrs
)[i
].addr
!= 0)
586 (*addrs
)[i
].addr
-= sect
->addr
;
587 lower_offset
= (*addrs
)[i
].addr
;
590 (*addrs
)[i
].addr
= lower_offset
;
594 /* addr_section_name transformation is not used for SECT_NAME. */
595 const std::string
§_name
= (*addrs
)[i
].name
;
597 /* This section does not exist in ABFD, which is normally
598 unexpected and we want to issue a warning.
600 However, the ELF prelinker does create a few sections which are
601 marked in the main executable as loadable (they are loaded in
602 memory from the DYNAMIC segment) and yet are not present in
603 separate debug info files. This is fine, and should not cause
604 a warning. Shared libraries contain just the section
605 ".gnu.liblist" but it is not marked as loadable there. There is
606 no other way to identify them than by their name as the sections
607 created by prelink have no special flags.
609 For the sections `.bss' and `.sbss' see addr_section_name. */
611 if (!(sect_name
== ".gnu.liblist"
612 || sect_name
== ".gnu.conflict"
613 || (sect_name
== ".bss"
615 && (*addrs
)[i
- 1].name
== ".dynbss"
616 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
617 || (sect_name
== ".sbss"
619 && (*addrs
)[i
- 1].name
== ".sdynbss"
620 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
621 warning (_("section %s not found in %s"), sect_name
.c_str (),
622 bfd_get_filename (abfd
));
624 (*addrs
)[i
].addr
= 0;
625 (*addrs
)[i
].sectindex
= -1;
630 /* Parse the user's idea of an offset for dynamic linking, into our idea
631 of how to represent it for fast symbol reading. This is the default
632 version of the sym_fns.sym_offsets function for symbol readers that
633 don't need to do anything special. It allocates a section_offsets table
634 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
637 default_symfile_offsets (struct objfile
*objfile
,
638 const section_addr_info
&addrs
)
640 objfile
->num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
641 objfile
->section_offsets
= (struct section_offsets
*)
642 obstack_alloc (&objfile
->objfile_obstack
,
643 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
644 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
645 objfile
->num_sections
, addrs
);
647 /* For relocatable files, all loadable sections will start at zero.
648 The zero is meaningless, so try to pick arbitrary addresses such
649 that no loadable sections overlap. This algorithm is quadratic,
650 but the number of sections in a single object file is generally
652 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
654 struct place_section_arg arg
;
655 bfd
*abfd
= objfile
->obfd
;
658 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
659 /* We do not expect this to happen; just skip this step if the
660 relocatable file has a section with an assigned VMA. */
661 if (bfd_section_vma (abfd
, cur_sec
) != 0)
666 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
668 /* Pick non-overlapping offsets for sections the user did not
670 arg
.offsets
= objfile
->section_offsets
;
672 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
674 /* Correctly filling in the section offsets is not quite
675 enough. Relocatable files have two properties that
676 (most) shared objects do not:
678 - Their debug information will contain relocations. Some
679 shared libraries do also, but many do not, so this can not
682 - If there are multiple code sections they will be loaded
683 at different relative addresses in memory than they are
684 in the objfile, since all sections in the file will start
687 Because GDB has very limited ability to map from an
688 address in debug info to the correct code section,
689 it relies on adding SECT_OFF_TEXT to things which might be
690 code. If we clear all the section offsets, and set the
691 section VMAs instead, then symfile_relocate_debug_section
692 will return meaningful debug information pointing at the
695 GDB has too many different data structures for section
696 addresses - a bfd, objfile, and so_list all have section
697 tables, as does exec_ops. Some of these could probably
700 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
701 cur_sec
= cur_sec
->next
)
703 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
706 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
707 exec_set_section_address (bfd_get_filename (abfd
),
709 offsets
[cur_sec
->index
]);
710 offsets
[cur_sec
->index
] = 0;
715 /* Remember the bfd indexes for the .text, .data, .bss and
717 init_objfile_sect_indices (objfile
);
720 /* Divide the file into segments, which are individual relocatable units.
721 This is the default version of the sym_fns.sym_segments function for
722 symbol readers that do not have an explicit representation of segments.
723 It assumes that object files do not have segments, and fully linked
724 files have a single segment. */
726 struct symfile_segment_data
*
727 default_symfile_segments (bfd
*abfd
)
731 struct symfile_segment_data
*data
;
734 /* Relocatable files contain enough information to position each
735 loadable section independently; they should not be relocated
737 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
740 /* Make sure there is at least one loadable section in the file. */
741 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
743 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
751 low
= bfd_get_section_vma (abfd
, sect
);
752 high
= low
+ bfd_get_section_size (sect
);
754 data
= XCNEW (struct symfile_segment_data
);
755 data
->num_segments
= 1;
756 data
->segment_bases
= XCNEW (CORE_ADDR
);
757 data
->segment_sizes
= XCNEW (CORE_ADDR
);
759 num_sections
= bfd_count_sections (abfd
);
760 data
->segment_info
= XCNEWVEC (int, num_sections
);
762 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
766 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
769 vma
= bfd_get_section_vma (abfd
, sect
);
772 if (vma
+ bfd_get_section_size (sect
) > high
)
773 high
= vma
+ bfd_get_section_size (sect
);
775 data
->segment_info
[i
] = 1;
778 data
->segment_bases
[0] = low
;
779 data
->segment_sizes
[0] = high
- low
;
784 /* This is a convenience function to call sym_read for OBJFILE and
785 possibly force the partial symbols to be read. */
788 read_symbols (struct objfile
*objfile
, symfile_add_flags add_flags
)
790 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
791 objfile
->per_bfd
->minsyms_read
= true;
793 /* find_separate_debug_file_in_section should be called only if there is
794 single binary with no existing separate debug info file. */
795 if (!objfile_has_partial_symbols (objfile
)
796 && objfile
->separate_debug_objfile
== NULL
797 && objfile
->separate_debug_objfile_backlink
== NULL
)
799 gdb_bfd_ref_ptr
abfd (find_separate_debug_file_in_section (objfile
));
803 /* find_separate_debug_file_in_section uses the same filename for the
804 virtual section-as-bfd like the bfd filename containing the
805 section. Therefore use also non-canonical name form for the same
806 file containing the section. */
807 symbol_file_add_separate (abfd
.get (),
808 bfd_get_filename (abfd
.get ()),
809 add_flags
| SYMFILE_NOT_FILENAME
, objfile
);
812 if ((add_flags
& SYMFILE_NO_READ
) == 0)
813 require_partial_symbols (objfile
, 0);
816 /* Initialize entry point information for this objfile. */
819 init_entry_point_info (struct objfile
*objfile
)
821 struct entry_info
*ei
= &objfile
->per_bfd
->ei
;
827 /* Save startup file's range of PC addresses to help blockframe.c
828 decide where the bottom of the stack is. */
830 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
832 /* Executable file -- record its entry point so we'll recognize
833 the startup file because it contains the entry point. */
834 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
835 ei
->entry_point_p
= 1;
837 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
838 && bfd_get_start_address (objfile
->obfd
) != 0)
840 /* Some shared libraries may have entry points set and be
841 runnable. There's no clear way to indicate this, so just check
842 for values other than zero. */
843 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
844 ei
->entry_point_p
= 1;
848 /* Examination of non-executable.o files. Short-circuit this stuff. */
849 ei
->entry_point_p
= 0;
852 if (ei
->entry_point_p
)
854 struct obj_section
*osect
;
855 CORE_ADDR entry_point
= ei
->entry_point
;
858 /* Make certain that the address points at real code, and not a
859 function descriptor. */
861 = gdbarch_convert_from_func_ptr_addr (get_objfile_arch (objfile
),
863 current_top_target ());
865 /* Remove any ISA markers, so that this matches entries in the
868 = gdbarch_addr_bits_remove (get_objfile_arch (objfile
), entry_point
);
871 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
873 struct bfd_section
*sect
= osect
->the_bfd_section
;
875 if (entry_point
>= bfd_get_section_vma (objfile
->obfd
, sect
)
876 && entry_point
< (bfd_get_section_vma (objfile
->obfd
, sect
)
877 + bfd_get_section_size (sect
)))
879 ei
->the_bfd_section_index
880 = gdb_bfd_section_index (objfile
->obfd
, sect
);
887 ei
->the_bfd_section_index
= SECT_OFF_TEXT (objfile
);
891 /* Process a symbol file, as either the main file or as a dynamically
894 This function does not set the OBJFILE's entry-point info.
896 OBJFILE is where the symbols are to be read from.
898 ADDRS is the list of section load addresses. If the user has given
899 an 'add-symbol-file' command, then this is the list of offsets and
900 addresses he or she provided as arguments to the command; or, if
901 we're handling a shared library, these are the actual addresses the
902 sections are loaded at, according to the inferior's dynamic linker
903 (as gleaned by GDB's shared library code). We convert each address
904 into an offset from the section VMA's as it appears in the object
905 file, and then call the file's sym_offsets function to convert this
906 into a format-specific offset table --- a `struct section_offsets'.
907 The sectindex field is used to control the ordering of sections
908 with the same name. Upon return, it is updated to contain the
909 correspondig BFD section index, or -1 if the section was not found.
911 ADD_FLAGS encodes verbosity level, whether this is main symbol or
912 an extra symbol file such as dynamically loaded code, and wether
913 breakpoint reset should be deferred. */
916 syms_from_objfile_1 (struct objfile
*objfile
,
917 section_addr_info
*addrs
,
918 symfile_add_flags add_flags
)
920 section_addr_info local_addr
;
921 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
923 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
925 if (objfile
->sf
== NULL
)
927 /* No symbols to load, but we still need to make sure
928 that the section_offsets table is allocated. */
929 int num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
930 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_sections
);
932 objfile
->num_sections
= num_sections
;
933 objfile
->section_offsets
934 = (struct section_offsets
*) obstack_alloc (&objfile
->objfile_obstack
,
936 memset (objfile
->section_offsets
, 0, size
);
940 /* Make sure that partially constructed symbol tables will be cleaned up
941 if an error occurs during symbol reading. */
942 gdb::optional
<clear_symtab_users_cleanup
> defer_clear_users
;
944 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
946 /* If ADDRS is NULL, put together a dummy address list.
947 We now establish the convention that an addr of zero means
948 no load address was specified. */
954 /* We will modify the main symbol table, make sure that all its users
955 will be cleaned up if an error occurs during symbol reading. */
956 defer_clear_users
.emplace ((symfile_add_flag
) 0);
958 /* Since no error yet, throw away the old symbol table. */
960 if (symfile_objfile
!= NULL
)
962 delete symfile_objfile
;
963 gdb_assert (symfile_objfile
== NULL
);
966 /* Currently we keep symbols from the add-symbol-file command.
967 If the user wants to get rid of them, they should do "symbol-file"
968 without arguments first. Not sure this is the best behavior
971 (*objfile
->sf
->sym_new_init
) (objfile
);
974 /* Convert addr into an offset rather than an absolute address.
975 We find the lowest address of a loaded segment in the objfile,
976 and assume that <addr> is where that got loaded.
978 We no longer warn if the lowest section is not a text segment (as
979 happens for the PA64 port. */
980 if (addrs
->size () > 0)
981 addr_info_make_relative (addrs
, objfile
->obfd
);
983 /* Initialize symbol reading routines for this objfile, allow complaints to
984 appear for this new file, and record how verbose to be, then do the
985 initial symbol reading for this file. */
987 (*objfile
->sf
->sym_init
) (objfile
);
990 (*objfile
->sf
->sym_offsets
) (objfile
, *addrs
);
992 read_symbols (objfile
, add_flags
);
994 /* Discard cleanups as symbol reading was successful. */
996 objfile_holder
.release ();
997 if (defer_clear_users
)
998 defer_clear_users
->release ();
1001 /* Same as syms_from_objfile_1, but also initializes the objfile
1002 entry-point info. */
1005 syms_from_objfile (struct objfile
*objfile
,
1006 section_addr_info
*addrs
,
1007 symfile_add_flags add_flags
)
1009 syms_from_objfile_1 (objfile
, addrs
, add_flags
);
1010 init_entry_point_info (objfile
);
1013 /* Perform required actions after either reading in the initial
1014 symbols for a new objfile, or mapping in the symbols from a reusable
1015 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1018 finish_new_objfile (struct objfile
*objfile
, symfile_add_flags add_flags
)
1020 /* If this is the main symbol file we have to clean up all users of the
1021 old main symbol file. Otherwise it is sufficient to fixup all the
1022 breakpoints that may have been redefined by this symbol file. */
1023 if (add_flags
& SYMFILE_MAINLINE
)
1025 /* OK, make it the "real" symbol file. */
1026 symfile_objfile
= objfile
;
1028 clear_symtab_users (add_flags
);
1030 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1032 breakpoint_re_set ();
1035 /* We're done reading the symbol file; finish off complaints. */
1036 clear_complaints ();
1039 /* Process a symbol file, as either the main file or as a dynamically
1042 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1043 A new reference is acquired by this function.
1045 For NAME description see the objfile constructor.
1047 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1048 extra, such as dynamically loaded code, and what to do with breakpoins.
1050 ADDRS is as described for syms_from_objfile_1, above.
1051 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1053 PARENT is the original objfile if ABFD is a separate debug info file.
1054 Otherwise PARENT is NULL.
1056 Upon success, returns a pointer to the objfile that was added.
1057 Upon failure, jumps back to command level (never returns). */
1059 static struct objfile
*
1060 symbol_file_add_with_addrs (bfd
*abfd
, const char *name
,
1061 symfile_add_flags add_flags
,
1062 section_addr_info
*addrs
,
1063 objfile_flags flags
, struct objfile
*parent
)
1065 struct objfile
*objfile
;
1066 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1067 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1068 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
1069 && (readnow_symbol_files
1070 || (add_flags
& SYMFILE_NO_READ
) == 0));
1072 if (readnow_symbol_files
)
1074 flags
|= OBJF_READNOW
;
1075 add_flags
&= ~SYMFILE_NO_READ
;
1077 else if (readnever_symbol_files
1078 || (parent
!= NULL
&& (parent
->flags
& OBJF_READNEVER
)))
1080 flags
|= OBJF_READNEVER
;
1081 add_flags
|= SYMFILE_NO_READ
;
1083 if ((add_flags
& SYMFILE_NOT_FILENAME
) != 0)
1084 flags
|= OBJF_NOT_FILENAME
;
1086 /* Give user a chance to burp if we'd be
1087 interactively wiping out any existing symbols. */
1089 if ((have_full_symbols () || have_partial_symbols ())
1092 && !query (_("Load new symbol table from \"%s\"? "), name
))
1093 error (_("Not confirmed."));
1096 flags
|= OBJF_MAINLINE
;
1097 objfile
= new struct objfile (abfd
, name
, flags
);
1100 add_separate_debug_objfile (objfile
, parent
);
1102 /* We either created a new mapped symbol table, mapped an existing
1103 symbol table file which has not had initial symbol reading
1104 performed, or need to read an unmapped symbol table. */
1107 if (deprecated_pre_add_symbol_hook
)
1108 deprecated_pre_add_symbol_hook (name
);
1111 puts_filtered (_("Reading symbols from "));
1112 fputs_styled (name
, file_name_style
.style (), gdb_stdout
);
1113 puts_filtered ("...\n");
1116 syms_from_objfile (objfile
, addrs
, add_flags
);
1118 /* We now have at least a partial symbol table. Check to see if the
1119 user requested that all symbols be read on initial access via either
1120 the gdb startup command line or on a per symbol file basis. Expand
1121 all partial symbol tables for this objfile if so. */
1123 if ((flags
& OBJF_READNOW
))
1126 printf_filtered (_("Expanding full symbols from %s...\n"), name
);
1129 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1132 /* Note that we only print a message if we have no symbols and have
1133 no separate debug file. If there is a separate debug file which
1134 does not have symbols, we'll have emitted this message for that
1135 file, and so printing it twice is just redundant. */
1136 if (should_print
&& !objfile_has_symbols (objfile
)
1137 && objfile
->separate_debug_objfile
== nullptr)
1138 printf_filtered (_("(No debugging symbols found in %s)\n"), name
);
1142 if (deprecated_post_add_symbol_hook
)
1143 deprecated_post_add_symbol_hook ();
1146 /* We print some messages regardless of whether 'from_tty ||
1147 info_verbose' is true, so make sure they go out at the right
1149 gdb_flush (gdb_stdout
);
1151 if (objfile
->sf
== NULL
)
1153 gdb::observers::new_objfile
.notify (objfile
);
1154 return objfile
; /* No symbols. */
1157 finish_new_objfile (objfile
, add_flags
);
1159 gdb::observers::new_objfile
.notify (objfile
);
1161 bfd_cache_close_all ();
1165 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1166 see the objfile constructor. */
1169 symbol_file_add_separate (bfd
*bfd
, const char *name
,
1170 symfile_add_flags symfile_flags
,
1171 struct objfile
*objfile
)
1173 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1174 because sections of BFD may not match sections of OBJFILE and because
1175 vma may have been modified by tools such as prelink. */
1176 section_addr_info sap
= build_section_addr_info_from_objfile (objfile
);
1178 symbol_file_add_with_addrs
1179 (bfd
, name
, symfile_flags
, &sap
,
1180 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1185 /* Process the symbol file ABFD, as either the main file or as a
1186 dynamically loaded file.
1187 See symbol_file_add_with_addrs's comments for details. */
1190 symbol_file_add_from_bfd (bfd
*abfd
, const char *name
,
1191 symfile_add_flags add_flags
,
1192 section_addr_info
*addrs
,
1193 objfile_flags flags
, struct objfile
*parent
)
1195 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1199 /* Process a symbol file, as either the main file or as a dynamically
1200 loaded file. See symbol_file_add_with_addrs's comments for details. */
1203 symbol_file_add (const char *name
, symfile_add_flags add_flags
,
1204 section_addr_info
*addrs
, objfile_flags flags
)
1206 gdb_bfd_ref_ptr
bfd (symfile_bfd_open (name
));
1208 return symbol_file_add_from_bfd (bfd
.get (), name
, add_flags
, addrs
,
1212 /* Call symbol_file_add() with default values and update whatever is
1213 affected by the loading of a new main().
1214 Used when the file is supplied in the gdb command line
1215 and by some targets with special loading requirements.
1216 The auxiliary function, symbol_file_add_main_1(), has the flags
1217 argument for the switches that can only be specified in the symbol_file
1221 symbol_file_add_main (const char *args
, symfile_add_flags add_flags
)
1223 symbol_file_add_main_1 (args
, add_flags
, 0, 0);
1227 symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
1228 objfile_flags flags
, CORE_ADDR reloff
)
1230 add_flags
|= current_inferior ()->symfile_flags
| SYMFILE_MAINLINE
;
1232 struct objfile
*objfile
= symbol_file_add (args
, add_flags
, NULL
, flags
);
1234 objfile_rebase (objfile
, reloff
);
1236 /* Getting new symbols may change our opinion about
1237 what is frameless. */
1238 reinit_frame_cache ();
1240 if ((add_flags
& SYMFILE_NO_READ
) == 0)
1241 set_initial_language ();
1245 symbol_file_clear (int from_tty
)
1247 if ((have_full_symbols () || have_partial_symbols ())
1250 ? !query (_("Discard symbol table from `%s'? "),
1251 objfile_name (symfile_objfile
))
1252 : !query (_("Discard symbol table? "))))
1253 error (_("Not confirmed."));
1255 /* solib descriptors may have handles to objfiles. Wipe them before their
1256 objfiles get stale by free_all_objfiles. */
1257 no_shared_libraries (NULL
, from_tty
);
1259 free_all_objfiles ();
1261 gdb_assert (symfile_objfile
== NULL
);
1263 printf_filtered (_("No symbol file now.\n"));
1266 /* See symfile.h. */
1268 int separate_debug_file_debug
= 0;
1271 separate_debug_file_exists (const std::string
&name
, unsigned long crc
,
1272 struct objfile
*parent_objfile
)
1274 unsigned long file_crc
;
1276 struct stat parent_stat
, abfd_stat
;
1277 int verified_as_different
;
1279 /* Find a separate debug info file as if symbols would be present in
1280 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1281 section can contain just the basename of PARENT_OBJFILE without any
1282 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1283 the separate debug infos with the same basename can exist. */
1285 if (filename_cmp (name
.c_str (), objfile_name (parent_objfile
)) == 0)
1288 if (separate_debug_file_debug
)
1290 printf_filtered (_(" Trying %s..."), name
.c_str ());
1291 gdb_flush (gdb_stdout
);
1294 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (name
.c_str (), gnutarget
, -1));
1298 if (separate_debug_file_debug
)
1299 printf_filtered (_(" no, unable to open.\n"));
1304 /* Verify symlinks were not the cause of filename_cmp name difference above.
1306 Some operating systems, e.g. Windows, do not provide a meaningful
1307 st_ino; they always set it to zero. (Windows does provide a
1308 meaningful st_dev.) Files accessed from gdbservers that do not
1309 support the vFile:fstat packet will also have st_ino set to zero.
1310 Do not indicate a duplicate library in either case. While there
1311 is no guarantee that a system that provides meaningful inode
1312 numbers will never set st_ino to zero, this is merely an
1313 optimization, so we do not need to worry about false negatives. */
1315 if (bfd_stat (abfd
.get (), &abfd_stat
) == 0
1316 && abfd_stat
.st_ino
!= 0
1317 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1319 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1320 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1322 if (separate_debug_file_debug
)
1323 printf_filtered (_(" no, same file as the objfile.\n"));
1327 verified_as_different
= 1;
1330 verified_as_different
= 0;
1332 file_crc_p
= gdb_bfd_crc (abfd
.get (), &file_crc
);
1336 if (separate_debug_file_debug
)
1337 printf_filtered (_(" no, error computing CRC.\n"));
1342 if (crc
!= file_crc
)
1344 unsigned long parent_crc
;
1346 /* If the files could not be verified as different with
1347 bfd_stat then we need to calculate the parent's CRC
1348 to verify whether the files are different or not. */
1350 if (!verified_as_different
)
1352 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1354 if (separate_debug_file_debug
)
1355 printf_filtered (_(" no, error computing CRC.\n"));
1361 if (verified_as_different
|| parent_crc
!= file_crc
)
1362 warning (_("the debug information found in \"%s\""
1363 " does not match \"%s\" (CRC mismatch).\n"),
1364 name
.c_str (), objfile_name (parent_objfile
));
1366 if (separate_debug_file_debug
)
1367 printf_filtered (_(" no, CRC doesn't match.\n"));
1372 if (separate_debug_file_debug
)
1373 printf_filtered (_(" yes!\n"));
1378 char *debug_file_directory
= NULL
;
1380 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1381 struct cmd_list_element
*c
, const char *value
)
1383 fprintf_filtered (file
,
1384 _("The directory where separate debug "
1385 "symbols are searched for is \"%s\".\n"),
1389 #if ! defined (DEBUG_SUBDIRECTORY)
1390 #define DEBUG_SUBDIRECTORY ".debug"
1393 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1394 where the original file resides (may not be the same as
1395 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1396 looking for. CANON_DIR is the "realpath" form of DIR.
1397 DIR must contain a trailing '/'.
1398 Returns the path of the file with separate debug info, or an empty
1402 find_separate_debug_file (const char *dir
,
1403 const char *canon_dir
,
1404 const char *debuglink
,
1405 unsigned long crc32
, struct objfile
*objfile
)
1407 if (separate_debug_file_debug
)
1408 printf_filtered (_("\nLooking for separate debug info (debug link) for "
1409 "%s\n"), objfile_name (objfile
));
1411 /* First try in the same directory as the original file. */
1412 std::string debugfile
= dir
;
1413 debugfile
+= debuglink
;
1415 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1418 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1420 debugfile
+= DEBUG_SUBDIRECTORY
;
1422 debugfile
+= debuglink
;
1424 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1427 /* Then try in the global debugfile directories.
1429 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1430 cause "/..." lookups. */
1432 bool target_prefix
= startswith (dir
, "target:");
1433 const char *dir_notarget
= target_prefix
? dir
+ strlen ("target:") : dir
;
1434 std::vector
<gdb::unique_xmalloc_ptr
<char>> debugdir_vec
1435 = dirnames_to_char_ptr_vec (debug_file_directory
);
1436 gdb::unique_xmalloc_ptr
<char> canon_sysroot
= gdb_realpath (gdb_sysroot
);
1438 /* MS-Windows/MS-DOS don't allow colons in file names; we must
1439 convert the drive letter into a one-letter directory, so that the
1440 file name resulting from splicing below will be valid.
1442 FIXME: The below only works when GDB runs on MS-Windows/MS-DOS.
1443 There are various remote-debugging scenarios where such a
1444 transformation of the drive letter might be required when GDB runs
1445 on a Posix host, see
1447 https://sourceware.org/ml/gdb-patches/2019-04/msg00605.html
1449 If some of those scenarions need to be supported, we will need to
1450 use a different condition for HAS_DRIVE_SPEC and a different macro
1451 instead of STRIP_DRIVE_SPEC, which work on Posix systems as well. */
1453 if (HAS_DRIVE_SPEC (dir_notarget
))
1455 drive
= dir_notarget
[0];
1456 dir_notarget
= STRIP_DRIVE_SPEC (dir_notarget
);
1459 for (const gdb::unique_xmalloc_ptr
<char> &debugdir
: debugdir_vec
)
1461 debugfile
= target_prefix
? "target:" : "";
1462 debugfile
+= debugdir
.get ();
1465 debugfile
+= dir_notarget
;
1466 debugfile
+= debuglink
;
1468 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1471 const char *base_path
= NULL
;
1472 if (canon_dir
!= NULL
)
1474 if (canon_sysroot
.get () != NULL
)
1475 base_path
= child_path (canon_sysroot
.get (), canon_dir
);
1477 base_path
= child_path (gdb_sysroot
, canon_dir
);
1479 if (base_path
!= NULL
)
1481 /* If the file is in the sysroot, try using its base path in
1482 the global debugfile directory. */
1483 debugfile
= target_prefix
? "target:" : "";
1484 debugfile
+= debugdir
.get ();
1486 debugfile
+= base_path
;
1488 debugfile
+= debuglink
;
1490 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1493 /* If the file is in the sysroot, try using its base path in
1494 the sysroot's global debugfile directory. */
1495 debugfile
= target_prefix
? "target:" : "";
1496 debugfile
+= gdb_sysroot
;
1497 debugfile
+= debugdir
.get ();
1499 debugfile
+= base_path
;
1501 debugfile
+= debuglink
;
1503 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1509 return std::string ();
1512 /* Modify PATH to contain only "[/]directory/" part of PATH.
1513 If there were no directory separators in PATH, PATH will be empty
1514 string on return. */
1517 terminate_after_last_dir_separator (char *path
)
1521 /* Strip off the final filename part, leaving the directory name,
1522 followed by a slash. The directory can be relative or absolute. */
1523 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1524 if (IS_DIR_SEPARATOR (path
[i
]))
1527 /* If I is -1 then no directory is present there and DIR will be "". */
1531 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1532 Returns pathname, or an empty string. */
1535 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1537 unsigned long crc32
;
1539 gdb::unique_xmalloc_ptr
<char> debuglink
1540 (bfd_get_debug_link_info (objfile
->obfd
, &crc32
));
1542 if (debuglink
== NULL
)
1544 /* There's no separate debug info, hence there's no way we could
1545 load it => no warning. */
1546 return std::string ();
1549 std::string dir
= objfile_name (objfile
);
1550 terminate_after_last_dir_separator (&dir
[0]);
1551 gdb::unique_xmalloc_ptr
<char> canon_dir (lrealpath (dir
.c_str ()));
1553 std::string debugfile
1554 = find_separate_debug_file (dir
.c_str (), canon_dir
.get (),
1555 debuglink
.get (), crc32
, objfile
);
1557 if (debugfile
.empty ())
1559 /* For PR gdb/9538, try again with realpath (if different from the
1564 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1565 && S_ISLNK (st_buf
.st_mode
))
1567 gdb::unique_xmalloc_ptr
<char> symlink_dir
1568 (lrealpath (objfile_name (objfile
)));
1569 if (symlink_dir
!= NULL
)
1571 terminate_after_last_dir_separator (symlink_dir
.get ());
1572 if (dir
!= symlink_dir
.get ())
1574 /* Different directory, so try using it. */
1575 debugfile
= find_separate_debug_file (symlink_dir
.get (),
1588 /* Make sure that OBJF_{READNOW,READNEVER} are not set
1592 validate_readnow_readnever (objfile_flags flags
)
1594 if ((flags
& OBJF_READNOW
) && (flags
& OBJF_READNEVER
))
1595 error (_("-readnow and -readnever cannot be used simultaneously"));
1598 /* This is the symbol-file command. Read the file, analyze its
1599 symbols, and add a struct symtab to a symtab list. The syntax of
1600 the command is rather bizarre:
1602 1. The function buildargv implements various quoting conventions
1603 which are undocumented and have little or nothing in common with
1604 the way things are quoted (or not quoted) elsewhere in GDB.
1606 2. Options are used, which are not generally used in GDB (perhaps
1607 "set mapped on", "set readnow on" would be better)
1609 3. The order of options matters, which is contrary to GNU
1610 conventions (because it is confusing and inconvenient). */
1613 symbol_file_command (const char *args
, int from_tty
)
1619 symbol_file_clear (from_tty
);
1623 objfile_flags flags
= OBJF_USERLOADED
;
1624 symfile_add_flags add_flags
= 0;
1626 bool stop_processing_options
= false;
1627 CORE_ADDR offset
= 0;
1632 add_flags
|= SYMFILE_VERBOSE
;
1634 gdb_argv
built_argv (args
);
1635 for (arg
= built_argv
[0], idx
= 0; arg
!= NULL
; arg
= built_argv
[++idx
])
1637 if (stop_processing_options
|| *arg
!= '-')
1642 error (_("Unrecognized argument \"%s\""), arg
);
1644 else if (strcmp (arg
, "-readnow") == 0)
1645 flags
|= OBJF_READNOW
;
1646 else if (strcmp (arg
, "-readnever") == 0)
1647 flags
|= OBJF_READNEVER
;
1648 else if (strcmp (arg
, "-o") == 0)
1650 arg
= built_argv
[++idx
];
1652 error (_("Missing argument to -o"));
1654 offset
= parse_and_eval_address (arg
);
1656 else if (strcmp (arg
, "--") == 0)
1657 stop_processing_options
= true;
1659 error (_("Unrecognized argument \"%s\""), arg
);
1663 error (_("no symbol file name was specified"));
1665 validate_readnow_readnever (flags
);
1667 /* Set SYMFILE_DEFER_BP_RESET because the proper displacement for a PIE
1668 (Position Independent Executable) main symbol file will only be
1669 computed by the solib_create_inferior_hook below. Without it,
1670 breakpoint_re_set would fail to insert the breakpoints with the zero
1672 add_flags
|= SYMFILE_DEFER_BP_RESET
;
1674 symbol_file_add_main_1 (name
, add_flags
, flags
, offset
);
1676 solib_create_inferior_hook (from_tty
);
1678 /* Now it's safe to re-add the breakpoints. */
1679 breakpoint_re_set ();
1683 /* Set the initial language.
1685 FIXME: A better solution would be to record the language in the
1686 psymtab when reading partial symbols, and then use it (if known) to
1687 set the language. This would be a win for formats that encode the
1688 language in an easily discoverable place, such as DWARF. For
1689 stabs, we can jump through hoops looking for specially named
1690 symbols or try to intuit the language from the specific type of
1691 stabs we find, but we can't do that until later when we read in
1695 set_initial_language (void)
1697 enum language lang
= main_language ();
1699 if (lang
== language_unknown
)
1701 const char *name
= main_name ();
1702 struct symbol
*sym
= lookup_symbol (name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
1705 lang
= SYMBOL_LANGUAGE (sym
);
1708 if (lang
== language_unknown
)
1710 /* Make C the default language */
1714 set_language (lang
);
1715 expected_language
= current_language
; /* Don't warn the user. */
1718 /* Open the file specified by NAME and hand it off to BFD for
1719 preliminary analysis. Return a newly initialized bfd *, which
1720 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1721 absolute). In case of trouble, error() is called. */
1724 symfile_bfd_open (const char *name
)
1728 gdb::unique_xmalloc_ptr
<char> absolute_name
;
1729 if (!is_target_filename (name
))
1731 gdb::unique_xmalloc_ptr
<char> expanded_name (tilde_expand (name
));
1733 /* Look down path for it, allocate 2nd new malloc'd copy. */
1734 desc
= openp (getenv ("PATH"),
1735 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1736 expanded_name
.get (), O_RDONLY
| O_BINARY
, &absolute_name
);
1737 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1740 char *exename
= (char *) alloca (strlen (expanded_name
.get ()) + 5);
1742 strcat (strcpy (exename
, expanded_name
.get ()), ".exe");
1743 desc
= openp (getenv ("PATH"),
1744 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1745 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1749 perror_with_name (expanded_name
.get ());
1751 name
= absolute_name
.get ();
1754 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (name
, gnutarget
, desc
));
1755 if (sym_bfd
== NULL
)
1756 error (_("`%s': can't open to read symbols: %s."), name
,
1757 bfd_errmsg (bfd_get_error ()));
1759 if (!gdb_bfd_has_target_filename (sym_bfd
.get ()))
1760 bfd_set_cacheable (sym_bfd
.get (), 1);
1762 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
1763 error (_("`%s': can't read symbols: %s."), name
,
1764 bfd_errmsg (bfd_get_error ()));
1769 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1770 the section was not found. */
1773 get_section_index (struct objfile
*objfile
, const char *section_name
)
1775 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1783 /* Link SF into the global symtab_fns list.
1784 FLAVOUR is the file format that SF handles.
1785 Called on startup by the _initialize routine in each object file format
1786 reader, to register information about each format the reader is prepared
1790 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1792 symtab_fns
.emplace_back (flavour
, sf
);
1795 /* Initialize OBJFILE to read symbols from its associated BFD. It
1796 either returns or calls error(). The result is an initialized
1797 struct sym_fns in the objfile structure, that contains cached
1798 information about the symbol file. */
1800 static const struct sym_fns
*
1801 find_sym_fns (bfd
*abfd
)
1803 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1805 if (our_flavour
== bfd_target_srec_flavour
1806 || our_flavour
== bfd_target_ihex_flavour
1807 || our_flavour
== bfd_target_tekhex_flavour
)
1808 return NULL
; /* No symbols. */
1810 for (const registered_sym_fns
&rsf
: symtab_fns
)
1811 if (our_flavour
== rsf
.sym_flavour
)
1814 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1815 bfd_get_target (abfd
));
1819 /* This function runs the load command of our current target. */
1822 load_command (const char *arg
, int from_tty
)
1826 /* The user might be reloading because the binary has changed. Take
1827 this opportunity to check. */
1828 reopen_exec_file ();
1834 const char *parg
, *prev
;
1836 arg
= get_exec_file (1);
1838 /* We may need to quote this string so buildargv can pull it
1841 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1843 temp
.append (prev
, parg
- prev
);
1845 temp
.push_back ('\\');
1847 /* If we have not copied anything yet, then we didn't see a
1848 character to quote, and we can just leave ARG unchanged. */
1852 arg
= temp
.c_str ();
1856 target_load (arg
, from_tty
);
1858 /* After re-loading the executable, we don't really know which
1859 overlays are mapped any more. */
1860 overlay_cache_invalid
= 1;
1863 /* This version of "load" should be usable for any target. Currently
1864 it is just used for remote targets, not inftarg.c or core files,
1865 on the theory that only in that case is it useful.
1867 Avoiding xmodem and the like seems like a win (a) because we don't have
1868 to worry about finding it, and (b) On VMS, fork() is very slow and so
1869 we don't want to run a subprocess. On the other hand, I'm not sure how
1870 performance compares. */
1872 static int validate_download
= 0;
1874 /* Callback service function for generic_load (bfd_map_over_sections). */
1877 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1879 bfd_size_type
*sum
= (bfd_size_type
*) data
;
1881 *sum
+= bfd_get_section_size (asec
);
1884 /* Opaque data for load_progress. */
1885 struct load_progress_data
1887 /* Cumulative data. */
1888 unsigned long write_count
= 0;
1889 unsigned long data_count
= 0;
1890 bfd_size_type total_size
= 0;
1893 /* Opaque data for load_progress for a single section. */
1894 struct load_progress_section_data
1896 load_progress_section_data (load_progress_data
*cumulative_
,
1897 const char *section_name_
, ULONGEST section_size_
,
1898 CORE_ADDR lma_
, gdb_byte
*buffer_
)
1899 : cumulative (cumulative_
), section_name (section_name_
),
1900 section_size (section_size_
), lma (lma_
), buffer (buffer_
)
1903 struct load_progress_data
*cumulative
;
1905 /* Per-section data. */
1906 const char *section_name
;
1907 ULONGEST section_sent
= 0;
1908 ULONGEST section_size
;
1913 /* Opaque data for load_section_callback. */
1914 struct load_section_data
1916 load_section_data (load_progress_data
*progress_data_
)
1917 : progress_data (progress_data_
)
1920 ~load_section_data ()
1922 for (auto &&request
: requests
)
1924 xfree (request
.data
);
1925 delete ((load_progress_section_data
*) request
.baton
);
1929 CORE_ADDR load_offset
= 0;
1930 struct load_progress_data
*progress_data
;
1931 std::vector
<struct memory_write_request
> requests
;
1934 /* Target write callback routine for progress reporting. */
1937 load_progress (ULONGEST bytes
, void *untyped_arg
)
1939 struct load_progress_section_data
*args
1940 = (struct load_progress_section_data
*) untyped_arg
;
1941 struct load_progress_data
*totals
;
1944 /* Writing padding data. No easy way to get at the cumulative
1945 stats, so just ignore this. */
1948 totals
= args
->cumulative
;
1950 if (bytes
== 0 && args
->section_sent
== 0)
1952 /* The write is just starting. Let the user know we've started
1954 current_uiout
->message ("Loading section %s, size %s lma %s\n",
1956 hex_string (args
->section_size
),
1957 paddress (target_gdbarch (), args
->lma
));
1961 if (validate_download
)
1963 /* Broken memories and broken monitors manifest themselves here
1964 when bring new computers to life. This doubles already slow
1966 /* NOTE: cagney/1999-10-18: A more efficient implementation
1967 might add a verify_memory() method to the target vector and
1968 then use that. remote.c could implement that method using
1969 the ``qCRC'' packet. */
1970 gdb::byte_vector
check (bytes
);
1972 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1973 error (_("Download verify read failed at %s"),
1974 paddress (target_gdbarch (), args
->lma
));
1975 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1976 error (_("Download verify compare failed at %s"),
1977 paddress (target_gdbarch (), args
->lma
));
1979 totals
->data_count
+= bytes
;
1981 args
->buffer
+= bytes
;
1982 totals
->write_count
+= 1;
1983 args
->section_sent
+= bytes
;
1984 if (check_quit_flag ()
1985 || (deprecated_ui_load_progress_hook
!= NULL
1986 && deprecated_ui_load_progress_hook (args
->section_name
,
1987 args
->section_sent
)))
1988 error (_("Canceled the download"));
1990 if (deprecated_show_load_progress
!= NULL
)
1991 deprecated_show_load_progress (args
->section_name
,
1995 totals
->total_size
);
1998 /* Callback service function for generic_load (bfd_map_over_sections). */
2001 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
2003 struct load_section_data
*args
= (struct load_section_data
*) data
;
2004 bfd_size_type size
= bfd_get_section_size (asec
);
2005 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
2007 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
2013 ULONGEST begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
2014 ULONGEST end
= begin
+ size
;
2015 gdb_byte
*buffer
= (gdb_byte
*) xmalloc (size
);
2016 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2018 load_progress_section_data
*section_data
2019 = new load_progress_section_data (args
->progress_data
, sect_name
, size
,
2022 args
->requests
.emplace_back (begin
, end
, buffer
, section_data
);
2025 static void print_transfer_performance (struct ui_file
*stream
,
2026 unsigned long data_count
,
2027 unsigned long write_count
,
2028 std::chrono::steady_clock::duration d
);
2030 /* See symfile.h. */
2033 generic_load (const char *args
, int from_tty
)
2035 struct load_progress_data total_progress
;
2036 struct load_section_data
cbdata (&total_progress
);
2037 struct ui_out
*uiout
= current_uiout
;
2040 error_no_arg (_("file to load"));
2042 gdb_argv
argv (args
);
2044 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2046 if (argv
[1] != NULL
)
2050 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2052 /* If the last word was not a valid number then
2053 treat it as a file name with spaces in. */
2054 if (argv
[1] == endptr
)
2055 error (_("Invalid download offset:%s."), argv
[1]);
2057 if (argv
[2] != NULL
)
2058 error (_("Too many parameters."));
2061 /* Open the file for loading. */
2062 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
2063 if (loadfile_bfd
== NULL
)
2064 perror_with_name (filename
.get ());
2066 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
2068 error (_("\"%s\" is not an object file: %s"), filename
.get (),
2069 bfd_errmsg (bfd_get_error ()));
2072 bfd_map_over_sections (loadfile_bfd
.get (), add_section_size_callback
,
2073 (void *) &total_progress
.total_size
);
2075 bfd_map_over_sections (loadfile_bfd
.get (), load_section_callback
, &cbdata
);
2077 using namespace std::chrono
;
2079 steady_clock::time_point start_time
= steady_clock::now ();
2081 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2082 load_progress
) != 0)
2083 error (_("Load failed"));
2085 steady_clock::time_point end_time
= steady_clock::now ();
2087 CORE_ADDR entry
= bfd_get_start_address (loadfile_bfd
.get ());
2088 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2089 uiout
->text ("Start address ");
2090 uiout
->field_core_addr ("address", target_gdbarch (), entry
);
2091 uiout
->text (", load size ");
2092 uiout
->field_unsigned ("load-size", total_progress
.data_count
);
2094 regcache_write_pc (get_current_regcache (), entry
);
2096 /* Reset breakpoints, now that we have changed the load image. For
2097 instance, breakpoints may have been set (or reset, by
2098 post_create_inferior) while connected to the target but before we
2099 loaded the program. In that case, the prologue analyzer could
2100 have read instructions from the target to find the right
2101 breakpoint locations. Loading has changed the contents of that
2104 breakpoint_re_set ();
2106 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2107 total_progress
.write_count
,
2108 end_time
- start_time
);
2111 /* Report on STREAM the performance of a memory transfer operation,
2112 such as 'load'. DATA_COUNT is the number of bytes transferred.
2113 WRITE_COUNT is the number of separate write operations, or 0, if
2114 that information is not available. TIME is how long the operation
2118 print_transfer_performance (struct ui_file
*stream
,
2119 unsigned long data_count
,
2120 unsigned long write_count
,
2121 std::chrono::steady_clock::duration time
)
2123 using namespace std::chrono
;
2124 struct ui_out
*uiout
= current_uiout
;
2126 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2128 uiout
->text ("Transfer rate: ");
2129 if (ms
.count () > 0)
2131 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2133 if (uiout
->is_mi_like_p ())
2135 uiout
->field_unsigned ("transfer-rate", rate
* 8);
2136 uiout
->text (" bits/sec");
2138 else if (rate
< 1024)
2140 uiout
->field_unsigned ("transfer-rate", rate
);
2141 uiout
->text (" bytes/sec");
2145 uiout
->field_unsigned ("transfer-rate", rate
/ 1024);
2146 uiout
->text (" KB/sec");
2151 uiout
->field_unsigned ("transferred-bits", (data_count
* 8));
2152 uiout
->text (" bits in <1 sec");
2154 if (write_count
> 0)
2157 uiout
->field_unsigned ("write-rate", data_count
/ write_count
);
2158 uiout
->text (" bytes/write");
2160 uiout
->text (".\n");
2163 /* Add an OFFSET to the start address of each section in OBJF, except
2164 sections that were specified in ADDRS. */
2167 set_objfile_default_section_offset (struct objfile
*objf
,
2168 const section_addr_info
&addrs
,
2171 /* Add OFFSET to all sections by default. */
2172 std::vector
<struct section_offsets
> offsets (objf
->num_sections
,
2175 /* Create sorted lists of all sections in ADDRS as well as all
2176 sections in OBJF. */
2178 std::vector
<const struct other_sections
*> addrs_sorted
2179 = addrs_section_sort (addrs
);
2181 section_addr_info objf_addrs
2182 = build_section_addr_info_from_objfile (objf
);
2183 std::vector
<const struct other_sections
*> objf_addrs_sorted
2184 = addrs_section_sort (objf_addrs
);
2186 /* Walk the BFD section list, and if a matching section is found in
2187 ADDRS_SORTED_LIST, set its offset to zero to keep its address
2190 Note that both lists may contain multiple sections with the same
2191 name, and then the sections from ADDRS are matched in BFD order
2192 (thanks to sectindex). */
2194 std::vector
<const struct other_sections
*>::iterator addrs_sorted_iter
2195 = addrs_sorted
.begin ();
2196 for (const other_sections
*objf_sect
: objf_addrs_sorted
)
2198 const char *objf_name
= addr_section_name (objf_sect
->name
.c_str ());
2201 while (cmp
< 0 && addrs_sorted_iter
!= addrs_sorted
.end ())
2203 const struct other_sections
*sect
= *addrs_sorted_iter
;
2204 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
2205 cmp
= strcmp (sect_name
, objf_name
);
2207 ++addrs_sorted_iter
;
2211 offsets
[objf_sect
->sectindex
].offsets
[0] = 0;
2214 /* Apply the new section offsets. */
2215 objfile_relocate (objf
, offsets
.data ());
2218 /* This function allows the addition of incrementally linked object files.
2219 It does not modify any state in the target, only in the debugger. */
2222 add_symbol_file_command (const char *args
, int from_tty
)
2224 struct gdbarch
*gdbarch
= get_current_arch ();
2225 gdb::unique_xmalloc_ptr
<char> filename
;
2228 struct objfile
*objf
;
2229 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2230 symfile_add_flags add_flags
= 0;
2233 add_flags
|= SYMFILE_VERBOSE
;
2241 std::vector
<sect_opt
> sect_opts
= { { ".text", NULL
} };
2242 bool stop_processing_options
= false;
2243 CORE_ADDR offset
= 0;
2248 error (_("add-symbol-file takes a file name and an address"));
2250 bool seen_addr
= false;
2251 bool seen_offset
= false;
2252 gdb_argv
argv (args
);
2254 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2256 if (stop_processing_options
|| *arg
!= '-')
2258 if (filename
== NULL
)
2260 /* First non-option argument is always the filename. */
2261 filename
.reset (tilde_expand (arg
));
2263 else if (!seen_addr
)
2265 /* The second non-option argument is always the text
2266 address at which to load the program. */
2267 sect_opts
[0].value
= arg
;
2271 error (_("Unrecognized argument \"%s\""), arg
);
2273 else if (strcmp (arg
, "-readnow") == 0)
2274 flags
|= OBJF_READNOW
;
2275 else if (strcmp (arg
, "-readnever") == 0)
2276 flags
|= OBJF_READNEVER
;
2277 else if (strcmp (arg
, "-s") == 0)
2279 if (argv
[argcnt
+ 1] == NULL
)
2280 error (_("Missing section name after \"-s\""));
2281 else if (argv
[argcnt
+ 2] == NULL
)
2282 error (_("Missing section address after \"-s\""));
2284 sect_opt sect
= { argv
[argcnt
+ 1], argv
[argcnt
+ 2] };
2286 sect_opts
.push_back (sect
);
2289 else if (strcmp (arg
, "-o") == 0)
2291 arg
= argv
[++argcnt
];
2293 error (_("Missing argument to -o"));
2295 offset
= parse_and_eval_address (arg
);
2298 else if (strcmp (arg
, "--") == 0)
2299 stop_processing_options
= true;
2301 error (_("Unrecognized argument \"%s\""), arg
);
2304 if (filename
== NULL
)
2305 error (_("You must provide a filename to be loaded."));
2307 validate_readnow_readnever (flags
);
2309 /* Print the prompt for the query below. And save the arguments into
2310 a sect_addr_info structure to be passed around to other
2311 functions. We have to split this up into separate print
2312 statements because hex_string returns a local static
2315 printf_unfiltered (_("add symbol table from file \"%s\""),
2317 section_addr_info section_addrs
;
2318 std::vector
<sect_opt
>::const_iterator it
= sect_opts
.begin ();
2321 for (; it
!= sect_opts
.end (); ++it
)
2324 const char *val
= it
->value
;
2325 const char *sec
= it
->name
;
2327 if (section_addrs
.empty ())
2328 printf_unfiltered (_(" at\n"));
2329 addr
= parse_and_eval_address (val
);
2331 /* Here we store the section offsets in the order they were
2332 entered on the command line. Every array element is
2333 assigned an ascending section index to preserve the above
2334 order over an unstable sorting algorithm. This dummy
2335 index is not used for any other purpose.
2337 section_addrs
.emplace_back (addr
, sec
, section_addrs
.size ());
2338 printf_filtered ("\t%s_addr = %s\n", sec
,
2339 paddress (gdbarch
, addr
));
2341 /* The object's sections are initialized when a
2342 call is made to build_objfile_section_table (objfile).
2343 This happens in reread_symbols.
2344 At this point, we don't know what file type this is,
2345 so we can't determine what section names are valid. */
2348 printf_unfiltered (_("%s offset by %s\n"),
2349 (section_addrs
.empty ()
2350 ? _(" with all sections")
2351 : _("with other sections")),
2352 paddress (gdbarch
, offset
));
2353 else if (section_addrs
.empty ())
2354 printf_unfiltered ("\n");
2356 if (from_tty
&& (!query ("%s", "")))
2357 error (_("Not confirmed."));
2359 objf
= symbol_file_add (filename
.get (), add_flags
, §ion_addrs
,
2361 if (!objfile_has_symbols (objf
) && objf
->per_bfd
->minimal_symbol_count
<= 0)
2362 warning (_("newly-added symbol file \"%s\" does not provide any symbols"),
2366 set_objfile_default_section_offset (objf
, section_addrs
, offset
);
2368 add_target_sections_of_objfile (objf
);
2370 /* Getting new symbols may change our opinion about what is
2372 reinit_frame_cache ();
2376 /* This function removes a symbol file that was added via add-symbol-file. */
2379 remove_symbol_file_command (const char *args
, int from_tty
)
2381 struct objfile
*objf
= NULL
;
2382 struct program_space
*pspace
= current_program_space
;
2387 error (_("remove-symbol-file: no symbol file provided"));
2389 gdb_argv
argv (args
);
2391 if (strcmp (argv
[0], "-a") == 0)
2393 /* Interpret the next argument as an address. */
2396 if (argv
[1] == NULL
)
2397 error (_("Missing address argument"));
2399 if (argv
[2] != NULL
)
2400 error (_("Junk after %s"), argv
[1]);
2402 addr
= parse_and_eval_address (argv
[1]);
2404 for (objfile
*objfile
: current_program_space
->objfiles ())
2406 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2407 && (objfile
->flags
& OBJF_SHARED
) != 0
2408 && objfile
->pspace
== pspace
2409 && is_addr_in_objfile (addr
, objfile
))
2416 else if (argv
[0] != NULL
)
2418 /* Interpret the current argument as a file name. */
2420 if (argv
[1] != NULL
)
2421 error (_("Junk after %s"), argv
[0]);
2423 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2425 for (objfile
*objfile
: current_program_space
->objfiles ())
2427 if ((objfile
->flags
& OBJF_USERLOADED
) != 0
2428 && (objfile
->flags
& OBJF_SHARED
) != 0
2429 && objfile
->pspace
== pspace
2430 && filename_cmp (filename
.get (), objfile_name (objfile
)) == 0)
2439 error (_("No symbol file found"));
2442 && !query (_("Remove symbol table from file \"%s\"? "),
2443 objfile_name (objf
)))
2444 error (_("Not confirmed."));
2447 clear_symtab_users (0);
2450 /* Re-read symbols if a symbol-file has changed. */
2453 reread_symbols (void)
2456 struct stat new_statbuf
;
2458 std::vector
<struct objfile
*> new_objfiles
;
2460 for (objfile
*objfile
: current_program_space
->objfiles ())
2462 if (objfile
->obfd
== NULL
)
2465 /* Separate debug objfiles are handled in the main objfile. */
2466 if (objfile
->separate_debug_objfile_backlink
)
2469 /* If this object is from an archive (what you usually create with
2470 `ar', often called a `static library' on most systems, though
2471 a `shared library' on AIX is also an archive), then you should
2472 stat on the archive name, not member name. */
2473 if (objfile
->obfd
->my_archive
)
2474 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2476 res
= stat (objfile_name (objfile
), &new_statbuf
);
2479 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2480 printf_filtered (_("`%s' has disappeared; keeping its symbols.\n"),
2481 objfile_name (objfile
));
2484 new_modtime
= new_statbuf
.st_mtime
;
2485 if (new_modtime
!= objfile
->mtime
)
2487 struct section_offsets
*offsets
;
2490 printf_filtered (_("`%s' has changed; re-reading symbols.\n"),
2491 objfile_name (objfile
));
2493 /* There are various functions like symbol_file_add,
2494 symfile_bfd_open, syms_from_objfile, etc., which might
2495 appear to do what we want. But they have various other
2496 effects which we *don't* want. So we just do stuff
2497 ourselves. We don't worry about mapped files (for one thing,
2498 any mapped file will be out of date). */
2500 /* If we get an error, blow away this objfile (not sure if
2501 that is the correct response for things like shared
2503 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
2505 /* We need to do this whenever any symbols go away. */
2506 clear_symtab_users_cleanup
defer_clear_users (0);
2508 if (exec_bfd
!= NULL
2509 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2510 bfd_get_filename (exec_bfd
)) == 0)
2512 /* Reload EXEC_BFD without asking anything. */
2514 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2517 /* Keep the calls order approx. the same as in free_objfile. */
2519 /* Free the separate debug objfiles. It will be
2520 automatically recreated by sym_read. */
2521 free_objfile_separate_debug (objfile
);
2523 /* Remove any references to this objfile in the global
2525 preserve_values (objfile
);
2527 /* Nuke all the state that we will re-read. Much of the following
2528 code which sets things to NULL really is necessary to tell
2529 other parts of GDB that there is nothing currently there.
2531 Try to keep the freeing order compatible with free_objfile. */
2533 if (objfile
->sf
!= NULL
)
2535 (*objfile
->sf
->sym_finish
) (objfile
);
2538 clear_objfile_data (objfile
);
2540 /* Clean up any state BFD has sitting around. */
2542 gdb_bfd_ref_ptr
obfd (objfile
->obfd
);
2543 const char *obfd_filename
;
2545 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2546 /* Open the new BFD before freeing the old one, so that
2547 the filename remains live. */
2548 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
, -1));
2549 objfile
->obfd
= temp
.release ();
2550 if (objfile
->obfd
== NULL
)
2551 error (_("Can't open %s to read symbols."), obfd_filename
);
2554 std::string original_name
= objfile
->original_name
;
2556 /* bfd_openr sets cacheable to true, which is what we want. */
2557 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2558 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2559 bfd_errmsg (bfd_get_error ()));
2561 /* Save the offsets, we will nuke them with the rest of the
2563 num_offsets
= objfile
->num_sections
;
2564 offsets
= ((struct section_offsets
*)
2565 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2566 memcpy (offsets
, objfile
->section_offsets
,
2567 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2569 objfile
->reset_psymtabs ();
2571 /* NB: after this call to obstack_free, objfiles_changed
2572 will need to be called (see discussion below). */
2573 obstack_free (&objfile
->objfile_obstack
, 0);
2574 objfile
->sections
= NULL
;
2575 objfile
->compunit_symtabs
= NULL
;
2576 objfile
->template_symbols
= NULL
;
2577 objfile
->static_links
.reset (nullptr);
2579 /* obstack_init also initializes the obstack so it is
2580 empty. We could use obstack_specify_allocation but
2581 gdb_obstack.h specifies the alloc/dealloc functions. */
2582 obstack_init (&objfile
->objfile_obstack
);
2584 /* set_objfile_per_bfd potentially allocates the per-bfd
2585 data on the objfile's obstack (if sharing data across
2586 multiple users is not possible), so it's important to
2587 do it *after* the obstack has been initialized. */
2588 set_objfile_per_bfd (objfile
);
2590 objfile
->original_name
2591 = obstack_strdup (&objfile
->objfile_obstack
, original_name
);
2593 /* Reset the sym_fns pointer. The ELF reader can change it
2594 based on whether .gdb_index is present, and we need it to
2595 start over. PR symtab/15885 */
2596 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
2598 build_objfile_section_table (objfile
);
2600 /* We use the same section offsets as from last time. I'm not
2601 sure whether that is always correct for shared libraries. */
2602 objfile
->section_offsets
= (struct section_offsets
*)
2603 obstack_alloc (&objfile
->objfile_obstack
,
2604 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2605 memcpy (objfile
->section_offsets
, offsets
,
2606 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2607 objfile
->num_sections
= num_offsets
;
2609 /* What the hell is sym_new_init for, anyway? The concept of
2610 distinguishing between the main file and additional files
2611 in this way seems rather dubious. */
2612 if (objfile
== symfile_objfile
)
2614 (*objfile
->sf
->sym_new_init
) (objfile
);
2617 (*objfile
->sf
->sym_init
) (objfile
);
2618 clear_complaints ();
2620 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2622 /* We are about to read new symbols and potentially also
2623 DWARF information. Some targets may want to pass addresses
2624 read from DWARF DIE's through an adjustment function before
2625 saving them, like MIPS, which may call into
2626 "find_pc_section". When called, that function will make
2627 use of per-objfile program space data.
2629 Since we discarded our section information above, we have
2630 dangling pointers in the per-objfile program space data
2631 structure. Force GDB to update the section mapping
2632 information by letting it know the objfile has changed,
2633 making the dangling pointers point to correct data
2636 objfiles_changed ();
2638 read_symbols (objfile
, 0);
2640 if (!objfile_has_symbols (objfile
))
2643 printf_filtered (_("(no debugging symbols found)\n"));
2647 /* We're done reading the symbol file; finish off complaints. */
2648 clear_complaints ();
2650 /* Getting new symbols may change our opinion about what is
2653 reinit_frame_cache ();
2655 /* Discard cleanups as symbol reading was successful. */
2656 objfile_holder
.release ();
2657 defer_clear_users
.release ();
2659 /* If the mtime has changed between the time we set new_modtime
2660 and now, we *want* this to be out of date, so don't call stat
2662 objfile
->mtime
= new_modtime
;
2663 init_entry_point_info (objfile
);
2665 new_objfiles
.push_back (objfile
);
2669 if (!new_objfiles
.empty ())
2671 clear_symtab_users (0);
2673 /* clear_objfile_data for each objfile was called before freeing it and
2674 gdb::observers::new_objfile.notify (NULL) has been called by
2675 clear_symtab_users above. Notify the new files now. */
2676 for (auto iter
: new_objfiles
)
2677 gdb::observers::new_objfile
.notify (iter
);
2679 /* At least one objfile has changed, so we can consider that
2680 the executable we're debugging has changed too. */
2681 gdb::observers::executable_changed
.notify ();
2686 struct filename_language
2688 filename_language (const std::string
&ext_
, enum language lang_
)
2689 : ext (ext_
), lang (lang_
)
2696 static std::vector
<filename_language
> filename_language_table
;
2698 /* See symfile.h. */
2701 add_filename_language (const char *ext
, enum language lang
)
2703 filename_language_table
.emplace_back (ext
, lang
);
2706 static char *ext_args
;
2708 show_ext_args (struct ui_file
*file
, int from_tty
,
2709 struct cmd_list_element
*c
, const char *value
)
2711 fprintf_filtered (file
,
2712 _("Mapping between filename extension "
2713 "and source language is \"%s\".\n"),
2718 set_ext_lang_command (const char *args
,
2719 int from_tty
, struct cmd_list_element
*e
)
2721 char *cp
= ext_args
;
2724 /* First arg is filename extension, starting with '.' */
2726 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2728 /* Find end of first arg. */
2729 while (*cp
&& !isspace (*cp
))
2733 error (_("'%s': two arguments required -- "
2734 "filename extension and language"),
2737 /* Null-terminate first arg. */
2740 /* Find beginning of second arg, which should be a source language. */
2741 cp
= skip_spaces (cp
);
2744 error (_("'%s': two arguments required -- "
2745 "filename extension and language"),
2748 /* Lookup the language from among those we know. */
2749 lang
= language_enum (cp
);
2751 auto it
= filename_language_table
.begin ();
2752 /* Now lookup the filename extension: do we already know it? */
2753 for (; it
!= filename_language_table
.end (); it
++)
2755 if (it
->ext
== ext_args
)
2759 if (it
== filename_language_table
.end ())
2761 /* New file extension. */
2762 add_filename_language (ext_args
, lang
);
2766 /* Redefining a previously known filename extension. */
2769 /* query ("Really make files of type %s '%s'?", */
2770 /* ext_args, language_str (lang)); */
2777 info_ext_lang_command (const char *args
, int from_tty
)
2779 printf_filtered (_("Filename extensions and the languages they represent:"));
2780 printf_filtered ("\n\n");
2781 for (const filename_language
&entry
: filename_language_table
)
2782 printf_filtered ("\t%s\t- %s\n", entry
.ext
.c_str (),
2783 language_str (entry
.lang
));
2787 deduce_language_from_filename (const char *filename
)
2791 if (filename
!= NULL
)
2792 if ((cp
= strrchr (filename
, '.')) != NULL
)
2794 for (const filename_language
&entry
: filename_language_table
)
2795 if (entry
.ext
== cp
)
2799 return language_unknown
;
2802 /* Allocate and initialize a new symbol table.
2803 CUST is from the result of allocate_compunit_symtab. */
2806 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
)
2808 struct objfile
*objfile
= cust
->objfile
;
2809 struct symtab
*symtab
2810 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2813 = ((const char *) objfile
->per_bfd
->filename_cache
.insert
2814 (filename
, strlen (filename
) + 1));
2815 symtab
->fullname
= NULL
;
2816 symtab
->language
= deduce_language_from_filename (filename
);
2818 /* This can be very verbose with lots of headers.
2819 Only print at higher debug levels. */
2820 if (symtab_create_debug
>= 2)
2822 /* Be a bit clever with debugging messages, and don't print objfile
2823 every time, only when it changes. */
2824 static char *last_objfile_name
= NULL
;
2826 if (last_objfile_name
== NULL
2827 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
2829 xfree (last_objfile_name
);
2830 last_objfile_name
= xstrdup (objfile_name (objfile
));
2831 fprintf_filtered (gdb_stdlog
,
2832 "Creating one or more symtabs for objfile %s ...\n",
2835 fprintf_filtered (gdb_stdlog
,
2836 "Created symtab %s for module %s.\n",
2837 host_address_to_string (symtab
), filename
);
2840 /* Add it to CUST's list of symtabs. */
2841 if (cust
->filetabs
== NULL
)
2843 cust
->filetabs
= symtab
;
2844 cust
->last_filetab
= symtab
;
2848 cust
->last_filetab
->next
= symtab
;
2849 cust
->last_filetab
= symtab
;
2852 /* Backlink to the containing compunit symtab. */
2853 symtab
->compunit_symtab
= cust
;
2858 /* Allocate and initialize a new compunit.
2859 NAME is the name of the main source file, if there is one, or some
2860 descriptive text if there are no source files. */
2862 struct compunit_symtab
*
2863 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2865 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2866 struct compunit_symtab
);
2867 const char *saved_name
;
2869 cu
->objfile
= objfile
;
2871 /* The name we record here is only for display/debugging purposes.
2872 Just save the basename to avoid path issues (too long for display,
2873 relative vs absolute, etc.). */
2874 saved_name
= lbasename (name
);
2875 cu
->name
= obstack_strdup (&objfile
->objfile_obstack
, saved_name
);
2877 COMPUNIT_DEBUGFORMAT (cu
) = "unknown";
2879 if (symtab_create_debug
)
2881 fprintf_filtered (gdb_stdlog
,
2882 "Created compunit symtab %s for %s.\n",
2883 host_address_to_string (cu
),
2890 /* Hook CU to the objfile it comes from. */
2893 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2895 cu
->next
= cu
->objfile
->compunit_symtabs
;
2896 cu
->objfile
->compunit_symtabs
= cu
;
2900 /* Reset all data structures in gdb which may contain references to
2901 symbol table data. */
2904 clear_symtab_users (symfile_add_flags add_flags
)
2906 /* Someday, we should do better than this, by only blowing away
2907 the things that really need to be blown. */
2909 /* Clear the "current" symtab first, because it is no longer valid.
2910 breakpoint_re_set may try to access the current symtab. */
2911 clear_current_source_symtab_and_line ();
2914 clear_last_displayed_sal ();
2915 clear_pc_function_cache ();
2916 gdb::observers::new_objfile
.notify (NULL
);
2918 /* Varobj may refer to old symbols, perform a cleanup. */
2919 varobj_invalidate ();
2921 /* Now that the various caches have been cleared, we can re_set
2922 our breakpoints without risking it using stale data. */
2923 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2924 breakpoint_re_set ();
2928 The following code implements an abstraction for debugging overlay sections.
2930 The target model is as follows:
2931 1) The gnu linker will permit multiple sections to be mapped into the
2932 same VMA, each with its own unique LMA (or load address).
2933 2) It is assumed that some runtime mechanism exists for mapping the
2934 sections, one by one, from the load address into the VMA address.
2935 3) This code provides a mechanism for gdb to keep track of which
2936 sections should be considered to be mapped from the VMA to the LMA.
2937 This information is used for symbol lookup, and memory read/write.
2938 For instance, if a section has been mapped then its contents
2939 should be read from the VMA, otherwise from the LMA.
2941 Two levels of debugger support for overlays are available. One is
2942 "manual", in which the debugger relies on the user to tell it which
2943 overlays are currently mapped. This level of support is
2944 implemented entirely in the core debugger, and the information about
2945 whether a section is mapped is kept in the objfile->obj_section table.
2947 The second level of support is "automatic", and is only available if
2948 the target-specific code provides functionality to read the target's
2949 overlay mapping table, and translate its contents for the debugger
2950 (by updating the mapped state information in the obj_section tables).
2952 The interface is as follows:
2954 overlay map <name> -- tell gdb to consider this section mapped
2955 overlay unmap <name> -- tell gdb to consider this section unmapped
2956 overlay list -- list the sections that GDB thinks are mapped
2957 overlay read-target -- get the target's state of what's mapped
2958 overlay off/manual/auto -- set overlay debugging state
2959 Functional interface:
2960 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2961 section, return that section.
2962 find_pc_overlay(pc): find any overlay section that contains
2963 the pc, either in its VMA or its LMA
2964 section_is_mapped(sect): true if overlay is marked as mapped
2965 section_is_overlay(sect): true if section's VMA != LMA
2966 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2967 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2968 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2969 overlay_mapped_address(...): map an address from section's LMA to VMA
2970 overlay_unmapped_address(...): map an address from section's VMA to LMA
2971 symbol_overlayed_address(...): Return a "current" address for symbol:
2972 either in VMA or LMA depending on whether
2973 the symbol's section is currently mapped. */
2975 /* Overlay debugging state: */
2977 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2978 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2980 /* Function: section_is_overlay (SECTION)
2981 Returns true if SECTION has VMA not equal to LMA, ie.
2982 SECTION is loaded at an address different from where it will "run". */
2985 section_is_overlay (struct obj_section
*section
)
2987 if (overlay_debugging
&& section
)
2989 asection
*bfd_section
= section
->the_bfd_section
;
2991 if (bfd_section_lma (abfd
, bfd_section
) != 0
2992 && bfd_section_lma (abfd
, bfd_section
)
2993 != bfd_section_vma (abfd
, bfd_section
))
3000 /* Function: overlay_invalidate_all (void)
3001 Invalidate the mapped state of all overlay sections (mark it as stale). */
3004 overlay_invalidate_all (void)
3006 struct obj_section
*sect
;
3008 for (objfile
*objfile
: current_program_space
->objfiles ())
3009 ALL_OBJFILE_OSECTIONS (objfile
, sect
)
3010 if (section_is_overlay (sect
))
3011 sect
->ovly_mapped
= -1;
3014 /* Function: section_is_mapped (SECTION)
3015 Returns true if section is an overlay, and is currently mapped.
3017 Access to the ovly_mapped flag is restricted to this function, so
3018 that we can do automatic update. If the global flag
3019 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3020 overlay_invalidate_all. If the mapped state of the particular
3021 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3024 section_is_mapped (struct obj_section
*osect
)
3026 struct gdbarch
*gdbarch
;
3028 if (osect
== 0 || !section_is_overlay (osect
))
3031 switch (overlay_debugging
)
3035 return 0; /* overlay debugging off */
3036 case ovly_auto
: /* overlay debugging automatic */
3037 /* Unles there is a gdbarch_overlay_update function,
3038 there's really nothing useful to do here (can't really go auto). */
3039 gdbarch
= get_objfile_arch (osect
->objfile
);
3040 if (gdbarch_overlay_update_p (gdbarch
))
3042 if (overlay_cache_invalid
)
3044 overlay_invalidate_all ();
3045 overlay_cache_invalid
= 0;
3047 if (osect
->ovly_mapped
== -1)
3048 gdbarch_overlay_update (gdbarch
, osect
);
3051 case ovly_on
: /* overlay debugging manual */
3052 return osect
->ovly_mapped
== 1;
3056 /* Function: pc_in_unmapped_range
3057 If PC falls into the lma range of SECTION, return true, else false. */
3060 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3062 if (section_is_overlay (section
))
3064 bfd
*abfd
= section
->objfile
->obfd
;
3065 asection
*bfd_section
= section
->the_bfd_section
;
3067 /* We assume the LMA is relocated by the same offset as the VMA. */
3068 bfd_vma size
= bfd_get_section_size (bfd_section
);
3069 CORE_ADDR offset
= obj_section_offset (section
);
3071 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3072 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3079 /* Function: pc_in_mapped_range
3080 If PC falls into the vma range of SECTION, return true, else false. */
3083 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3085 if (section_is_overlay (section
))
3087 if (obj_section_addr (section
) <= pc
3088 && pc
< obj_section_endaddr (section
))
3095 /* Return true if the mapped ranges of sections A and B overlap, false
3099 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3101 CORE_ADDR a_start
= obj_section_addr (a
);
3102 CORE_ADDR a_end
= obj_section_endaddr (a
);
3103 CORE_ADDR b_start
= obj_section_addr (b
);
3104 CORE_ADDR b_end
= obj_section_endaddr (b
);
3106 return (a_start
< b_end
&& b_start
< a_end
);
3109 /* Function: overlay_unmapped_address (PC, SECTION)
3110 Returns the address corresponding to PC in the unmapped (load) range.
3111 May be the same as PC. */
3114 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3116 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3118 asection
*bfd_section
= section
->the_bfd_section
;
3120 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3121 - bfd_section_vma (abfd
, bfd_section
);
3127 /* Function: overlay_mapped_address (PC, SECTION)
3128 Returns the address corresponding to PC in the mapped (runtime) range.
3129 May be the same as PC. */
3132 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3134 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3136 asection
*bfd_section
= section
->the_bfd_section
;
3138 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3139 - bfd_section_lma (abfd
, bfd_section
);
3145 /* Function: symbol_overlayed_address
3146 Return one of two addresses (relative to the VMA or to the LMA),
3147 depending on whether the section is mapped or not. */
3150 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3152 if (overlay_debugging
)
3154 /* If the symbol has no section, just return its regular address. */
3157 /* If the symbol's section is not an overlay, just return its
3159 if (!section_is_overlay (section
))
3161 /* If the symbol's section is mapped, just return its address. */
3162 if (section_is_mapped (section
))
3165 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3166 * then return its LOADED address rather than its vma address!!
3168 return overlay_unmapped_address (address
, section
);
3173 /* Function: find_pc_overlay (PC)
3174 Return the best-match overlay section for PC:
3175 If PC matches a mapped overlay section's VMA, return that section.
3176 Else if PC matches an unmapped section's VMA, return that section.
3177 Else if PC matches an unmapped section's LMA, return that section. */
3179 struct obj_section
*
3180 find_pc_overlay (CORE_ADDR pc
)
3182 struct obj_section
*osect
, *best_match
= NULL
;
3184 if (overlay_debugging
)
3186 for (objfile
*objfile
: current_program_space
->objfiles ())
3187 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3188 if (section_is_overlay (osect
))
3190 if (pc_in_mapped_range (pc
, osect
))
3192 if (section_is_mapped (osect
))
3197 else if (pc_in_unmapped_range (pc
, osect
))
3204 /* Function: find_pc_mapped_section (PC)
3205 If PC falls into the VMA address range of an overlay section that is
3206 currently marked as MAPPED, return that section. Else return NULL. */
3208 struct obj_section
*
3209 find_pc_mapped_section (CORE_ADDR pc
)
3211 struct obj_section
*osect
;
3213 if (overlay_debugging
)
3215 for (objfile
*objfile
: current_program_space
->objfiles ())
3216 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3217 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3224 /* Function: list_overlays_command
3225 Print a list of mapped sections and their PC ranges. */
3228 list_overlays_command (const char *args
, int from_tty
)
3231 struct obj_section
*osect
;
3233 if (overlay_debugging
)
3235 for (objfile
*objfile
: current_program_space
->objfiles ())
3236 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3237 if (section_is_mapped (osect
))
3239 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3244 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3245 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3246 size
= bfd_get_section_size (osect
->the_bfd_section
);
3247 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3249 printf_filtered ("Section %s, loaded at ", name
);
3250 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3251 puts_filtered (" - ");
3252 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3253 printf_filtered (", mapped at ");
3254 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3255 puts_filtered (" - ");
3256 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3257 puts_filtered ("\n");
3263 printf_filtered (_("No sections are mapped.\n"));
3266 /* Function: map_overlay_command
3267 Mark the named section as mapped (ie. residing at its VMA address). */
3270 map_overlay_command (const char *args
, int from_tty
)
3272 struct obj_section
*sec
, *sec2
;
3274 if (!overlay_debugging
)
3275 error (_("Overlay debugging not enabled. Use "
3276 "either the 'overlay auto' or\n"
3277 "the 'overlay manual' command."));
3279 if (args
== 0 || *args
== 0)
3280 error (_("Argument required: name of an overlay section"));
3282 /* First, find a section matching the user supplied argument. */
3283 for (objfile
*obj_file
: current_program_space
->objfiles ())
3284 ALL_OBJFILE_OSECTIONS (obj_file
, sec
)
3285 if (!strcmp (bfd_section_name (obj_file
->obfd
, sec
->the_bfd_section
),
3288 /* Now, check to see if the section is an overlay. */
3289 if (!section_is_overlay (sec
))
3290 continue; /* not an overlay section */
3292 /* Mark the overlay as "mapped". */
3293 sec
->ovly_mapped
= 1;
3295 /* Next, make a pass and unmap any sections that are
3296 overlapped by this new section: */
3297 for (objfile
*objfile2
: current_program_space
->objfiles ())
3298 ALL_OBJFILE_OSECTIONS (objfile2
, sec2
)
3299 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
,
3303 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3304 bfd_section_name (obj_file
->obfd
,
3305 sec2
->the_bfd_section
));
3306 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3310 error (_("No overlay section called %s"), args
);
3313 /* Function: unmap_overlay_command
3314 Mark the overlay section as unmapped
3315 (ie. resident in its LMA address range, rather than the VMA range). */
3318 unmap_overlay_command (const char *args
, int from_tty
)
3320 struct obj_section
*sec
= NULL
;
3322 if (!overlay_debugging
)
3323 error (_("Overlay debugging not enabled. "
3324 "Use either the 'overlay auto' or\n"
3325 "the 'overlay manual' command."));
3327 if (args
== 0 || *args
== 0)
3328 error (_("Argument required: name of an overlay section"));
3330 /* First, find a section matching the user supplied argument. */
3331 for (objfile
*objfile
: current_program_space
->objfiles ())
3332 ALL_OBJFILE_OSECTIONS (objfile
, sec
)
3333 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3335 if (!sec
->ovly_mapped
)
3336 error (_("Section %s is not mapped"), args
);
3337 sec
->ovly_mapped
= 0;
3340 error (_("No overlay section called %s"), args
);
3343 /* Function: overlay_auto_command
3344 A utility command to turn on overlay debugging.
3345 Possibly this should be done via a set/show command. */
3348 overlay_auto_command (const char *args
, int from_tty
)
3350 overlay_debugging
= ovly_auto
;
3351 enable_overlay_breakpoints ();
3353 printf_unfiltered (_("Automatic overlay debugging enabled."));
3356 /* Function: overlay_manual_command
3357 A utility command to turn on overlay debugging.
3358 Possibly this should be done via a set/show command. */
3361 overlay_manual_command (const char *args
, int from_tty
)
3363 overlay_debugging
= ovly_on
;
3364 disable_overlay_breakpoints ();
3366 printf_unfiltered (_("Overlay debugging enabled."));
3369 /* Function: overlay_off_command
3370 A utility command to turn on overlay debugging.
3371 Possibly this should be done via a set/show command. */
3374 overlay_off_command (const char *args
, int from_tty
)
3376 overlay_debugging
= ovly_off
;
3377 disable_overlay_breakpoints ();
3379 printf_unfiltered (_("Overlay debugging disabled."));
3383 overlay_load_command (const char *args
, int from_tty
)
3385 struct gdbarch
*gdbarch
= get_current_arch ();
3387 if (gdbarch_overlay_update_p (gdbarch
))
3388 gdbarch_overlay_update (gdbarch
, NULL
);
3390 error (_("This target does not know how to read its overlay state."));
3393 /* Function: overlay_command
3394 A place-holder for a mis-typed command. */
3396 /* Command list chain containing all defined "overlay" subcommands. */
3397 static struct cmd_list_element
*overlaylist
;
3400 overlay_command (const char *args
, int from_tty
)
3403 ("\"overlay\" must be followed by the name of an overlay command.\n");
3404 help_list (overlaylist
, "overlay ", all_commands
, gdb_stdout
);
3407 /* Target Overlays for the "Simplest" overlay manager:
3409 This is GDB's default target overlay layer. It works with the
3410 minimal overlay manager supplied as an example by Cygnus. The
3411 entry point is via a function pointer "gdbarch_overlay_update",
3412 so targets that use a different runtime overlay manager can
3413 substitute their own overlay_update function and take over the
3416 The overlay_update function pokes around in the target's data structures
3417 to see what overlays are mapped, and updates GDB's overlay mapping with
3420 In this simple implementation, the target data structures are as follows:
3421 unsigned _novlys; /# number of overlay sections #/
3422 unsigned _ovly_table[_novlys][4] = {
3423 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3424 {..., ..., ..., ...},
3426 unsigned _novly_regions; /# number of overlay regions #/
3427 unsigned _ovly_region_table[_novly_regions][3] = {
3428 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3431 These functions will attempt to update GDB's mappedness state in the
3432 symbol section table, based on the target's mappedness state.
3434 To do this, we keep a cached copy of the target's _ovly_table, and
3435 attempt to detect when the cached copy is invalidated. The main
3436 entry point is "simple_overlay_update(SECT), which looks up SECT in
3437 the cached table and re-reads only the entry for that section from
3438 the target (whenever possible). */
3440 /* Cached, dynamically allocated copies of the target data structures: */
3441 static unsigned (*cache_ovly_table
)[4] = 0;
3442 static unsigned cache_novlys
= 0;
3443 static CORE_ADDR cache_ovly_table_base
= 0;
3446 VMA
, OSIZE
, LMA
, MAPPED
3449 /* Throw away the cached copy of _ovly_table. */
3452 simple_free_overlay_table (void)
3454 if (cache_ovly_table
)
3455 xfree (cache_ovly_table
);
3457 cache_ovly_table
= NULL
;
3458 cache_ovly_table_base
= 0;
3461 /* Read an array of ints of size SIZE from the target into a local buffer.
3462 Convert to host order. int LEN is number of ints. */
3465 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3466 int len
, int size
, enum bfd_endian byte_order
)
3468 /* FIXME (alloca): Not safe if array is very large. */
3469 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3472 read_memory (memaddr
, buf
, len
* size
);
3473 for (i
= 0; i
< len
; i
++)
3474 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3477 /* Find and grab a copy of the target _ovly_table
3478 (and _novlys, which is needed for the table's size). */
3481 simple_read_overlay_table (void)
3483 struct bound_minimal_symbol novlys_msym
;
3484 struct bound_minimal_symbol ovly_table_msym
;
3485 struct gdbarch
*gdbarch
;
3487 enum bfd_endian byte_order
;
3489 simple_free_overlay_table ();
3490 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3491 if (! novlys_msym
.minsym
)
3493 error (_("Error reading inferior's overlay table: "
3494 "couldn't find `_novlys' variable\n"
3495 "in inferior. Use `overlay manual' mode."));
3499 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3500 if (! ovly_table_msym
.minsym
)
3502 error (_("Error reading inferior's overlay table: couldn't find "
3503 "`_ovly_table' array\n"
3504 "in inferior. Use `overlay manual' mode."));
3508 gdbarch
= get_objfile_arch (ovly_table_msym
.objfile
);
3509 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3510 byte_order
= gdbarch_byte_order (gdbarch
);
3512 cache_novlys
= read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym
),
3515 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3516 cache_ovly_table_base
= BMSYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3517 read_target_long_array (cache_ovly_table_base
,
3518 (unsigned int *) cache_ovly_table
,
3519 cache_novlys
* 4, word_size
, byte_order
);
3521 return 1; /* SUCCESS */
3524 /* Function: simple_overlay_update_1
3525 A helper function for simple_overlay_update. Assuming a cached copy
3526 of _ovly_table exists, look through it to find an entry whose vma,
3527 lma and size match those of OSECT. Re-read the entry and make sure
3528 it still matches OSECT (else the table may no longer be valid).
3529 Set OSECT's mapped state to match the entry. Return: 1 for
3530 success, 0 for failure. */
3533 simple_overlay_update_1 (struct obj_section
*osect
)
3536 asection
*bsect
= osect
->the_bfd_section
;
3537 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3538 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3539 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3541 for (i
= 0; i
< cache_novlys
; i
++)
3542 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3543 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3545 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3546 (unsigned int *) cache_ovly_table
[i
],
3547 4, word_size
, byte_order
);
3548 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3549 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3551 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3554 else /* Warning! Warning! Target's ovly table has changed! */
3560 /* Function: simple_overlay_update
3561 If OSECT is NULL, then update all sections' mapped state
3562 (after re-reading the entire target _ovly_table).
3563 If OSECT is non-NULL, then try to find a matching entry in the
3564 cached ovly_table and update only OSECT's mapped state.
3565 If a cached entry can't be found or the cache isn't valid, then
3566 re-read the entire cache, and go ahead and update all sections. */
3569 simple_overlay_update (struct obj_section
*osect
)
3571 /* Were we given an osect to look up? NULL means do all of them. */
3573 /* Have we got a cached copy of the target's overlay table? */
3574 if (cache_ovly_table
!= NULL
)
3576 /* Does its cached location match what's currently in the
3578 struct bound_minimal_symbol minsym
3579 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3581 if (minsym
.minsym
== NULL
)
3582 error (_("Error reading inferior's overlay table: couldn't "
3583 "find `_ovly_table' array\n"
3584 "in inferior. Use `overlay manual' mode."));
3586 if (cache_ovly_table_base
== BMSYMBOL_VALUE_ADDRESS (minsym
))
3587 /* Then go ahead and try to look up this single section in
3589 if (simple_overlay_update_1 (osect
))
3590 /* Found it! We're done. */
3594 /* Cached table no good: need to read the entire table anew.
3595 Or else we want all the sections, in which case it's actually
3596 more efficient to read the whole table in one block anyway. */
3598 if (! simple_read_overlay_table ())
3601 /* Now may as well update all sections, even if only one was requested. */
3602 for (objfile
*objfile
: current_program_space
->objfiles ())
3603 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
3604 if (section_is_overlay (osect
))
3607 asection
*bsect
= osect
->the_bfd_section
;
3609 for (i
= 0; i
< cache_novlys
; i
++)
3610 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3611 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3612 { /* obj_section matches i'th entry in ovly_table. */
3613 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3614 break; /* finished with inner for loop: break out. */
3619 /* Set the output sections and output offsets for section SECTP in
3620 ABFD. The relocation code in BFD will read these offsets, so we
3621 need to be sure they're initialized. We map each section to itself,
3622 with no offset; this means that SECTP->vma will be honored. */
3625 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3627 sectp
->output_section
= sectp
;
3628 sectp
->output_offset
= 0;
3631 /* Default implementation for sym_relocate. */
3634 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3637 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3639 bfd
*abfd
= sectp
->owner
;
3641 /* We're only interested in sections with relocation
3643 if ((sectp
->flags
& SEC_RELOC
) == 0)
3646 /* We will handle section offsets properly elsewhere, so relocate as if
3647 all sections begin at 0. */
3648 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3650 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3653 /* Relocate the contents of a debug section SECTP in ABFD. The
3654 contents are stored in BUF if it is non-NULL, or returned in a
3655 malloc'd buffer otherwise.
3657 For some platforms and debug info formats, shared libraries contain
3658 relocations against the debug sections (particularly for DWARF-2;
3659 one affected platform is PowerPC GNU/Linux, although it depends on
3660 the version of the linker in use). Also, ELF object files naturally
3661 have unresolved relocations for their debug sections. We need to apply
3662 the relocations in order to get the locations of symbols correct.
3663 Another example that may require relocation processing, is the
3664 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3668 symfile_relocate_debug_section (struct objfile
*objfile
,
3669 asection
*sectp
, bfd_byte
*buf
)
3671 gdb_assert (objfile
->sf
->sym_relocate
);
3673 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3676 struct symfile_segment_data
*
3677 get_symfile_segment_data (bfd
*abfd
)
3679 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3684 return sf
->sym_segments (abfd
);
3688 free_symfile_segment_data (struct symfile_segment_data
*data
)
3690 xfree (data
->segment_bases
);
3691 xfree (data
->segment_sizes
);
3692 xfree (data
->segment_info
);
3697 - DATA, containing segment addresses from the object file ABFD, and
3698 the mapping from ABFD's sections onto the segments that own them,
3700 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3701 segment addresses reported by the target,
3702 store the appropriate offsets for each section in OFFSETS.
3704 If there are fewer entries in SEGMENT_BASES than there are segments
3705 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3707 If there are more entries, then ignore the extra. The target may
3708 not be able to distinguish between an empty data segment and a
3709 missing data segment; a missing text segment is less plausible. */
3712 symfile_map_offsets_to_segments (bfd
*abfd
,
3713 const struct symfile_segment_data
*data
,
3714 struct section_offsets
*offsets
,
3715 int num_segment_bases
,
3716 const CORE_ADDR
*segment_bases
)
3721 /* It doesn't make sense to call this function unless you have some
3722 segment base addresses. */
3723 gdb_assert (num_segment_bases
> 0);
3725 /* If we do not have segment mappings for the object file, we
3726 can not relocate it by segments. */
3727 gdb_assert (data
!= NULL
);
3728 gdb_assert (data
->num_segments
> 0);
3730 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3732 int which
= data
->segment_info
[i
];
3734 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3736 /* Don't bother computing offsets for sections that aren't
3737 loaded as part of any segment. */
3741 /* Use the last SEGMENT_BASES entry as the address of any extra
3742 segments mentioned in DATA->segment_info. */
3743 if (which
> num_segment_bases
)
3744 which
= num_segment_bases
;
3746 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3747 - data
->segment_bases
[which
- 1]);
3754 symfile_find_segment_sections (struct objfile
*objfile
)
3756 bfd
*abfd
= objfile
->obfd
;
3759 struct symfile_segment_data
*data
;
3761 data
= get_symfile_segment_data (objfile
->obfd
);
3765 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3767 free_symfile_segment_data (data
);
3771 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3773 int which
= data
->segment_info
[i
];
3777 if (objfile
->sect_index_text
== -1)
3778 objfile
->sect_index_text
= sect
->index
;
3780 if (objfile
->sect_index_rodata
== -1)
3781 objfile
->sect_index_rodata
= sect
->index
;
3783 else if (which
== 2)
3785 if (objfile
->sect_index_data
== -1)
3786 objfile
->sect_index_data
= sect
->index
;
3788 if (objfile
->sect_index_bss
== -1)
3789 objfile
->sect_index_bss
= sect
->index
;
3793 free_symfile_segment_data (data
);
3796 /* Listen for free_objfile events. */
3799 symfile_free_objfile (struct objfile
*objfile
)
3801 /* Remove the target sections owned by this objfile. */
3802 if (objfile
!= NULL
)
3803 remove_target_sections ((void *) objfile
);
3806 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3807 Expand all symtabs that match the specified criteria.
3808 See quick_symbol_functions.expand_symtabs_matching for details. */
3811 expand_symtabs_matching
3812 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3813 const lookup_name_info
&lookup_name
,
3814 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3815 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3816 enum search_domain kind
)
3818 for (objfile
*objfile
: current_program_space
->objfiles ())
3821 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, file_matcher
,
3824 expansion_notify
, kind
);
3828 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3829 Map function FUN over every file.
3830 See quick_symbol_functions.map_symbol_filenames for details. */
3833 map_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
3836 for (objfile
*objfile
: current_program_space
->objfiles ())
3839 objfile
->sf
->qf
->map_symbol_filenames (objfile
, fun
, data
,
3846 namespace selftests
{
3847 namespace filename_language
{
3849 static void test_filename_language ()
3851 /* This test messes up the filename_language_table global. */
3852 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3854 /* Test deducing an unknown extension. */
3855 language lang
= deduce_language_from_filename ("myfile.blah");
3856 SELF_CHECK (lang
== language_unknown
);
3858 /* Test deducing a known extension. */
3859 lang
= deduce_language_from_filename ("myfile.c");
3860 SELF_CHECK (lang
== language_c
);
3862 /* Test adding a new extension using the internal API. */
3863 add_filename_language (".blah", language_pascal
);
3864 lang
= deduce_language_from_filename ("myfile.blah");
3865 SELF_CHECK (lang
== language_pascal
);
3869 test_set_ext_lang_command ()
3871 /* This test messes up the filename_language_table global. */
3872 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3874 /* Confirm that the .hello extension is not known. */
3875 language lang
= deduce_language_from_filename ("cake.hello");
3876 SELF_CHECK (lang
== language_unknown
);
3878 /* Test adding a new extension using the CLI command. */
3879 auto args_holder
= make_unique_xstrdup (".hello rust");
3880 ext_args
= args_holder
.get ();
3881 set_ext_lang_command (NULL
, 1, NULL
);
3883 lang
= deduce_language_from_filename ("cake.hello");
3884 SELF_CHECK (lang
== language_rust
);
3886 /* Test overriding an existing extension using the CLI command. */
3887 int size_before
= filename_language_table
.size ();
3888 args_holder
.reset (xstrdup (".hello pascal"));
3889 ext_args
= args_holder
.get ();
3890 set_ext_lang_command (NULL
, 1, NULL
);
3891 int size_after
= filename_language_table
.size ();
3893 lang
= deduce_language_from_filename ("cake.hello");
3894 SELF_CHECK (lang
== language_pascal
);
3895 SELF_CHECK (size_before
== size_after
);
3898 } /* namespace filename_language */
3899 } /* namespace selftests */
3901 #endif /* GDB_SELF_TEST */
3904 _initialize_symfile (void)
3906 struct cmd_list_element
*c
;
3908 gdb::observers::free_objfile
.attach (symfile_free_objfile
);
3910 #define READNOW_READNEVER_HELP \
3911 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3912 immediately. This makes the command slower, but may make future operations\n\
3914 The '-readnever' option will prevent GDB from reading the symbol file's\n\
3915 symbolic debug information."
3917 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3918 Load symbol table from executable file FILE.\n\
3919 Usage: symbol-file [-readnow | -readnever] [-o OFF] FILE\n\
3920 OFF is an optional offset which is added to each section address.\n\
3921 The `file' command can also load symbol tables, as well as setting the file\n\
3922 to execute.\n" READNOW_READNEVER_HELP
), &cmdlist
);
3923 set_cmd_completer (c
, filename_completer
);
3925 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3926 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3927 Usage: add-symbol-file FILE [-readnow | -readnever] [-o OFF] [ADDR] \
3928 [-s SECT-NAME SECT-ADDR]...\n\
3929 ADDR is the starting address of the file's text.\n\
3930 Each '-s' argument provides a section name and address, and\n\
3931 should be specified if the data and bss segments are not contiguous\n\
3932 with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n\
3933 OFF is an optional offset which is added to the default load addresses\n\
3934 of all sections for which no other address was specified.\n"
3935 READNOW_READNEVER_HELP
),
3937 set_cmd_completer (c
, filename_completer
);
3939 c
= add_cmd ("remove-symbol-file", class_files
,
3940 remove_symbol_file_command
, _("\
3941 Remove a symbol file added via the add-symbol-file command.\n\
3942 Usage: remove-symbol-file FILENAME\n\
3943 remove-symbol-file -a ADDRESS\n\
3944 The file to remove can be identified by its filename or by an address\n\
3945 that lies within the boundaries of this symbol file in memory."),
3948 c
= add_cmd ("load", class_files
, load_command
, _("\
3949 Dynamically load FILE into the running program.\n\
3950 FILE symbols are recorded for access from GDB.\n\
3951 Usage: load [FILE] [OFFSET]\n\
3952 An optional load OFFSET may also be given as a literal address.\n\
3953 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3954 on its own."), &cmdlist
);
3955 set_cmd_completer (c
, filename_completer
);
3957 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3958 _("Commands for debugging overlays."), &overlaylist
,
3959 "overlay ", 0, &cmdlist
);
3961 add_com_alias ("ovly", "overlay", class_alias
, 1);
3962 add_com_alias ("ov", "overlay", class_alias
, 1);
3964 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3965 _("Assert that an overlay section is mapped."), &overlaylist
);
3967 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3968 _("Assert that an overlay section is unmapped."), &overlaylist
);
3970 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3971 _("List mappings of overlay sections."), &overlaylist
);
3973 add_cmd ("manual", class_support
, overlay_manual_command
,
3974 _("Enable overlay debugging."), &overlaylist
);
3975 add_cmd ("off", class_support
, overlay_off_command
,
3976 _("Disable overlay debugging."), &overlaylist
);
3977 add_cmd ("auto", class_support
, overlay_auto_command
,
3978 _("Enable automatic overlay debugging."), &overlaylist
);
3979 add_cmd ("load-target", class_support
, overlay_load_command
,
3980 _("Read the overlay mapping state from the target."), &overlaylist
);
3982 /* Filename extension to source language lookup table: */
3983 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3985 Set mapping between filename extension and source language."), _("\
3986 Show mapping between filename extension and source language."), _("\
3987 Usage: set extension-language .foo bar"),
3988 set_ext_lang_command
,
3990 &setlist
, &showlist
);
3992 add_info ("extensions", info_ext_lang_command
,
3993 _("All filename extensions associated with a source language."));
3995 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3996 &debug_file_directory
, _("\
3997 Set the directories where separate debug symbols are searched for."), _("\
3998 Show the directories where separate debug symbols are searched for."), _("\
3999 Separate debug symbols are first searched for in the same\n\
4000 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
4001 and lastly at the path of the directory of the binary with\n\
4002 each global debug-file-directory component prepended."),
4004 show_debug_file_directory
,
4005 &setlist
, &showlist
);
4007 add_setshow_enum_cmd ("symbol-loading", no_class
,
4008 print_symbol_loading_enums
, &print_symbol_loading
,
4010 Set printing of symbol loading messages."), _("\
4011 Show printing of symbol loading messages."), _("\
4012 off == turn all messages off\n\
4013 brief == print messages for the executable,\n\
4014 and brief messages for shared libraries\n\
4015 full == print messages for the executable,\n\
4016 and messages for each shared library."),
4019 &setprintlist
, &showprintlist
);
4021 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
4022 &separate_debug_file_debug
, _("\
4023 Set printing of separate debug info file search debug."), _("\
4024 Show printing of separate debug info file search debug."), _("\
4025 When on, GDB prints the searched locations while looking for separate debug \
4026 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
4029 selftests::register_test
4030 ("filename_language", selftests::filename_language::test_filename_language
);
4031 selftests::register_test
4032 ("set_ext_lang_command",
4033 selftests::filename_language::test_set_ext_lang_command
);