1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990-2018 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 "common/byte-vector.h"
62 #include <sys/types.h>
71 int (*deprecated_ui_load_progress_hook
) (const char *section
,
73 void (*deprecated_show_load_progress
) (const char *section
,
74 unsigned long section_sent
,
75 unsigned long section_size
,
76 unsigned long total_sent
,
77 unsigned long total_size
);
78 void (*deprecated_pre_add_symbol_hook
) (const char *);
79 void (*deprecated_post_add_symbol_hook
) (void);
81 static void clear_symtab_users_cleanup (void *ignore
);
83 /* Global variables owned by this file. */
84 int readnow_symbol_files
; /* Read full symbols immediately. */
85 int readnever_symbol_files
; /* Never read full symbols. */
87 /* Functions this file defines. */
89 static void symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
92 static const struct sym_fns
*find_sym_fns (bfd
*);
94 static void overlay_invalidate_all (void);
96 static void simple_free_overlay_table (void);
98 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
101 static int simple_read_overlay_table (void);
103 static int simple_overlay_update_1 (struct obj_section
*);
105 static void symfile_find_segment_sections (struct objfile
*objfile
);
107 /* List of all available sym_fns. On gdb startup, each object file reader
108 calls add_symtab_fns() to register information on each format it is
111 struct registered_sym_fns
113 registered_sym_fns (bfd_flavour sym_flavour_
, const struct sym_fns
*sym_fns_
)
114 : sym_flavour (sym_flavour_
), sym_fns (sym_fns_
)
117 /* BFD flavour that we handle. */
118 enum bfd_flavour sym_flavour
;
120 /* The "vtable" of symbol functions. */
121 const struct sym_fns
*sym_fns
;
124 static std::vector
<registered_sym_fns
> symtab_fns
;
126 /* Values for "set print symbol-loading". */
128 const char print_symbol_loading_off
[] = "off";
129 const char print_symbol_loading_brief
[] = "brief";
130 const char print_symbol_loading_full
[] = "full";
131 static const char *print_symbol_loading_enums
[] =
133 print_symbol_loading_off
,
134 print_symbol_loading_brief
,
135 print_symbol_loading_full
,
138 static const char *print_symbol_loading
= print_symbol_loading_full
;
140 /* If non-zero, shared library symbols will be added automatically
141 when the inferior is created, new libraries are loaded, or when
142 attaching to the inferior. This is almost always what users will
143 want to have happen; but for very large programs, the startup time
144 will be excessive, and so if this is a problem, the user can clear
145 this flag and then add the shared library symbols as needed. Note
146 that there is a potential for confusion, since if the shared
147 library symbols are not loaded, commands like "info fun" will *not*
148 report all the functions that are actually present. */
150 int auto_solib_add
= 1;
153 /* Return non-zero if symbol-loading messages should be printed.
154 FROM_TTY is the standard from_tty argument to gdb commands.
155 If EXEC is non-zero the messages are for the executable.
156 Otherwise, messages are for shared libraries.
157 If FULL is non-zero then the caller is printing a detailed message.
158 E.g., the message includes the shared library name.
159 Otherwise, the caller is printing a brief "summary" message. */
162 print_symbol_loading_p (int from_tty
, int exec
, int full
)
164 if (!from_tty
&& !info_verbose
)
169 /* We don't check FULL for executables, there are few such
170 messages, therefore brief == full. */
171 return print_symbol_loading
!= print_symbol_loading_off
;
174 return print_symbol_loading
== print_symbol_loading_full
;
175 return print_symbol_loading
== print_symbol_loading_brief
;
178 /* True if we are reading a symbol table. */
180 int currently_reading_symtab
= 0;
182 /* Increment currently_reading_symtab and return a cleanup that can be
183 used to decrement it. */
185 scoped_restore_tmpl
<int>
186 increment_reading_symtab (void)
188 gdb_assert (currently_reading_symtab
>= 0);
189 return make_scoped_restore (¤tly_reading_symtab
,
190 currently_reading_symtab
+ 1);
193 /* Remember the lowest-addressed loadable section we've seen.
194 This function is called via bfd_map_over_sections.
196 In case of equal vmas, the section with the largest size becomes the
197 lowest-addressed loadable section.
199 If the vmas and sizes are equal, the last section is considered the
200 lowest-addressed loadable section. */
203 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
205 asection
**lowest
= (asection
**) obj
;
207 if (0 == (bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
)))
210 *lowest
= sect
; /* First loadable section */
211 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
212 *lowest
= sect
; /* A lower loadable section */
213 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
214 && (bfd_section_size (abfd
, (*lowest
))
215 <= bfd_section_size (abfd
, sect
)))
219 /* Build (allocate and populate) a section_addr_info struct from
220 an existing section table. */
223 build_section_addr_info_from_section_table (const struct target_section
*start
,
224 const struct target_section
*end
)
226 const struct target_section
*stp
;
228 section_addr_info sap
;
230 for (stp
= start
; stp
!= end
; stp
++)
232 struct bfd_section
*asect
= stp
->the_bfd_section
;
233 bfd
*abfd
= asect
->owner
;
235 if (bfd_get_section_flags (abfd
, asect
) & (SEC_ALLOC
| SEC_LOAD
)
236 && sap
.size () < end
- start
)
237 sap
.emplace_back (stp
->addr
,
238 bfd_section_name (abfd
, asect
),
239 gdb_bfd_section_index (abfd
, asect
));
245 /* Create a section_addr_info from section offsets in ABFD. */
247 static section_addr_info
248 build_section_addr_info_from_bfd (bfd
*abfd
)
250 struct bfd_section
*sec
;
252 section_addr_info sap
;
253 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
254 if (bfd_get_section_flags (abfd
, sec
) & (SEC_ALLOC
| SEC_LOAD
))
255 sap
.emplace_back (bfd_get_section_vma (abfd
, sec
),
256 bfd_get_section_name (abfd
, sec
),
257 gdb_bfd_section_index (abfd
, sec
));
262 /* Create a section_addr_info from section offsets in OBJFILE. */
265 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
269 /* Before reread_symbols gets rewritten it is not safe to call:
270 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
272 section_addr_info sap
= build_section_addr_info_from_bfd (objfile
->obfd
);
273 for (i
= 0; i
< sap
.size (); i
++)
275 int sectindex
= sap
[i
].sectindex
;
277 sap
[i
].addr
+= objfile
->section_offsets
->offsets
[sectindex
];
282 /* Initialize OBJFILE's sect_index_* members. */
285 init_objfile_sect_indices (struct objfile
*objfile
)
290 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
292 objfile
->sect_index_text
= sect
->index
;
294 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
296 objfile
->sect_index_data
= sect
->index
;
298 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
300 objfile
->sect_index_bss
= sect
->index
;
302 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
304 objfile
->sect_index_rodata
= sect
->index
;
306 /* This is where things get really weird... We MUST have valid
307 indices for the various sect_index_* members or gdb will abort.
308 So if for example, there is no ".text" section, we have to
309 accomodate that. First, check for a file with the standard
310 one or two segments. */
312 symfile_find_segment_sections (objfile
);
314 /* Except when explicitly adding symbol files at some address,
315 section_offsets contains nothing but zeros, so it doesn't matter
316 which slot in section_offsets the individual sect_index_* members
317 index into. So if they are all zero, it is safe to just point
318 all the currently uninitialized indices to the first slot. But
319 beware: if this is the main executable, it may be relocated
320 later, e.g. by the remote qOffsets packet, and then this will
321 be wrong! That's why we try segments first. */
323 for (i
= 0; i
< objfile
->num_sections
; i
++)
325 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
330 if (i
== objfile
->num_sections
)
332 if (objfile
->sect_index_text
== -1)
333 objfile
->sect_index_text
= 0;
334 if (objfile
->sect_index_data
== -1)
335 objfile
->sect_index_data
= 0;
336 if (objfile
->sect_index_bss
== -1)
337 objfile
->sect_index_bss
= 0;
338 if (objfile
->sect_index_rodata
== -1)
339 objfile
->sect_index_rodata
= 0;
343 /* The arguments to place_section. */
345 struct place_section_arg
347 struct section_offsets
*offsets
;
351 /* Find a unique offset to use for loadable section SECT if
352 the user did not provide an offset. */
355 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
357 struct place_section_arg
*arg
= (struct place_section_arg
*) obj
;
358 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
360 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
362 /* We are only interested in allocated sections. */
363 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
366 /* If the user specified an offset, honor it. */
367 if (offsets
[gdb_bfd_section_index (abfd
, sect
)] != 0)
370 /* Otherwise, let's try to find a place for the section. */
371 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
378 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
380 int indx
= cur_sec
->index
;
382 /* We don't need to compare against ourself. */
386 /* We can only conflict with allocated sections. */
387 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
390 /* If the section offset is 0, either the section has not been placed
391 yet, or it was the lowest section placed (in which case LOWEST
392 will be past its end). */
393 if (offsets
[indx
] == 0)
396 /* If this section would overlap us, then we must move up. */
397 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
398 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
400 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
401 start_addr
= (start_addr
+ align
- 1) & -align
;
406 /* Otherwise, we appear to be OK. So far. */
411 offsets
[gdb_bfd_section_index (abfd
, sect
)] = start_addr
;
412 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
415 /* Store section_addr_info as prepared (made relative and with SECTINDEX
416 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
420 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
422 const section_addr_info
&addrs
)
426 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
428 /* Now calculate offsets for section that were specified by the caller. */
429 for (i
= 0; i
< addrs
.size (); i
++)
431 const struct other_sections
*osp
;
434 if (osp
->sectindex
== -1)
437 /* Record all sections in offsets. */
438 /* The section_offsets in the objfile are here filled in using
440 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
444 /* Transform section name S for a name comparison. prelink can split section
445 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
446 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
447 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
448 (`.sbss') section has invalid (increased) virtual address. */
451 addr_section_name (const char *s
)
453 if (strcmp (s
, ".dynbss") == 0)
455 if (strcmp (s
, ".sdynbss") == 0)
461 /* std::sort comparator for addrs_section_sort. Sort entries in
462 ascending order by their (name, sectindex) pair. sectindex makes
463 the sort by name stable. */
466 addrs_section_compar (const struct other_sections
*a
,
467 const struct other_sections
*b
)
471 retval
= strcmp (addr_section_name (a
->name
.c_str ()),
472 addr_section_name (b
->name
.c_str ()));
476 return a
->sectindex
< b
->sectindex
;
479 /* Provide sorted array of pointers to sections of ADDRS. */
481 static std::vector
<const struct other_sections
*>
482 addrs_section_sort (const section_addr_info
&addrs
)
486 std::vector
<const struct other_sections
*> array (addrs
.size ());
487 for (i
= 0; i
< addrs
.size (); i
++)
488 array
[i
] = &addrs
[i
];
490 std::sort (array
.begin (), array
.end (), addrs_section_compar
);
495 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
496 also SECTINDEXes specific to ABFD there. This function can be used to
497 rebase ADDRS to start referencing different BFD than before. */
500 addr_info_make_relative (section_addr_info
*addrs
, bfd
*abfd
)
502 asection
*lower_sect
;
503 CORE_ADDR lower_offset
;
506 /* Find lowest loadable section to be used as starting point for
507 continguous sections. */
509 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
510 if (lower_sect
== NULL
)
512 warning (_("no loadable sections found in added symbol-file %s"),
513 bfd_get_filename (abfd
));
517 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
519 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
520 in ABFD. Section names are not unique - there can be multiple sections of
521 the same name. Also the sections of the same name do not have to be
522 adjacent to each other. Some sections may be present only in one of the
523 files. Even sections present in both files do not have to be in the same
526 Use stable sort by name for the sections in both files. Then linearly
527 scan both lists matching as most of the entries as possible. */
529 std::vector
<const struct other_sections
*> addrs_sorted
530 = addrs_section_sort (*addrs
);
532 section_addr_info abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
533 std::vector
<const struct other_sections
*> abfd_addrs_sorted
534 = addrs_section_sort (abfd_addrs
);
536 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
537 ABFD_ADDRS_SORTED. */
539 std::vector
<const struct other_sections
*>
540 addrs_to_abfd_addrs (addrs
->size (), nullptr);
542 std::vector
<const struct other_sections
*>::iterator abfd_sorted_iter
543 = abfd_addrs_sorted
.begin ();
544 for (const struct other_sections
*sect
: addrs_sorted
)
546 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
548 while (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
549 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
553 if (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
554 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
559 /* Make the found item directly addressable from ADDRS. */
560 index_in_addrs
= sect
- addrs
->data ();
561 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
562 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_sorted_iter
;
564 /* Never use the same ABFD entry twice. */
569 /* Calculate offsets for the loadable sections.
570 FIXME! Sections must be in order of increasing loadable section
571 so that contiguous sections can use the lower-offset!!!
573 Adjust offsets if the segments are not contiguous.
574 If the section is contiguous, its offset should be set to
575 the offset of the highest loadable section lower than it
576 (the loadable section directly below it in memory).
577 this_offset = lower_offset = lower_addr - lower_orig_addr */
579 for (i
= 0; i
< addrs
->size (); i
++)
581 const struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
585 /* This is the index used by BFD. */
586 (*addrs
)[i
].sectindex
= sect
->sectindex
;
588 if ((*addrs
)[i
].addr
!= 0)
590 (*addrs
)[i
].addr
-= sect
->addr
;
591 lower_offset
= (*addrs
)[i
].addr
;
594 (*addrs
)[i
].addr
= lower_offset
;
598 /* addr_section_name transformation is not used for SECT_NAME. */
599 const std::string
§_name
= (*addrs
)[i
].name
;
601 /* This section does not exist in ABFD, which is normally
602 unexpected and we want to issue a warning.
604 However, the ELF prelinker does create a few sections which are
605 marked in the main executable as loadable (they are loaded in
606 memory from the DYNAMIC segment) and yet are not present in
607 separate debug info files. This is fine, and should not cause
608 a warning. Shared libraries contain just the section
609 ".gnu.liblist" but it is not marked as loadable there. There is
610 no other way to identify them than by their name as the sections
611 created by prelink have no special flags.
613 For the sections `.bss' and `.sbss' see addr_section_name. */
615 if (!(sect_name
== ".gnu.liblist"
616 || sect_name
== ".gnu.conflict"
617 || (sect_name
== ".bss"
619 && (*addrs
)[i
- 1].name
== ".dynbss"
620 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
621 || (sect_name
== ".sbss"
623 && (*addrs
)[i
- 1].name
== ".sdynbss"
624 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
625 warning (_("section %s not found in %s"), sect_name
.c_str (),
626 bfd_get_filename (abfd
));
628 (*addrs
)[i
].addr
= 0;
629 (*addrs
)[i
].sectindex
= -1;
634 /* Parse the user's idea of an offset for dynamic linking, into our idea
635 of how to represent it for fast symbol reading. This is the default
636 version of the sym_fns.sym_offsets function for symbol readers that
637 don't need to do anything special. It allocates a section_offsets table
638 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
641 default_symfile_offsets (struct objfile
*objfile
,
642 const section_addr_info
&addrs
)
644 objfile
->num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
645 objfile
->section_offsets
= (struct section_offsets
*)
646 obstack_alloc (&objfile
->objfile_obstack
,
647 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
648 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
649 objfile
->num_sections
, addrs
);
651 /* For relocatable files, all loadable sections will start at zero.
652 The zero is meaningless, so try to pick arbitrary addresses such
653 that no loadable sections overlap. This algorithm is quadratic,
654 but the number of sections in a single object file is generally
656 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
658 struct place_section_arg arg
;
659 bfd
*abfd
= objfile
->obfd
;
662 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
663 /* We do not expect this to happen; just skip this step if the
664 relocatable file has a section with an assigned VMA. */
665 if (bfd_section_vma (abfd
, cur_sec
) != 0)
670 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
672 /* Pick non-overlapping offsets for sections the user did not
674 arg
.offsets
= objfile
->section_offsets
;
676 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
678 /* Correctly filling in the section offsets is not quite
679 enough. Relocatable files have two properties that
680 (most) shared objects do not:
682 - Their debug information will contain relocations. Some
683 shared libraries do also, but many do not, so this can not
686 - If there are multiple code sections they will be loaded
687 at different relative addresses in memory than they are
688 in the objfile, since all sections in the file will start
691 Because GDB has very limited ability to map from an
692 address in debug info to the correct code section,
693 it relies on adding SECT_OFF_TEXT to things which might be
694 code. If we clear all the section offsets, and set the
695 section VMAs instead, then symfile_relocate_debug_section
696 will return meaningful debug information pointing at the
699 GDB has too many different data structures for section
700 addresses - a bfd, objfile, and so_list all have section
701 tables, as does exec_ops. Some of these could probably
704 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
705 cur_sec
= cur_sec
->next
)
707 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
710 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
711 exec_set_section_address (bfd_get_filename (abfd
),
713 offsets
[cur_sec
->index
]);
714 offsets
[cur_sec
->index
] = 0;
719 /* Remember the bfd indexes for the .text, .data, .bss and
721 init_objfile_sect_indices (objfile
);
724 /* Divide the file into segments, which are individual relocatable units.
725 This is the default version of the sym_fns.sym_segments function for
726 symbol readers that do not have an explicit representation of segments.
727 It assumes that object files do not have segments, and fully linked
728 files have a single segment. */
730 struct symfile_segment_data
*
731 default_symfile_segments (bfd
*abfd
)
735 struct symfile_segment_data
*data
;
738 /* Relocatable files contain enough information to position each
739 loadable section independently; they should not be relocated
741 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
744 /* Make sure there is at least one loadable section in the file. */
745 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
747 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
755 low
= bfd_get_section_vma (abfd
, sect
);
756 high
= low
+ bfd_get_section_size (sect
);
758 data
= XCNEW (struct symfile_segment_data
);
759 data
->num_segments
= 1;
760 data
->segment_bases
= XCNEW (CORE_ADDR
);
761 data
->segment_sizes
= XCNEW (CORE_ADDR
);
763 num_sections
= bfd_count_sections (abfd
);
764 data
->segment_info
= XCNEWVEC (int, num_sections
);
766 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
770 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
773 vma
= bfd_get_section_vma (abfd
, sect
);
776 if (vma
+ bfd_get_section_size (sect
) > high
)
777 high
= vma
+ bfd_get_section_size (sect
);
779 data
->segment_info
[i
] = 1;
782 data
->segment_bases
[0] = low
;
783 data
->segment_sizes
[0] = high
- low
;
788 /* This is a convenience function to call sym_read for OBJFILE and
789 possibly force the partial symbols to be read. */
792 read_symbols (struct objfile
*objfile
, symfile_add_flags add_flags
)
794 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
795 objfile
->per_bfd
->minsyms_read
= true;
797 /* find_separate_debug_file_in_section should be called only if there is
798 single binary with no existing separate debug info file. */
799 if (!objfile_has_partial_symbols (objfile
)
800 && objfile
->separate_debug_objfile
== NULL
801 && objfile
->separate_debug_objfile_backlink
== NULL
)
803 gdb_bfd_ref_ptr
abfd (find_separate_debug_file_in_section (objfile
));
807 /* find_separate_debug_file_in_section uses the same filename for the
808 virtual section-as-bfd like the bfd filename containing the
809 section. Therefore use also non-canonical name form for the same
810 file containing the section. */
811 symbol_file_add_separate (abfd
.get (), objfile
->original_name
,
815 if ((add_flags
& SYMFILE_NO_READ
) == 0)
816 require_partial_symbols (objfile
, 0);
819 /* Initialize entry point information for this objfile. */
822 init_entry_point_info (struct objfile
*objfile
)
824 struct entry_info
*ei
= &objfile
->per_bfd
->ei
;
830 /* Save startup file's range of PC addresses to help blockframe.c
831 decide where the bottom of the stack is. */
833 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
835 /* Executable file -- record its entry point so we'll recognize
836 the startup file because it contains the entry point. */
837 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
838 ei
->entry_point_p
= 1;
840 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
841 && bfd_get_start_address (objfile
->obfd
) != 0)
843 /* Some shared libraries may have entry points set and be
844 runnable. There's no clear way to indicate this, so just check
845 for values other than zero. */
846 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
847 ei
->entry_point_p
= 1;
851 /* Examination of non-executable.o files. Short-circuit this stuff. */
852 ei
->entry_point_p
= 0;
855 if (ei
->entry_point_p
)
857 struct obj_section
*osect
;
858 CORE_ADDR entry_point
= ei
->entry_point
;
861 /* Make certain that the address points at real code, and not a
862 function descriptor. */
864 = gdbarch_convert_from_func_ptr_addr (get_objfile_arch (objfile
),
868 /* Remove any ISA markers, so that this matches entries in the
871 = gdbarch_addr_bits_remove (get_objfile_arch (objfile
), entry_point
);
874 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
876 struct bfd_section
*sect
= osect
->the_bfd_section
;
878 if (entry_point
>= bfd_get_section_vma (objfile
->obfd
, sect
)
879 && entry_point
< (bfd_get_section_vma (objfile
->obfd
, sect
)
880 + bfd_get_section_size (sect
)))
882 ei
->the_bfd_section_index
883 = gdb_bfd_section_index (objfile
->obfd
, sect
);
890 ei
->the_bfd_section_index
= SECT_OFF_TEXT (objfile
);
894 /* Process a symbol file, as either the main file or as a dynamically
897 This function does not set the OBJFILE's entry-point info.
899 OBJFILE is where the symbols are to be read from.
901 ADDRS is the list of section load addresses. If the user has given
902 an 'add-symbol-file' command, then this is the list of offsets and
903 addresses he or she provided as arguments to the command; or, if
904 we're handling a shared library, these are the actual addresses the
905 sections are loaded at, according to the inferior's dynamic linker
906 (as gleaned by GDB's shared library code). We convert each address
907 into an offset from the section VMA's as it appears in the object
908 file, and then call the file's sym_offsets function to convert this
909 into a format-specific offset table --- a `struct section_offsets'.
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 struct cleanup
*old_chain
;
922 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
924 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
926 if (objfile
->sf
== NULL
)
928 /* No symbols to load, but we still need to make sure
929 that the section_offsets table is allocated. */
930 int num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
931 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_sections
);
933 objfile
->num_sections
= num_sections
;
934 objfile
->section_offsets
935 = (struct section_offsets
*) obstack_alloc (&objfile
->objfile_obstack
,
937 memset (objfile
->section_offsets
, 0, size
);
941 /* Make sure that partially constructed symbol tables will be cleaned up
942 if an error occurs during symbol reading. */
943 old_chain
= make_cleanup (null_cleanup
, NULL
);
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 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
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
);
988 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
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 discard_cleanups (old_chain
);
1000 /* Same as syms_from_objfile_1, but also initializes the objfile
1001 entry-point info. */
1004 syms_from_objfile (struct objfile
*objfile
,
1005 section_addr_info
*addrs
,
1006 symfile_add_flags add_flags
)
1008 syms_from_objfile_1 (objfile
, addrs
, add_flags
);
1009 init_entry_point_info (objfile
);
1012 /* Perform required actions after either reading in the initial
1013 symbols for a new objfile, or mapping in the symbols from a reusable
1014 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1017 finish_new_objfile (struct objfile
*objfile
, symfile_add_flags add_flags
)
1019 /* If this is the main symbol file we have to clean up all users of the
1020 old main symbol file. Otherwise it is sufficient to fixup all the
1021 breakpoints that may have been redefined by this symbol file. */
1022 if (add_flags
& SYMFILE_MAINLINE
)
1024 /* OK, make it the "real" symbol file. */
1025 symfile_objfile
= objfile
;
1027 clear_symtab_users (add_flags
);
1029 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1031 breakpoint_re_set ();
1034 /* We're done reading the symbol file; finish off complaints. */
1035 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
1038 /* Process a symbol file, as either the main file or as a dynamically
1041 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1042 A new reference is acquired by this function.
1044 For NAME description see the objfile constructor.
1046 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1047 extra, such as dynamically loaded code, and what to do with breakpoins.
1049 ADDRS is as described for syms_from_objfile_1, above.
1050 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1052 PARENT is the original objfile if ABFD is a separate debug info file.
1053 Otherwise PARENT is NULL.
1055 Upon success, returns a pointer to the objfile that was added.
1056 Upon failure, jumps back to command level (never returns). */
1058 static struct objfile
*
1059 symbol_file_add_with_addrs (bfd
*abfd
, const char *name
,
1060 symfile_add_flags add_flags
,
1061 section_addr_info
*addrs
,
1062 objfile_flags flags
, struct objfile
*parent
)
1064 struct objfile
*objfile
;
1065 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1066 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1067 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
1068 && (readnow_symbol_files
1069 || (add_flags
& SYMFILE_NO_READ
) == 0));
1071 if (readnow_symbol_files
)
1073 flags
|= OBJF_READNOW
;
1074 add_flags
&= ~SYMFILE_NO_READ
;
1076 else if (readnever_symbol_files
1077 || (parent
!= NULL
&& (parent
->flags
& OBJF_READNEVER
)))
1079 flags
|= OBJF_READNEVER
;
1080 add_flags
|= SYMFILE_NO_READ
;
1083 /* Give user a chance to burp if we'd be
1084 interactively wiping out any existing symbols. */
1086 if ((have_full_symbols () || have_partial_symbols ())
1089 && !query (_("Load new symbol table from \"%s\"? "), name
))
1090 error (_("Not confirmed."));
1093 flags
|= OBJF_MAINLINE
;
1094 objfile
= new struct objfile (abfd
, name
, flags
);
1097 add_separate_debug_objfile (objfile
, parent
);
1099 /* We either created a new mapped symbol table, mapped an existing
1100 symbol table file which has not had initial symbol reading
1101 performed, or need to read an unmapped symbol table. */
1104 if (deprecated_pre_add_symbol_hook
)
1105 deprecated_pre_add_symbol_hook (name
);
1108 printf_unfiltered (_("Reading symbols from %s..."), name
);
1110 gdb_flush (gdb_stdout
);
1113 syms_from_objfile (objfile
, addrs
, add_flags
);
1115 /* We now have at least a partial symbol table. Check to see if the
1116 user requested that all symbols be read on initial access via either
1117 the gdb startup command line or on a per symbol file basis. Expand
1118 all partial symbol tables for this objfile if so. */
1120 if ((flags
& OBJF_READNOW
))
1124 printf_unfiltered (_("expanding to full symbols..."));
1126 gdb_flush (gdb_stdout
);
1130 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1133 if (should_print
&& !objfile_has_symbols (objfile
))
1136 printf_unfiltered (_("(no debugging symbols found)..."));
1142 if (deprecated_post_add_symbol_hook
)
1143 deprecated_post_add_symbol_hook ();
1145 printf_unfiltered (_("done.\n"));
1148 /* We print some messages regardless of whether 'from_tty ||
1149 info_verbose' is true, so make sure they go out at the right
1151 gdb_flush (gdb_stdout
);
1153 if (objfile
->sf
== NULL
)
1155 gdb::observers::new_objfile
.notify (objfile
);
1156 return objfile
; /* No symbols. */
1159 finish_new_objfile (objfile
, add_flags
);
1161 gdb::observers::new_objfile
.notify (objfile
);
1163 bfd_cache_close_all ();
1167 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1168 see the objfile constructor. */
1171 symbol_file_add_separate (bfd
*bfd
, const char *name
,
1172 symfile_add_flags symfile_flags
,
1173 struct objfile
*objfile
)
1175 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1176 because sections of BFD may not match sections of OBJFILE and because
1177 vma may have been modified by tools such as prelink. */
1178 section_addr_info sap
= build_section_addr_info_from_objfile (objfile
);
1180 symbol_file_add_with_addrs
1181 (bfd
, name
, symfile_flags
, &sap
,
1182 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1187 /* Process the symbol file ABFD, as either the main file or as a
1188 dynamically loaded file.
1189 See symbol_file_add_with_addrs's comments for details. */
1192 symbol_file_add_from_bfd (bfd
*abfd
, const char *name
,
1193 symfile_add_flags add_flags
,
1194 section_addr_info
*addrs
,
1195 objfile_flags flags
, struct objfile
*parent
)
1197 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1201 /* Process a symbol file, as either the main file or as a dynamically
1202 loaded file. See symbol_file_add_with_addrs's comments for details. */
1205 symbol_file_add (const char *name
, symfile_add_flags add_flags
,
1206 section_addr_info
*addrs
, objfile_flags flags
)
1208 gdb_bfd_ref_ptr
bfd (symfile_bfd_open (name
));
1210 return symbol_file_add_from_bfd (bfd
.get (), name
, add_flags
, addrs
,
1214 /* Call symbol_file_add() with default values and update whatever is
1215 affected by the loading of a new main().
1216 Used when the file is supplied in the gdb command line
1217 and by some targets with special loading requirements.
1218 The auxiliary function, symbol_file_add_main_1(), has the flags
1219 argument for the switches that can only be specified in the symbol_file
1223 symbol_file_add_main (const char *args
, symfile_add_flags add_flags
)
1225 symbol_file_add_main_1 (args
, add_flags
, 0);
1229 symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
1230 objfile_flags flags
)
1232 add_flags
|= current_inferior ()->symfile_flags
| SYMFILE_MAINLINE
;
1234 symbol_file_add (args
, add_flags
, NULL
, flags
);
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_unfiltered (_("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
)
1289 printf_unfiltered (_(" Trying %s\n"), name
.c_str ());
1291 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (name
.c_str (), gnutarget
, -1));
1296 /* Verify symlinks were not the cause of filename_cmp name difference above.
1298 Some operating systems, e.g. Windows, do not provide a meaningful
1299 st_ino; they always set it to zero. (Windows does provide a
1300 meaningful st_dev.) Files accessed from gdbservers that do not
1301 support the vFile:fstat packet will also have st_ino set to zero.
1302 Do not indicate a duplicate library in either case. While there
1303 is no guarantee that a system that provides meaningful inode
1304 numbers will never set st_ino to zero, this is merely an
1305 optimization, so we do not need to worry about false negatives. */
1307 if (bfd_stat (abfd
.get (), &abfd_stat
) == 0
1308 && abfd_stat
.st_ino
!= 0
1309 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1311 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1312 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1314 verified_as_different
= 1;
1317 verified_as_different
= 0;
1319 file_crc_p
= gdb_bfd_crc (abfd
.get (), &file_crc
);
1324 if (crc
!= file_crc
)
1326 unsigned long parent_crc
;
1328 /* If the files could not be verified as different with
1329 bfd_stat then we need to calculate the parent's CRC
1330 to verify whether the files are different or not. */
1332 if (!verified_as_different
)
1334 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1338 if (verified_as_different
|| parent_crc
!= file_crc
)
1339 warning (_("the debug information found in \"%s\""
1340 " does not match \"%s\" (CRC mismatch).\n"),
1341 name
.c_str (), objfile_name (parent_objfile
));
1349 char *debug_file_directory
= NULL
;
1351 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1352 struct cmd_list_element
*c
, const char *value
)
1354 fprintf_filtered (file
,
1355 _("The directory where separate debug "
1356 "symbols are searched for is \"%s\".\n"),
1360 #if ! defined (DEBUG_SUBDIRECTORY)
1361 #define DEBUG_SUBDIRECTORY ".debug"
1364 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1365 where the original file resides (may not be the same as
1366 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1367 looking for. CANON_DIR is the "realpath" form of DIR.
1368 DIR must contain a trailing '/'.
1369 Returns the path of the file with separate debug info, or an empty
1373 find_separate_debug_file (const char *dir
,
1374 const char *canon_dir
,
1375 const char *debuglink
,
1376 unsigned long crc32
, struct objfile
*objfile
)
1378 if (separate_debug_file_debug
)
1379 printf_unfiltered (_("\nLooking for separate debug info (debug link) for "
1380 "%s\n"), objfile_name (objfile
));
1382 /* First try in the same directory as the original file. */
1383 std::string debugfile
= dir
;
1384 debugfile
+= debuglink
;
1386 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1389 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1391 debugfile
+= DEBUG_SUBDIRECTORY
;
1393 debugfile
+= debuglink
;
1395 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1398 /* Then try in the global debugfile directories.
1400 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1401 cause "/..." lookups. */
1403 std::vector
<gdb::unique_xmalloc_ptr
<char>> debugdir_vec
1404 = dirnames_to_char_ptr_vec (debug_file_directory
);
1406 for (const gdb::unique_xmalloc_ptr
<char> &debugdir
: debugdir_vec
)
1408 debugfile
= debugdir
.get ();
1411 debugfile
+= debuglink
;
1413 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1416 /* If the file is in the sysroot, try using its base path in the
1417 global debugfile directory. */
1418 if (canon_dir
!= NULL
1419 && filename_ncmp (canon_dir
, gdb_sysroot
,
1420 strlen (gdb_sysroot
)) == 0
1421 && IS_DIR_SEPARATOR (canon_dir
[strlen (gdb_sysroot
)]))
1423 debugfile
= debugdir
.get ();
1424 debugfile
+= (canon_dir
+ strlen (gdb_sysroot
));
1426 debugfile
+= debuglink
;
1428 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1433 return std::string ();
1436 /* Modify PATH to contain only "[/]directory/" part of PATH.
1437 If there were no directory separators in PATH, PATH will be empty
1438 string on return. */
1441 terminate_after_last_dir_separator (char *path
)
1445 /* Strip off the final filename part, leaving the directory name,
1446 followed by a slash. The directory can be relative or absolute. */
1447 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1448 if (IS_DIR_SEPARATOR (path
[i
]))
1451 /* If I is -1 then no directory is present there and DIR will be "". */
1455 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1456 Returns pathname, or an empty string. */
1459 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1461 unsigned long crc32
;
1463 gdb::unique_xmalloc_ptr
<char> debuglink
1464 (bfd_get_debug_link_info (objfile
->obfd
, &crc32
));
1466 if (debuglink
== NULL
)
1468 /* There's no separate debug info, hence there's no way we could
1469 load it => no warning. */
1470 return std::string ();
1473 std::string dir
= objfile_name (objfile
);
1474 terminate_after_last_dir_separator (&dir
[0]);
1475 gdb::unique_xmalloc_ptr
<char> canon_dir (lrealpath (dir
.c_str ()));
1477 std::string debugfile
1478 = find_separate_debug_file (dir
.c_str (), canon_dir
.get (),
1479 debuglink
.get (), crc32
, objfile
);
1481 if (debugfile
.empty ())
1483 /* For PR gdb/9538, try again with realpath (if different from the
1488 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1489 && S_ISLNK (st_buf
.st_mode
))
1491 gdb::unique_xmalloc_ptr
<char> symlink_dir
1492 (lrealpath (objfile_name (objfile
)));
1493 if (symlink_dir
!= NULL
)
1495 terminate_after_last_dir_separator (symlink_dir
.get ());
1496 if (dir
!= symlink_dir
.get ())
1498 /* Different directory, so try using it. */
1499 debugfile
= find_separate_debug_file (symlink_dir
.get (),
1512 /* Make sure that OBJF_{READNOW,READNEVER} are not set
1516 validate_readnow_readnever (objfile_flags flags
)
1518 if ((flags
& OBJF_READNOW
) && (flags
& OBJF_READNEVER
))
1519 error (_("-readnow and -readnever cannot be used simultaneously"));
1522 /* This is the symbol-file command. Read the file, analyze its
1523 symbols, and add a struct symtab to a symtab list. The syntax of
1524 the command is rather bizarre:
1526 1. The function buildargv implements various quoting conventions
1527 which are undocumented and have little or nothing in common with
1528 the way things are quoted (or not quoted) elsewhere in GDB.
1530 2. Options are used, which are not generally used in GDB (perhaps
1531 "set mapped on", "set readnow on" would be better)
1533 3. The order of options matters, which is contrary to GNU
1534 conventions (because it is confusing and inconvenient). */
1537 symbol_file_command (const char *args
, int from_tty
)
1543 symbol_file_clear (from_tty
);
1547 objfile_flags flags
= OBJF_USERLOADED
;
1548 symfile_add_flags add_flags
= 0;
1550 bool stop_processing_options
= false;
1555 add_flags
|= SYMFILE_VERBOSE
;
1557 gdb_argv
built_argv (args
);
1558 for (arg
= built_argv
[0], idx
= 0; arg
!= NULL
; arg
= built_argv
[++idx
])
1560 if (stop_processing_options
|| *arg
!= '-')
1565 error (_("Unrecognized argument \"%s\""), arg
);
1567 else if (strcmp (arg
, "-readnow") == 0)
1568 flags
|= OBJF_READNOW
;
1569 else if (strcmp (arg
, "-readnever") == 0)
1570 flags
|= OBJF_READNEVER
;
1571 else if (strcmp (arg
, "--") == 0)
1572 stop_processing_options
= true;
1574 error (_("Unrecognized argument \"%s\""), arg
);
1578 error (_("no symbol file name was specified"));
1580 validate_readnow_readnever (flags
);
1582 symbol_file_add_main_1 (name
, add_flags
, flags
);
1586 /* Set the initial language.
1588 FIXME: A better solution would be to record the language in the
1589 psymtab when reading partial symbols, and then use it (if known) to
1590 set the language. This would be a win for formats that encode the
1591 language in an easily discoverable place, such as DWARF. For
1592 stabs, we can jump through hoops looking for specially named
1593 symbols or try to intuit the language from the specific type of
1594 stabs we find, but we can't do that until later when we read in
1598 set_initial_language (void)
1600 enum language lang
= main_language ();
1602 if (lang
== language_unknown
)
1604 char *name
= main_name ();
1605 struct symbol
*sym
= lookup_symbol (name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
1608 lang
= SYMBOL_LANGUAGE (sym
);
1611 if (lang
== language_unknown
)
1613 /* Make C the default language */
1617 set_language (lang
);
1618 expected_language
= current_language
; /* Don't warn the user. */
1621 /* Open the file specified by NAME and hand it off to BFD for
1622 preliminary analysis. Return a newly initialized bfd *, which
1623 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1624 absolute). In case of trouble, error() is called. */
1627 symfile_bfd_open (const char *name
)
1631 gdb::unique_xmalloc_ptr
<char> absolute_name
;
1632 if (!is_target_filename (name
))
1634 gdb::unique_xmalloc_ptr
<char> expanded_name (tilde_expand (name
));
1636 /* Look down path for it, allocate 2nd new malloc'd copy. */
1637 desc
= openp (getenv ("PATH"),
1638 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1639 expanded_name
.get (), O_RDONLY
| O_BINARY
, &absolute_name
);
1640 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1643 char *exename
= (char *) alloca (strlen (expanded_name
.get ()) + 5);
1645 strcat (strcpy (exename
, expanded_name
.get ()), ".exe");
1646 desc
= openp (getenv ("PATH"),
1647 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1648 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1652 perror_with_name (expanded_name
.get ());
1654 name
= absolute_name
.get ();
1657 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (name
, gnutarget
, desc
));
1658 if (sym_bfd
== NULL
)
1659 error (_("`%s': can't open to read symbols: %s."), name
,
1660 bfd_errmsg (bfd_get_error ()));
1662 if (!gdb_bfd_has_target_filename (sym_bfd
.get ()))
1663 bfd_set_cacheable (sym_bfd
.get (), 1);
1665 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
1666 error (_("`%s': can't read symbols: %s."), name
,
1667 bfd_errmsg (bfd_get_error ()));
1672 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1673 the section was not found. */
1676 get_section_index (struct objfile
*objfile
, const char *section_name
)
1678 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1686 /* Link SF into the global symtab_fns list.
1687 FLAVOUR is the file format that SF handles.
1688 Called on startup by the _initialize routine in each object file format
1689 reader, to register information about each format the reader is prepared
1693 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1695 symtab_fns
.emplace_back (flavour
, sf
);
1698 /* Initialize OBJFILE to read symbols from its associated BFD. It
1699 either returns or calls error(). The result is an initialized
1700 struct sym_fns in the objfile structure, that contains cached
1701 information about the symbol file. */
1703 static const struct sym_fns
*
1704 find_sym_fns (bfd
*abfd
)
1706 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1708 if (our_flavour
== bfd_target_srec_flavour
1709 || our_flavour
== bfd_target_ihex_flavour
1710 || our_flavour
== bfd_target_tekhex_flavour
)
1711 return NULL
; /* No symbols. */
1713 for (const registered_sym_fns
&rsf
: symtab_fns
)
1714 if (our_flavour
== rsf
.sym_flavour
)
1717 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1718 bfd_get_target (abfd
));
1722 /* This function runs the load command of our current target. */
1725 load_command (const char *arg
, int from_tty
)
1729 /* The user might be reloading because the binary has changed. Take
1730 this opportunity to check. */
1731 reopen_exec_file ();
1737 const char *parg
, *prev
;
1739 arg
= get_exec_file (1);
1741 /* We may need to quote this string so buildargv can pull it
1744 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1746 temp
.append (prev
, parg
- prev
);
1748 temp
.push_back ('\\');
1750 /* If we have not copied anything yet, then we didn't see a
1751 character to quote, and we can just leave ARG unchanged. */
1755 arg
= temp
.c_str ();
1759 target_load (arg
, from_tty
);
1761 /* After re-loading the executable, we don't really know which
1762 overlays are mapped any more. */
1763 overlay_cache_invalid
= 1;
1766 /* This version of "load" should be usable for any target. Currently
1767 it is just used for remote targets, not inftarg.c or core files,
1768 on the theory that only in that case is it useful.
1770 Avoiding xmodem and the like seems like a win (a) because we don't have
1771 to worry about finding it, and (b) On VMS, fork() is very slow and so
1772 we don't want to run a subprocess. On the other hand, I'm not sure how
1773 performance compares. */
1775 static int validate_download
= 0;
1777 /* Callback service function for generic_load (bfd_map_over_sections). */
1780 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1782 bfd_size_type
*sum
= (bfd_size_type
*) data
;
1784 *sum
+= bfd_get_section_size (asec
);
1787 /* Opaque data for load_progress. */
1788 struct load_progress_data
1790 /* Cumulative data. */
1791 unsigned long write_count
= 0;
1792 unsigned long data_count
= 0;
1793 bfd_size_type total_size
= 0;
1796 /* Opaque data for load_progress for a single section. */
1797 struct load_progress_section_data
1799 load_progress_section_data (load_progress_data
*cumulative_
,
1800 const char *section_name_
, ULONGEST section_size_
,
1801 CORE_ADDR lma_
, gdb_byte
*buffer_
)
1802 : cumulative (cumulative_
), section_name (section_name_
),
1803 section_size (section_size_
), lma (lma_
), buffer (buffer_
)
1806 struct load_progress_data
*cumulative
;
1808 /* Per-section data. */
1809 const char *section_name
;
1810 ULONGEST section_sent
= 0;
1811 ULONGEST section_size
;
1816 /* Opaque data for load_section_callback. */
1817 struct load_section_data
1819 load_section_data (load_progress_data
*progress_data_
)
1820 : progress_data (progress_data_
)
1823 ~load_section_data ()
1825 for (auto &&request
: requests
)
1827 xfree (request
.data
);
1828 delete ((load_progress_section_data
*) request
.baton
);
1832 CORE_ADDR load_offset
= 0;
1833 struct load_progress_data
*progress_data
;
1834 std::vector
<struct memory_write_request
> requests
;
1837 /* Target write callback routine for progress reporting. */
1840 load_progress (ULONGEST bytes
, void *untyped_arg
)
1842 struct load_progress_section_data
*args
1843 = (struct load_progress_section_data
*) untyped_arg
;
1844 struct load_progress_data
*totals
;
1847 /* Writing padding data. No easy way to get at the cumulative
1848 stats, so just ignore this. */
1851 totals
= args
->cumulative
;
1853 if (bytes
== 0 && args
->section_sent
== 0)
1855 /* The write is just starting. Let the user know we've started
1857 current_uiout
->message ("Loading section %s, size %s lma %s\n",
1859 hex_string (args
->section_size
),
1860 paddress (target_gdbarch (), args
->lma
));
1864 if (validate_download
)
1866 /* Broken memories and broken monitors manifest themselves here
1867 when bring new computers to life. This doubles already slow
1869 /* NOTE: cagney/1999-10-18: A more efficient implementation
1870 might add a verify_memory() method to the target vector and
1871 then use that. remote.c could implement that method using
1872 the ``qCRC'' packet. */
1873 gdb::byte_vector
check (bytes
);
1875 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1876 error (_("Download verify read failed at %s"),
1877 paddress (target_gdbarch (), args
->lma
));
1878 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1879 error (_("Download verify compare failed at %s"),
1880 paddress (target_gdbarch (), args
->lma
));
1882 totals
->data_count
+= bytes
;
1884 args
->buffer
+= bytes
;
1885 totals
->write_count
+= 1;
1886 args
->section_sent
+= bytes
;
1887 if (check_quit_flag ()
1888 || (deprecated_ui_load_progress_hook
!= NULL
1889 && deprecated_ui_load_progress_hook (args
->section_name
,
1890 args
->section_sent
)))
1891 error (_("Canceled the download"));
1893 if (deprecated_show_load_progress
!= NULL
)
1894 deprecated_show_load_progress (args
->section_name
,
1898 totals
->total_size
);
1901 /* Callback service function for generic_load (bfd_map_over_sections). */
1904 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1906 struct load_section_data
*args
= (struct load_section_data
*) data
;
1907 bfd_size_type size
= bfd_get_section_size (asec
);
1908 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1910 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1916 ULONGEST begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1917 ULONGEST end
= begin
+ size
;
1918 gdb_byte
*buffer
= (gdb_byte
*) xmalloc (size
);
1919 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1921 load_progress_section_data
*section_data
1922 = new load_progress_section_data (args
->progress_data
, sect_name
, size
,
1925 args
->requests
.emplace_back (begin
, end
, buffer
, section_data
);
1928 static void print_transfer_performance (struct ui_file
*stream
,
1929 unsigned long data_count
,
1930 unsigned long write_count
,
1931 std::chrono::steady_clock::duration d
);
1934 generic_load (const char *args
, int from_tty
)
1936 struct load_progress_data total_progress
;
1937 struct load_section_data
cbdata (&total_progress
);
1938 struct ui_out
*uiout
= current_uiout
;
1941 error_no_arg (_("file to load"));
1943 gdb_argv
argv (args
);
1945 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
1947 if (argv
[1] != NULL
)
1951 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
1953 /* If the last word was not a valid number then
1954 treat it as a file name with spaces in. */
1955 if (argv
[1] == endptr
)
1956 error (_("Invalid download offset:%s."), argv
[1]);
1958 if (argv
[2] != NULL
)
1959 error (_("Too many parameters."));
1962 /* Open the file for loading. */
1963 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
1964 if (loadfile_bfd
== NULL
)
1965 perror_with_name (filename
.get ());
1967 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
1969 error (_("\"%s\" is not an object file: %s"), filename
.get (),
1970 bfd_errmsg (bfd_get_error ()));
1973 bfd_map_over_sections (loadfile_bfd
.get (), add_section_size_callback
,
1974 (void *) &total_progress
.total_size
);
1976 bfd_map_over_sections (loadfile_bfd
.get (), load_section_callback
, &cbdata
);
1978 using namespace std::chrono
;
1980 steady_clock::time_point start_time
= steady_clock::now ();
1982 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
1983 load_progress
) != 0)
1984 error (_("Load failed"));
1986 steady_clock::time_point end_time
= steady_clock::now ();
1988 CORE_ADDR entry
= bfd_get_start_address (loadfile_bfd
.get ());
1989 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
1990 uiout
->text ("Start address ");
1991 uiout
->field_fmt ("address", "%s", paddress (target_gdbarch (), entry
));
1992 uiout
->text (", load size ");
1993 uiout
->field_fmt ("load-size", "%lu", total_progress
.data_count
);
1995 regcache_write_pc (get_current_regcache (), entry
);
1997 /* Reset breakpoints, now that we have changed the load image. For
1998 instance, breakpoints may have been set (or reset, by
1999 post_create_inferior) while connected to the target but before we
2000 loaded the program. In that case, the prologue analyzer could
2001 have read instructions from the target to find the right
2002 breakpoint locations. Loading has changed the contents of that
2005 breakpoint_re_set ();
2007 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2008 total_progress
.write_count
,
2009 end_time
- start_time
);
2012 /* Report on STREAM the performance of a memory transfer operation,
2013 such as 'load'. DATA_COUNT is the number of bytes transferred.
2014 WRITE_COUNT is the number of separate write operations, or 0, if
2015 that information is not available. TIME is how long the operation
2019 print_transfer_performance (struct ui_file
*stream
,
2020 unsigned long data_count
,
2021 unsigned long write_count
,
2022 std::chrono::steady_clock::duration time
)
2024 using namespace std::chrono
;
2025 struct ui_out
*uiout
= current_uiout
;
2027 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2029 uiout
->text ("Transfer rate: ");
2030 if (ms
.count () > 0)
2032 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2034 if (uiout
->is_mi_like_p ())
2036 uiout
->field_fmt ("transfer-rate", "%lu", rate
* 8);
2037 uiout
->text (" bits/sec");
2039 else if (rate
< 1024)
2041 uiout
->field_fmt ("transfer-rate", "%lu", rate
);
2042 uiout
->text (" bytes/sec");
2046 uiout
->field_fmt ("transfer-rate", "%lu", rate
/ 1024);
2047 uiout
->text (" KB/sec");
2052 uiout
->field_fmt ("transferred-bits", "%lu", (data_count
* 8));
2053 uiout
->text (" bits in <1 sec");
2055 if (write_count
> 0)
2058 uiout
->field_fmt ("write-rate", "%lu", data_count
/ write_count
);
2059 uiout
->text (" bytes/write");
2061 uiout
->text (".\n");
2064 /* This function allows the addition of incrementally linked object files.
2065 It does not modify any state in the target, only in the debugger. */
2066 /* Note: ezannoni 2000-04-13 This function/command used to have a
2067 special case syntax for the rombug target (Rombug is the boot
2068 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2069 rombug case, the user doesn't need to supply a text address,
2070 instead a call to target_link() (in target.c) would supply the
2071 value to use. We are now discontinuing this type of ad hoc syntax. */
2074 add_symbol_file_command (const char *args
, int from_tty
)
2076 struct gdbarch
*gdbarch
= get_current_arch ();
2077 gdb::unique_xmalloc_ptr
<char> filename
;
2080 struct objfile
*objf
;
2081 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2082 symfile_add_flags add_flags
= 0;
2085 add_flags
|= SYMFILE_VERBOSE
;
2093 std::vector
<sect_opt
> sect_opts
= { { ".text", NULL
} };
2094 bool stop_processing_options
= false;
2099 error (_("add-symbol-file takes a file name and an address"));
2101 bool seen_addr
= false;
2102 gdb_argv
argv (args
);
2104 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2106 if (stop_processing_options
|| *arg
!= '-')
2108 if (filename
== NULL
)
2110 /* First non-option argument is always the filename. */
2111 filename
.reset (tilde_expand (arg
));
2113 else if (!seen_addr
)
2115 /* The second non-option argument is always the text
2116 address at which to load the program. */
2117 sect_opts
[0].value
= arg
;
2121 error (_("Unrecognized argument \"%s\""), arg
);
2123 else if (strcmp (arg
, "-readnow") == 0)
2124 flags
|= OBJF_READNOW
;
2125 else if (strcmp (arg
, "-readnever") == 0)
2126 flags
|= OBJF_READNEVER
;
2127 else if (strcmp (arg
, "-s") == 0)
2129 if (argv
[argcnt
+ 1] == NULL
)
2130 error (_("Missing section name after \"-s\""));
2131 else if (argv
[argcnt
+ 2] == NULL
)
2132 error (_("Missing section address after \"-s\""));
2134 sect_opt sect
= { argv
[argcnt
+ 1], argv
[argcnt
+ 2] };
2136 sect_opts
.push_back (sect
);
2139 else if (strcmp (arg
, "--") == 0)
2140 stop_processing_options
= true;
2142 error (_("Unrecognized argument \"%s\""), arg
);
2145 if (filename
== NULL
)
2146 error (_("You must provide a filename to be loaded."));
2148 validate_readnow_readnever (flags
);
2150 /* This command takes at least two arguments. The first one is a
2151 filename, and the second is the address where this file has been
2152 loaded. Abort now if this address hasn't been provided by the
2155 error (_("The address where %s has been loaded is missing"),
2158 /* Print the prompt for the query below. And save the arguments into
2159 a sect_addr_info structure to be passed around to other
2160 functions. We have to split this up into separate print
2161 statements because hex_string returns a local static
2164 printf_unfiltered (_("add symbol table from file \"%s\" at\n"),
2166 section_addr_info section_addrs
;
2167 for (sect_opt
§
: sect_opts
)
2170 const char *val
= sect
.value
;
2171 const char *sec
= sect
.name
;
2173 addr
= parse_and_eval_address (val
);
2175 /* Here we store the section offsets in the order they were
2176 entered on the command line. */
2177 section_addrs
.emplace_back (addr
, sec
, 0);
2178 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2179 paddress (gdbarch
, addr
));
2181 /* The object's sections are initialized when a
2182 call is made to build_objfile_section_table (objfile).
2183 This happens in reread_symbols.
2184 At this point, we don't know what file type this is,
2185 so we can't determine what section names are valid. */
2188 if (from_tty
&& (!query ("%s", "")))
2189 error (_("Not confirmed."));
2191 objf
= symbol_file_add (filename
.get (), add_flags
, §ion_addrs
,
2194 add_target_sections_of_objfile (objf
);
2196 /* Getting new symbols may change our opinion about what is
2198 reinit_frame_cache ();
2202 /* This function removes a symbol file that was added via add-symbol-file. */
2205 remove_symbol_file_command (const char *args
, int from_tty
)
2207 struct objfile
*objf
= NULL
;
2208 struct program_space
*pspace
= current_program_space
;
2213 error (_("remove-symbol-file: no symbol file provided"));
2215 gdb_argv
argv (args
);
2217 if (strcmp (argv
[0], "-a") == 0)
2219 /* Interpret the next argument as an address. */
2222 if (argv
[1] == NULL
)
2223 error (_("Missing address argument"));
2225 if (argv
[2] != NULL
)
2226 error (_("Junk after %s"), argv
[1]);
2228 addr
= parse_and_eval_address (argv
[1]);
2232 if ((objf
->flags
& OBJF_USERLOADED
) != 0
2233 && (objf
->flags
& OBJF_SHARED
) != 0
2234 && objf
->pspace
== pspace
&& is_addr_in_objfile (addr
, objf
))
2238 else if (argv
[0] != NULL
)
2240 /* Interpret the current argument as a file name. */
2242 if (argv
[1] != NULL
)
2243 error (_("Junk after %s"), argv
[0]);
2245 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2249 if ((objf
->flags
& OBJF_USERLOADED
) != 0
2250 && (objf
->flags
& OBJF_SHARED
) != 0
2251 && objf
->pspace
== pspace
2252 && filename_cmp (filename
.get (), objfile_name (objf
)) == 0)
2258 error (_("No symbol file found"));
2261 && !query (_("Remove symbol table from file \"%s\"? "),
2262 objfile_name (objf
)))
2263 error (_("Not confirmed."));
2266 clear_symtab_users (0);
2269 /* Re-read symbols if a symbol-file has changed. */
2272 reread_symbols (void)
2274 struct objfile
*objfile
;
2276 struct stat new_statbuf
;
2278 std::vector
<struct objfile
*> new_objfiles
;
2280 /* With the addition of shared libraries, this should be modified,
2281 the load time should be saved in the partial symbol tables, since
2282 different tables may come from different source files. FIXME.
2283 This routine should then walk down each partial symbol table
2284 and see if the symbol table that it originates from has been changed. */
2286 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2288 if (objfile
->obfd
== NULL
)
2291 /* Separate debug objfiles are handled in the main objfile. */
2292 if (objfile
->separate_debug_objfile_backlink
)
2295 /* If this object is from an archive (what you usually create with
2296 `ar', often called a `static library' on most systems, though
2297 a `shared library' on AIX is also an archive), then you should
2298 stat on the archive name, not member name. */
2299 if (objfile
->obfd
->my_archive
)
2300 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2302 res
= stat (objfile_name (objfile
), &new_statbuf
);
2305 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2306 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2307 objfile_name (objfile
));
2310 new_modtime
= new_statbuf
.st_mtime
;
2311 if (new_modtime
!= objfile
->mtime
)
2313 struct cleanup
*old_cleanups
;
2314 struct section_offsets
*offsets
;
2316 char *original_name
;
2318 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2319 objfile_name (objfile
));
2321 /* There are various functions like symbol_file_add,
2322 symfile_bfd_open, syms_from_objfile, etc., which might
2323 appear to do what we want. But they have various other
2324 effects which we *don't* want. So we just do stuff
2325 ourselves. We don't worry about mapped files (for one thing,
2326 any mapped file will be out of date). */
2328 /* If we get an error, blow away this objfile (not sure if
2329 that is the correct response for things like shared
2331 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
2333 /* We need to do this whenever any symbols go away. */
2334 old_cleanups
= make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2336 if (exec_bfd
!= NULL
2337 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2338 bfd_get_filename (exec_bfd
)) == 0)
2340 /* Reload EXEC_BFD without asking anything. */
2342 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2345 /* Keep the calls order approx. the same as in free_objfile. */
2347 /* Free the separate debug objfiles. It will be
2348 automatically recreated by sym_read. */
2349 free_objfile_separate_debug (objfile
);
2351 /* Remove any references to this objfile in the global
2353 preserve_values (objfile
);
2355 /* Nuke all the state that we will re-read. Much of the following
2356 code which sets things to NULL really is necessary to tell
2357 other parts of GDB that there is nothing currently there.
2359 Try to keep the freeing order compatible with free_objfile. */
2361 if (objfile
->sf
!= NULL
)
2363 (*objfile
->sf
->sym_finish
) (objfile
);
2366 clear_objfile_data (objfile
);
2368 /* Clean up any state BFD has sitting around. */
2370 gdb_bfd_ref_ptr
obfd (objfile
->obfd
);
2371 char *obfd_filename
;
2373 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2374 /* Open the new BFD before freeing the old one, so that
2375 the filename remains live. */
2376 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
, -1));
2377 objfile
->obfd
= temp
.release ();
2378 if (objfile
->obfd
== NULL
)
2379 error (_("Can't open %s to read symbols."), obfd_filename
);
2382 original_name
= xstrdup (objfile
->original_name
);
2383 make_cleanup (xfree
, original_name
);
2385 /* bfd_openr sets cacheable to true, which is what we want. */
2386 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2387 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2388 bfd_errmsg (bfd_get_error ()));
2390 /* Save the offsets, we will nuke them with the rest of the
2392 num_offsets
= objfile
->num_sections
;
2393 offsets
= ((struct section_offsets
*)
2394 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2395 memcpy (offsets
, objfile
->section_offsets
,
2396 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2398 /* FIXME: Do we have to free a whole linked list, or is this
2400 objfile
->global_psymbols
.clear ();
2401 objfile
->static_psymbols
.clear ();
2403 /* Free the obstacks for non-reusable objfiles. */
2404 psymbol_bcache_free (objfile
->psymbol_cache
);
2405 objfile
->psymbol_cache
= psymbol_bcache_init ();
2407 /* NB: after this call to obstack_free, objfiles_changed
2408 will need to be called (see discussion below). */
2409 obstack_free (&objfile
->objfile_obstack
, 0);
2410 objfile
->sections
= NULL
;
2411 objfile
->compunit_symtabs
= NULL
;
2412 objfile
->psymtabs
= NULL
;
2413 objfile
->psymtabs_addrmap
= NULL
;
2414 objfile
->free_psymtabs
= NULL
;
2415 objfile
->template_symbols
= NULL
;
2417 /* obstack_init also initializes the obstack so it is
2418 empty. We could use obstack_specify_allocation but
2419 gdb_obstack.h specifies the alloc/dealloc functions. */
2420 obstack_init (&objfile
->objfile_obstack
);
2422 /* set_objfile_per_bfd potentially allocates the per-bfd
2423 data on the objfile's obstack (if sharing data across
2424 multiple users is not possible), so it's important to
2425 do it *after* the obstack has been initialized. */
2426 set_objfile_per_bfd (objfile
);
2428 objfile
->original_name
2429 = (char *) obstack_copy0 (&objfile
->objfile_obstack
, original_name
,
2430 strlen (original_name
));
2432 /* Reset the sym_fns pointer. The ELF reader can change it
2433 based on whether .gdb_index is present, and we need it to
2434 start over. PR symtab/15885 */
2435 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
2437 build_objfile_section_table (objfile
);
2438 terminate_minimal_symbol_table (objfile
);
2440 /* We use the same section offsets as from last time. I'm not
2441 sure whether that is always correct for shared libraries. */
2442 objfile
->section_offsets
= (struct section_offsets
*)
2443 obstack_alloc (&objfile
->objfile_obstack
,
2444 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2445 memcpy (objfile
->section_offsets
, offsets
,
2446 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2447 objfile
->num_sections
= num_offsets
;
2449 /* What the hell is sym_new_init for, anyway? The concept of
2450 distinguishing between the main file and additional files
2451 in this way seems rather dubious. */
2452 if (objfile
== symfile_objfile
)
2454 (*objfile
->sf
->sym_new_init
) (objfile
);
2457 (*objfile
->sf
->sym_init
) (objfile
);
2458 clear_complaints (&symfile_complaints
, 1, 1);
2460 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2462 /* We are about to read new symbols and potentially also
2463 DWARF information. Some targets may want to pass addresses
2464 read from DWARF DIE's through an adjustment function before
2465 saving them, like MIPS, which may call into
2466 "find_pc_section". When called, that function will make
2467 use of per-objfile program space data.
2469 Since we discarded our section information above, we have
2470 dangling pointers in the per-objfile program space data
2471 structure. Force GDB to update the section mapping
2472 information by letting it know the objfile has changed,
2473 making the dangling pointers point to correct data
2476 objfiles_changed ();
2478 read_symbols (objfile
, 0);
2480 if (!objfile_has_symbols (objfile
))
2483 printf_unfiltered (_("(no debugging symbols found)\n"));
2487 /* We're done reading the symbol file; finish off complaints. */
2488 clear_complaints (&symfile_complaints
, 0, 1);
2490 /* Getting new symbols may change our opinion about what is
2493 reinit_frame_cache ();
2495 /* Discard cleanups as symbol reading was successful. */
2496 objfile_holder
.release ();
2497 discard_cleanups (old_cleanups
);
2499 /* If the mtime has changed between the time we set new_modtime
2500 and now, we *want* this to be out of date, so don't call stat
2502 objfile
->mtime
= new_modtime
;
2503 init_entry_point_info (objfile
);
2505 new_objfiles
.push_back (objfile
);
2509 if (!new_objfiles
.empty ())
2511 clear_symtab_users (0);
2513 /* clear_objfile_data for each objfile was called before freeing it and
2514 gdb::observers::new_objfile.notify (NULL) has been called by
2515 clear_symtab_users above. Notify the new files now. */
2516 for (auto iter
: new_objfiles
)
2517 gdb::observers::new_objfile
.notify (objfile
);
2519 /* At least one objfile has changed, so we can consider that
2520 the executable we're debugging has changed too. */
2521 gdb::observers::executable_changed
.notify ();
2526 struct filename_language
2528 filename_language (const std::string
&ext_
, enum language lang_
)
2529 : ext (ext_
), lang (lang_
)
2536 static std::vector
<filename_language
> filename_language_table
;
2538 /* See symfile.h. */
2541 add_filename_language (const char *ext
, enum language lang
)
2543 filename_language_table
.emplace_back (ext
, lang
);
2546 static char *ext_args
;
2548 show_ext_args (struct ui_file
*file
, int from_tty
,
2549 struct cmd_list_element
*c
, const char *value
)
2551 fprintf_filtered (file
,
2552 _("Mapping between filename extension "
2553 "and source language is \"%s\".\n"),
2558 set_ext_lang_command (const char *args
,
2559 int from_tty
, struct cmd_list_element
*e
)
2561 char *cp
= ext_args
;
2564 /* First arg is filename extension, starting with '.' */
2566 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2568 /* Find end of first arg. */
2569 while (*cp
&& !isspace (*cp
))
2573 error (_("'%s': two arguments required -- "
2574 "filename extension and language"),
2577 /* Null-terminate first arg. */
2580 /* Find beginning of second arg, which should be a source language. */
2581 cp
= skip_spaces (cp
);
2584 error (_("'%s': two arguments required -- "
2585 "filename extension and language"),
2588 /* Lookup the language from among those we know. */
2589 lang
= language_enum (cp
);
2591 auto it
= filename_language_table
.begin ();
2592 /* Now lookup the filename extension: do we already know it? */
2593 for (; it
!= filename_language_table
.end (); it
++)
2595 if (it
->ext
== ext_args
)
2599 if (it
== filename_language_table
.end ())
2601 /* New file extension. */
2602 add_filename_language (ext_args
, lang
);
2606 /* Redefining a previously known filename extension. */
2609 /* query ("Really make files of type %s '%s'?", */
2610 /* ext_args, language_str (lang)); */
2617 info_ext_lang_command (const char *args
, int from_tty
)
2619 printf_filtered (_("Filename extensions and the languages they represent:"));
2620 printf_filtered ("\n\n");
2621 for (const filename_language
&entry
: filename_language_table
)
2622 printf_filtered ("\t%s\t- %s\n", entry
.ext
.c_str (),
2623 language_str (entry
.lang
));
2627 deduce_language_from_filename (const char *filename
)
2631 if (filename
!= NULL
)
2632 if ((cp
= strrchr (filename
, '.')) != NULL
)
2634 for (const filename_language
&entry
: filename_language_table
)
2635 if (entry
.ext
== cp
)
2639 return language_unknown
;
2642 /* Allocate and initialize a new symbol table.
2643 CUST is from the result of allocate_compunit_symtab. */
2646 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
)
2648 struct objfile
*objfile
= cust
->objfile
;
2649 struct symtab
*symtab
2650 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2653 = (const char *) bcache (filename
, strlen (filename
) + 1,
2654 objfile
->per_bfd
->filename_cache
);
2655 symtab
->fullname
= NULL
;
2656 symtab
->language
= deduce_language_from_filename (filename
);
2658 /* This can be very verbose with lots of headers.
2659 Only print at higher debug levels. */
2660 if (symtab_create_debug
>= 2)
2662 /* Be a bit clever with debugging messages, and don't print objfile
2663 every time, only when it changes. */
2664 static char *last_objfile_name
= NULL
;
2666 if (last_objfile_name
== NULL
2667 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
2669 xfree (last_objfile_name
);
2670 last_objfile_name
= xstrdup (objfile_name (objfile
));
2671 fprintf_unfiltered (gdb_stdlog
,
2672 "Creating one or more symtabs for objfile %s ...\n",
2675 fprintf_unfiltered (gdb_stdlog
,
2676 "Created symtab %s for module %s.\n",
2677 host_address_to_string (symtab
), filename
);
2680 /* Add it to CUST's list of symtabs. */
2681 if (cust
->filetabs
== NULL
)
2683 cust
->filetabs
= symtab
;
2684 cust
->last_filetab
= symtab
;
2688 cust
->last_filetab
->next
= symtab
;
2689 cust
->last_filetab
= symtab
;
2692 /* Backlink to the containing compunit symtab. */
2693 symtab
->compunit_symtab
= cust
;
2698 /* Allocate and initialize a new compunit.
2699 NAME is the name of the main source file, if there is one, or some
2700 descriptive text if there are no source files. */
2702 struct compunit_symtab
*
2703 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2705 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2706 struct compunit_symtab
);
2707 const char *saved_name
;
2709 cu
->objfile
= objfile
;
2711 /* The name we record here is only for display/debugging purposes.
2712 Just save the basename to avoid path issues (too long for display,
2713 relative vs absolute, etc.). */
2714 saved_name
= lbasename (name
);
2716 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
, saved_name
,
2717 strlen (saved_name
));
2719 COMPUNIT_DEBUGFORMAT (cu
) = "unknown";
2721 if (symtab_create_debug
)
2723 fprintf_unfiltered (gdb_stdlog
,
2724 "Created compunit symtab %s for %s.\n",
2725 host_address_to_string (cu
),
2732 /* Hook CU to the objfile it comes from. */
2735 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2737 cu
->next
= cu
->objfile
->compunit_symtabs
;
2738 cu
->objfile
->compunit_symtabs
= cu
;
2742 /* Reset all data structures in gdb which may contain references to
2743 symbol table data. */
2746 clear_symtab_users (symfile_add_flags add_flags
)
2748 /* Someday, we should do better than this, by only blowing away
2749 the things that really need to be blown. */
2751 /* Clear the "current" symtab first, because it is no longer valid.
2752 breakpoint_re_set may try to access the current symtab. */
2753 clear_current_source_symtab_and_line ();
2756 clear_last_displayed_sal ();
2757 clear_pc_function_cache ();
2758 gdb::observers::new_objfile
.notify (NULL
);
2760 /* Clear globals which might have pointed into a removed objfile.
2761 FIXME: It's not clear which of these are supposed to persist
2762 between expressions and which ought to be reset each time. */
2763 expression_context_block
= NULL
;
2764 innermost_block
.reset ();
2766 /* Varobj may refer to old symbols, perform a cleanup. */
2767 varobj_invalidate ();
2769 /* Now that the various caches have been cleared, we can re_set
2770 our breakpoints without risking it using stale data. */
2771 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2772 breakpoint_re_set ();
2776 clear_symtab_users_cleanup (void *ignore
)
2778 clear_symtab_users (0);
2782 The following code implements an abstraction for debugging overlay sections.
2784 The target model is as follows:
2785 1) The gnu linker will permit multiple sections to be mapped into the
2786 same VMA, each with its own unique LMA (or load address).
2787 2) It is assumed that some runtime mechanism exists for mapping the
2788 sections, one by one, from the load address into the VMA address.
2789 3) This code provides a mechanism for gdb to keep track of which
2790 sections should be considered to be mapped from the VMA to the LMA.
2791 This information is used for symbol lookup, and memory read/write.
2792 For instance, if a section has been mapped then its contents
2793 should be read from the VMA, otherwise from the LMA.
2795 Two levels of debugger support for overlays are available. One is
2796 "manual", in which the debugger relies on the user to tell it which
2797 overlays are currently mapped. This level of support is
2798 implemented entirely in the core debugger, and the information about
2799 whether a section is mapped is kept in the objfile->obj_section table.
2801 The second level of support is "automatic", and is only available if
2802 the target-specific code provides functionality to read the target's
2803 overlay mapping table, and translate its contents for the debugger
2804 (by updating the mapped state information in the obj_section tables).
2806 The interface is as follows:
2808 overlay map <name> -- tell gdb to consider this section mapped
2809 overlay unmap <name> -- tell gdb to consider this section unmapped
2810 overlay list -- list the sections that GDB thinks are mapped
2811 overlay read-target -- get the target's state of what's mapped
2812 overlay off/manual/auto -- set overlay debugging state
2813 Functional interface:
2814 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2815 section, return that section.
2816 find_pc_overlay(pc): find any overlay section that contains
2817 the pc, either in its VMA or its LMA
2818 section_is_mapped(sect): true if overlay is marked as mapped
2819 section_is_overlay(sect): true if section's VMA != LMA
2820 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2821 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2822 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2823 overlay_mapped_address(...): map an address from section's LMA to VMA
2824 overlay_unmapped_address(...): map an address from section's VMA to LMA
2825 symbol_overlayed_address(...): Return a "current" address for symbol:
2826 either in VMA or LMA depending on whether
2827 the symbol's section is currently mapped. */
2829 /* Overlay debugging state: */
2831 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2832 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2834 /* Function: section_is_overlay (SECTION)
2835 Returns true if SECTION has VMA not equal to LMA, ie.
2836 SECTION is loaded at an address different from where it will "run". */
2839 section_is_overlay (struct obj_section
*section
)
2841 if (overlay_debugging
&& section
)
2843 asection
*bfd_section
= section
->the_bfd_section
;
2845 if (bfd_section_lma (abfd
, bfd_section
) != 0
2846 && bfd_section_lma (abfd
, bfd_section
)
2847 != bfd_section_vma (abfd
, bfd_section
))
2854 /* Function: overlay_invalidate_all (void)
2855 Invalidate the mapped state of all overlay sections (mark it as stale). */
2858 overlay_invalidate_all (void)
2860 struct objfile
*objfile
;
2861 struct obj_section
*sect
;
2863 ALL_OBJSECTIONS (objfile
, sect
)
2864 if (section_is_overlay (sect
))
2865 sect
->ovly_mapped
= -1;
2868 /* Function: section_is_mapped (SECTION)
2869 Returns true if section is an overlay, and is currently mapped.
2871 Access to the ovly_mapped flag is restricted to this function, so
2872 that we can do automatic update. If the global flag
2873 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2874 overlay_invalidate_all. If the mapped state of the particular
2875 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2878 section_is_mapped (struct obj_section
*osect
)
2880 struct gdbarch
*gdbarch
;
2882 if (osect
== 0 || !section_is_overlay (osect
))
2885 switch (overlay_debugging
)
2889 return 0; /* overlay debugging off */
2890 case ovly_auto
: /* overlay debugging automatic */
2891 /* Unles there is a gdbarch_overlay_update function,
2892 there's really nothing useful to do here (can't really go auto). */
2893 gdbarch
= get_objfile_arch (osect
->objfile
);
2894 if (gdbarch_overlay_update_p (gdbarch
))
2896 if (overlay_cache_invalid
)
2898 overlay_invalidate_all ();
2899 overlay_cache_invalid
= 0;
2901 if (osect
->ovly_mapped
== -1)
2902 gdbarch_overlay_update (gdbarch
, osect
);
2905 case ovly_on
: /* overlay debugging manual */
2906 return osect
->ovly_mapped
== 1;
2910 /* Function: pc_in_unmapped_range
2911 If PC falls into the lma range of SECTION, return true, else false. */
2914 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
2916 if (section_is_overlay (section
))
2918 bfd
*abfd
= section
->objfile
->obfd
;
2919 asection
*bfd_section
= section
->the_bfd_section
;
2921 /* We assume the LMA is relocated by the same offset as the VMA. */
2922 bfd_vma size
= bfd_get_section_size (bfd_section
);
2923 CORE_ADDR offset
= obj_section_offset (section
);
2925 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
2926 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
2933 /* Function: pc_in_mapped_range
2934 If PC falls into the vma range of SECTION, return true, else false. */
2937 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
2939 if (section_is_overlay (section
))
2941 if (obj_section_addr (section
) <= pc
2942 && pc
< obj_section_endaddr (section
))
2949 /* Return true if the mapped ranges of sections A and B overlap, false
2953 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
2955 CORE_ADDR a_start
= obj_section_addr (a
);
2956 CORE_ADDR a_end
= obj_section_endaddr (a
);
2957 CORE_ADDR b_start
= obj_section_addr (b
);
2958 CORE_ADDR b_end
= obj_section_endaddr (b
);
2960 return (a_start
< b_end
&& b_start
< a_end
);
2963 /* Function: overlay_unmapped_address (PC, SECTION)
2964 Returns the address corresponding to PC in the unmapped (load) range.
2965 May be the same as PC. */
2968 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
2970 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
2972 asection
*bfd_section
= section
->the_bfd_section
;
2974 return pc
+ bfd_section_lma (abfd
, bfd_section
)
2975 - bfd_section_vma (abfd
, bfd_section
);
2981 /* Function: overlay_mapped_address (PC, SECTION)
2982 Returns the address corresponding to PC in the mapped (runtime) range.
2983 May be the same as PC. */
2986 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
2988 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
2990 asection
*bfd_section
= section
->the_bfd_section
;
2992 return pc
+ bfd_section_vma (abfd
, bfd_section
)
2993 - bfd_section_lma (abfd
, bfd_section
);
2999 /* Function: symbol_overlayed_address
3000 Return one of two addresses (relative to the VMA or to the LMA),
3001 depending on whether the section is mapped or not. */
3004 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3006 if (overlay_debugging
)
3008 /* If the symbol has no section, just return its regular address. */
3011 /* If the symbol's section is not an overlay, just return its
3013 if (!section_is_overlay (section
))
3015 /* If the symbol's section is mapped, just return its address. */
3016 if (section_is_mapped (section
))
3019 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3020 * then return its LOADED address rather than its vma address!!
3022 return overlay_unmapped_address (address
, section
);
3027 /* Function: find_pc_overlay (PC)
3028 Return the best-match overlay section for PC:
3029 If PC matches a mapped overlay section's VMA, return that section.
3030 Else if PC matches an unmapped section's VMA, return that section.
3031 Else if PC matches an unmapped section's LMA, return that section. */
3033 struct obj_section
*
3034 find_pc_overlay (CORE_ADDR pc
)
3036 struct objfile
*objfile
;
3037 struct obj_section
*osect
, *best_match
= NULL
;
3039 if (overlay_debugging
)
3041 ALL_OBJSECTIONS (objfile
, osect
)
3042 if (section_is_overlay (osect
))
3044 if (pc_in_mapped_range (pc
, osect
))
3046 if (section_is_mapped (osect
))
3051 else if (pc_in_unmapped_range (pc
, osect
))
3058 /* Function: find_pc_mapped_section (PC)
3059 If PC falls into the VMA address range of an overlay section that is
3060 currently marked as MAPPED, return that section. Else return NULL. */
3062 struct obj_section
*
3063 find_pc_mapped_section (CORE_ADDR pc
)
3065 struct objfile
*objfile
;
3066 struct obj_section
*osect
;
3068 if (overlay_debugging
)
3070 ALL_OBJSECTIONS (objfile
, osect
)
3071 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3078 /* Function: list_overlays_command
3079 Print a list of mapped sections and their PC ranges. */
3082 list_overlays_command (const char *args
, int from_tty
)
3085 struct objfile
*objfile
;
3086 struct obj_section
*osect
;
3088 if (overlay_debugging
)
3090 ALL_OBJSECTIONS (objfile
, osect
)
3091 if (section_is_mapped (osect
))
3093 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3098 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3099 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3100 size
= bfd_get_section_size (osect
->the_bfd_section
);
3101 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3103 printf_filtered ("Section %s, loaded at ", name
);
3104 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3105 puts_filtered (" - ");
3106 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3107 printf_filtered (", mapped at ");
3108 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3109 puts_filtered (" - ");
3110 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3111 puts_filtered ("\n");
3117 printf_filtered (_("No sections are mapped.\n"));
3120 /* Function: map_overlay_command
3121 Mark the named section as mapped (ie. residing at its VMA address). */
3124 map_overlay_command (const char *args
, int from_tty
)
3126 struct objfile
*objfile
, *objfile2
;
3127 struct obj_section
*sec
, *sec2
;
3129 if (!overlay_debugging
)
3130 error (_("Overlay debugging not enabled. Use "
3131 "either the 'overlay auto' or\n"
3132 "the 'overlay manual' command."));
3134 if (args
== 0 || *args
== 0)
3135 error (_("Argument required: name of an overlay section"));
3137 /* First, find a section matching the user supplied argument. */
3138 ALL_OBJSECTIONS (objfile
, sec
)
3139 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3141 /* Now, check to see if the section is an overlay. */
3142 if (!section_is_overlay (sec
))
3143 continue; /* not an overlay section */
3145 /* Mark the overlay as "mapped". */
3146 sec
->ovly_mapped
= 1;
3148 /* Next, make a pass and unmap any sections that are
3149 overlapped by this new section: */
3150 ALL_OBJSECTIONS (objfile2
, sec2
)
3151 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3154 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3155 bfd_section_name (objfile
->obfd
,
3156 sec2
->the_bfd_section
));
3157 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3161 error (_("No overlay section called %s"), args
);
3164 /* Function: unmap_overlay_command
3165 Mark the overlay section as unmapped
3166 (ie. resident in its LMA address range, rather than the VMA range). */
3169 unmap_overlay_command (const char *args
, int from_tty
)
3171 struct objfile
*objfile
;
3172 struct obj_section
*sec
= NULL
;
3174 if (!overlay_debugging
)
3175 error (_("Overlay debugging not enabled. "
3176 "Use either the 'overlay auto' or\n"
3177 "the 'overlay manual' command."));
3179 if (args
== 0 || *args
== 0)
3180 error (_("Argument required: name of an overlay section"));
3182 /* First, find a section matching the user supplied argument. */
3183 ALL_OBJSECTIONS (objfile
, sec
)
3184 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3186 if (!sec
->ovly_mapped
)
3187 error (_("Section %s is not mapped"), args
);
3188 sec
->ovly_mapped
= 0;
3191 error (_("No overlay section called %s"), args
);
3194 /* Function: overlay_auto_command
3195 A utility command to turn on overlay debugging.
3196 Possibly this should be done via a set/show command. */
3199 overlay_auto_command (const char *args
, int from_tty
)
3201 overlay_debugging
= ovly_auto
;
3202 enable_overlay_breakpoints ();
3204 printf_unfiltered (_("Automatic overlay debugging enabled."));
3207 /* Function: overlay_manual_command
3208 A utility command to turn on overlay debugging.
3209 Possibly this should be done via a set/show command. */
3212 overlay_manual_command (const char *args
, int from_tty
)
3214 overlay_debugging
= ovly_on
;
3215 disable_overlay_breakpoints ();
3217 printf_unfiltered (_("Overlay debugging enabled."));
3220 /* Function: overlay_off_command
3221 A utility command to turn on overlay debugging.
3222 Possibly this should be done via a set/show command. */
3225 overlay_off_command (const char *args
, int from_tty
)
3227 overlay_debugging
= ovly_off
;
3228 disable_overlay_breakpoints ();
3230 printf_unfiltered (_("Overlay debugging disabled."));
3234 overlay_load_command (const char *args
, int from_tty
)
3236 struct gdbarch
*gdbarch
= get_current_arch ();
3238 if (gdbarch_overlay_update_p (gdbarch
))
3239 gdbarch_overlay_update (gdbarch
, NULL
);
3241 error (_("This target does not know how to read its overlay state."));
3244 /* Function: overlay_command
3245 A place-holder for a mis-typed command. */
3247 /* Command list chain containing all defined "overlay" subcommands. */
3248 static struct cmd_list_element
*overlaylist
;
3251 overlay_command (const char *args
, int from_tty
)
3254 ("\"overlay\" must be followed by the name of an overlay command.\n");
3255 help_list (overlaylist
, "overlay ", all_commands
, gdb_stdout
);
3258 /* Target Overlays for the "Simplest" overlay manager:
3260 This is GDB's default target overlay layer. It works with the
3261 minimal overlay manager supplied as an example by Cygnus. The
3262 entry point is via a function pointer "gdbarch_overlay_update",
3263 so targets that use a different runtime overlay manager can
3264 substitute their own overlay_update function and take over the
3267 The overlay_update function pokes around in the target's data structures
3268 to see what overlays are mapped, and updates GDB's overlay mapping with
3271 In this simple implementation, the target data structures are as follows:
3272 unsigned _novlys; /# number of overlay sections #/
3273 unsigned _ovly_table[_novlys][4] = {
3274 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3275 {..., ..., ..., ...},
3277 unsigned _novly_regions; /# number of overlay regions #/
3278 unsigned _ovly_region_table[_novly_regions][3] = {
3279 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3282 These functions will attempt to update GDB's mappedness state in the
3283 symbol section table, based on the target's mappedness state.
3285 To do this, we keep a cached copy of the target's _ovly_table, and
3286 attempt to detect when the cached copy is invalidated. The main
3287 entry point is "simple_overlay_update(SECT), which looks up SECT in
3288 the cached table and re-reads only the entry for that section from
3289 the target (whenever possible). */
3291 /* Cached, dynamically allocated copies of the target data structures: */
3292 static unsigned (*cache_ovly_table
)[4] = 0;
3293 static unsigned cache_novlys
= 0;
3294 static CORE_ADDR cache_ovly_table_base
= 0;
3297 VMA
, OSIZE
, LMA
, MAPPED
3300 /* Throw away the cached copy of _ovly_table. */
3303 simple_free_overlay_table (void)
3305 if (cache_ovly_table
)
3306 xfree (cache_ovly_table
);
3308 cache_ovly_table
= NULL
;
3309 cache_ovly_table_base
= 0;
3312 /* Read an array of ints of size SIZE from the target into a local buffer.
3313 Convert to host order. int LEN is number of ints. */
3316 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3317 int len
, int size
, enum bfd_endian byte_order
)
3319 /* FIXME (alloca): Not safe if array is very large. */
3320 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3323 read_memory (memaddr
, buf
, len
* size
);
3324 for (i
= 0; i
< len
; i
++)
3325 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3328 /* Find and grab a copy of the target _ovly_table
3329 (and _novlys, which is needed for the table's size). */
3332 simple_read_overlay_table (void)
3334 struct bound_minimal_symbol novlys_msym
;
3335 struct bound_minimal_symbol ovly_table_msym
;
3336 struct gdbarch
*gdbarch
;
3338 enum bfd_endian byte_order
;
3340 simple_free_overlay_table ();
3341 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3342 if (! novlys_msym
.minsym
)
3344 error (_("Error reading inferior's overlay table: "
3345 "couldn't find `_novlys' variable\n"
3346 "in inferior. Use `overlay manual' mode."));
3350 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3351 if (! ovly_table_msym
.minsym
)
3353 error (_("Error reading inferior's overlay table: couldn't find "
3354 "`_ovly_table' array\n"
3355 "in inferior. Use `overlay manual' mode."));
3359 gdbarch
= get_objfile_arch (ovly_table_msym
.objfile
);
3360 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3361 byte_order
= gdbarch_byte_order (gdbarch
);
3363 cache_novlys
= read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym
),
3366 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3367 cache_ovly_table_base
= BMSYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3368 read_target_long_array (cache_ovly_table_base
,
3369 (unsigned int *) cache_ovly_table
,
3370 cache_novlys
* 4, word_size
, byte_order
);
3372 return 1; /* SUCCESS */
3375 /* Function: simple_overlay_update_1
3376 A helper function for simple_overlay_update. Assuming a cached copy
3377 of _ovly_table exists, look through it to find an entry whose vma,
3378 lma and size match those of OSECT. Re-read the entry and make sure
3379 it still matches OSECT (else the table may no longer be valid).
3380 Set OSECT's mapped state to match the entry. Return: 1 for
3381 success, 0 for failure. */
3384 simple_overlay_update_1 (struct obj_section
*osect
)
3387 asection
*bsect
= osect
->the_bfd_section
;
3388 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3389 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3390 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3392 for (i
= 0; i
< cache_novlys
; i
++)
3393 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3394 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3396 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3397 (unsigned int *) cache_ovly_table
[i
],
3398 4, word_size
, byte_order
);
3399 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3400 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3402 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3405 else /* Warning! Warning! Target's ovly table has changed! */
3411 /* Function: simple_overlay_update
3412 If OSECT is NULL, then update all sections' mapped state
3413 (after re-reading the entire target _ovly_table).
3414 If OSECT is non-NULL, then try to find a matching entry in the
3415 cached ovly_table and update only OSECT's mapped state.
3416 If a cached entry can't be found or the cache isn't valid, then
3417 re-read the entire cache, and go ahead and update all sections. */
3420 simple_overlay_update (struct obj_section
*osect
)
3422 struct objfile
*objfile
;
3424 /* Were we given an osect to look up? NULL means do all of them. */
3426 /* Have we got a cached copy of the target's overlay table? */
3427 if (cache_ovly_table
!= NULL
)
3429 /* Does its cached location match what's currently in the
3431 struct bound_minimal_symbol minsym
3432 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3434 if (minsym
.minsym
== NULL
)
3435 error (_("Error reading inferior's overlay table: couldn't "
3436 "find `_ovly_table' array\n"
3437 "in inferior. Use `overlay manual' mode."));
3439 if (cache_ovly_table_base
== BMSYMBOL_VALUE_ADDRESS (minsym
))
3440 /* Then go ahead and try to look up this single section in
3442 if (simple_overlay_update_1 (osect
))
3443 /* Found it! We're done. */
3447 /* Cached table no good: need to read the entire table anew.
3448 Or else we want all the sections, in which case it's actually
3449 more efficient to read the whole table in one block anyway. */
3451 if (! simple_read_overlay_table ())
3454 /* Now may as well update all sections, even if only one was requested. */
3455 ALL_OBJSECTIONS (objfile
, osect
)
3456 if (section_is_overlay (osect
))
3459 asection
*bsect
= osect
->the_bfd_section
;
3461 for (i
= 0; i
< cache_novlys
; i
++)
3462 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3463 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3464 { /* obj_section matches i'th entry in ovly_table. */
3465 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3466 break; /* finished with inner for loop: break out. */
3471 /* Set the output sections and output offsets for section SECTP in
3472 ABFD. The relocation code in BFD will read these offsets, so we
3473 need to be sure they're initialized. We map each section to itself,
3474 with no offset; this means that SECTP->vma will be honored. */
3477 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3479 sectp
->output_section
= sectp
;
3480 sectp
->output_offset
= 0;
3483 /* Default implementation for sym_relocate. */
3486 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3489 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3491 bfd
*abfd
= sectp
->owner
;
3493 /* We're only interested in sections with relocation
3495 if ((sectp
->flags
& SEC_RELOC
) == 0)
3498 /* We will handle section offsets properly elsewhere, so relocate as if
3499 all sections begin at 0. */
3500 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3502 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3505 /* Relocate the contents of a debug section SECTP in ABFD. The
3506 contents are stored in BUF if it is non-NULL, or returned in a
3507 malloc'd buffer otherwise.
3509 For some platforms and debug info formats, shared libraries contain
3510 relocations against the debug sections (particularly for DWARF-2;
3511 one affected platform is PowerPC GNU/Linux, although it depends on
3512 the version of the linker in use). Also, ELF object files naturally
3513 have unresolved relocations for their debug sections. We need to apply
3514 the relocations in order to get the locations of symbols correct.
3515 Another example that may require relocation processing, is the
3516 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3520 symfile_relocate_debug_section (struct objfile
*objfile
,
3521 asection
*sectp
, bfd_byte
*buf
)
3523 gdb_assert (objfile
->sf
->sym_relocate
);
3525 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3528 struct symfile_segment_data
*
3529 get_symfile_segment_data (bfd
*abfd
)
3531 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3536 return sf
->sym_segments (abfd
);
3540 free_symfile_segment_data (struct symfile_segment_data
*data
)
3542 xfree (data
->segment_bases
);
3543 xfree (data
->segment_sizes
);
3544 xfree (data
->segment_info
);
3549 - DATA, containing segment addresses from the object file ABFD, and
3550 the mapping from ABFD's sections onto the segments that own them,
3552 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3553 segment addresses reported by the target,
3554 store the appropriate offsets for each section in OFFSETS.
3556 If there are fewer entries in SEGMENT_BASES than there are segments
3557 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3559 If there are more entries, then ignore the extra. The target may
3560 not be able to distinguish between an empty data segment and a
3561 missing data segment; a missing text segment is less plausible. */
3564 symfile_map_offsets_to_segments (bfd
*abfd
,
3565 const struct symfile_segment_data
*data
,
3566 struct section_offsets
*offsets
,
3567 int num_segment_bases
,
3568 const CORE_ADDR
*segment_bases
)
3573 /* It doesn't make sense to call this function unless you have some
3574 segment base addresses. */
3575 gdb_assert (num_segment_bases
> 0);
3577 /* If we do not have segment mappings for the object file, we
3578 can not relocate it by segments. */
3579 gdb_assert (data
!= NULL
);
3580 gdb_assert (data
->num_segments
> 0);
3582 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3584 int which
= data
->segment_info
[i
];
3586 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3588 /* Don't bother computing offsets for sections that aren't
3589 loaded as part of any segment. */
3593 /* Use the last SEGMENT_BASES entry as the address of any extra
3594 segments mentioned in DATA->segment_info. */
3595 if (which
> num_segment_bases
)
3596 which
= num_segment_bases
;
3598 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3599 - data
->segment_bases
[which
- 1]);
3606 symfile_find_segment_sections (struct objfile
*objfile
)
3608 bfd
*abfd
= objfile
->obfd
;
3611 struct symfile_segment_data
*data
;
3613 data
= get_symfile_segment_data (objfile
->obfd
);
3617 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3619 free_symfile_segment_data (data
);
3623 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3625 int which
= data
->segment_info
[i
];
3629 if (objfile
->sect_index_text
== -1)
3630 objfile
->sect_index_text
= sect
->index
;
3632 if (objfile
->sect_index_rodata
== -1)
3633 objfile
->sect_index_rodata
= sect
->index
;
3635 else if (which
== 2)
3637 if (objfile
->sect_index_data
== -1)
3638 objfile
->sect_index_data
= sect
->index
;
3640 if (objfile
->sect_index_bss
== -1)
3641 objfile
->sect_index_bss
= sect
->index
;
3645 free_symfile_segment_data (data
);
3648 /* Listen for free_objfile events. */
3651 symfile_free_objfile (struct objfile
*objfile
)
3653 /* Remove the target sections owned by this objfile. */
3654 if (objfile
!= NULL
)
3655 remove_target_sections ((void *) objfile
);
3658 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3659 Expand all symtabs that match the specified criteria.
3660 See quick_symbol_functions.expand_symtabs_matching for details. */
3663 expand_symtabs_matching
3664 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3665 const lookup_name_info
&lookup_name
,
3666 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3667 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3668 enum search_domain kind
)
3670 struct objfile
*objfile
;
3672 ALL_OBJFILES (objfile
)
3675 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, file_matcher
,
3678 expansion_notify
, kind
);
3682 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3683 Map function FUN over every file.
3684 See quick_symbol_functions.map_symbol_filenames for details. */
3687 map_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
3690 struct objfile
*objfile
;
3692 ALL_OBJFILES (objfile
)
3695 objfile
->sf
->qf
->map_symbol_filenames (objfile
, fun
, data
,
3702 namespace selftests
{
3703 namespace filename_language
{
3705 static void test_filename_language ()
3707 /* This test messes up the filename_language_table global. */
3708 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3710 /* Test deducing an unknown extension. */
3711 language lang
= deduce_language_from_filename ("myfile.blah");
3712 SELF_CHECK (lang
== language_unknown
);
3714 /* Test deducing a known extension. */
3715 lang
= deduce_language_from_filename ("myfile.c");
3716 SELF_CHECK (lang
== language_c
);
3718 /* Test adding a new extension using the internal API. */
3719 add_filename_language (".blah", language_pascal
);
3720 lang
= deduce_language_from_filename ("myfile.blah");
3721 SELF_CHECK (lang
== language_pascal
);
3725 test_set_ext_lang_command ()
3727 /* This test messes up the filename_language_table global. */
3728 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3730 /* Confirm that the .hello extension is not known. */
3731 language lang
= deduce_language_from_filename ("cake.hello");
3732 SELF_CHECK (lang
== language_unknown
);
3734 /* Test adding a new extension using the CLI command. */
3735 gdb::unique_xmalloc_ptr
<char> args_holder (xstrdup (".hello rust"));
3736 ext_args
= args_holder
.get ();
3737 set_ext_lang_command (NULL
, 1, NULL
);
3739 lang
= deduce_language_from_filename ("cake.hello");
3740 SELF_CHECK (lang
== language_rust
);
3742 /* Test overriding an existing extension using the CLI command. */
3743 int size_before
= filename_language_table
.size ();
3744 args_holder
.reset (xstrdup (".hello pascal"));
3745 ext_args
= args_holder
.get ();
3746 set_ext_lang_command (NULL
, 1, NULL
);
3747 int size_after
= filename_language_table
.size ();
3749 lang
= deduce_language_from_filename ("cake.hello");
3750 SELF_CHECK (lang
== language_pascal
);
3751 SELF_CHECK (size_before
== size_after
);
3754 } /* namespace filename_language */
3755 } /* namespace selftests */
3757 #endif /* GDB_SELF_TEST */
3760 _initialize_symfile (void)
3762 struct cmd_list_element
*c
;
3764 gdb::observers::free_objfile
.attach (symfile_free_objfile
);
3766 #define READNOW_READNEVER_HELP \
3767 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3768 immediately. This makes the command slower, but may make future operations\n\
3770 The '-readnever' option will prevent GDB from reading the symbol file's\n\
3771 symbolic debug information."
3773 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3774 Load symbol table from executable file FILE.\n\
3775 Usage: symbol-file [-readnow | -readnever] FILE\n\
3776 The `file' command can also load symbol tables, as well as setting the file\n\
3777 to execute.\n" READNOW_READNEVER_HELP
), &cmdlist
);
3778 set_cmd_completer (c
, filename_completer
);
3780 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3781 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3782 Usage: add-symbol-file FILE ADDR [-readnow | -readnever | \
3783 -s SECT-NAME SECT-ADDR]...\n\
3784 ADDR is the starting address of the file's text.\n\
3785 Each '-s' argument provides a section name and address, and\n\
3786 should be specified if the data and bss segments are not contiguous\n\
3787 with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n"
3788 READNOW_READNEVER_HELP
),
3790 set_cmd_completer (c
, filename_completer
);
3792 c
= add_cmd ("remove-symbol-file", class_files
,
3793 remove_symbol_file_command
, _("\
3794 Remove a symbol file added via the add-symbol-file command.\n\
3795 Usage: remove-symbol-file FILENAME\n\
3796 remove-symbol-file -a ADDRESS\n\
3797 The file to remove can be identified by its filename or by an address\n\
3798 that lies within the boundaries of this symbol file in memory."),
3801 c
= add_cmd ("load", class_files
, load_command
, _("\
3802 Dynamically load FILE into the running program, and record its symbols\n\
3803 for access from GDB.\n\
3804 Usage: load [FILE] [OFFSET]\n\
3805 An optional load OFFSET may also be given as a literal address.\n\
3806 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3807 on its own."), &cmdlist
);
3808 set_cmd_completer (c
, filename_completer
);
3810 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3811 _("Commands for debugging overlays."), &overlaylist
,
3812 "overlay ", 0, &cmdlist
);
3814 add_com_alias ("ovly", "overlay", class_alias
, 1);
3815 add_com_alias ("ov", "overlay", class_alias
, 1);
3817 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3818 _("Assert that an overlay section is mapped."), &overlaylist
);
3820 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3821 _("Assert that an overlay section is unmapped."), &overlaylist
);
3823 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3824 _("List mappings of overlay sections."), &overlaylist
);
3826 add_cmd ("manual", class_support
, overlay_manual_command
,
3827 _("Enable overlay debugging."), &overlaylist
);
3828 add_cmd ("off", class_support
, overlay_off_command
,
3829 _("Disable overlay debugging."), &overlaylist
);
3830 add_cmd ("auto", class_support
, overlay_auto_command
,
3831 _("Enable automatic overlay debugging."), &overlaylist
);
3832 add_cmd ("load-target", class_support
, overlay_load_command
,
3833 _("Read the overlay mapping state from the target."), &overlaylist
);
3835 /* Filename extension to source language lookup table: */
3836 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3838 Set mapping between filename extension and source language."), _("\
3839 Show mapping between filename extension and source language."), _("\
3840 Usage: set extension-language .foo bar"),
3841 set_ext_lang_command
,
3843 &setlist
, &showlist
);
3845 add_info ("extensions", info_ext_lang_command
,
3846 _("All filename extensions associated with a source language."));
3848 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3849 &debug_file_directory
, _("\
3850 Set the directories where separate debug symbols are searched for."), _("\
3851 Show the directories where separate debug symbols are searched for."), _("\
3852 Separate debug symbols are first searched for in the same\n\
3853 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3854 and lastly at the path of the directory of the binary with\n\
3855 each global debug-file-directory component prepended."),
3857 show_debug_file_directory
,
3858 &setlist
, &showlist
);
3860 add_setshow_enum_cmd ("symbol-loading", no_class
,
3861 print_symbol_loading_enums
, &print_symbol_loading
,
3863 Set printing of symbol loading messages."), _("\
3864 Show printing of symbol loading messages."), _("\
3865 off == turn all messages off\n\
3866 brief == print messages for the executable,\n\
3867 and brief messages for shared libraries\n\
3868 full == print messages for the executable,\n\
3869 and messages for each shared library."),
3872 &setprintlist
, &showprintlist
);
3874 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
3875 &separate_debug_file_debug
, _("\
3876 Set printing of separate debug info file search debug."), _("\
3877 Show printing of separate debug info file search debug."), _("\
3878 When on, GDB prints the searched locations while looking for separate debug \
3879 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
3882 selftests::register_test
3883 ("filename_language", selftests::filename_language::test_filename_language
);
3884 selftests::register_test
3885 ("set_ext_lang_command",
3886 selftests::filename_language::test_set_ext_lang_command
);