1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990-2019 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
35 #include "breakpoint.h"
37 #include "complaints.h"
41 #include "filenames.h" /* for DOSish file names */
42 #include "gdb-stabs.h"
43 #include "gdb_obstack.h"
44 #include "completer.h"
47 #include "readline/readline.h"
49 #include "observable.h"
51 #include "parser-defs.h"
58 #include "cli/cli-utils.h"
59 #include "common/byte-vector.h"
61 #include "cli/cli-style.h"
63 #include <sys/types.h>
72 int (*deprecated_ui_load_progress_hook
) (const char *section
,
74 void (*deprecated_show_load_progress
) (const char *section
,
75 unsigned long section_sent
,
76 unsigned long section_size
,
77 unsigned long total_sent
,
78 unsigned long total_size
);
79 void (*deprecated_pre_add_symbol_hook
) (const char *);
80 void (*deprecated_post_add_symbol_hook
) (void);
82 static void clear_symtab_users_cleanup (void *ignore
);
84 /* Global variables owned by this file. */
85 int readnow_symbol_files
; /* Read full symbols immediately. */
86 int readnever_symbol_files
; /* Never read full symbols. */
88 /* Functions this file defines. */
90 static void symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
91 objfile_flags flags
, CORE_ADDR reloff
);
93 static const struct sym_fns
*find_sym_fns (bfd
*);
95 static void overlay_invalidate_all (void);
97 static void simple_free_overlay_table (void);
99 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
102 static int simple_read_overlay_table (void);
104 static int simple_overlay_update_1 (struct obj_section
*);
106 static void symfile_find_segment_sections (struct objfile
*objfile
);
108 /* List of all available sym_fns. On gdb startup, each object file reader
109 calls add_symtab_fns() to register information on each format it is
112 struct registered_sym_fns
114 registered_sym_fns (bfd_flavour sym_flavour_
, const struct sym_fns
*sym_fns_
)
115 : sym_flavour (sym_flavour_
), sym_fns (sym_fns_
)
118 /* BFD flavour that we handle. */
119 enum bfd_flavour sym_flavour
;
121 /* The "vtable" of symbol functions. */
122 const struct sym_fns
*sym_fns
;
125 static std::vector
<registered_sym_fns
> symtab_fns
;
127 /* Values for "set print symbol-loading". */
129 const char print_symbol_loading_off
[] = "off";
130 const char print_symbol_loading_brief
[] = "brief";
131 const char print_symbol_loading_full
[] = "full";
132 static const char *print_symbol_loading_enums
[] =
134 print_symbol_loading_off
,
135 print_symbol_loading_brief
,
136 print_symbol_loading_full
,
139 static const char *print_symbol_loading
= print_symbol_loading_full
;
141 /* If non-zero, shared library symbols will be added automatically
142 when the inferior is created, new libraries are loaded, or when
143 attaching to the inferior. This is almost always what users will
144 want to have happen; but for very large programs, the startup time
145 will be excessive, and so if this is a problem, the user can clear
146 this flag and then add the shared library symbols as needed. Note
147 that there is a potential for confusion, since if the shared
148 library symbols are not loaded, commands like "info fun" will *not*
149 report all the functions that are actually present. */
151 int auto_solib_add
= 1;
154 /* Return non-zero if symbol-loading messages should be printed.
155 FROM_TTY is the standard from_tty argument to gdb commands.
156 If EXEC is non-zero the messages are for the executable.
157 Otherwise, messages are for shared libraries.
158 If FULL is non-zero then the caller is printing a detailed message.
159 E.g., the message includes the shared library name.
160 Otherwise, the caller is printing a brief "summary" message. */
163 print_symbol_loading_p (int from_tty
, int exec
, int full
)
165 if (!from_tty
&& !info_verbose
)
170 /* We don't check FULL for executables, there are few such
171 messages, therefore brief == full. */
172 return print_symbol_loading
!= print_symbol_loading_off
;
175 return print_symbol_loading
== print_symbol_loading_full
;
176 return print_symbol_loading
== print_symbol_loading_brief
;
179 /* True if we are reading a symbol table. */
181 int currently_reading_symtab
= 0;
183 /* Increment currently_reading_symtab and return a cleanup that can be
184 used to decrement it. */
186 scoped_restore_tmpl
<int>
187 increment_reading_symtab (void)
189 gdb_assert (currently_reading_symtab
>= 0);
190 return make_scoped_restore (¤tly_reading_symtab
,
191 currently_reading_symtab
+ 1);
194 /* Remember the lowest-addressed loadable section we've seen.
195 This function is called via bfd_map_over_sections.
197 In case of equal vmas, the section with the largest size becomes the
198 lowest-addressed loadable section.
200 If the vmas and sizes are equal, the last section is considered the
201 lowest-addressed loadable section. */
204 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
206 asection
**lowest
= (asection
**) obj
;
208 if (0 == (bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
)))
211 *lowest
= sect
; /* First loadable section */
212 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
213 *lowest
= sect
; /* A lower loadable section */
214 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
215 && (bfd_section_size (abfd
, (*lowest
))
216 <= bfd_section_size (abfd
, sect
)))
220 /* Build (allocate and populate) a section_addr_info struct from
221 an existing section table. */
224 build_section_addr_info_from_section_table (const struct target_section
*start
,
225 const struct target_section
*end
)
227 const struct target_section
*stp
;
229 section_addr_info sap
;
231 for (stp
= start
; stp
!= end
; stp
++)
233 struct bfd_section
*asect
= stp
->the_bfd_section
;
234 bfd
*abfd
= asect
->owner
;
236 if (bfd_get_section_flags (abfd
, asect
) & (SEC_ALLOC
| SEC_LOAD
)
237 && sap
.size () < end
- start
)
238 sap
.emplace_back (stp
->addr
,
239 bfd_section_name (abfd
, asect
),
240 gdb_bfd_section_index (abfd
, asect
));
246 /* Create a section_addr_info from section offsets in ABFD. */
248 static section_addr_info
249 build_section_addr_info_from_bfd (bfd
*abfd
)
251 struct bfd_section
*sec
;
253 section_addr_info sap
;
254 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
255 if (bfd_get_section_flags (abfd
, sec
) & (SEC_ALLOC
| SEC_LOAD
))
256 sap
.emplace_back (bfd_get_section_vma (abfd
, sec
),
257 bfd_get_section_name (abfd
, sec
),
258 gdb_bfd_section_index (abfd
, sec
));
263 /* Create a section_addr_info from section offsets in OBJFILE. */
266 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
270 /* Before reread_symbols gets rewritten it is not safe to call:
271 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
273 section_addr_info sap
= build_section_addr_info_from_bfd (objfile
->obfd
);
274 for (i
= 0; i
< sap
.size (); i
++)
276 int sectindex
= sap
[i
].sectindex
;
278 sap
[i
].addr
+= objfile
->section_offsets
->offsets
[sectindex
];
283 /* Initialize OBJFILE's sect_index_* members. */
286 init_objfile_sect_indices (struct objfile
*objfile
)
291 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
293 objfile
->sect_index_text
= sect
->index
;
295 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
297 objfile
->sect_index_data
= sect
->index
;
299 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
301 objfile
->sect_index_bss
= sect
->index
;
303 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
305 objfile
->sect_index_rodata
= sect
->index
;
307 /* This is where things get really weird... We MUST have valid
308 indices for the various sect_index_* members or gdb will abort.
309 So if for example, there is no ".text" section, we have to
310 accomodate that. First, check for a file with the standard
311 one or two segments. */
313 symfile_find_segment_sections (objfile
);
315 /* Except when explicitly adding symbol files at some address,
316 section_offsets contains nothing but zeros, so it doesn't matter
317 which slot in section_offsets the individual sect_index_* members
318 index into. So if they are all zero, it is safe to just point
319 all the currently uninitialized indices to the first slot. But
320 beware: if this is the main executable, it may be relocated
321 later, e.g. by the remote qOffsets packet, and then this will
322 be wrong! That's why we try segments first. */
324 for (i
= 0; i
< objfile
->num_sections
; i
++)
326 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
331 if (i
== objfile
->num_sections
)
333 if (objfile
->sect_index_text
== -1)
334 objfile
->sect_index_text
= 0;
335 if (objfile
->sect_index_data
== -1)
336 objfile
->sect_index_data
= 0;
337 if (objfile
->sect_index_bss
== -1)
338 objfile
->sect_index_bss
= 0;
339 if (objfile
->sect_index_rodata
== -1)
340 objfile
->sect_index_rodata
= 0;
344 /* The arguments to place_section. */
346 struct place_section_arg
348 struct section_offsets
*offsets
;
352 /* Find a unique offset to use for loadable section SECT if
353 the user did not provide an offset. */
356 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
358 struct place_section_arg
*arg
= (struct place_section_arg
*) obj
;
359 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
361 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
363 /* We are only interested in allocated sections. */
364 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
367 /* If the user specified an offset, honor it. */
368 if (offsets
[gdb_bfd_section_index (abfd
, sect
)] != 0)
371 /* Otherwise, let's try to find a place for the section. */
372 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
379 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
381 int indx
= cur_sec
->index
;
383 /* We don't need to compare against ourself. */
387 /* We can only conflict with allocated sections. */
388 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
391 /* If the section offset is 0, either the section has not been placed
392 yet, or it was the lowest section placed (in which case LOWEST
393 will be past its end). */
394 if (offsets
[indx
] == 0)
397 /* If this section would overlap us, then we must move up. */
398 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
399 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
401 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
402 start_addr
= (start_addr
+ align
- 1) & -align
;
407 /* Otherwise, we appear to be OK. So far. */
412 offsets
[gdb_bfd_section_index (abfd
, sect
)] = start_addr
;
413 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
416 /* Store section_addr_info as prepared (made relative and with SECTINDEX
417 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
421 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
423 const section_addr_info
&addrs
)
427 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
429 /* Now calculate offsets for section that were specified by the caller. */
430 for (i
= 0; i
< addrs
.size (); i
++)
432 const struct other_sections
*osp
;
435 if (osp
->sectindex
== -1)
438 /* Record all sections in offsets. */
439 /* The section_offsets in the objfile are here filled in using
441 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
445 /* Transform section name S for a name comparison. prelink can split section
446 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
447 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
448 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
449 (`.sbss') section has invalid (increased) virtual address. */
452 addr_section_name (const char *s
)
454 if (strcmp (s
, ".dynbss") == 0)
456 if (strcmp (s
, ".sdynbss") == 0)
462 /* std::sort comparator for addrs_section_sort. Sort entries in
463 ascending order by their (name, sectindex) pair. sectindex makes
464 the sort by name stable. */
467 addrs_section_compar (const struct other_sections
*a
,
468 const struct other_sections
*b
)
472 retval
= strcmp (addr_section_name (a
->name
.c_str ()),
473 addr_section_name (b
->name
.c_str ()));
477 return a
->sectindex
< b
->sectindex
;
480 /* Provide sorted array of pointers to sections of ADDRS. */
482 static std::vector
<const struct other_sections
*>
483 addrs_section_sort (const section_addr_info
&addrs
)
487 std::vector
<const struct other_sections
*> array (addrs
.size ());
488 for (i
= 0; i
< addrs
.size (); i
++)
489 array
[i
] = &addrs
[i
];
491 std::sort (array
.begin (), array
.end (), addrs_section_compar
);
496 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
497 also SECTINDEXes specific to ABFD there. This function can be used to
498 rebase ADDRS to start referencing different BFD than before. */
501 addr_info_make_relative (section_addr_info
*addrs
, bfd
*abfd
)
503 asection
*lower_sect
;
504 CORE_ADDR lower_offset
;
507 /* Find lowest loadable section to be used as starting point for
508 continguous sections. */
510 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
511 if (lower_sect
== NULL
)
513 warning (_("no loadable sections found in added symbol-file %s"),
514 bfd_get_filename (abfd
));
518 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
520 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
521 in ABFD. Section names are not unique - there can be multiple sections of
522 the same name. Also the sections of the same name do not have to be
523 adjacent to each other. Some sections may be present only in one of the
524 files. Even sections present in both files do not have to be in the same
527 Use stable sort by name for the sections in both files. Then linearly
528 scan both lists matching as most of the entries as possible. */
530 std::vector
<const struct other_sections
*> addrs_sorted
531 = addrs_section_sort (*addrs
);
533 section_addr_info abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
534 std::vector
<const struct other_sections
*> abfd_addrs_sorted
535 = addrs_section_sort (abfd_addrs
);
537 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
538 ABFD_ADDRS_SORTED. */
540 std::vector
<const struct other_sections
*>
541 addrs_to_abfd_addrs (addrs
->size (), nullptr);
543 std::vector
<const struct other_sections
*>::iterator abfd_sorted_iter
544 = abfd_addrs_sorted
.begin ();
545 for (const other_sections
*sect
: addrs_sorted
)
547 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
549 while (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
550 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
554 if (abfd_sorted_iter
!= abfd_addrs_sorted
.end ()
555 && strcmp (addr_section_name ((*abfd_sorted_iter
)->name
.c_str ()),
560 /* Make the found item directly addressable from ADDRS. */
561 index_in_addrs
= sect
- addrs
->data ();
562 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
563 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_sorted_iter
;
565 /* Never use the same ABFD entry twice. */
570 /* Calculate offsets for the loadable sections.
571 FIXME! Sections must be in order of increasing loadable section
572 so that contiguous sections can use the lower-offset!!!
574 Adjust offsets if the segments are not contiguous.
575 If the section is contiguous, its offset should be set to
576 the offset of the highest loadable section lower than it
577 (the loadable section directly below it in memory).
578 this_offset = lower_offset = lower_addr - lower_orig_addr */
580 for (i
= 0; i
< addrs
->size (); i
++)
582 const struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
586 /* This is the index used by BFD. */
587 (*addrs
)[i
].sectindex
= sect
->sectindex
;
589 if ((*addrs
)[i
].addr
!= 0)
591 (*addrs
)[i
].addr
-= sect
->addr
;
592 lower_offset
= (*addrs
)[i
].addr
;
595 (*addrs
)[i
].addr
= lower_offset
;
599 /* addr_section_name transformation is not used for SECT_NAME. */
600 const std::string
§_name
= (*addrs
)[i
].name
;
602 /* This section does not exist in ABFD, which is normally
603 unexpected and we want to issue a warning.
605 However, the ELF prelinker does create a few sections which are
606 marked in the main executable as loadable (they are loaded in
607 memory from the DYNAMIC segment) and yet are not present in
608 separate debug info files. This is fine, and should not cause
609 a warning. Shared libraries contain just the section
610 ".gnu.liblist" but it is not marked as loadable there. There is
611 no other way to identify them than by their name as the sections
612 created by prelink have no special flags.
614 For the sections `.bss' and `.sbss' see addr_section_name. */
616 if (!(sect_name
== ".gnu.liblist"
617 || sect_name
== ".gnu.conflict"
618 || (sect_name
== ".bss"
620 && (*addrs
)[i
- 1].name
== ".dynbss"
621 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
622 || (sect_name
== ".sbss"
624 && (*addrs
)[i
- 1].name
== ".sdynbss"
625 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
626 warning (_("section %s not found in %s"), sect_name
.c_str (),
627 bfd_get_filename (abfd
));
629 (*addrs
)[i
].addr
= 0;
630 (*addrs
)[i
].sectindex
= -1;
635 /* Parse the user's idea of an offset for dynamic linking, into our idea
636 of how to represent it for fast symbol reading. This is the default
637 version of the sym_fns.sym_offsets function for symbol readers that
638 don't need to do anything special. It allocates a section_offsets table
639 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
642 default_symfile_offsets (struct objfile
*objfile
,
643 const section_addr_info
&addrs
)
645 objfile
->num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
646 objfile
->section_offsets
= (struct section_offsets
*)
647 obstack_alloc (&objfile
->objfile_obstack
,
648 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
649 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
650 objfile
->num_sections
, addrs
);
652 /* For relocatable files, all loadable sections will start at zero.
653 The zero is meaningless, so try to pick arbitrary addresses such
654 that no loadable sections overlap. This algorithm is quadratic,
655 but the number of sections in a single object file is generally
657 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
659 struct place_section_arg arg
;
660 bfd
*abfd
= objfile
->obfd
;
663 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
664 /* We do not expect this to happen; just skip this step if the
665 relocatable file has a section with an assigned VMA. */
666 if (bfd_section_vma (abfd
, cur_sec
) != 0)
671 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
673 /* Pick non-overlapping offsets for sections the user did not
675 arg
.offsets
= objfile
->section_offsets
;
677 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
679 /* Correctly filling in the section offsets is not quite
680 enough. Relocatable files have two properties that
681 (most) shared objects do not:
683 - Their debug information will contain relocations. Some
684 shared libraries do also, but many do not, so this can not
687 - If there are multiple code sections they will be loaded
688 at different relative addresses in memory than they are
689 in the objfile, since all sections in the file will start
692 Because GDB has very limited ability to map from an
693 address in debug info to the correct code section,
694 it relies on adding SECT_OFF_TEXT to things which might be
695 code. If we clear all the section offsets, and set the
696 section VMAs instead, then symfile_relocate_debug_section
697 will return meaningful debug information pointing at the
700 GDB has too many different data structures for section
701 addresses - a bfd, objfile, and so_list all have section
702 tables, as does exec_ops. Some of these could probably
705 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
706 cur_sec
= cur_sec
->next
)
708 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
711 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
712 exec_set_section_address (bfd_get_filename (abfd
),
714 offsets
[cur_sec
->index
]);
715 offsets
[cur_sec
->index
] = 0;
720 /* Remember the bfd indexes for the .text, .data, .bss and
722 init_objfile_sect_indices (objfile
);
725 /* Divide the file into segments, which are individual relocatable units.
726 This is the default version of the sym_fns.sym_segments function for
727 symbol readers that do not have an explicit representation of segments.
728 It assumes that object files do not have segments, and fully linked
729 files have a single segment. */
731 struct symfile_segment_data
*
732 default_symfile_segments (bfd
*abfd
)
736 struct symfile_segment_data
*data
;
739 /* Relocatable files contain enough information to position each
740 loadable section independently; they should not be relocated
742 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
745 /* Make sure there is at least one loadable section in the file. */
746 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
748 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
756 low
= bfd_get_section_vma (abfd
, sect
);
757 high
= low
+ bfd_get_section_size (sect
);
759 data
= XCNEW (struct symfile_segment_data
);
760 data
->num_segments
= 1;
761 data
->segment_bases
= XCNEW (CORE_ADDR
);
762 data
->segment_sizes
= XCNEW (CORE_ADDR
);
764 num_sections
= bfd_count_sections (abfd
);
765 data
->segment_info
= XCNEWVEC (int, num_sections
);
767 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
771 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
774 vma
= bfd_get_section_vma (abfd
, sect
);
777 if (vma
+ bfd_get_section_size (sect
) > high
)
778 high
= vma
+ bfd_get_section_size (sect
);
780 data
->segment_info
[i
] = 1;
783 data
->segment_bases
[0] = low
;
784 data
->segment_sizes
[0] = high
- low
;
789 /* This is a convenience function to call sym_read for OBJFILE and
790 possibly force the partial symbols to be read. */
793 read_symbols (struct objfile
*objfile
, symfile_add_flags add_flags
)
795 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
796 objfile
->per_bfd
->minsyms_read
= true;
798 /* find_separate_debug_file_in_section should be called only if there is
799 single binary with no existing separate debug info file. */
800 if (!objfile_has_partial_symbols (objfile
)
801 && objfile
->separate_debug_objfile
== NULL
802 && objfile
->separate_debug_objfile_backlink
== NULL
)
804 gdb_bfd_ref_ptr
abfd (find_separate_debug_file_in_section (objfile
));
808 /* find_separate_debug_file_in_section uses the same filename for the
809 virtual section-as-bfd like the bfd filename containing the
810 section. Therefore use also non-canonical name form for the same
811 file containing the section. */
812 symbol_file_add_separate (abfd
.get (),
813 bfd_get_filename (abfd
.get ()),
814 add_flags
| SYMFILE_NOT_FILENAME
, objfile
);
817 if ((add_flags
& SYMFILE_NO_READ
) == 0)
818 require_partial_symbols (objfile
, 0);
821 /* Initialize entry point information for this objfile. */
824 init_entry_point_info (struct objfile
*objfile
)
826 struct entry_info
*ei
= &objfile
->per_bfd
->ei
;
832 /* Save startup file's range of PC addresses to help blockframe.c
833 decide where the bottom of the stack is. */
835 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
837 /* Executable file -- record its entry point so we'll recognize
838 the startup file because it contains the entry point. */
839 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
840 ei
->entry_point_p
= 1;
842 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
843 && bfd_get_start_address (objfile
->obfd
) != 0)
845 /* Some shared libraries may have entry points set and be
846 runnable. There's no clear way to indicate this, so just check
847 for values other than zero. */
848 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
849 ei
->entry_point_p
= 1;
853 /* Examination of non-executable.o files. Short-circuit this stuff. */
854 ei
->entry_point_p
= 0;
857 if (ei
->entry_point_p
)
859 struct obj_section
*osect
;
860 CORE_ADDR entry_point
= ei
->entry_point
;
863 /* Make certain that the address points at real code, and not a
864 function descriptor. */
866 = gdbarch_convert_from_func_ptr_addr (get_objfile_arch (objfile
),
868 current_top_target ());
870 /* Remove any ISA markers, so that this matches entries in the
873 = gdbarch_addr_bits_remove (get_objfile_arch (objfile
), entry_point
);
876 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
878 struct bfd_section
*sect
= osect
->the_bfd_section
;
880 if (entry_point
>= bfd_get_section_vma (objfile
->obfd
, sect
)
881 && entry_point
< (bfd_get_section_vma (objfile
->obfd
, sect
)
882 + bfd_get_section_size (sect
)))
884 ei
->the_bfd_section_index
885 = gdb_bfd_section_index (objfile
->obfd
, sect
);
892 ei
->the_bfd_section_index
= SECT_OFF_TEXT (objfile
);
896 /* Process a symbol file, as either the main file or as a dynamically
899 This function does not set the OBJFILE's entry-point info.
901 OBJFILE is where the symbols are to be read from.
903 ADDRS is the list of section load addresses. If the user has given
904 an 'add-symbol-file' command, then this is the list of offsets and
905 addresses he or she provided as arguments to the command; or, if
906 we're handling a shared library, these are the actual addresses the
907 sections are loaded at, according to the inferior's dynamic linker
908 (as gleaned by GDB's shared library code). We convert each address
909 into an offset from the section VMA's as it appears in the object
910 file, and then call the file's sym_offsets function to convert this
911 into a format-specific offset table --- a `struct section_offsets'.
912 The sectindex field is used to control the ordering of sections
913 with the same name. Upon return, it is updated to contain the
914 correspondig BFD section index, or -1 if the section was not found.
916 ADD_FLAGS encodes verbosity level, whether this is main symbol or
917 an extra symbol file such as dynamically loaded code, and wether
918 breakpoint reset should be deferred. */
921 syms_from_objfile_1 (struct objfile
*objfile
,
922 section_addr_info
*addrs
,
923 symfile_add_flags add_flags
)
925 section_addr_info local_addr
;
926 struct cleanup
*old_chain
;
927 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
929 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
931 if (objfile
->sf
== NULL
)
933 /* No symbols to load, but we still need to make sure
934 that the section_offsets table is allocated. */
935 int num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
936 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_sections
);
938 objfile
->num_sections
= num_sections
;
939 objfile
->section_offsets
940 = (struct section_offsets
*) obstack_alloc (&objfile
->objfile_obstack
,
942 memset (objfile
->section_offsets
, 0, size
);
946 /* Make sure that partially constructed symbol tables will be cleaned up
947 if an error occurs during symbol reading. */
948 old_chain
= make_cleanup (null_cleanup
, NULL
);
949 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
951 /* If ADDRS is NULL, put together a dummy address list.
952 We now establish the convention that an addr of zero means
953 no load address was specified. */
959 /* We will modify the main symbol table, make sure that all its users
960 will be cleaned up if an error occurs during symbol reading. */
961 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
963 /* Since no error yet, throw away the old symbol table. */
965 if (symfile_objfile
!= NULL
)
967 delete symfile_objfile
;
968 gdb_assert (symfile_objfile
== NULL
);
971 /* Currently we keep symbols from the add-symbol-file command.
972 If the user wants to get rid of them, they should do "symbol-file"
973 without arguments first. Not sure this is the best behavior
976 (*objfile
->sf
->sym_new_init
) (objfile
);
979 /* Convert addr into an offset rather than an absolute address.
980 We find the lowest address of a loaded segment in the objfile,
981 and assume that <addr> is where that got loaded.
983 We no longer warn if the lowest section is not a text segment (as
984 happens for the PA64 port. */
985 if (addrs
->size () > 0)
986 addr_info_make_relative (addrs
, objfile
->obfd
);
988 /* Initialize symbol reading routines for this objfile, allow complaints to
989 appear for this new file, and record how verbose to be, then do the
990 initial symbol reading for this file. */
992 (*objfile
->sf
->sym_init
) (objfile
);
995 (*objfile
->sf
->sym_offsets
) (objfile
, *addrs
);
997 read_symbols (objfile
, add_flags
);
999 /* Discard cleanups as symbol reading was successful. */
1001 objfile_holder
.release ();
1002 discard_cleanups (old_chain
);
1005 /* Same as syms_from_objfile_1, but also initializes the objfile
1006 entry-point info. */
1009 syms_from_objfile (struct objfile
*objfile
,
1010 section_addr_info
*addrs
,
1011 symfile_add_flags add_flags
)
1013 syms_from_objfile_1 (objfile
, addrs
, add_flags
);
1014 init_entry_point_info (objfile
);
1017 /* Perform required actions after either reading in the initial
1018 symbols for a new objfile, or mapping in the symbols from a reusable
1019 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1022 finish_new_objfile (struct objfile
*objfile
, symfile_add_flags add_flags
)
1024 /* If this is the main symbol file we have to clean up all users of the
1025 old main symbol file. Otherwise it is sufficient to fixup all the
1026 breakpoints that may have been redefined by this symbol file. */
1027 if (add_flags
& SYMFILE_MAINLINE
)
1029 /* OK, make it the "real" symbol file. */
1030 symfile_objfile
= objfile
;
1032 clear_symtab_users (add_flags
);
1034 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1036 breakpoint_re_set ();
1039 /* We're done reading the symbol file; finish off complaints. */
1040 clear_complaints ();
1043 /* Process a symbol file, as either the main file or as a dynamically
1046 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1047 A new reference is acquired by this function.
1049 For NAME description see the objfile constructor.
1051 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1052 extra, such as dynamically loaded code, and what to do with breakpoins.
1054 ADDRS is as described for syms_from_objfile_1, above.
1055 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1057 PARENT is the original objfile if ABFD is a separate debug info file.
1058 Otherwise PARENT is NULL.
1060 Upon success, returns a pointer to the objfile that was added.
1061 Upon failure, jumps back to command level (never returns). */
1063 static struct objfile
*
1064 symbol_file_add_with_addrs (bfd
*abfd
, const char *name
,
1065 symfile_add_flags add_flags
,
1066 section_addr_info
*addrs
,
1067 objfile_flags flags
, struct objfile
*parent
)
1069 struct objfile
*objfile
;
1070 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1071 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1072 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
1073 && (readnow_symbol_files
1074 || (add_flags
& SYMFILE_NO_READ
) == 0));
1076 if (readnow_symbol_files
)
1078 flags
|= OBJF_READNOW
;
1079 add_flags
&= ~SYMFILE_NO_READ
;
1081 else if (readnever_symbol_files
1082 || (parent
!= NULL
&& (parent
->flags
& OBJF_READNEVER
)))
1084 flags
|= OBJF_READNEVER
;
1085 add_flags
|= SYMFILE_NO_READ
;
1087 if ((add_flags
& SYMFILE_NOT_FILENAME
) != 0)
1088 flags
|= OBJF_NOT_FILENAME
;
1090 /* Give user a chance to burp if we'd be
1091 interactively wiping out any existing symbols. */
1093 if ((have_full_symbols () || have_partial_symbols ())
1096 && !query (_("Load new symbol table from \"%s\"? "), name
))
1097 error (_("Not confirmed."));
1100 flags
|= OBJF_MAINLINE
;
1101 objfile
= new struct objfile (abfd
, name
, flags
);
1104 add_separate_debug_objfile (objfile
, parent
);
1106 /* We either created a new mapped symbol table, mapped an existing
1107 symbol table file which has not had initial symbol reading
1108 performed, or need to read an unmapped symbol table. */
1111 if (deprecated_pre_add_symbol_hook
)
1112 deprecated_pre_add_symbol_hook (name
);
1115 puts_filtered (_("Reading symbols from "));
1116 fputs_styled (name
, file_name_style
.style (), gdb_stdout
);
1117 puts_filtered ("...\n");
1120 syms_from_objfile (objfile
, addrs
, add_flags
);
1122 /* We now have at least a partial symbol table. Check to see if the
1123 user requested that all symbols be read on initial access via either
1124 the gdb startup command line or on a per symbol file basis. Expand
1125 all partial symbol tables for this objfile if so. */
1127 if ((flags
& OBJF_READNOW
))
1130 printf_filtered (_("Expanding full symbols from %s...\n"), name
);
1133 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1136 /* Note that we only print a message if we have no symbols and have
1137 no separate debug file. If there is a separate debug file which
1138 does not have symbols, we'll have emitted this message for that
1139 file, and so printing it twice is just redundant. */
1140 if (should_print
&& !objfile_has_symbols (objfile
)
1141 && objfile
->separate_debug_objfile
== nullptr)
1142 printf_filtered (_("(No debugging symbols found in %s)\n"), name
);
1146 if (deprecated_post_add_symbol_hook
)
1147 deprecated_post_add_symbol_hook ();
1150 /* We print some messages regardless of whether 'from_tty ||
1151 info_verbose' is true, so make sure they go out at the right
1153 gdb_flush (gdb_stdout
);
1155 if (objfile
->sf
== NULL
)
1157 gdb::observers::new_objfile
.notify (objfile
);
1158 return objfile
; /* No symbols. */
1161 finish_new_objfile (objfile
, add_flags
);
1163 gdb::observers::new_objfile
.notify (objfile
);
1165 bfd_cache_close_all ();
1169 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1170 see the objfile constructor. */
1173 symbol_file_add_separate (bfd
*bfd
, const char *name
,
1174 symfile_add_flags symfile_flags
,
1175 struct objfile
*objfile
)
1177 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1178 because sections of BFD may not match sections of OBJFILE and because
1179 vma may have been modified by tools such as prelink. */
1180 section_addr_info sap
= build_section_addr_info_from_objfile (objfile
);
1182 symbol_file_add_with_addrs
1183 (bfd
, name
, symfile_flags
, &sap
,
1184 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1189 /* Process the symbol file ABFD, as either the main file or as a
1190 dynamically loaded file.
1191 See symbol_file_add_with_addrs's comments for details. */
1194 symbol_file_add_from_bfd (bfd
*abfd
, const char *name
,
1195 symfile_add_flags add_flags
,
1196 section_addr_info
*addrs
,
1197 objfile_flags flags
, struct objfile
*parent
)
1199 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1203 /* Process a symbol file, as either the main file or as a dynamically
1204 loaded file. See symbol_file_add_with_addrs's comments for details. */
1207 symbol_file_add (const char *name
, symfile_add_flags add_flags
,
1208 section_addr_info
*addrs
, objfile_flags flags
)
1210 gdb_bfd_ref_ptr
bfd (symfile_bfd_open (name
));
1212 return symbol_file_add_from_bfd (bfd
.get (), name
, add_flags
, addrs
,
1216 /* Call symbol_file_add() with default values and update whatever is
1217 affected by the loading of a new main().
1218 Used when the file is supplied in the gdb command line
1219 and by some targets with special loading requirements.
1220 The auxiliary function, symbol_file_add_main_1(), has the flags
1221 argument for the switches that can only be specified in the symbol_file
1225 symbol_file_add_main (const char *args
, symfile_add_flags add_flags
)
1227 symbol_file_add_main_1 (args
, add_flags
, 0, 0);
1231 symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
1232 objfile_flags flags
, CORE_ADDR reloff
)
1234 add_flags
|= current_inferior ()->symfile_flags
| SYMFILE_MAINLINE
;
1236 struct objfile
*objfile
= symbol_file_add (args
, add_flags
, NULL
, flags
);
1238 objfile_rebase (objfile
, reloff
);
1240 /* Getting new symbols may change our opinion about
1241 what is frameless. */
1242 reinit_frame_cache ();
1244 if ((add_flags
& SYMFILE_NO_READ
) == 0)
1245 set_initial_language ();
1249 symbol_file_clear (int from_tty
)
1251 if ((have_full_symbols () || have_partial_symbols ())
1254 ? !query (_("Discard symbol table from `%s'? "),
1255 objfile_name (symfile_objfile
))
1256 : !query (_("Discard symbol table? "))))
1257 error (_("Not confirmed."));
1259 /* solib descriptors may have handles to objfiles. Wipe them before their
1260 objfiles get stale by free_all_objfiles. */
1261 no_shared_libraries (NULL
, from_tty
);
1263 free_all_objfiles ();
1265 gdb_assert (symfile_objfile
== NULL
);
1267 printf_filtered (_("No symbol file now.\n"));
1270 /* See symfile.h. */
1272 int separate_debug_file_debug
= 0;
1275 separate_debug_file_exists (const std::string
&name
, unsigned long crc
,
1276 struct objfile
*parent_objfile
)
1278 unsigned long file_crc
;
1280 struct stat parent_stat
, abfd_stat
;
1281 int verified_as_different
;
1283 /* Find a separate debug info file as if symbols would be present in
1284 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1285 section can contain just the basename of PARENT_OBJFILE without any
1286 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1287 the separate debug infos with the same basename can exist. */
1289 if (filename_cmp (name
.c_str (), objfile_name (parent_objfile
)) == 0)
1292 if (separate_debug_file_debug
)
1294 printf_filtered (_(" Trying %s..."), name
.c_str ());
1295 gdb_flush (gdb_stdout
);
1298 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (name
.c_str (), gnutarget
, -1));
1302 if (separate_debug_file_debug
)
1303 printf_filtered (_(" no, unable to open.\n"));
1308 /* Verify symlinks were not the cause of filename_cmp name difference above.
1310 Some operating systems, e.g. Windows, do not provide a meaningful
1311 st_ino; they always set it to zero. (Windows does provide a
1312 meaningful st_dev.) Files accessed from gdbservers that do not
1313 support the vFile:fstat packet will also have st_ino set to zero.
1314 Do not indicate a duplicate library in either case. While there
1315 is no guarantee that a system that provides meaningful inode
1316 numbers will never set st_ino to zero, this is merely an
1317 optimization, so we do not need to worry about false negatives. */
1319 if (bfd_stat (abfd
.get (), &abfd_stat
) == 0
1320 && abfd_stat
.st_ino
!= 0
1321 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1323 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1324 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1326 if (separate_debug_file_debug
)
1327 printf_filtered (_(" no, same file as the objfile.\n"));
1331 verified_as_different
= 1;
1334 verified_as_different
= 0;
1336 file_crc_p
= gdb_bfd_crc (abfd
.get (), &file_crc
);
1340 if (separate_debug_file_debug
)
1341 printf_filtered (_(" no, error computing CRC.\n"));
1346 if (crc
!= file_crc
)
1348 unsigned long parent_crc
;
1350 /* If the files could not be verified as different with
1351 bfd_stat then we need to calculate the parent's CRC
1352 to verify whether the files are different or not. */
1354 if (!verified_as_different
)
1356 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1358 if (separate_debug_file_debug
)
1359 printf_filtered (_(" no, error computing CRC.\n"));
1365 if (verified_as_different
|| parent_crc
!= file_crc
)
1366 warning (_("the debug information found in \"%s\""
1367 " does not match \"%s\" (CRC mismatch).\n"),
1368 name
.c_str (), objfile_name (parent_objfile
));
1370 if (separate_debug_file_debug
)
1371 printf_filtered (_(" no, CRC doesn't match.\n"));
1376 if (separate_debug_file_debug
)
1377 printf_filtered (_(" yes!\n"));
1382 char *debug_file_directory
= NULL
;
1384 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1385 struct cmd_list_element
*c
, const char *value
)
1387 fprintf_filtered (file
,
1388 _("The directory where separate debug "
1389 "symbols are searched for is \"%s\".\n"),
1393 #if ! defined (DEBUG_SUBDIRECTORY)
1394 #define DEBUG_SUBDIRECTORY ".debug"
1397 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1398 where the original file resides (may not be the same as
1399 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1400 looking for. CANON_DIR is the "realpath" form of DIR.
1401 DIR must contain a trailing '/'.
1402 Returns the path of the file with separate debug info, or an empty
1406 find_separate_debug_file (const char *dir
,
1407 const char *canon_dir
,
1408 const char *debuglink
,
1409 unsigned long crc32
, struct objfile
*objfile
)
1411 if (separate_debug_file_debug
)
1412 printf_filtered (_("\nLooking for separate debug info (debug link) for "
1413 "%s\n"), objfile_name (objfile
));
1415 /* First try in the same directory as the original file. */
1416 std::string debugfile
= dir
;
1417 debugfile
+= debuglink
;
1419 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1422 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1424 debugfile
+= DEBUG_SUBDIRECTORY
;
1426 debugfile
+= debuglink
;
1428 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1431 /* Then try in the global debugfile directories.
1433 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1434 cause "/..." lookups. */
1436 std::vector
<gdb::unique_xmalloc_ptr
<char>> debugdir_vec
1437 = dirnames_to_char_ptr_vec (debug_file_directory
);
1439 for (const gdb::unique_xmalloc_ptr
<char> &debugdir
: debugdir_vec
)
1441 debugfile
= debugdir
.get ();
1444 debugfile
+= debuglink
;
1446 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1449 /* If the file is in the sysroot, try using its base path in the
1450 global debugfile directory. */
1451 if (canon_dir
!= NULL
1452 && filename_ncmp (canon_dir
, gdb_sysroot
,
1453 strlen (gdb_sysroot
)) == 0
1454 && IS_DIR_SEPARATOR (canon_dir
[strlen (gdb_sysroot
)]))
1456 debugfile
= debugdir
.get ();
1457 debugfile
+= (canon_dir
+ strlen (gdb_sysroot
));
1459 debugfile
+= debuglink
;
1461 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1466 return std::string ();
1469 /* Modify PATH to contain only "[/]directory/" part of PATH.
1470 If there were no directory separators in PATH, PATH will be empty
1471 string on return. */
1474 terminate_after_last_dir_separator (char *path
)
1478 /* Strip off the final filename part, leaving the directory name,
1479 followed by a slash. The directory can be relative or absolute. */
1480 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1481 if (IS_DIR_SEPARATOR (path
[i
]))
1484 /* If I is -1 then no directory is present there and DIR will be "". */
1488 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1489 Returns pathname, or an empty string. */
1492 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1494 unsigned long crc32
;
1496 gdb::unique_xmalloc_ptr
<char> debuglink
1497 (bfd_get_debug_link_info (objfile
->obfd
, &crc32
));
1499 if (debuglink
== NULL
)
1501 /* There's no separate debug info, hence there's no way we could
1502 load it => no warning. */
1503 return std::string ();
1506 std::string dir
= objfile_name (objfile
);
1507 terminate_after_last_dir_separator (&dir
[0]);
1508 gdb::unique_xmalloc_ptr
<char> canon_dir (lrealpath (dir
.c_str ()));
1510 std::string debugfile
1511 = find_separate_debug_file (dir
.c_str (), canon_dir
.get (),
1512 debuglink
.get (), crc32
, objfile
);
1514 if (debugfile
.empty ())
1516 /* For PR gdb/9538, try again with realpath (if different from the
1521 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1522 && S_ISLNK (st_buf
.st_mode
))
1524 gdb::unique_xmalloc_ptr
<char> symlink_dir
1525 (lrealpath (objfile_name (objfile
)));
1526 if (symlink_dir
!= NULL
)
1528 terminate_after_last_dir_separator (symlink_dir
.get ());
1529 if (dir
!= symlink_dir
.get ())
1531 /* Different directory, so try using it. */
1532 debugfile
= find_separate_debug_file (symlink_dir
.get (),
1545 /* Make sure that OBJF_{READNOW,READNEVER} are not set
1549 validate_readnow_readnever (objfile_flags flags
)
1551 if ((flags
& OBJF_READNOW
) && (flags
& OBJF_READNEVER
))
1552 error (_("-readnow and -readnever cannot be used simultaneously"));
1555 /* This is the symbol-file command. Read the file, analyze its
1556 symbols, and add a struct symtab to a symtab list. The syntax of
1557 the command is rather bizarre:
1559 1. The function buildargv implements various quoting conventions
1560 which are undocumented and have little or nothing in common with
1561 the way things are quoted (or not quoted) elsewhere in GDB.
1563 2. Options are used, which are not generally used in GDB (perhaps
1564 "set mapped on", "set readnow on" would be better)
1566 3. The order of options matters, which is contrary to GNU
1567 conventions (because it is confusing and inconvenient). */
1570 symbol_file_command (const char *args
, int from_tty
)
1576 symbol_file_clear (from_tty
);
1580 objfile_flags flags
= OBJF_USERLOADED
;
1581 symfile_add_flags add_flags
= 0;
1583 bool stop_processing_options
= false;
1584 CORE_ADDR offset
= 0;
1589 add_flags
|= SYMFILE_VERBOSE
;
1591 gdb_argv
built_argv (args
);
1592 for (arg
= built_argv
[0], idx
= 0; arg
!= NULL
; arg
= built_argv
[++idx
])
1594 if (stop_processing_options
|| *arg
!= '-')
1599 error (_("Unrecognized argument \"%s\""), arg
);
1601 else if (strcmp (arg
, "-readnow") == 0)
1602 flags
|= OBJF_READNOW
;
1603 else if (strcmp (arg
, "-readnever") == 0)
1604 flags
|= OBJF_READNEVER
;
1605 else if (strcmp (arg
, "-o") == 0)
1607 arg
= built_argv
[++idx
];
1609 error (_("Missing argument to -o"));
1611 offset
= parse_and_eval_address (arg
);
1613 else if (strcmp (arg
, "--") == 0)
1614 stop_processing_options
= true;
1616 error (_("Unrecognized argument \"%s\""), arg
);
1620 error (_("no symbol file name was specified"));
1622 validate_readnow_readnever (flags
);
1624 symbol_file_add_main_1 (name
, add_flags
, flags
, offset
);
1628 /* Set the initial language.
1630 FIXME: A better solution would be to record the language in the
1631 psymtab when reading partial symbols, and then use it (if known) to
1632 set the language. This would be a win for formats that encode the
1633 language in an easily discoverable place, such as DWARF. For
1634 stabs, we can jump through hoops looking for specially named
1635 symbols or try to intuit the language from the specific type of
1636 stabs we find, but we can't do that until later when we read in
1640 set_initial_language (void)
1642 enum language lang
= main_language ();
1644 if (lang
== language_unknown
)
1646 char *name
= main_name ();
1647 struct symbol
*sym
= lookup_symbol (name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
1650 lang
= SYMBOL_LANGUAGE (sym
);
1653 if (lang
== language_unknown
)
1655 /* Make C the default language */
1659 set_language (lang
);
1660 expected_language
= current_language
; /* Don't warn the user. */
1663 /* Open the file specified by NAME and hand it off to BFD for
1664 preliminary analysis. Return a newly initialized bfd *, which
1665 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1666 absolute). In case of trouble, error() is called. */
1669 symfile_bfd_open (const char *name
)
1673 gdb::unique_xmalloc_ptr
<char> absolute_name
;
1674 if (!is_target_filename (name
))
1676 gdb::unique_xmalloc_ptr
<char> expanded_name (tilde_expand (name
));
1678 /* Look down path for it, allocate 2nd new malloc'd copy. */
1679 desc
= openp (getenv ("PATH"),
1680 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1681 expanded_name
.get (), O_RDONLY
| O_BINARY
, &absolute_name
);
1682 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1685 char *exename
= (char *) alloca (strlen (expanded_name
.get ()) + 5);
1687 strcat (strcpy (exename
, expanded_name
.get ()), ".exe");
1688 desc
= openp (getenv ("PATH"),
1689 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1690 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1694 perror_with_name (expanded_name
.get ());
1696 name
= absolute_name
.get ();
1699 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (name
, gnutarget
, desc
));
1700 if (sym_bfd
== NULL
)
1701 error (_("`%s': can't open to read symbols: %s."), name
,
1702 bfd_errmsg (bfd_get_error ()));
1704 if (!gdb_bfd_has_target_filename (sym_bfd
.get ()))
1705 bfd_set_cacheable (sym_bfd
.get (), 1);
1707 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
1708 error (_("`%s': can't read symbols: %s."), name
,
1709 bfd_errmsg (bfd_get_error ()));
1714 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1715 the section was not found. */
1718 get_section_index (struct objfile
*objfile
, const char *section_name
)
1720 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1728 /* Link SF into the global symtab_fns list.
1729 FLAVOUR is the file format that SF handles.
1730 Called on startup by the _initialize routine in each object file format
1731 reader, to register information about each format the reader is prepared
1735 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1737 symtab_fns
.emplace_back (flavour
, sf
);
1740 /* Initialize OBJFILE to read symbols from its associated BFD. It
1741 either returns or calls error(). The result is an initialized
1742 struct sym_fns in the objfile structure, that contains cached
1743 information about the symbol file. */
1745 static const struct sym_fns
*
1746 find_sym_fns (bfd
*abfd
)
1748 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1750 if (our_flavour
== bfd_target_srec_flavour
1751 || our_flavour
== bfd_target_ihex_flavour
1752 || our_flavour
== bfd_target_tekhex_flavour
)
1753 return NULL
; /* No symbols. */
1755 for (const registered_sym_fns
&rsf
: symtab_fns
)
1756 if (our_flavour
== rsf
.sym_flavour
)
1759 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1760 bfd_get_target (abfd
));
1764 /* This function runs the load command of our current target. */
1767 load_command (const char *arg
, int from_tty
)
1771 /* The user might be reloading because the binary has changed. Take
1772 this opportunity to check. */
1773 reopen_exec_file ();
1779 const char *parg
, *prev
;
1781 arg
= get_exec_file (1);
1783 /* We may need to quote this string so buildargv can pull it
1786 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1788 temp
.append (prev
, parg
- prev
);
1790 temp
.push_back ('\\');
1792 /* If we have not copied anything yet, then we didn't see a
1793 character to quote, and we can just leave ARG unchanged. */
1797 arg
= temp
.c_str ();
1801 target_load (arg
, from_tty
);
1803 /* After re-loading the executable, we don't really know which
1804 overlays are mapped any more. */
1805 overlay_cache_invalid
= 1;
1808 /* This version of "load" should be usable for any target. Currently
1809 it is just used for remote targets, not inftarg.c or core files,
1810 on the theory that only in that case is it useful.
1812 Avoiding xmodem and the like seems like a win (a) because we don't have
1813 to worry about finding it, and (b) On VMS, fork() is very slow and so
1814 we don't want to run a subprocess. On the other hand, I'm not sure how
1815 performance compares. */
1817 static int validate_download
= 0;
1819 /* Callback service function for generic_load (bfd_map_over_sections). */
1822 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1824 bfd_size_type
*sum
= (bfd_size_type
*) data
;
1826 *sum
+= bfd_get_section_size (asec
);
1829 /* Opaque data for load_progress. */
1830 struct load_progress_data
1832 /* Cumulative data. */
1833 unsigned long write_count
= 0;
1834 unsigned long data_count
= 0;
1835 bfd_size_type total_size
= 0;
1838 /* Opaque data for load_progress for a single section. */
1839 struct load_progress_section_data
1841 load_progress_section_data (load_progress_data
*cumulative_
,
1842 const char *section_name_
, ULONGEST section_size_
,
1843 CORE_ADDR lma_
, gdb_byte
*buffer_
)
1844 : cumulative (cumulative_
), section_name (section_name_
),
1845 section_size (section_size_
), lma (lma_
), buffer (buffer_
)
1848 struct load_progress_data
*cumulative
;
1850 /* Per-section data. */
1851 const char *section_name
;
1852 ULONGEST section_sent
= 0;
1853 ULONGEST section_size
;
1858 /* Opaque data for load_section_callback. */
1859 struct load_section_data
1861 load_section_data (load_progress_data
*progress_data_
)
1862 : progress_data (progress_data_
)
1865 ~load_section_data ()
1867 for (auto &&request
: requests
)
1869 xfree (request
.data
);
1870 delete ((load_progress_section_data
*) request
.baton
);
1874 CORE_ADDR load_offset
= 0;
1875 struct load_progress_data
*progress_data
;
1876 std::vector
<struct memory_write_request
> requests
;
1879 /* Target write callback routine for progress reporting. */
1882 load_progress (ULONGEST bytes
, void *untyped_arg
)
1884 struct load_progress_section_data
*args
1885 = (struct load_progress_section_data
*) untyped_arg
;
1886 struct load_progress_data
*totals
;
1889 /* Writing padding data. No easy way to get at the cumulative
1890 stats, so just ignore this. */
1893 totals
= args
->cumulative
;
1895 if (bytes
== 0 && args
->section_sent
== 0)
1897 /* The write is just starting. Let the user know we've started
1899 current_uiout
->message ("Loading section %s, size %s lma %s\n",
1901 hex_string (args
->section_size
),
1902 paddress (target_gdbarch (), args
->lma
));
1906 if (validate_download
)
1908 /* Broken memories and broken monitors manifest themselves here
1909 when bring new computers to life. This doubles already slow
1911 /* NOTE: cagney/1999-10-18: A more efficient implementation
1912 might add a verify_memory() method to the target vector and
1913 then use that. remote.c could implement that method using
1914 the ``qCRC'' packet. */
1915 gdb::byte_vector
check (bytes
);
1917 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1918 error (_("Download verify read failed at %s"),
1919 paddress (target_gdbarch (), args
->lma
));
1920 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1921 error (_("Download verify compare failed at %s"),
1922 paddress (target_gdbarch (), args
->lma
));
1924 totals
->data_count
+= bytes
;
1926 args
->buffer
+= bytes
;
1927 totals
->write_count
+= 1;
1928 args
->section_sent
+= bytes
;
1929 if (check_quit_flag ()
1930 || (deprecated_ui_load_progress_hook
!= NULL
1931 && deprecated_ui_load_progress_hook (args
->section_name
,
1932 args
->section_sent
)))
1933 error (_("Canceled the download"));
1935 if (deprecated_show_load_progress
!= NULL
)
1936 deprecated_show_load_progress (args
->section_name
,
1940 totals
->total_size
);
1943 /* Callback service function for generic_load (bfd_map_over_sections). */
1946 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1948 struct load_section_data
*args
= (struct load_section_data
*) data
;
1949 bfd_size_type size
= bfd_get_section_size (asec
);
1950 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1952 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1958 ULONGEST begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1959 ULONGEST end
= begin
+ size
;
1960 gdb_byte
*buffer
= (gdb_byte
*) xmalloc (size
);
1961 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1963 load_progress_section_data
*section_data
1964 = new load_progress_section_data (args
->progress_data
, sect_name
, size
,
1967 args
->requests
.emplace_back (begin
, end
, buffer
, section_data
);
1970 static void print_transfer_performance (struct ui_file
*stream
,
1971 unsigned long data_count
,
1972 unsigned long write_count
,
1973 std::chrono::steady_clock::duration d
);
1976 generic_load (const char *args
, int from_tty
)
1978 struct load_progress_data total_progress
;
1979 struct load_section_data
cbdata (&total_progress
);
1980 struct ui_out
*uiout
= current_uiout
;
1983 error_no_arg (_("file to load"));
1985 gdb_argv
argv (args
);
1987 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
1989 if (argv
[1] != NULL
)
1993 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
1995 /* If the last word was not a valid number then
1996 treat it as a file name with spaces in. */
1997 if (argv
[1] == endptr
)
1998 error (_("Invalid download offset:%s."), argv
[1]);
2000 if (argv
[2] != NULL
)
2001 error (_("Too many parameters."));
2004 /* Open the file for loading. */
2005 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
2006 if (loadfile_bfd
== NULL
)
2007 perror_with_name (filename
.get ());
2009 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
2011 error (_("\"%s\" is not an object file: %s"), filename
.get (),
2012 bfd_errmsg (bfd_get_error ()));
2015 bfd_map_over_sections (loadfile_bfd
.get (), add_section_size_callback
,
2016 (void *) &total_progress
.total_size
);
2018 bfd_map_over_sections (loadfile_bfd
.get (), load_section_callback
, &cbdata
);
2020 using namespace std::chrono
;
2022 steady_clock::time_point start_time
= steady_clock::now ();
2024 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2025 load_progress
) != 0)
2026 error (_("Load failed"));
2028 steady_clock::time_point end_time
= steady_clock::now ();
2030 CORE_ADDR entry
= bfd_get_start_address (loadfile_bfd
.get ());
2031 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2032 uiout
->text ("Start address ");
2033 uiout
->field_fmt ("address", "%s", paddress (target_gdbarch (), entry
));
2034 uiout
->text (", load size ");
2035 uiout
->field_fmt ("load-size", "%lu", total_progress
.data_count
);
2037 regcache_write_pc (get_current_regcache (), entry
);
2039 /* Reset breakpoints, now that we have changed the load image. For
2040 instance, breakpoints may have been set (or reset, by
2041 post_create_inferior) while connected to the target but before we
2042 loaded the program. In that case, the prologue analyzer could
2043 have read instructions from the target to find the right
2044 breakpoint locations. Loading has changed the contents of that
2047 breakpoint_re_set ();
2049 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2050 total_progress
.write_count
,
2051 end_time
- start_time
);
2054 /* Report on STREAM the performance of a memory transfer operation,
2055 such as 'load'. DATA_COUNT is the number of bytes transferred.
2056 WRITE_COUNT is the number of separate write operations, or 0, if
2057 that information is not available. TIME is how long the operation
2061 print_transfer_performance (struct ui_file
*stream
,
2062 unsigned long data_count
,
2063 unsigned long write_count
,
2064 std::chrono::steady_clock::duration time
)
2066 using namespace std::chrono
;
2067 struct ui_out
*uiout
= current_uiout
;
2069 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2071 uiout
->text ("Transfer rate: ");
2072 if (ms
.count () > 0)
2074 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2076 if (uiout
->is_mi_like_p ())
2078 uiout
->field_fmt ("transfer-rate", "%lu", rate
* 8);
2079 uiout
->text (" bits/sec");
2081 else if (rate
< 1024)
2083 uiout
->field_fmt ("transfer-rate", "%lu", rate
);
2084 uiout
->text (" bytes/sec");
2088 uiout
->field_fmt ("transfer-rate", "%lu", rate
/ 1024);
2089 uiout
->text (" KB/sec");
2094 uiout
->field_fmt ("transferred-bits", "%lu", (data_count
* 8));
2095 uiout
->text (" bits in <1 sec");
2097 if (write_count
> 0)
2100 uiout
->field_fmt ("write-rate", "%lu", data_count
/ write_count
);
2101 uiout
->text (" bytes/write");
2103 uiout
->text (".\n");
2106 /* Add an OFFSET to the start address of each section in OBJF, except
2107 sections that were specified in ADDRS. */
2110 set_objfile_default_section_offset (struct objfile
*objf
,
2111 const section_addr_info
&addrs
,
2114 /* Add OFFSET to all sections by default. */
2115 std::vector
<struct section_offsets
> offsets (objf
->num_sections
,
2118 /* Create sorted lists of all sections in ADDRS as well as all
2119 sections in OBJF. */
2121 std::vector
<const struct other_sections
*> addrs_sorted
2122 = addrs_section_sort (addrs
);
2124 section_addr_info objf_addrs
2125 = build_section_addr_info_from_objfile (objf
);
2126 std::vector
<const struct other_sections
*> objf_addrs_sorted
2127 = addrs_section_sort (objf_addrs
);
2129 /* Walk the BFD section list, and if a matching section is found in
2130 ADDRS_SORTED_LIST, set its offset to zero to keep its address
2133 Note that both lists may contain multiple sections with the same
2134 name, and then the sections from ADDRS are matched in BFD order
2135 (thanks to sectindex). */
2137 std::vector
<const struct other_sections
*>::iterator addrs_sorted_iter
2138 = addrs_sorted
.begin ();
2139 for (const other_sections
*objf_sect
: objf_addrs_sorted
)
2141 const char *objf_name
= addr_section_name (objf_sect
->name
.c_str ());
2144 while (cmp
< 0 && addrs_sorted_iter
!= addrs_sorted
.end ())
2146 const struct other_sections
*sect
= *addrs_sorted_iter
;
2147 const char *sect_name
= addr_section_name (sect
->name
.c_str ());
2148 cmp
= strcmp (sect_name
, objf_name
);
2150 ++addrs_sorted_iter
;
2154 offsets
[objf_sect
->sectindex
].offsets
[0] = 0;
2157 /* Apply the new section offsets. */
2158 objfile_relocate (objf
, offsets
.data ());
2161 /* This function allows the addition of incrementally linked object files.
2162 It does not modify any state in the target, only in the debugger. */
2163 /* Note: ezannoni 2000-04-13 This function/command used to have a
2164 special case syntax for the rombug target (Rombug is the boot
2165 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2166 rombug case, the user doesn't need to supply a text address,
2167 instead a call to target_link() (in target.c) would supply the
2168 value to use. We are now discontinuing this type of ad hoc syntax. */
2171 add_symbol_file_command (const char *args
, int from_tty
)
2173 struct gdbarch
*gdbarch
= get_current_arch ();
2174 gdb::unique_xmalloc_ptr
<char> filename
;
2177 struct objfile
*objf
;
2178 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2179 symfile_add_flags add_flags
= 0;
2182 add_flags
|= SYMFILE_VERBOSE
;
2190 std::vector
<sect_opt
> sect_opts
= { { ".text", NULL
} };
2191 bool stop_processing_options
= false;
2192 CORE_ADDR offset
= 0;
2197 error (_("add-symbol-file takes a file name and an address"));
2199 bool seen_addr
= false;
2200 bool seen_offset
= false;
2201 gdb_argv
argv (args
);
2203 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2205 if (stop_processing_options
|| *arg
!= '-')
2207 if (filename
== NULL
)
2209 /* First non-option argument is always the filename. */
2210 filename
.reset (tilde_expand (arg
));
2212 else if (!seen_addr
)
2214 /* The second non-option argument is always the text
2215 address at which to load the program. */
2216 sect_opts
[0].value
= arg
;
2220 error (_("Unrecognized argument \"%s\""), arg
);
2222 else if (strcmp (arg
, "-readnow") == 0)
2223 flags
|= OBJF_READNOW
;
2224 else if (strcmp (arg
, "-readnever") == 0)
2225 flags
|= OBJF_READNEVER
;
2226 else if (strcmp (arg
, "-s") == 0)
2228 if (argv
[argcnt
+ 1] == NULL
)
2229 error (_("Missing section name after \"-s\""));
2230 else if (argv
[argcnt
+ 2] == NULL
)
2231 error (_("Missing section address after \"-s\""));
2233 sect_opt sect
= { argv
[argcnt
+ 1], argv
[argcnt
+ 2] };
2235 sect_opts
.push_back (sect
);
2238 else if (strcmp (arg
, "-o") == 0)
2240 arg
= argv
[++argcnt
];
2242 error (_("Missing argument to -o"));
2244 offset
= parse_and_eval_address (arg
);
2247 else if (strcmp (arg
, "--") == 0)
2248 stop_processing_options
= true;
2250 error (_("Unrecognized argument \"%s\""), arg
);
2253 if (filename
== NULL
)
2254 error (_("You must provide a filename to be loaded."));
2256 validate_readnow_readnever (flags
);
2258 /* Print the prompt for the query below. And save the arguments into
2259 a sect_addr_info structure to be passed around to other
2260 functions. We have to split this up into separate print
2261 statements because hex_string returns a local static
2264 printf_unfiltered (_("add symbol table from file \"%s\""),
2266 section_addr_info section_addrs
;
2267 std::vector
<sect_opt
>::const_iterator it
= sect_opts
.begin ();
2270 for (; it
!= sect_opts
.end (); ++it
)
2273 const char *val
= it
->value
;
2274 const char *sec
= it
->name
;
2276 if (section_addrs
.empty ())
2277 printf_unfiltered (_(" at\n"));
2278 addr
= parse_and_eval_address (val
);
2280 /* Here we store the section offsets in the order they were
2281 entered on the command line. Every array element is
2282 assigned an ascending section index to preserve the above
2283 order over an unstable sorting algorithm. This dummy
2284 index is not used for any other purpose.
2286 section_addrs
.emplace_back (addr
, sec
, section_addrs
.size ());
2287 printf_filtered ("\t%s_addr = %s\n", sec
,
2288 paddress (gdbarch
, addr
));
2290 /* The object's sections are initialized when a
2291 call is made to build_objfile_section_table (objfile).
2292 This happens in reread_symbols.
2293 At this point, we don't know what file type this is,
2294 so we can't determine what section names are valid. */
2297 printf_unfiltered (_("%s offset by %s\n"),
2298 (section_addrs
.empty ()
2299 ? _(" with all sections")
2300 : _("with other sections")),
2301 paddress (gdbarch
, offset
));
2302 else if (section_addrs
.empty ())
2303 printf_unfiltered ("\n");
2305 if (from_tty
&& (!query ("%s", "")))
2306 error (_("Not confirmed."));
2308 objf
= symbol_file_add (filename
.get (), add_flags
, §ion_addrs
,
2312 set_objfile_default_section_offset (objf
, section_addrs
, offset
);
2314 add_target_sections_of_objfile (objf
);
2316 /* Getting new symbols may change our opinion about what is
2318 reinit_frame_cache ();
2322 /* This function removes a symbol file that was added via add-symbol-file. */
2325 remove_symbol_file_command (const char *args
, int from_tty
)
2327 struct objfile
*objf
= NULL
;
2328 struct program_space
*pspace
= current_program_space
;
2333 error (_("remove-symbol-file: no symbol file provided"));
2335 gdb_argv
argv (args
);
2337 if (strcmp (argv
[0], "-a") == 0)
2339 /* Interpret the next argument as an address. */
2342 if (argv
[1] == NULL
)
2343 error (_("Missing address argument"));
2345 if (argv
[2] != NULL
)
2346 error (_("Junk after %s"), argv
[1]);
2348 addr
= parse_and_eval_address (argv
[1]);
2352 if ((objf
->flags
& OBJF_USERLOADED
) != 0
2353 && (objf
->flags
& OBJF_SHARED
) != 0
2354 && objf
->pspace
== pspace
&& is_addr_in_objfile (addr
, objf
))
2358 else if (argv
[0] != NULL
)
2360 /* Interpret the current argument as a file name. */
2362 if (argv
[1] != NULL
)
2363 error (_("Junk after %s"), argv
[0]);
2365 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2369 if ((objf
->flags
& OBJF_USERLOADED
) != 0
2370 && (objf
->flags
& OBJF_SHARED
) != 0
2371 && objf
->pspace
== pspace
2372 && filename_cmp (filename
.get (), objfile_name (objf
)) == 0)
2378 error (_("No symbol file found"));
2381 && !query (_("Remove symbol table from file \"%s\"? "),
2382 objfile_name (objf
)))
2383 error (_("Not confirmed."));
2386 clear_symtab_users (0);
2389 /* Re-read symbols if a symbol-file has changed. */
2392 reread_symbols (void)
2394 struct objfile
*objfile
;
2396 struct stat new_statbuf
;
2398 std::vector
<struct objfile
*> new_objfiles
;
2400 /* With the addition of shared libraries, this should be modified,
2401 the load time should be saved in the partial symbol tables, since
2402 different tables may come from different source files. FIXME.
2403 This routine should then walk down each partial symbol table
2404 and see if the symbol table that it originates from has been changed. */
2406 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2408 if (objfile
->obfd
== NULL
)
2411 /* Separate debug objfiles are handled in the main objfile. */
2412 if (objfile
->separate_debug_objfile_backlink
)
2415 /* If this object is from an archive (what you usually create with
2416 `ar', often called a `static library' on most systems, though
2417 a `shared library' on AIX is also an archive), then you should
2418 stat on the archive name, not member name. */
2419 if (objfile
->obfd
->my_archive
)
2420 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2422 res
= stat (objfile_name (objfile
), &new_statbuf
);
2425 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2426 printf_filtered (_("`%s' has disappeared; keeping its symbols.\n"),
2427 objfile_name (objfile
));
2430 new_modtime
= new_statbuf
.st_mtime
;
2431 if (new_modtime
!= objfile
->mtime
)
2433 struct cleanup
*old_cleanups
;
2434 struct section_offsets
*offsets
;
2437 printf_filtered (_("`%s' has changed; re-reading symbols.\n"),
2438 objfile_name (objfile
));
2440 /* There are various functions like symbol_file_add,
2441 symfile_bfd_open, syms_from_objfile, etc., which might
2442 appear to do what we want. But they have various other
2443 effects which we *don't* want. So we just do stuff
2444 ourselves. We don't worry about mapped files (for one thing,
2445 any mapped file will be out of date). */
2447 /* If we get an error, blow away this objfile (not sure if
2448 that is the correct response for things like shared
2450 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
2452 /* We need to do this whenever any symbols go away. */
2453 old_cleanups
= make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2455 if (exec_bfd
!= NULL
2456 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2457 bfd_get_filename (exec_bfd
)) == 0)
2459 /* Reload EXEC_BFD without asking anything. */
2461 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2464 /* Keep the calls order approx. the same as in free_objfile. */
2466 /* Free the separate debug objfiles. It will be
2467 automatically recreated by sym_read. */
2468 free_objfile_separate_debug (objfile
);
2470 /* Remove any references to this objfile in the global
2472 preserve_values (objfile
);
2474 /* Nuke all the state that we will re-read. Much of the following
2475 code which sets things to NULL really is necessary to tell
2476 other parts of GDB that there is nothing currently there.
2478 Try to keep the freeing order compatible with free_objfile. */
2480 if (objfile
->sf
!= NULL
)
2482 (*objfile
->sf
->sym_finish
) (objfile
);
2485 clear_objfile_data (objfile
);
2487 /* Clean up any state BFD has sitting around. */
2489 gdb_bfd_ref_ptr
obfd (objfile
->obfd
);
2490 char *obfd_filename
;
2492 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2493 /* Open the new BFD before freeing the old one, so that
2494 the filename remains live. */
2495 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
, -1));
2496 objfile
->obfd
= temp
.release ();
2497 if (objfile
->obfd
== NULL
)
2498 error (_("Can't open %s to read symbols."), obfd_filename
);
2501 std::string original_name
= objfile
->original_name
;
2503 /* bfd_openr sets cacheable to true, which is what we want. */
2504 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2505 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2506 bfd_errmsg (bfd_get_error ()));
2508 /* Save the offsets, we will nuke them with the rest of the
2510 num_offsets
= objfile
->num_sections
;
2511 offsets
= ((struct section_offsets
*)
2512 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2513 memcpy (offsets
, objfile
->section_offsets
,
2514 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2516 /* FIXME: Do we have to free a whole linked list, or is this
2518 objfile
->global_psymbols
.clear ();
2519 objfile
->static_psymbols
.clear ();
2521 /* Free the obstacks for non-reusable objfiles. */
2522 psymbol_bcache_free (objfile
->psymbol_cache
);
2523 objfile
->psymbol_cache
= psymbol_bcache_init ();
2525 /* NB: after this call to obstack_free, objfiles_changed
2526 will need to be called (see discussion below). */
2527 obstack_free (&objfile
->objfile_obstack
, 0);
2528 objfile
->sections
= NULL
;
2529 objfile
->compunit_symtabs
= NULL
;
2530 objfile
->psymtabs
= NULL
;
2531 objfile
->psymtabs_addrmap
= NULL
;
2532 objfile
->free_psymtabs
= NULL
;
2533 objfile
->template_symbols
= NULL
;
2534 objfile
->static_links
= NULL
;
2536 /* obstack_init also initializes the obstack so it is
2537 empty. We could use obstack_specify_allocation but
2538 gdb_obstack.h specifies the alloc/dealloc functions. */
2539 obstack_init (&objfile
->objfile_obstack
);
2541 /* set_objfile_per_bfd potentially allocates the per-bfd
2542 data on the objfile's obstack (if sharing data across
2543 multiple users is not possible), so it's important to
2544 do it *after* the obstack has been initialized. */
2545 set_objfile_per_bfd (objfile
);
2547 objfile
->original_name
2548 = (char *) obstack_copy0 (&objfile
->objfile_obstack
,
2549 original_name
.c_str (),
2550 original_name
.size ());
2552 /* Reset the sym_fns pointer. The ELF reader can change it
2553 based on whether .gdb_index is present, and we need it to
2554 start over. PR symtab/15885 */
2555 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
2557 build_objfile_section_table (objfile
);
2558 terminate_minimal_symbol_table (objfile
);
2560 /* We use the same section offsets as from last time. I'm not
2561 sure whether that is always correct for shared libraries. */
2562 objfile
->section_offsets
= (struct section_offsets
*)
2563 obstack_alloc (&objfile
->objfile_obstack
,
2564 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2565 memcpy (objfile
->section_offsets
, offsets
,
2566 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2567 objfile
->num_sections
= num_offsets
;
2569 /* What the hell is sym_new_init for, anyway? The concept of
2570 distinguishing between the main file and additional files
2571 in this way seems rather dubious. */
2572 if (objfile
== symfile_objfile
)
2574 (*objfile
->sf
->sym_new_init
) (objfile
);
2577 (*objfile
->sf
->sym_init
) (objfile
);
2578 clear_complaints ();
2580 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2582 /* We are about to read new symbols and potentially also
2583 DWARF information. Some targets may want to pass addresses
2584 read from DWARF DIE's through an adjustment function before
2585 saving them, like MIPS, which may call into
2586 "find_pc_section". When called, that function will make
2587 use of per-objfile program space data.
2589 Since we discarded our section information above, we have
2590 dangling pointers in the per-objfile program space data
2591 structure. Force GDB to update the section mapping
2592 information by letting it know the objfile has changed,
2593 making the dangling pointers point to correct data
2596 objfiles_changed ();
2598 read_symbols (objfile
, 0);
2600 if (!objfile_has_symbols (objfile
))
2603 printf_filtered (_("(no debugging symbols found)\n"));
2607 /* We're done reading the symbol file; finish off complaints. */
2608 clear_complaints ();
2610 /* Getting new symbols may change our opinion about what is
2613 reinit_frame_cache ();
2615 /* Discard cleanups as symbol reading was successful. */
2616 objfile_holder
.release ();
2617 discard_cleanups (old_cleanups
);
2619 /* If the mtime has changed between the time we set new_modtime
2620 and now, we *want* this to be out of date, so don't call stat
2622 objfile
->mtime
= new_modtime
;
2623 init_entry_point_info (objfile
);
2625 new_objfiles
.push_back (objfile
);
2629 if (!new_objfiles
.empty ())
2631 clear_symtab_users (0);
2633 /* clear_objfile_data for each objfile was called before freeing it and
2634 gdb::observers::new_objfile.notify (NULL) has been called by
2635 clear_symtab_users above. Notify the new files now. */
2636 for (auto iter
: new_objfiles
)
2637 gdb::observers::new_objfile
.notify (iter
);
2639 /* At least one objfile has changed, so we can consider that
2640 the executable we're debugging has changed too. */
2641 gdb::observers::executable_changed
.notify ();
2646 struct filename_language
2648 filename_language (const std::string
&ext_
, enum language lang_
)
2649 : ext (ext_
), lang (lang_
)
2656 static std::vector
<filename_language
> filename_language_table
;
2658 /* See symfile.h. */
2661 add_filename_language (const char *ext
, enum language lang
)
2663 filename_language_table
.emplace_back (ext
, lang
);
2666 static char *ext_args
;
2668 show_ext_args (struct ui_file
*file
, int from_tty
,
2669 struct cmd_list_element
*c
, const char *value
)
2671 fprintf_filtered (file
,
2672 _("Mapping between filename extension "
2673 "and source language is \"%s\".\n"),
2678 set_ext_lang_command (const char *args
,
2679 int from_tty
, struct cmd_list_element
*e
)
2681 char *cp
= ext_args
;
2684 /* First arg is filename extension, starting with '.' */
2686 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2688 /* Find end of first arg. */
2689 while (*cp
&& !isspace (*cp
))
2693 error (_("'%s': two arguments required -- "
2694 "filename extension and language"),
2697 /* Null-terminate first arg. */
2700 /* Find beginning of second arg, which should be a source language. */
2701 cp
= skip_spaces (cp
);
2704 error (_("'%s': two arguments required -- "
2705 "filename extension and language"),
2708 /* Lookup the language from among those we know. */
2709 lang
= language_enum (cp
);
2711 auto it
= filename_language_table
.begin ();
2712 /* Now lookup the filename extension: do we already know it? */
2713 for (; it
!= filename_language_table
.end (); it
++)
2715 if (it
->ext
== ext_args
)
2719 if (it
== filename_language_table
.end ())
2721 /* New file extension. */
2722 add_filename_language (ext_args
, lang
);
2726 /* Redefining a previously known filename extension. */
2729 /* query ("Really make files of type %s '%s'?", */
2730 /* ext_args, language_str (lang)); */
2737 info_ext_lang_command (const char *args
, int from_tty
)
2739 printf_filtered (_("Filename extensions and the languages they represent:"));
2740 printf_filtered ("\n\n");
2741 for (const filename_language
&entry
: filename_language_table
)
2742 printf_filtered ("\t%s\t- %s\n", entry
.ext
.c_str (),
2743 language_str (entry
.lang
));
2747 deduce_language_from_filename (const char *filename
)
2751 if (filename
!= NULL
)
2752 if ((cp
= strrchr (filename
, '.')) != NULL
)
2754 for (const filename_language
&entry
: filename_language_table
)
2755 if (entry
.ext
== cp
)
2759 return language_unknown
;
2762 /* Allocate and initialize a new symbol table.
2763 CUST is from the result of allocate_compunit_symtab. */
2766 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
)
2768 struct objfile
*objfile
= cust
->objfile
;
2769 struct symtab
*symtab
2770 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2773 = (const char *) bcache (filename
, strlen (filename
) + 1,
2774 objfile
->per_bfd
->filename_cache
);
2775 symtab
->fullname
= NULL
;
2776 symtab
->language
= deduce_language_from_filename (filename
);
2778 /* This can be very verbose with lots of headers.
2779 Only print at higher debug levels. */
2780 if (symtab_create_debug
>= 2)
2782 /* Be a bit clever with debugging messages, and don't print objfile
2783 every time, only when it changes. */
2784 static char *last_objfile_name
= NULL
;
2786 if (last_objfile_name
== NULL
2787 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
2789 xfree (last_objfile_name
);
2790 last_objfile_name
= xstrdup (objfile_name (objfile
));
2791 fprintf_filtered (gdb_stdlog
,
2792 "Creating one or more symtabs for objfile %s ...\n",
2795 fprintf_filtered (gdb_stdlog
,
2796 "Created symtab %s for module %s.\n",
2797 host_address_to_string (symtab
), filename
);
2800 /* Add it to CUST's list of symtabs. */
2801 if (cust
->filetabs
== NULL
)
2803 cust
->filetabs
= symtab
;
2804 cust
->last_filetab
= symtab
;
2808 cust
->last_filetab
->next
= symtab
;
2809 cust
->last_filetab
= symtab
;
2812 /* Backlink to the containing compunit symtab. */
2813 symtab
->compunit_symtab
= cust
;
2818 /* Allocate and initialize a new compunit.
2819 NAME is the name of the main source file, if there is one, or some
2820 descriptive text if there are no source files. */
2822 struct compunit_symtab
*
2823 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2825 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2826 struct compunit_symtab
);
2827 const char *saved_name
;
2829 cu
->objfile
= objfile
;
2831 /* The name we record here is only for display/debugging purposes.
2832 Just save the basename to avoid path issues (too long for display,
2833 relative vs absolute, etc.). */
2834 saved_name
= lbasename (name
);
2836 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
, saved_name
,
2837 strlen (saved_name
));
2839 COMPUNIT_DEBUGFORMAT (cu
) = "unknown";
2841 if (symtab_create_debug
)
2843 fprintf_filtered (gdb_stdlog
,
2844 "Created compunit symtab %s for %s.\n",
2845 host_address_to_string (cu
),
2852 /* Hook CU to the objfile it comes from. */
2855 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2857 cu
->next
= cu
->objfile
->compunit_symtabs
;
2858 cu
->objfile
->compunit_symtabs
= cu
;
2862 /* Reset all data structures in gdb which may contain references to
2863 symbol table data. */
2866 clear_symtab_users (symfile_add_flags add_flags
)
2868 /* Someday, we should do better than this, by only blowing away
2869 the things that really need to be blown. */
2871 /* Clear the "current" symtab first, because it is no longer valid.
2872 breakpoint_re_set may try to access the current symtab. */
2873 clear_current_source_symtab_and_line ();
2876 clear_last_displayed_sal ();
2877 clear_pc_function_cache ();
2878 gdb::observers::new_objfile
.notify (NULL
);
2880 /* Clear globals which might have pointed into a removed objfile.
2881 FIXME: It's not clear which of these are supposed to persist
2882 between expressions and which ought to be reset each time. */
2883 expression_context_block
= NULL
;
2884 innermost_block
.reset ();
2886 /* Varobj may refer to old symbols, perform a cleanup. */
2887 varobj_invalidate ();
2889 /* Now that the various caches have been cleared, we can re_set
2890 our breakpoints without risking it using stale data. */
2891 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2892 breakpoint_re_set ();
2896 clear_symtab_users_cleanup (void *ignore
)
2898 clear_symtab_users (0);
2902 The following code implements an abstraction for debugging overlay sections.
2904 The target model is as follows:
2905 1) The gnu linker will permit multiple sections to be mapped into the
2906 same VMA, each with its own unique LMA (or load address).
2907 2) It is assumed that some runtime mechanism exists for mapping the
2908 sections, one by one, from the load address into the VMA address.
2909 3) This code provides a mechanism for gdb to keep track of which
2910 sections should be considered to be mapped from the VMA to the LMA.
2911 This information is used for symbol lookup, and memory read/write.
2912 For instance, if a section has been mapped then its contents
2913 should be read from the VMA, otherwise from the LMA.
2915 Two levels of debugger support for overlays are available. One is
2916 "manual", in which the debugger relies on the user to tell it which
2917 overlays are currently mapped. This level of support is
2918 implemented entirely in the core debugger, and the information about
2919 whether a section is mapped is kept in the objfile->obj_section table.
2921 The second level of support is "automatic", and is only available if
2922 the target-specific code provides functionality to read the target's
2923 overlay mapping table, and translate its contents for the debugger
2924 (by updating the mapped state information in the obj_section tables).
2926 The interface is as follows:
2928 overlay map <name> -- tell gdb to consider this section mapped
2929 overlay unmap <name> -- tell gdb to consider this section unmapped
2930 overlay list -- list the sections that GDB thinks are mapped
2931 overlay read-target -- get the target's state of what's mapped
2932 overlay off/manual/auto -- set overlay debugging state
2933 Functional interface:
2934 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2935 section, return that section.
2936 find_pc_overlay(pc): find any overlay section that contains
2937 the pc, either in its VMA or its LMA
2938 section_is_mapped(sect): true if overlay is marked as mapped
2939 section_is_overlay(sect): true if section's VMA != LMA
2940 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2941 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2942 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2943 overlay_mapped_address(...): map an address from section's LMA to VMA
2944 overlay_unmapped_address(...): map an address from section's VMA to LMA
2945 symbol_overlayed_address(...): Return a "current" address for symbol:
2946 either in VMA or LMA depending on whether
2947 the symbol's section is currently mapped. */
2949 /* Overlay debugging state: */
2951 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2952 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2954 /* Function: section_is_overlay (SECTION)
2955 Returns true if SECTION has VMA not equal to LMA, ie.
2956 SECTION is loaded at an address different from where it will "run". */
2959 section_is_overlay (struct obj_section
*section
)
2961 if (overlay_debugging
&& section
)
2963 asection
*bfd_section
= section
->the_bfd_section
;
2965 if (bfd_section_lma (abfd
, bfd_section
) != 0
2966 && bfd_section_lma (abfd
, bfd_section
)
2967 != bfd_section_vma (abfd
, bfd_section
))
2974 /* Function: overlay_invalidate_all (void)
2975 Invalidate the mapped state of all overlay sections (mark it as stale). */
2978 overlay_invalidate_all (void)
2980 struct objfile
*objfile
;
2981 struct obj_section
*sect
;
2983 ALL_OBJSECTIONS (objfile
, sect
)
2984 if (section_is_overlay (sect
))
2985 sect
->ovly_mapped
= -1;
2988 /* Function: section_is_mapped (SECTION)
2989 Returns true if section is an overlay, and is currently mapped.
2991 Access to the ovly_mapped flag is restricted to this function, so
2992 that we can do automatic update. If the global flag
2993 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2994 overlay_invalidate_all. If the mapped state of the particular
2995 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2998 section_is_mapped (struct obj_section
*osect
)
3000 struct gdbarch
*gdbarch
;
3002 if (osect
== 0 || !section_is_overlay (osect
))
3005 switch (overlay_debugging
)
3009 return 0; /* overlay debugging off */
3010 case ovly_auto
: /* overlay debugging automatic */
3011 /* Unles there is a gdbarch_overlay_update function,
3012 there's really nothing useful to do here (can't really go auto). */
3013 gdbarch
= get_objfile_arch (osect
->objfile
);
3014 if (gdbarch_overlay_update_p (gdbarch
))
3016 if (overlay_cache_invalid
)
3018 overlay_invalidate_all ();
3019 overlay_cache_invalid
= 0;
3021 if (osect
->ovly_mapped
== -1)
3022 gdbarch_overlay_update (gdbarch
, osect
);
3025 case ovly_on
: /* overlay debugging manual */
3026 return osect
->ovly_mapped
== 1;
3030 /* Function: pc_in_unmapped_range
3031 If PC falls into the lma range of SECTION, return true, else false. */
3034 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3036 if (section_is_overlay (section
))
3038 bfd
*abfd
= section
->objfile
->obfd
;
3039 asection
*bfd_section
= section
->the_bfd_section
;
3041 /* We assume the LMA is relocated by the same offset as the VMA. */
3042 bfd_vma size
= bfd_get_section_size (bfd_section
);
3043 CORE_ADDR offset
= obj_section_offset (section
);
3045 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3046 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3053 /* Function: pc_in_mapped_range
3054 If PC falls into the vma range of SECTION, return true, else false. */
3057 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3059 if (section_is_overlay (section
))
3061 if (obj_section_addr (section
) <= pc
3062 && pc
< obj_section_endaddr (section
))
3069 /* Return true if the mapped ranges of sections A and B overlap, false
3073 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3075 CORE_ADDR a_start
= obj_section_addr (a
);
3076 CORE_ADDR a_end
= obj_section_endaddr (a
);
3077 CORE_ADDR b_start
= obj_section_addr (b
);
3078 CORE_ADDR b_end
= obj_section_endaddr (b
);
3080 return (a_start
< b_end
&& b_start
< a_end
);
3083 /* Function: overlay_unmapped_address (PC, SECTION)
3084 Returns the address corresponding to PC in the unmapped (load) range.
3085 May be the same as PC. */
3088 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3090 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3092 asection
*bfd_section
= section
->the_bfd_section
;
3094 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3095 - bfd_section_vma (abfd
, bfd_section
);
3101 /* Function: overlay_mapped_address (PC, SECTION)
3102 Returns the address corresponding to PC in the mapped (runtime) range.
3103 May be the same as PC. */
3106 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3108 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3110 asection
*bfd_section
= section
->the_bfd_section
;
3112 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3113 - bfd_section_lma (abfd
, bfd_section
);
3119 /* Function: symbol_overlayed_address
3120 Return one of two addresses (relative to the VMA or to the LMA),
3121 depending on whether the section is mapped or not. */
3124 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3126 if (overlay_debugging
)
3128 /* If the symbol has no section, just return its regular address. */
3131 /* If the symbol's section is not an overlay, just return its
3133 if (!section_is_overlay (section
))
3135 /* If the symbol's section is mapped, just return its address. */
3136 if (section_is_mapped (section
))
3139 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3140 * then return its LOADED address rather than its vma address!!
3142 return overlay_unmapped_address (address
, section
);
3147 /* Function: find_pc_overlay (PC)
3148 Return the best-match overlay section for PC:
3149 If PC matches a mapped overlay section's VMA, return that section.
3150 Else if PC matches an unmapped section's VMA, return that section.
3151 Else if PC matches an unmapped section's LMA, return that section. */
3153 struct obj_section
*
3154 find_pc_overlay (CORE_ADDR pc
)
3156 struct objfile
*objfile
;
3157 struct obj_section
*osect
, *best_match
= NULL
;
3159 if (overlay_debugging
)
3161 ALL_OBJSECTIONS (objfile
, osect
)
3162 if (section_is_overlay (osect
))
3164 if (pc_in_mapped_range (pc
, osect
))
3166 if (section_is_mapped (osect
))
3171 else if (pc_in_unmapped_range (pc
, osect
))
3178 /* Function: find_pc_mapped_section (PC)
3179 If PC falls into the VMA address range of an overlay section that is
3180 currently marked as MAPPED, return that section. Else return NULL. */
3182 struct obj_section
*
3183 find_pc_mapped_section (CORE_ADDR pc
)
3185 struct objfile
*objfile
;
3186 struct obj_section
*osect
;
3188 if (overlay_debugging
)
3190 ALL_OBJSECTIONS (objfile
, osect
)
3191 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3198 /* Function: list_overlays_command
3199 Print a list of mapped sections and their PC ranges. */
3202 list_overlays_command (const char *args
, int from_tty
)
3205 struct objfile
*objfile
;
3206 struct obj_section
*osect
;
3208 if (overlay_debugging
)
3210 ALL_OBJSECTIONS (objfile
, osect
)
3211 if (section_is_mapped (osect
))
3213 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3218 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3219 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3220 size
= bfd_get_section_size (osect
->the_bfd_section
);
3221 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3223 printf_filtered ("Section %s, loaded at ", name
);
3224 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3225 puts_filtered (" - ");
3226 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3227 printf_filtered (", mapped at ");
3228 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3229 puts_filtered (" - ");
3230 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3231 puts_filtered ("\n");
3237 printf_filtered (_("No sections are mapped.\n"));
3240 /* Function: map_overlay_command
3241 Mark the named section as mapped (ie. residing at its VMA address). */
3244 map_overlay_command (const char *args
, int from_tty
)
3246 struct objfile
*objfile
, *objfile2
;
3247 struct obj_section
*sec
, *sec2
;
3249 if (!overlay_debugging
)
3250 error (_("Overlay debugging not enabled. Use "
3251 "either the 'overlay auto' or\n"
3252 "the 'overlay manual' command."));
3254 if (args
== 0 || *args
== 0)
3255 error (_("Argument required: name of an overlay section"));
3257 /* First, find a section matching the user supplied argument. */
3258 ALL_OBJSECTIONS (objfile
, sec
)
3259 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3261 /* Now, check to see if the section is an overlay. */
3262 if (!section_is_overlay (sec
))
3263 continue; /* not an overlay section */
3265 /* Mark the overlay as "mapped". */
3266 sec
->ovly_mapped
= 1;
3268 /* Next, make a pass and unmap any sections that are
3269 overlapped by this new section: */
3270 ALL_OBJSECTIONS (objfile2
, sec2
)
3271 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3274 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3275 bfd_section_name (objfile
->obfd
,
3276 sec2
->the_bfd_section
));
3277 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3281 error (_("No overlay section called %s"), args
);
3284 /* Function: unmap_overlay_command
3285 Mark the overlay section as unmapped
3286 (ie. resident in its LMA address range, rather than the VMA range). */
3289 unmap_overlay_command (const char *args
, int from_tty
)
3291 struct objfile
*objfile
;
3292 struct obj_section
*sec
= NULL
;
3294 if (!overlay_debugging
)
3295 error (_("Overlay debugging not enabled. "
3296 "Use either the 'overlay auto' or\n"
3297 "the 'overlay manual' command."));
3299 if (args
== 0 || *args
== 0)
3300 error (_("Argument required: name of an overlay section"));
3302 /* First, find a section matching the user supplied argument. */
3303 ALL_OBJSECTIONS (objfile
, sec
)
3304 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3306 if (!sec
->ovly_mapped
)
3307 error (_("Section %s is not mapped"), args
);
3308 sec
->ovly_mapped
= 0;
3311 error (_("No overlay section called %s"), args
);
3314 /* Function: overlay_auto_command
3315 A utility command to turn on overlay debugging.
3316 Possibly this should be done via a set/show command. */
3319 overlay_auto_command (const char *args
, int from_tty
)
3321 overlay_debugging
= ovly_auto
;
3322 enable_overlay_breakpoints ();
3324 printf_unfiltered (_("Automatic overlay debugging enabled."));
3327 /* Function: overlay_manual_command
3328 A utility command to turn on overlay debugging.
3329 Possibly this should be done via a set/show command. */
3332 overlay_manual_command (const char *args
, int from_tty
)
3334 overlay_debugging
= ovly_on
;
3335 disable_overlay_breakpoints ();
3337 printf_unfiltered (_("Overlay debugging enabled."));
3340 /* Function: overlay_off_command
3341 A utility command to turn on overlay debugging.
3342 Possibly this should be done via a set/show command. */
3345 overlay_off_command (const char *args
, int from_tty
)
3347 overlay_debugging
= ovly_off
;
3348 disable_overlay_breakpoints ();
3350 printf_unfiltered (_("Overlay debugging disabled."));
3354 overlay_load_command (const char *args
, int from_tty
)
3356 struct gdbarch
*gdbarch
= get_current_arch ();
3358 if (gdbarch_overlay_update_p (gdbarch
))
3359 gdbarch_overlay_update (gdbarch
, NULL
);
3361 error (_("This target does not know how to read its overlay state."));
3364 /* Function: overlay_command
3365 A place-holder for a mis-typed command. */
3367 /* Command list chain containing all defined "overlay" subcommands. */
3368 static struct cmd_list_element
*overlaylist
;
3371 overlay_command (const char *args
, int from_tty
)
3374 ("\"overlay\" must be followed by the name of an overlay command.\n");
3375 help_list (overlaylist
, "overlay ", all_commands
, gdb_stdout
);
3378 /* Target Overlays for the "Simplest" overlay manager:
3380 This is GDB's default target overlay layer. It works with the
3381 minimal overlay manager supplied as an example by Cygnus. The
3382 entry point is via a function pointer "gdbarch_overlay_update",
3383 so targets that use a different runtime overlay manager can
3384 substitute their own overlay_update function and take over the
3387 The overlay_update function pokes around in the target's data structures
3388 to see what overlays are mapped, and updates GDB's overlay mapping with
3391 In this simple implementation, the target data structures are as follows:
3392 unsigned _novlys; /# number of overlay sections #/
3393 unsigned _ovly_table[_novlys][4] = {
3394 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3395 {..., ..., ..., ...},
3397 unsigned _novly_regions; /# number of overlay regions #/
3398 unsigned _ovly_region_table[_novly_regions][3] = {
3399 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3402 These functions will attempt to update GDB's mappedness state in the
3403 symbol section table, based on the target's mappedness state.
3405 To do this, we keep a cached copy of the target's _ovly_table, and
3406 attempt to detect when the cached copy is invalidated. The main
3407 entry point is "simple_overlay_update(SECT), which looks up SECT in
3408 the cached table and re-reads only the entry for that section from
3409 the target (whenever possible). */
3411 /* Cached, dynamically allocated copies of the target data structures: */
3412 static unsigned (*cache_ovly_table
)[4] = 0;
3413 static unsigned cache_novlys
= 0;
3414 static CORE_ADDR cache_ovly_table_base
= 0;
3417 VMA
, OSIZE
, LMA
, MAPPED
3420 /* Throw away the cached copy of _ovly_table. */
3423 simple_free_overlay_table (void)
3425 if (cache_ovly_table
)
3426 xfree (cache_ovly_table
);
3428 cache_ovly_table
= NULL
;
3429 cache_ovly_table_base
= 0;
3432 /* Read an array of ints of size SIZE from the target into a local buffer.
3433 Convert to host order. int LEN is number of ints. */
3436 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3437 int len
, int size
, enum bfd_endian byte_order
)
3439 /* FIXME (alloca): Not safe if array is very large. */
3440 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3443 read_memory (memaddr
, buf
, len
* size
);
3444 for (i
= 0; i
< len
; i
++)
3445 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3448 /* Find and grab a copy of the target _ovly_table
3449 (and _novlys, which is needed for the table's size). */
3452 simple_read_overlay_table (void)
3454 struct bound_minimal_symbol novlys_msym
;
3455 struct bound_minimal_symbol ovly_table_msym
;
3456 struct gdbarch
*gdbarch
;
3458 enum bfd_endian byte_order
;
3460 simple_free_overlay_table ();
3461 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3462 if (! novlys_msym
.minsym
)
3464 error (_("Error reading inferior's overlay table: "
3465 "couldn't find `_novlys' variable\n"
3466 "in inferior. Use `overlay manual' mode."));
3470 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3471 if (! ovly_table_msym
.minsym
)
3473 error (_("Error reading inferior's overlay table: couldn't find "
3474 "`_ovly_table' array\n"
3475 "in inferior. Use `overlay manual' mode."));
3479 gdbarch
= get_objfile_arch (ovly_table_msym
.objfile
);
3480 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3481 byte_order
= gdbarch_byte_order (gdbarch
);
3483 cache_novlys
= read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym
),
3486 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3487 cache_ovly_table_base
= BMSYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3488 read_target_long_array (cache_ovly_table_base
,
3489 (unsigned int *) cache_ovly_table
,
3490 cache_novlys
* 4, word_size
, byte_order
);
3492 return 1; /* SUCCESS */
3495 /* Function: simple_overlay_update_1
3496 A helper function for simple_overlay_update. Assuming a cached copy
3497 of _ovly_table exists, look through it to find an entry whose vma,
3498 lma and size match those of OSECT. Re-read the entry and make sure
3499 it still matches OSECT (else the table may no longer be valid).
3500 Set OSECT's mapped state to match the entry. Return: 1 for
3501 success, 0 for failure. */
3504 simple_overlay_update_1 (struct obj_section
*osect
)
3507 asection
*bsect
= osect
->the_bfd_section
;
3508 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3509 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3510 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3512 for (i
= 0; i
< cache_novlys
; i
++)
3513 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3514 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3516 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3517 (unsigned int *) cache_ovly_table
[i
],
3518 4, word_size
, byte_order
);
3519 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3520 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3522 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3525 else /* Warning! Warning! Target's ovly table has changed! */
3531 /* Function: simple_overlay_update
3532 If OSECT is NULL, then update all sections' mapped state
3533 (after re-reading the entire target _ovly_table).
3534 If OSECT is non-NULL, then try to find a matching entry in the
3535 cached ovly_table and update only OSECT's mapped state.
3536 If a cached entry can't be found or the cache isn't valid, then
3537 re-read the entire cache, and go ahead and update all sections. */
3540 simple_overlay_update (struct obj_section
*osect
)
3542 struct objfile
*objfile
;
3544 /* Were we given an osect to look up? NULL means do all of them. */
3546 /* Have we got a cached copy of the target's overlay table? */
3547 if (cache_ovly_table
!= NULL
)
3549 /* Does its cached location match what's currently in the
3551 struct bound_minimal_symbol minsym
3552 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3554 if (minsym
.minsym
== NULL
)
3555 error (_("Error reading inferior's overlay table: couldn't "
3556 "find `_ovly_table' array\n"
3557 "in inferior. Use `overlay manual' mode."));
3559 if (cache_ovly_table_base
== BMSYMBOL_VALUE_ADDRESS (minsym
))
3560 /* Then go ahead and try to look up this single section in
3562 if (simple_overlay_update_1 (osect
))
3563 /* Found it! We're done. */
3567 /* Cached table no good: need to read the entire table anew.
3568 Or else we want all the sections, in which case it's actually
3569 more efficient to read the whole table in one block anyway. */
3571 if (! simple_read_overlay_table ())
3574 /* Now may as well update all sections, even if only one was requested. */
3575 ALL_OBJSECTIONS (objfile
, osect
)
3576 if (section_is_overlay (osect
))
3579 asection
*bsect
= osect
->the_bfd_section
;
3581 for (i
= 0; i
< cache_novlys
; i
++)
3582 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3583 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3584 { /* obj_section matches i'th entry in ovly_table. */
3585 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3586 break; /* finished with inner for loop: break out. */
3591 /* Set the output sections and output offsets for section SECTP in
3592 ABFD. The relocation code in BFD will read these offsets, so we
3593 need to be sure they're initialized. We map each section to itself,
3594 with no offset; this means that SECTP->vma will be honored. */
3597 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3599 sectp
->output_section
= sectp
;
3600 sectp
->output_offset
= 0;
3603 /* Default implementation for sym_relocate. */
3606 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3609 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3611 bfd
*abfd
= sectp
->owner
;
3613 /* We're only interested in sections with relocation
3615 if ((sectp
->flags
& SEC_RELOC
) == 0)
3618 /* We will handle section offsets properly elsewhere, so relocate as if
3619 all sections begin at 0. */
3620 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3622 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3625 /* Relocate the contents of a debug section SECTP in ABFD. The
3626 contents are stored in BUF if it is non-NULL, or returned in a
3627 malloc'd buffer otherwise.
3629 For some platforms and debug info formats, shared libraries contain
3630 relocations against the debug sections (particularly for DWARF-2;
3631 one affected platform is PowerPC GNU/Linux, although it depends on
3632 the version of the linker in use). Also, ELF object files naturally
3633 have unresolved relocations for their debug sections. We need to apply
3634 the relocations in order to get the locations of symbols correct.
3635 Another example that may require relocation processing, is the
3636 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3640 symfile_relocate_debug_section (struct objfile
*objfile
,
3641 asection
*sectp
, bfd_byte
*buf
)
3643 gdb_assert (objfile
->sf
->sym_relocate
);
3645 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3648 struct symfile_segment_data
*
3649 get_symfile_segment_data (bfd
*abfd
)
3651 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3656 return sf
->sym_segments (abfd
);
3660 free_symfile_segment_data (struct symfile_segment_data
*data
)
3662 xfree (data
->segment_bases
);
3663 xfree (data
->segment_sizes
);
3664 xfree (data
->segment_info
);
3669 - DATA, containing segment addresses from the object file ABFD, and
3670 the mapping from ABFD's sections onto the segments that own them,
3672 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3673 segment addresses reported by the target,
3674 store the appropriate offsets for each section in OFFSETS.
3676 If there are fewer entries in SEGMENT_BASES than there are segments
3677 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3679 If there are more entries, then ignore the extra. The target may
3680 not be able to distinguish between an empty data segment and a
3681 missing data segment; a missing text segment is less plausible. */
3684 symfile_map_offsets_to_segments (bfd
*abfd
,
3685 const struct symfile_segment_data
*data
,
3686 struct section_offsets
*offsets
,
3687 int num_segment_bases
,
3688 const CORE_ADDR
*segment_bases
)
3693 /* It doesn't make sense to call this function unless you have some
3694 segment base addresses. */
3695 gdb_assert (num_segment_bases
> 0);
3697 /* If we do not have segment mappings for the object file, we
3698 can not relocate it by segments. */
3699 gdb_assert (data
!= NULL
);
3700 gdb_assert (data
->num_segments
> 0);
3702 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3704 int which
= data
->segment_info
[i
];
3706 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3708 /* Don't bother computing offsets for sections that aren't
3709 loaded as part of any segment. */
3713 /* Use the last SEGMENT_BASES entry as the address of any extra
3714 segments mentioned in DATA->segment_info. */
3715 if (which
> num_segment_bases
)
3716 which
= num_segment_bases
;
3718 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3719 - data
->segment_bases
[which
- 1]);
3726 symfile_find_segment_sections (struct objfile
*objfile
)
3728 bfd
*abfd
= objfile
->obfd
;
3731 struct symfile_segment_data
*data
;
3733 data
= get_symfile_segment_data (objfile
->obfd
);
3737 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3739 free_symfile_segment_data (data
);
3743 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3745 int which
= data
->segment_info
[i
];
3749 if (objfile
->sect_index_text
== -1)
3750 objfile
->sect_index_text
= sect
->index
;
3752 if (objfile
->sect_index_rodata
== -1)
3753 objfile
->sect_index_rodata
= sect
->index
;
3755 else if (which
== 2)
3757 if (objfile
->sect_index_data
== -1)
3758 objfile
->sect_index_data
= sect
->index
;
3760 if (objfile
->sect_index_bss
== -1)
3761 objfile
->sect_index_bss
= sect
->index
;
3765 free_symfile_segment_data (data
);
3768 /* Listen for free_objfile events. */
3771 symfile_free_objfile (struct objfile
*objfile
)
3773 /* Remove the target sections owned by this objfile. */
3774 if (objfile
!= NULL
)
3775 remove_target_sections ((void *) objfile
);
3778 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3779 Expand all symtabs that match the specified criteria.
3780 See quick_symbol_functions.expand_symtabs_matching for details. */
3783 expand_symtabs_matching
3784 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3785 const lookup_name_info
&lookup_name
,
3786 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3787 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3788 enum search_domain kind
)
3790 struct objfile
*objfile
;
3792 ALL_OBJFILES (objfile
)
3795 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, file_matcher
,
3798 expansion_notify
, kind
);
3802 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3803 Map function FUN over every file.
3804 See quick_symbol_functions.map_symbol_filenames for details. */
3807 map_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
3810 struct objfile
*objfile
;
3812 ALL_OBJFILES (objfile
)
3815 objfile
->sf
->qf
->map_symbol_filenames (objfile
, fun
, data
,
3822 namespace selftests
{
3823 namespace filename_language
{
3825 static void test_filename_language ()
3827 /* This test messes up the filename_language_table global. */
3828 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3830 /* Test deducing an unknown extension. */
3831 language lang
= deduce_language_from_filename ("myfile.blah");
3832 SELF_CHECK (lang
== language_unknown
);
3834 /* Test deducing a known extension. */
3835 lang
= deduce_language_from_filename ("myfile.c");
3836 SELF_CHECK (lang
== language_c
);
3838 /* Test adding a new extension using the internal API. */
3839 add_filename_language (".blah", language_pascal
);
3840 lang
= deduce_language_from_filename ("myfile.blah");
3841 SELF_CHECK (lang
== language_pascal
);
3845 test_set_ext_lang_command ()
3847 /* This test messes up the filename_language_table global. */
3848 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3850 /* Confirm that the .hello extension is not known. */
3851 language lang
= deduce_language_from_filename ("cake.hello");
3852 SELF_CHECK (lang
== language_unknown
);
3854 /* Test adding a new extension using the CLI command. */
3855 gdb::unique_xmalloc_ptr
<char> args_holder (xstrdup (".hello rust"));
3856 ext_args
= args_holder
.get ();
3857 set_ext_lang_command (NULL
, 1, NULL
);
3859 lang
= deduce_language_from_filename ("cake.hello");
3860 SELF_CHECK (lang
== language_rust
);
3862 /* Test overriding an existing extension using the CLI command. */
3863 int size_before
= filename_language_table
.size ();
3864 args_holder
.reset (xstrdup (".hello pascal"));
3865 ext_args
= args_holder
.get ();
3866 set_ext_lang_command (NULL
, 1, NULL
);
3867 int size_after
= filename_language_table
.size ();
3869 lang
= deduce_language_from_filename ("cake.hello");
3870 SELF_CHECK (lang
== language_pascal
);
3871 SELF_CHECK (size_before
== size_after
);
3874 } /* namespace filename_language */
3875 } /* namespace selftests */
3877 #endif /* GDB_SELF_TEST */
3880 _initialize_symfile (void)
3882 struct cmd_list_element
*c
;
3884 gdb::observers::free_objfile
.attach (symfile_free_objfile
);
3886 #define READNOW_READNEVER_HELP \
3887 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3888 immediately. This makes the command slower, but may make future operations\n\
3890 The '-readnever' option will prevent GDB from reading the symbol file's\n\
3891 symbolic debug information."
3893 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3894 Load symbol table from executable file FILE.\n\
3895 Usage: symbol-file [-readnow | -readnever] [-o OFF] FILE\n\
3896 OFF is an optional offset which is added to each section address.\n\
3897 The `file' command can also load symbol tables, as well as setting the file\n\
3898 to execute.\n" READNOW_READNEVER_HELP
), &cmdlist
);
3899 set_cmd_completer (c
, filename_completer
);
3901 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3902 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3903 Usage: add-symbol-file FILE [-readnow | -readnever] [-o OFF] [ADDR] \
3904 [-s SECT-NAME SECT-ADDR]...\n\
3905 ADDR is the starting address of the file's text.\n\
3906 Each '-s' argument provides a section name and address, and\n\
3907 should be specified if the data and bss segments are not contiguous\n\
3908 with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n\
3909 OFF is an optional offset which is added to the default load addresses\n\
3910 of all sections for which no other address was specified.\n"
3911 READNOW_READNEVER_HELP
),
3913 set_cmd_completer (c
, filename_completer
);
3915 c
= add_cmd ("remove-symbol-file", class_files
,
3916 remove_symbol_file_command
, _("\
3917 Remove a symbol file added via the add-symbol-file command.\n\
3918 Usage: remove-symbol-file FILENAME\n\
3919 remove-symbol-file -a ADDRESS\n\
3920 The file to remove can be identified by its filename or by an address\n\
3921 that lies within the boundaries of this symbol file in memory."),
3924 c
= add_cmd ("load", class_files
, load_command
, _("\
3925 Dynamically load FILE into the running program, and record its symbols\n\
3926 for access from GDB.\n\
3927 Usage: load [FILE] [OFFSET]\n\
3928 An optional load OFFSET may also be given as a literal address.\n\
3929 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3930 on its own."), &cmdlist
);
3931 set_cmd_completer (c
, filename_completer
);
3933 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3934 _("Commands for debugging overlays."), &overlaylist
,
3935 "overlay ", 0, &cmdlist
);
3937 add_com_alias ("ovly", "overlay", class_alias
, 1);
3938 add_com_alias ("ov", "overlay", class_alias
, 1);
3940 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3941 _("Assert that an overlay section is mapped."), &overlaylist
);
3943 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3944 _("Assert that an overlay section is unmapped."), &overlaylist
);
3946 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3947 _("List mappings of overlay sections."), &overlaylist
);
3949 add_cmd ("manual", class_support
, overlay_manual_command
,
3950 _("Enable overlay debugging."), &overlaylist
);
3951 add_cmd ("off", class_support
, overlay_off_command
,
3952 _("Disable overlay debugging."), &overlaylist
);
3953 add_cmd ("auto", class_support
, overlay_auto_command
,
3954 _("Enable automatic overlay debugging."), &overlaylist
);
3955 add_cmd ("load-target", class_support
, overlay_load_command
,
3956 _("Read the overlay mapping state from the target."), &overlaylist
);
3958 /* Filename extension to source language lookup table: */
3959 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3961 Set mapping between filename extension and source language."), _("\
3962 Show mapping between filename extension and source language."), _("\
3963 Usage: set extension-language .foo bar"),
3964 set_ext_lang_command
,
3966 &setlist
, &showlist
);
3968 add_info ("extensions", info_ext_lang_command
,
3969 _("All filename extensions associated with a source language."));
3971 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3972 &debug_file_directory
, _("\
3973 Set the directories where separate debug symbols are searched for."), _("\
3974 Show the directories where separate debug symbols are searched for."), _("\
3975 Separate debug symbols are first searched for in the same\n\
3976 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3977 and lastly at the path of the directory of the binary with\n\
3978 each global debug-file-directory component prepended."),
3980 show_debug_file_directory
,
3981 &setlist
, &showlist
);
3983 add_setshow_enum_cmd ("symbol-loading", no_class
,
3984 print_symbol_loading_enums
, &print_symbol_loading
,
3986 Set printing of symbol loading messages."), _("\
3987 Show printing of symbol loading messages."), _("\
3988 off == turn all messages off\n\
3989 brief == print messages for the executable,\n\
3990 and brief messages for shared libraries\n\
3991 full == print messages for the executable,\n\
3992 and messages for each shared library."),
3995 &setprintlist
, &showprintlist
);
3997 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
3998 &separate_debug_file_debug
, _("\
3999 Set printing of separate debug info file search debug."), _("\
4000 Show printing of separate debug info file search debug."), _("\
4001 When on, GDB prints the searched locations while looking for separate debug \
4002 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
4005 selftests::register_test
4006 ("filename_language", selftests::filename_language::test_filename_language
);
4007 selftests::register_test
4008 ("set_ext_lang_command",
4009 selftests::filename_language::test_set_ext_lang_command
);