1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990-2017 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"
51 #include "parser-defs.h"
58 #include "cli/cli-utils.h"
59 #include "common/byte-vector.h"
62 #include <sys/types.h>
70 int (*deprecated_ui_load_progress_hook
) (const char *section
,
72 void (*deprecated_show_load_progress
) (const char *section
,
73 unsigned long section_sent
,
74 unsigned long section_size
,
75 unsigned long total_sent
,
76 unsigned long total_size
);
77 void (*deprecated_pre_add_symbol_hook
) (const char *);
78 void (*deprecated_post_add_symbol_hook
) (void);
80 static void clear_symtab_users_cleanup (void *ignore
);
82 /* Global variables owned by this file. */
83 int readnow_symbol_files
; /* Read full symbols immediately. */
85 /* Functions this file defines. */
87 static void symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
90 static const struct sym_fns
*find_sym_fns (bfd
*);
92 static void overlay_invalidate_all (void);
94 static void simple_free_overlay_table (void);
96 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
99 static int simple_read_overlay_table (void);
101 static int simple_overlay_update_1 (struct obj_section
*);
103 static void symfile_find_segment_sections (struct objfile
*objfile
);
105 /* List of all available sym_fns. On gdb startup, each object file reader
106 calls add_symtab_fns() to register information on each format it is
109 struct registered_sym_fns
111 registered_sym_fns (bfd_flavour sym_flavour_
, const struct sym_fns
*sym_fns_
)
112 : sym_flavour (sym_flavour_
), sym_fns (sym_fns_
)
115 /* BFD flavour that we handle. */
116 enum bfd_flavour sym_flavour
;
118 /* The "vtable" of symbol functions. */
119 const struct sym_fns
*sym_fns
;
122 static std::vector
<registered_sym_fns
> symtab_fns
;
124 /* Values for "set print symbol-loading". */
126 const char print_symbol_loading_off
[] = "off";
127 const char print_symbol_loading_brief
[] = "brief";
128 const char print_symbol_loading_full
[] = "full";
129 static const char *print_symbol_loading_enums
[] =
131 print_symbol_loading_off
,
132 print_symbol_loading_brief
,
133 print_symbol_loading_full
,
136 static const char *print_symbol_loading
= print_symbol_loading_full
;
138 /* If non-zero, shared library symbols will be added automatically
139 when the inferior is created, new libraries are loaded, or when
140 attaching to the inferior. This is almost always what users will
141 want to have happen; but for very large programs, the startup time
142 will be excessive, and so if this is a problem, the user can clear
143 this flag and then add the shared library symbols as needed. Note
144 that there is a potential for confusion, since if the shared
145 library symbols are not loaded, commands like "info fun" will *not*
146 report all the functions that are actually present. */
148 int auto_solib_add
= 1;
151 /* Return non-zero if symbol-loading messages should be printed.
152 FROM_TTY is the standard from_tty argument to gdb commands.
153 If EXEC is non-zero the messages are for the executable.
154 Otherwise, messages are for shared libraries.
155 If FULL is non-zero then the caller is printing a detailed message.
156 E.g., the message includes the shared library name.
157 Otherwise, the caller is printing a brief "summary" message. */
160 print_symbol_loading_p (int from_tty
, int exec
, int full
)
162 if (!from_tty
&& !info_verbose
)
167 /* We don't check FULL for executables, there are few such
168 messages, therefore brief == full. */
169 return print_symbol_loading
!= print_symbol_loading_off
;
172 return print_symbol_loading
== print_symbol_loading_full
;
173 return print_symbol_loading
== print_symbol_loading_brief
;
176 /* True if we are reading a symbol table. */
178 int currently_reading_symtab
= 0;
180 /* Increment currently_reading_symtab and return a cleanup that can be
181 used to decrement it. */
183 scoped_restore_tmpl
<int>
184 increment_reading_symtab (void)
186 gdb_assert (currently_reading_symtab
>= 0);
187 return make_scoped_restore (¤tly_reading_symtab
,
188 currently_reading_symtab
+ 1);
191 /* Remember the lowest-addressed loadable section we've seen.
192 This function is called via bfd_map_over_sections.
194 In case of equal vmas, the section with the largest size becomes the
195 lowest-addressed loadable section.
197 If the vmas and sizes are equal, the last section is considered the
198 lowest-addressed loadable section. */
201 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
203 asection
**lowest
= (asection
**) obj
;
205 if (0 == (bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
)))
208 *lowest
= sect
; /* First loadable section */
209 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
210 *lowest
= sect
; /* A lower loadable section */
211 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
212 && (bfd_section_size (abfd
, (*lowest
))
213 <= bfd_section_size (abfd
, sect
)))
217 /* Create a new section_addr_info, with room for NUM_SECTIONS. The
218 new object's 'num_sections' field is set to 0; it must be updated
221 struct section_addr_info
*
222 alloc_section_addr_info (size_t num_sections
)
224 struct section_addr_info
*sap
;
227 size
= (sizeof (struct section_addr_info
)
228 + sizeof (struct other_sections
) * (num_sections
- 1));
229 sap
= (struct section_addr_info
*) xmalloc (size
);
230 memset (sap
, 0, size
);
235 /* Build (allocate and populate) a section_addr_info struct from
236 an existing section table. */
238 extern struct section_addr_info
*
239 build_section_addr_info_from_section_table (const struct target_section
*start
,
240 const struct target_section
*end
)
242 struct section_addr_info
*sap
;
243 const struct target_section
*stp
;
246 sap
= alloc_section_addr_info (end
- start
);
248 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
250 struct bfd_section
*asect
= stp
->the_bfd_section
;
251 bfd
*abfd
= asect
->owner
;
253 if (bfd_get_section_flags (abfd
, asect
) & (SEC_ALLOC
| SEC_LOAD
)
254 && oidx
< end
- start
)
256 sap
->other
[oidx
].addr
= stp
->addr
;
257 sap
->other
[oidx
].name
= xstrdup (bfd_section_name (abfd
, asect
));
258 sap
->other
[oidx
].sectindex
= gdb_bfd_section_index (abfd
, asect
);
263 sap
->num_sections
= oidx
;
268 /* Create a section_addr_info from section offsets in ABFD. */
270 static struct section_addr_info
*
271 build_section_addr_info_from_bfd (bfd
*abfd
)
273 struct section_addr_info
*sap
;
275 struct bfd_section
*sec
;
277 sap
= alloc_section_addr_info (bfd_count_sections (abfd
));
278 for (i
= 0, sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
279 if (bfd_get_section_flags (abfd
, sec
) & (SEC_ALLOC
| SEC_LOAD
))
281 sap
->other
[i
].addr
= bfd_get_section_vma (abfd
, sec
);
282 sap
->other
[i
].name
= xstrdup (bfd_get_section_name (abfd
, sec
));
283 sap
->other
[i
].sectindex
= gdb_bfd_section_index (abfd
, sec
);
287 sap
->num_sections
= i
;
292 /* Create a section_addr_info from section offsets in OBJFILE. */
294 struct section_addr_info
*
295 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
297 struct section_addr_info
*sap
;
300 /* Before reread_symbols gets rewritten it is not safe to call:
301 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
303 sap
= build_section_addr_info_from_bfd (objfile
->obfd
);
304 for (i
= 0; i
< sap
->num_sections
; i
++)
306 int sectindex
= sap
->other
[i
].sectindex
;
308 sap
->other
[i
].addr
+= objfile
->section_offsets
->offsets
[sectindex
];
313 /* Free all memory allocated by build_section_addr_info_from_section_table. */
316 free_section_addr_info (struct section_addr_info
*sap
)
320 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
321 xfree (sap
->other
[idx
].name
);
325 /* Initialize OBJFILE's sect_index_* members. */
328 init_objfile_sect_indices (struct objfile
*objfile
)
333 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
335 objfile
->sect_index_text
= sect
->index
;
337 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
339 objfile
->sect_index_data
= sect
->index
;
341 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
343 objfile
->sect_index_bss
= sect
->index
;
345 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
347 objfile
->sect_index_rodata
= sect
->index
;
349 /* This is where things get really weird... We MUST have valid
350 indices for the various sect_index_* members or gdb will abort.
351 So if for example, there is no ".text" section, we have to
352 accomodate that. First, check for a file with the standard
353 one or two segments. */
355 symfile_find_segment_sections (objfile
);
357 /* Except when explicitly adding symbol files at some address,
358 section_offsets contains nothing but zeros, so it doesn't matter
359 which slot in section_offsets the individual sect_index_* members
360 index into. So if they are all zero, it is safe to just point
361 all the currently uninitialized indices to the first slot. But
362 beware: if this is the main executable, it may be relocated
363 later, e.g. by the remote qOffsets packet, and then this will
364 be wrong! That's why we try segments first. */
366 for (i
= 0; i
< objfile
->num_sections
; i
++)
368 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
373 if (i
== objfile
->num_sections
)
375 if (objfile
->sect_index_text
== -1)
376 objfile
->sect_index_text
= 0;
377 if (objfile
->sect_index_data
== -1)
378 objfile
->sect_index_data
= 0;
379 if (objfile
->sect_index_bss
== -1)
380 objfile
->sect_index_bss
= 0;
381 if (objfile
->sect_index_rodata
== -1)
382 objfile
->sect_index_rodata
= 0;
386 /* The arguments to place_section. */
388 struct place_section_arg
390 struct section_offsets
*offsets
;
394 /* Find a unique offset to use for loadable section SECT if
395 the user did not provide an offset. */
398 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
400 struct place_section_arg
*arg
= (struct place_section_arg
*) obj
;
401 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
403 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
405 /* We are only interested in allocated sections. */
406 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
409 /* If the user specified an offset, honor it. */
410 if (offsets
[gdb_bfd_section_index (abfd
, sect
)] != 0)
413 /* Otherwise, let's try to find a place for the section. */
414 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
421 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
423 int indx
= cur_sec
->index
;
425 /* We don't need to compare against ourself. */
429 /* We can only conflict with allocated sections. */
430 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
433 /* If the section offset is 0, either the section has not been placed
434 yet, or it was the lowest section placed (in which case LOWEST
435 will be past its end). */
436 if (offsets
[indx
] == 0)
439 /* If this section would overlap us, then we must move up. */
440 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
441 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
443 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
444 start_addr
= (start_addr
+ align
- 1) & -align
;
449 /* Otherwise, we appear to be OK. So far. */
454 offsets
[gdb_bfd_section_index (abfd
, sect
)] = start_addr
;
455 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
458 /* Store struct section_addr_info as prepared (made relative and with SECTINDEX
459 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
463 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
465 const struct section_addr_info
*addrs
)
469 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
471 /* Now calculate offsets for section that were specified by the caller. */
472 for (i
= 0; i
< addrs
->num_sections
; i
++)
474 const struct other_sections
*osp
;
476 osp
= &addrs
->other
[i
];
477 if (osp
->sectindex
== -1)
480 /* Record all sections in offsets. */
481 /* The section_offsets in the objfile are here filled in using
483 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
487 /* Transform section name S for a name comparison. prelink can split section
488 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
489 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
490 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
491 (`.sbss') section has invalid (increased) virtual address. */
494 addr_section_name (const char *s
)
496 if (strcmp (s
, ".dynbss") == 0)
498 if (strcmp (s
, ".sdynbss") == 0)
504 /* qsort comparator for addrs_section_sort. Sort entries in ascending order by
505 their (name, sectindex) pair. sectindex makes the sort by name stable. */
508 addrs_section_compar (const void *ap
, const void *bp
)
510 const struct other_sections
*a
= *((struct other_sections
**) ap
);
511 const struct other_sections
*b
= *((struct other_sections
**) bp
);
514 retval
= strcmp (addr_section_name (a
->name
), addr_section_name (b
->name
));
518 return a
->sectindex
- b
->sectindex
;
521 /* Provide sorted array of pointers to sections of ADDRS. The array is
522 terminated by NULL. Caller is responsible to call xfree for it. */
524 static struct other_sections
**
525 addrs_section_sort (struct section_addr_info
*addrs
)
527 struct other_sections
**array
;
530 /* `+ 1' for the NULL terminator. */
531 array
= XNEWVEC (struct other_sections
*, addrs
->num_sections
+ 1);
532 for (i
= 0; i
< addrs
->num_sections
; i
++)
533 array
[i
] = &addrs
->other
[i
];
536 qsort (array
, i
, sizeof (*array
), addrs_section_compar
);
541 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
542 also SECTINDEXes specific to ABFD there. This function can be used to
543 rebase ADDRS to start referencing different BFD than before. */
546 addr_info_make_relative (struct section_addr_info
*addrs
, bfd
*abfd
)
548 asection
*lower_sect
;
549 CORE_ADDR lower_offset
;
551 struct cleanup
*my_cleanup
;
552 struct section_addr_info
*abfd_addrs
;
553 struct other_sections
**addrs_sorted
, **abfd_addrs_sorted
;
554 struct other_sections
**addrs_to_abfd_addrs
;
556 /* Find lowest loadable section to be used as starting point for
557 continguous sections. */
559 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
560 if (lower_sect
== NULL
)
562 warning (_("no loadable sections found in added symbol-file %s"),
563 bfd_get_filename (abfd
));
567 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
569 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
570 in ABFD. Section names are not unique - there can be multiple sections of
571 the same name. Also the sections of the same name do not have to be
572 adjacent to each other. Some sections may be present only in one of the
573 files. Even sections present in both files do not have to be in the same
576 Use stable sort by name for the sections in both files. Then linearly
577 scan both lists matching as most of the entries as possible. */
579 addrs_sorted
= addrs_section_sort (addrs
);
580 my_cleanup
= make_cleanup (xfree
, addrs_sorted
);
582 abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
583 make_cleanup_free_section_addr_info (abfd_addrs
);
584 abfd_addrs_sorted
= addrs_section_sort (abfd_addrs
);
585 make_cleanup (xfree
, abfd_addrs_sorted
);
587 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
588 ABFD_ADDRS_SORTED. */
590 addrs_to_abfd_addrs
= XCNEWVEC (struct other_sections
*, addrs
->num_sections
);
591 make_cleanup (xfree
, addrs_to_abfd_addrs
);
593 while (*addrs_sorted
)
595 const char *sect_name
= addr_section_name ((*addrs_sorted
)->name
);
597 while (*abfd_addrs_sorted
598 && strcmp (addr_section_name ((*abfd_addrs_sorted
)->name
),
602 if (*abfd_addrs_sorted
603 && strcmp (addr_section_name ((*abfd_addrs_sorted
)->name
),
608 /* Make the found item directly addressable from ADDRS. */
609 index_in_addrs
= *addrs_sorted
- addrs
->other
;
610 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
611 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_addrs_sorted
;
613 /* Never use the same ABFD entry twice. */
620 /* Calculate offsets for the loadable sections.
621 FIXME! Sections must be in order of increasing loadable section
622 so that contiguous sections can use the lower-offset!!!
624 Adjust offsets if the segments are not contiguous.
625 If the section is contiguous, its offset should be set to
626 the offset of the highest loadable section lower than it
627 (the loadable section directly below it in memory).
628 this_offset = lower_offset = lower_addr - lower_orig_addr */
630 for (i
= 0; i
< addrs
->num_sections
; i
++)
632 struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
636 /* This is the index used by BFD. */
637 addrs
->other
[i
].sectindex
= sect
->sectindex
;
639 if (addrs
->other
[i
].addr
!= 0)
641 addrs
->other
[i
].addr
-= sect
->addr
;
642 lower_offset
= addrs
->other
[i
].addr
;
645 addrs
->other
[i
].addr
= lower_offset
;
649 /* addr_section_name transformation is not used for SECT_NAME. */
650 const char *sect_name
= addrs
->other
[i
].name
;
652 /* This section does not exist in ABFD, which is normally
653 unexpected and we want to issue a warning.
655 However, the ELF prelinker does create a few sections which are
656 marked in the main executable as loadable (they are loaded in
657 memory from the DYNAMIC segment) and yet are not present in
658 separate debug info files. This is fine, and should not cause
659 a warning. Shared libraries contain just the section
660 ".gnu.liblist" but it is not marked as loadable there. There is
661 no other way to identify them than by their name as the sections
662 created by prelink have no special flags.
664 For the sections `.bss' and `.sbss' see addr_section_name. */
666 if (!(strcmp (sect_name
, ".gnu.liblist") == 0
667 || strcmp (sect_name
, ".gnu.conflict") == 0
668 || (strcmp (sect_name
, ".bss") == 0
670 && strcmp (addrs
->other
[i
- 1].name
, ".dynbss") == 0
671 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
672 || (strcmp (sect_name
, ".sbss") == 0
674 && strcmp (addrs
->other
[i
- 1].name
, ".sdynbss") == 0
675 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
676 warning (_("section %s not found in %s"), sect_name
,
677 bfd_get_filename (abfd
));
679 addrs
->other
[i
].addr
= 0;
680 addrs
->other
[i
].sectindex
= -1;
684 do_cleanups (my_cleanup
);
687 /* Parse the user's idea of an offset for dynamic linking, into our idea
688 of how to represent it for fast symbol reading. This is the default
689 version of the sym_fns.sym_offsets function for symbol readers that
690 don't need to do anything special. It allocates a section_offsets table
691 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
694 default_symfile_offsets (struct objfile
*objfile
,
695 const struct section_addr_info
*addrs
)
697 objfile
->num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
698 objfile
->section_offsets
= (struct section_offsets
*)
699 obstack_alloc (&objfile
->objfile_obstack
,
700 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
701 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
702 objfile
->num_sections
, addrs
);
704 /* For relocatable files, all loadable sections will start at zero.
705 The zero is meaningless, so try to pick arbitrary addresses such
706 that no loadable sections overlap. This algorithm is quadratic,
707 but the number of sections in a single object file is generally
709 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
711 struct place_section_arg arg
;
712 bfd
*abfd
= objfile
->obfd
;
715 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
716 /* We do not expect this to happen; just skip this step if the
717 relocatable file has a section with an assigned VMA. */
718 if (bfd_section_vma (abfd
, cur_sec
) != 0)
723 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
725 /* Pick non-overlapping offsets for sections the user did not
727 arg
.offsets
= objfile
->section_offsets
;
729 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
731 /* Correctly filling in the section offsets is not quite
732 enough. Relocatable files have two properties that
733 (most) shared objects do not:
735 - Their debug information will contain relocations. Some
736 shared libraries do also, but many do not, so this can not
739 - If there are multiple code sections they will be loaded
740 at different relative addresses in memory than they are
741 in the objfile, since all sections in the file will start
744 Because GDB has very limited ability to map from an
745 address in debug info to the correct code section,
746 it relies on adding SECT_OFF_TEXT to things which might be
747 code. If we clear all the section offsets, and set the
748 section VMAs instead, then symfile_relocate_debug_section
749 will return meaningful debug information pointing at the
752 GDB has too many different data structures for section
753 addresses - a bfd, objfile, and so_list all have section
754 tables, as does exec_ops. Some of these could probably
757 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
758 cur_sec
= cur_sec
->next
)
760 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
763 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
764 exec_set_section_address (bfd_get_filename (abfd
),
766 offsets
[cur_sec
->index
]);
767 offsets
[cur_sec
->index
] = 0;
772 /* Remember the bfd indexes for the .text, .data, .bss and
774 init_objfile_sect_indices (objfile
);
777 /* Divide the file into segments, which are individual relocatable units.
778 This is the default version of the sym_fns.sym_segments function for
779 symbol readers that do not have an explicit representation of segments.
780 It assumes that object files do not have segments, and fully linked
781 files have a single segment. */
783 struct symfile_segment_data
*
784 default_symfile_segments (bfd
*abfd
)
788 struct symfile_segment_data
*data
;
791 /* Relocatable files contain enough information to position each
792 loadable section independently; they should not be relocated
794 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
797 /* Make sure there is at least one loadable section in the file. */
798 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
800 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
808 low
= bfd_get_section_vma (abfd
, sect
);
809 high
= low
+ bfd_get_section_size (sect
);
811 data
= XCNEW (struct symfile_segment_data
);
812 data
->num_segments
= 1;
813 data
->segment_bases
= XCNEW (CORE_ADDR
);
814 data
->segment_sizes
= XCNEW (CORE_ADDR
);
816 num_sections
= bfd_count_sections (abfd
);
817 data
->segment_info
= XCNEWVEC (int, num_sections
);
819 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
823 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
826 vma
= bfd_get_section_vma (abfd
, sect
);
829 if (vma
+ bfd_get_section_size (sect
) > high
)
830 high
= vma
+ bfd_get_section_size (sect
);
832 data
->segment_info
[i
] = 1;
835 data
->segment_bases
[0] = low
;
836 data
->segment_sizes
[0] = high
- low
;
841 /* This is a convenience function to call sym_read for OBJFILE and
842 possibly force the partial symbols to be read. */
845 read_symbols (struct objfile
*objfile
, symfile_add_flags add_flags
)
847 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
848 objfile
->per_bfd
->minsyms_read
= true;
850 /* find_separate_debug_file_in_section should be called only if there is
851 single binary with no existing separate debug info file. */
852 if (!objfile_has_partial_symbols (objfile
)
853 && objfile
->separate_debug_objfile
== NULL
854 && objfile
->separate_debug_objfile_backlink
== NULL
)
856 gdb_bfd_ref_ptr
abfd (find_separate_debug_file_in_section (objfile
));
860 /* find_separate_debug_file_in_section uses the same filename for the
861 virtual section-as-bfd like the bfd filename containing the
862 section. Therefore use also non-canonical name form for the same
863 file containing the section. */
864 symbol_file_add_separate (abfd
.get (), objfile
->original_name
,
868 if ((add_flags
& SYMFILE_NO_READ
) == 0)
869 require_partial_symbols (objfile
, 0);
872 /* Initialize entry point information for this objfile. */
875 init_entry_point_info (struct objfile
*objfile
)
877 struct entry_info
*ei
= &objfile
->per_bfd
->ei
;
883 /* Save startup file's range of PC addresses to help blockframe.c
884 decide where the bottom of the stack is. */
886 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
888 /* Executable file -- record its entry point so we'll recognize
889 the startup file because it contains the entry point. */
890 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
891 ei
->entry_point_p
= 1;
893 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
894 && bfd_get_start_address (objfile
->obfd
) != 0)
896 /* Some shared libraries may have entry points set and be
897 runnable. There's no clear way to indicate this, so just check
898 for values other than zero. */
899 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
900 ei
->entry_point_p
= 1;
904 /* Examination of non-executable.o files. Short-circuit this stuff. */
905 ei
->entry_point_p
= 0;
908 if (ei
->entry_point_p
)
910 struct obj_section
*osect
;
911 CORE_ADDR entry_point
= ei
->entry_point
;
914 /* Make certain that the address points at real code, and not a
915 function descriptor. */
917 = gdbarch_convert_from_func_ptr_addr (get_objfile_arch (objfile
),
921 /* Remove any ISA markers, so that this matches entries in the
924 = gdbarch_addr_bits_remove (get_objfile_arch (objfile
), entry_point
);
927 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
929 struct bfd_section
*sect
= osect
->the_bfd_section
;
931 if (entry_point
>= bfd_get_section_vma (objfile
->obfd
, sect
)
932 && entry_point
< (bfd_get_section_vma (objfile
->obfd
, sect
)
933 + bfd_get_section_size (sect
)))
935 ei
->the_bfd_section_index
936 = gdb_bfd_section_index (objfile
->obfd
, sect
);
943 ei
->the_bfd_section_index
= SECT_OFF_TEXT (objfile
);
947 /* Process a symbol file, as either the main file or as a dynamically
950 This function does not set the OBJFILE's entry-point info.
952 OBJFILE is where the symbols are to be read from.
954 ADDRS is the list of section load addresses. If the user has given
955 an 'add-symbol-file' command, then this is the list of offsets and
956 addresses he or she provided as arguments to the command; or, if
957 we're handling a shared library, these are the actual addresses the
958 sections are loaded at, according to the inferior's dynamic linker
959 (as gleaned by GDB's shared library code). We convert each address
960 into an offset from the section VMA's as it appears in the object
961 file, and then call the file's sym_offsets function to convert this
962 into a format-specific offset table --- a `struct section_offsets'.
964 ADD_FLAGS encodes verbosity level, whether this is main symbol or
965 an extra symbol file such as dynamically loaded code, and wether
966 breakpoint reset should be deferred. */
969 syms_from_objfile_1 (struct objfile
*objfile
,
970 struct section_addr_info
*addrs
,
971 symfile_add_flags add_flags
)
973 struct section_addr_info
*local_addr
= NULL
;
974 struct cleanup
*old_chain
;
975 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
977 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
979 if (objfile
->sf
== NULL
)
981 /* No symbols to load, but we still need to make sure
982 that the section_offsets table is allocated. */
983 int num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
984 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_sections
);
986 objfile
->num_sections
= num_sections
;
987 objfile
->section_offsets
988 = (struct section_offsets
*) obstack_alloc (&objfile
->objfile_obstack
,
990 memset (objfile
->section_offsets
, 0, size
);
994 /* Make sure that partially constructed symbol tables will be cleaned up
995 if an error occurs during symbol reading. */
996 old_chain
= make_cleanup (null_cleanup
, NULL
);
997 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
999 /* If ADDRS is NULL, put together a dummy address list.
1000 We now establish the convention that an addr of zero means
1001 no load address was specified. */
1004 local_addr
= alloc_section_addr_info (1);
1005 make_cleanup (xfree
, local_addr
);
1011 /* We will modify the main symbol table, make sure that all its users
1012 will be cleaned up if an error occurs during symbol reading. */
1013 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1015 /* Since no error yet, throw away the old symbol table. */
1017 if (symfile_objfile
!= NULL
)
1019 delete symfile_objfile
;
1020 gdb_assert (symfile_objfile
== NULL
);
1023 /* Currently we keep symbols from the add-symbol-file command.
1024 If the user wants to get rid of them, they should do "symbol-file"
1025 without arguments first. Not sure this is the best behavior
1028 (*objfile
->sf
->sym_new_init
) (objfile
);
1031 /* Convert addr into an offset rather than an absolute address.
1032 We find the lowest address of a loaded segment in the objfile,
1033 and assume that <addr> is where that got loaded.
1035 We no longer warn if the lowest section is not a text segment (as
1036 happens for the PA64 port. */
1037 if (addrs
->num_sections
> 0)
1038 addr_info_make_relative (addrs
, objfile
->obfd
);
1040 /* Initialize symbol reading routines for this objfile, allow complaints to
1041 appear for this new file, and record how verbose to be, then do the
1042 initial symbol reading for this file. */
1044 (*objfile
->sf
->sym_init
) (objfile
);
1045 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
1047 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
1049 read_symbols (objfile
, add_flags
);
1051 /* Discard cleanups as symbol reading was successful. */
1053 objfile_holder
.release ();
1054 discard_cleanups (old_chain
);
1058 /* Same as syms_from_objfile_1, but also initializes the objfile
1059 entry-point info. */
1062 syms_from_objfile (struct objfile
*objfile
,
1063 struct section_addr_info
*addrs
,
1064 symfile_add_flags add_flags
)
1066 syms_from_objfile_1 (objfile
, addrs
, add_flags
);
1067 init_entry_point_info (objfile
);
1070 /* Perform required actions after either reading in the initial
1071 symbols for a new objfile, or mapping in the symbols from a reusable
1072 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1075 finish_new_objfile (struct objfile
*objfile
, symfile_add_flags add_flags
)
1077 /* If this is the main symbol file we have to clean up all users of the
1078 old main symbol file. Otherwise it is sufficient to fixup all the
1079 breakpoints that may have been redefined by this symbol file. */
1080 if (add_flags
& SYMFILE_MAINLINE
)
1082 /* OK, make it the "real" symbol file. */
1083 symfile_objfile
= objfile
;
1085 clear_symtab_users (add_flags
);
1087 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1089 breakpoint_re_set ();
1092 /* We're done reading the symbol file; finish off complaints. */
1093 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
1096 /* Process a symbol file, as either the main file or as a dynamically
1099 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1100 A new reference is acquired by this function.
1102 For NAME description see the objfile constructor.
1104 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1105 extra, such as dynamically loaded code, and what to do with breakpoins.
1107 ADDRS is as described for syms_from_objfile_1, above.
1108 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1110 PARENT is the original objfile if ABFD is a separate debug info file.
1111 Otherwise PARENT is NULL.
1113 Upon success, returns a pointer to the objfile that was added.
1114 Upon failure, jumps back to command level (never returns). */
1116 static struct objfile
*
1117 symbol_file_add_with_addrs (bfd
*abfd
, const char *name
,
1118 symfile_add_flags add_flags
,
1119 struct section_addr_info
*addrs
,
1120 objfile_flags flags
, struct objfile
*parent
)
1122 struct objfile
*objfile
;
1123 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1124 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1125 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
1126 && (readnow_symbol_files
1127 || (add_flags
& SYMFILE_NO_READ
) == 0));
1129 if (readnow_symbol_files
)
1131 flags
|= OBJF_READNOW
;
1132 add_flags
&= ~SYMFILE_NO_READ
;
1135 /* Give user a chance to burp if we'd be
1136 interactively wiping out any existing symbols. */
1138 if ((have_full_symbols () || have_partial_symbols ())
1141 && !query (_("Load new symbol table from \"%s\"? "), name
))
1142 error (_("Not confirmed."));
1145 flags
|= OBJF_MAINLINE
;
1146 objfile
= new struct objfile (abfd
, name
, flags
);
1149 add_separate_debug_objfile (objfile
, parent
);
1151 /* We either created a new mapped symbol table, mapped an existing
1152 symbol table file which has not had initial symbol reading
1153 performed, or need to read an unmapped symbol table. */
1156 if (deprecated_pre_add_symbol_hook
)
1157 deprecated_pre_add_symbol_hook (name
);
1160 printf_unfiltered (_("Reading symbols from %s..."), name
);
1162 gdb_flush (gdb_stdout
);
1165 syms_from_objfile (objfile
, addrs
, add_flags
);
1167 /* We now have at least a partial symbol table. Check to see if the
1168 user requested that all symbols be read on initial access via either
1169 the gdb startup command line or on a per symbol file basis. Expand
1170 all partial symbol tables for this objfile if so. */
1172 if ((flags
& OBJF_READNOW
))
1176 printf_unfiltered (_("expanding to full symbols..."));
1178 gdb_flush (gdb_stdout
);
1182 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1185 if (should_print
&& !objfile_has_symbols (objfile
))
1188 printf_unfiltered (_("(no debugging symbols found)..."));
1194 if (deprecated_post_add_symbol_hook
)
1195 deprecated_post_add_symbol_hook ();
1197 printf_unfiltered (_("done.\n"));
1200 /* We print some messages regardless of whether 'from_tty ||
1201 info_verbose' is true, so make sure they go out at the right
1203 gdb_flush (gdb_stdout
);
1205 if (objfile
->sf
== NULL
)
1207 observer_notify_new_objfile (objfile
);
1208 return objfile
; /* No symbols. */
1211 finish_new_objfile (objfile
, add_flags
);
1213 observer_notify_new_objfile (objfile
);
1215 bfd_cache_close_all ();
1219 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1220 see the objfile constructor. */
1223 symbol_file_add_separate (bfd
*bfd
, const char *name
,
1224 symfile_add_flags symfile_flags
,
1225 struct objfile
*objfile
)
1227 struct section_addr_info
*sap
;
1228 struct cleanup
*my_cleanup
;
1230 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1231 because sections of BFD may not match sections of OBJFILE and because
1232 vma may have been modified by tools such as prelink. */
1233 sap
= build_section_addr_info_from_objfile (objfile
);
1234 my_cleanup
= make_cleanup_free_section_addr_info (sap
);
1236 symbol_file_add_with_addrs
1237 (bfd
, name
, symfile_flags
, sap
,
1238 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1242 do_cleanups (my_cleanup
);
1245 /* Process the symbol file ABFD, as either the main file or as a
1246 dynamically loaded file.
1247 See symbol_file_add_with_addrs's comments for details. */
1250 symbol_file_add_from_bfd (bfd
*abfd
, const char *name
,
1251 symfile_add_flags add_flags
,
1252 struct section_addr_info
*addrs
,
1253 objfile_flags flags
, struct objfile
*parent
)
1255 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1259 /* Process a symbol file, as either the main file or as a dynamically
1260 loaded file. See symbol_file_add_with_addrs's comments for details. */
1263 symbol_file_add (const char *name
, symfile_add_flags add_flags
,
1264 struct section_addr_info
*addrs
, objfile_flags flags
)
1266 gdb_bfd_ref_ptr
bfd (symfile_bfd_open (name
));
1268 return symbol_file_add_from_bfd (bfd
.get (), name
, add_flags
, addrs
,
1272 /* Call symbol_file_add() with default values and update whatever is
1273 affected by the loading of a new main().
1274 Used when the file is supplied in the gdb command line
1275 and by some targets with special loading requirements.
1276 The auxiliary function, symbol_file_add_main_1(), has the flags
1277 argument for the switches that can only be specified in the symbol_file
1281 symbol_file_add_main (const char *args
, symfile_add_flags add_flags
)
1283 symbol_file_add_main_1 (args
, add_flags
, 0);
1287 symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
1288 objfile_flags flags
)
1290 add_flags
|= current_inferior ()->symfile_flags
| SYMFILE_MAINLINE
;
1292 symbol_file_add (args
, add_flags
, NULL
, flags
);
1294 /* Getting new symbols may change our opinion about
1295 what is frameless. */
1296 reinit_frame_cache ();
1298 if ((add_flags
& SYMFILE_NO_READ
) == 0)
1299 set_initial_language ();
1303 symbol_file_clear (int from_tty
)
1305 if ((have_full_symbols () || have_partial_symbols ())
1308 ? !query (_("Discard symbol table from `%s'? "),
1309 objfile_name (symfile_objfile
))
1310 : !query (_("Discard symbol table? "))))
1311 error (_("Not confirmed."));
1313 /* solib descriptors may have handles to objfiles. Wipe them before their
1314 objfiles get stale by free_all_objfiles. */
1315 no_shared_libraries (NULL
, from_tty
);
1317 free_all_objfiles ();
1319 gdb_assert (symfile_objfile
== NULL
);
1321 printf_unfiltered (_("No symbol file now.\n"));
1324 /* See symfile.h. */
1326 int separate_debug_file_debug
= 0;
1329 separate_debug_file_exists (const char *name
, unsigned long crc
,
1330 struct objfile
*parent_objfile
)
1332 unsigned long file_crc
;
1334 struct stat parent_stat
, abfd_stat
;
1335 int verified_as_different
;
1337 /* Find a separate debug info file as if symbols would be present in
1338 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1339 section can contain just the basename of PARENT_OBJFILE without any
1340 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1341 the separate debug infos with the same basename can exist. */
1343 if (filename_cmp (name
, objfile_name (parent_objfile
)) == 0)
1346 if (separate_debug_file_debug
)
1347 printf_unfiltered (_(" Trying %s\n"), name
);
1349 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (name
, gnutarget
, -1));
1354 /* Verify symlinks were not the cause of filename_cmp name difference above.
1356 Some operating systems, e.g. Windows, do not provide a meaningful
1357 st_ino; they always set it to zero. (Windows does provide a
1358 meaningful st_dev.) Files accessed from gdbservers that do not
1359 support the vFile:fstat packet will also have st_ino set to zero.
1360 Do not indicate a duplicate library in either case. While there
1361 is no guarantee that a system that provides meaningful inode
1362 numbers will never set st_ino to zero, this is merely an
1363 optimization, so we do not need to worry about false negatives. */
1365 if (bfd_stat (abfd
.get (), &abfd_stat
) == 0
1366 && abfd_stat
.st_ino
!= 0
1367 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1369 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1370 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1372 verified_as_different
= 1;
1375 verified_as_different
= 0;
1377 file_crc_p
= gdb_bfd_crc (abfd
.get (), &file_crc
);
1382 if (crc
!= file_crc
)
1384 unsigned long parent_crc
;
1386 /* If the files could not be verified as different with
1387 bfd_stat then we need to calculate the parent's CRC
1388 to verify whether the files are different or not. */
1390 if (!verified_as_different
)
1392 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1396 if (verified_as_different
|| parent_crc
!= file_crc
)
1397 warning (_("the debug information found in \"%s\""
1398 " does not match \"%s\" (CRC mismatch).\n"),
1399 name
, objfile_name (parent_objfile
));
1407 char *debug_file_directory
= NULL
;
1409 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1410 struct cmd_list_element
*c
, const char *value
)
1412 fprintf_filtered (file
,
1413 _("The directory where separate debug "
1414 "symbols are searched for is \"%s\".\n"),
1418 #if ! defined (DEBUG_SUBDIRECTORY)
1419 #define DEBUG_SUBDIRECTORY ".debug"
1422 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1423 where the original file resides (may not be the same as
1424 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1425 looking for. CANON_DIR is the "realpath" form of DIR.
1426 DIR must contain a trailing '/'.
1427 Returns the path of the file with separate debug info, of NULL. */
1430 find_separate_debug_file (const char *dir
,
1431 const char *canon_dir
,
1432 const char *debuglink
,
1433 unsigned long crc32
, struct objfile
*objfile
)
1438 VEC (char_ptr
) *debugdir_vec
;
1439 struct cleanup
*back_to
;
1442 if (separate_debug_file_debug
)
1443 printf_unfiltered (_("\nLooking for separate debug info (debug link) for "
1444 "%s\n"), objfile_name (objfile
));
1446 /* Set I to std::max (strlen (canon_dir), strlen (dir)). */
1448 if (canon_dir
!= NULL
&& strlen (canon_dir
) > i
)
1449 i
= strlen (canon_dir
);
1452 = (char *) xmalloc (strlen (debug_file_directory
) + 1
1454 + strlen (DEBUG_SUBDIRECTORY
)
1456 + strlen (debuglink
)
1459 /* First try in the same directory as the original file. */
1460 strcpy (debugfile
, dir
);
1461 strcat (debugfile
, debuglink
);
1463 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1466 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1467 strcpy (debugfile
, dir
);
1468 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1469 strcat (debugfile
, "/");
1470 strcat (debugfile
, debuglink
);
1472 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1475 /* Then try in the global debugfile directories.
1477 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1478 cause "/..." lookups. */
1480 debugdir_vec
= dirnames_to_char_ptr_vec (debug_file_directory
);
1481 back_to
= make_cleanup_free_char_ptr_vec (debugdir_vec
);
1483 for (ix
= 0; VEC_iterate (char_ptr
, debugdir_vec
, ix
, debugdir
); ++ix
)
1485 strcpy (debugfile
, debugdir
);
1486 strcat (debugfile
, "/");
1487 strcat (debugfile
, dir
);
1488 strcat (debugfile
, debuglink
);
1490 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1492 do_cleanups (back_to
);
1496 /* If the file is in the sysroot, try using its base path in the
1497 global debugfile directory. */
1498 if (canon_dir
!= NULL
1499 && filename_ncmp (canon_dir
, gdb_sysroot
,
1500 strlen (gdb_sysroot
)) == 0
1501 && IS_DIR_SEPARATOR (canon_dir
[strlen (gdb_sysroot
)]))
1503 strcpy (debugfile
, debugdir
);
1504 strcat (debugfile
, canon_dir
+ strlen (gdb_sysroot
));
1505 strcat (debugfile
, "/");
1506 strcat (debugfile
, debuglink
);
1508 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1510 do_cleanups (back_to
);
1516 do_cleanups (back_to
);
1521 /* Modify PATH to contain only "[/]directory/" part of PATH.
1522 If there were no directory separators in PATH, PATH will be empty
1523 string on return. */
1526 terminate_after_last_dir_separator (char *path
)
1530 /* Strip off the final filename part, leaving the directory name,
1531 followed by a slash. The directory can be relative or absolute. */
1532 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1533 if (IS_DIR_SEPARATOR (path
[i
]))
1536 /* If I is -1 then no directory is present there and DIR will be "". */
1540 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1541 Returns pathname, or NULL. */
1544 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1547 unsigned long crc32
;
1549 gdb::unique_xmalloc_ptr
<char> debuglink
1550 (bfd_get_debug_link_info (objfile
->obfd
, &crc32
));
1552 if (debuglink
== NULL
)
1554 /* There's no separate debug info, hence there's no way we could
1555 load it => no warning. */
1559 std::string dir
= objfile_name (objfile
);
1560 terminate_after_last_dir_separator (&dir
[0]);
1561 gdb::unique_xmalloc_ptr
<char> canon_dir (lrealpath (dir
.c_str ()));
1563 debugfile
= find_separate_debug_file (dir
.c_str (), canon_dir
.get (),
1564 debuglink
.get (), crc32
, objfile
);
1566 if (debugfile
== NULL
)
1568 /* For PR gdb/9538, try again with realpath (if different from the
1573 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1574 && S_ISLNK (st_buf
.st_mode
))
1576 gdb::unique_xmalloc_ptr
<char> symlink_dir
1577 (lrealpath (objfile_name (objfile
)));
1578 if (symlink_dir
!= NULL
)
1580 terminate_after_last_dir_separator (symlink_dir
.get ());
1581 if (dir
!= symlink_dir
.get ())
1583 /* Different directory, so try using it. */
1584 debugfile
= find_separate_debug_file (symlink_dir
.get (),
1597 /* This is the symbol-file command. Read the file, analyze its
1598 symbols, and add a struct symtab to a symtab list. The syntax of
1599 the command is rather bizarre:
1601 1. The function buildargv implements various quoting conventions
1602 which are undocumented and have little or nothing in common with
1603 the way things are quoted (or not quoted) elsewhere in GDB.
1605 2. Options are used, which are not generally used in GDB (perhaps
1606 "set mapped on", "set readnow on" would be better)
1608 3. The order of options matters, which is contrary to GNU
1609 conventions (because it is confusing and inconvenient). */
1612 symbol_file_command (const char *args
, int from_tty
)
1618 symbol_file_clear (from_tty
);
1622 objfile_flags flags
= OBJF_USERLOADED
;
1623 symfile_add_flags add_flags
= 0;
1625 bool stop_processing_options
= false;
1630 add_flags
|= SYMFILE_VERBOSE
;
1632 gdb_argv
built_argv (args
);
1633 for (arg
= built_argv
[0], idx
= 0; arg
!= NULL
; arg
= built_argv
[++idx
])
1635 if (stop_processing_options
|| *arg
!= '-')
1640 error (_("Unrecognized argument \"%s\""), arg
);
1642 else if (strcmp (arg
, "-readnow") == 0)
1643 flags
|= OBJF_READNOW
;
1644 else if (strcmp (arg
, "--") == 0)
1645 stop_processing_options
= true;
1647 error (_("Unrecognized argument \"%s\""), arg
);
1651 error (_("no symbol file name was specified"));
1653 symbol_file_add_main_1 (name
, add_flags
, flags
);
1657 /* Set the initial language.
1659 FIXME: A better solution would be to record the language in the
1660 psymtab when reading partial symbols, and then use it (if known) to
1661 set the language. This would be a win for formats that encode the
1662 language in an easily discoverable place, such as DWARF. For
1663 stabs, we can jump through hoops looking for specially named
1664 symbols or try to intuit the language from the specific type of
1665 stabs we find, but we can't do that until later when we read in
1669 set_initial_language (void)
1671 enum language lang
= main_language ();
1673 if (lang
== language_unknown
)
1675 char *name
= main_name ();
1676 struct symbol
*sym
= lookup_symbol (name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
1679 lang
= SYMBOL_LANGUAGE (sym
);
1682 if (lang
== language_unknown
)
1684 /* Make C the default language */
1688 set_language (lang
);
1689 expected_language
= current_language
; /* Don't warn the user. */
1692 /* Open the file specified by NAME and hand it off to BFD for
1693 preliminary analysis. Return a newly initialized bfd *, which
1694 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1695 absolute). In case of trouble, error() is called. */
1698 symfile_bfd_open (const char *name
)
1701 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1703 if (!is_target_filename (name
))
1705 char *absolute_name
;
1707 gdb::unique_xmalloc_ptr
<char> expanded_name (tilde_expand (name
));
1709 /* Look down path for it, allocate 2nd new malloc'd copy. */
1710 desc
= openp (getenv ("PATH"),
1711 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1712 expanded_name
.get (), O_RDONLY
| O_BINARY
, &absolute_name
);
1713 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1716 char *exename
= (char *) alloca (strlen (expanded_name
.get ()) + 5);
1718 strcat (strcpy (exename
, expanded_name
.get ()), ".exe");
1719 desc
= openp (getenv ("PATH"),
1720 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1721 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1725 perror_with_name (expanded_name
.get ());
1727 make_cleanup (xfree
, absolute_name
);
1728 name
= absolute_name
;
1731 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (name
, gnutarget
, desc
));
1732 if (sym_bfd
== NULL
)
1733 error (_("`%s': can't open to read symbols: %s."), name
,
1734 bfd_errmsg (bfd_get_error ()));
1736 if (!gdb_bfd_has_target_filename (sym_bfd
.get ()))
1737 bfd_set_cacheable (sym_bfd
.get (), 1);
1739 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
1740 error (_("`%s': can't read symbols: %s."), name
,
1741 bfd_errmsg (bfd_get_error ()));
1743 do_cleanups (back_to
);
1748 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1749 the section was not found. */
1752 get_section_index (struct objfile
*objfile
, const char *section_name
)
1754 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1762 /* Link SF into the global symtab_fns list.
1763 FLAVOUR is the file format that SF handles.
1764 Called on startup by the _initialize routine in each object file format
1765 reader, to register information about each format the reader is prepared
1769 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1771 symtab_fns
.emplace_back (flavour
, sf
);
1774 /* Initialize OBJFILE to read symbols from its associated BFD. It
1775 either returns or calls error(). The result is an initialized
1776 struct sym_fns in the objfile structure, that contains cached
1777 information about the symbol file. */
1779 static const struct sym_fns
*
1780 find_sym_fns (bfd
*abfd
)
1782 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1784 if (our_flavour
== bfd_target_srec_flavour
1785 || our_flavour
== bfd_target_ihex_flavour
1786 || our_flavour
== bfd_target_tekhex_flavour
)
1787 return NULL
; /* No symbols. */
1789 for (const registered_sym_fns
&rsf
: symtab_fns
)
1790 if (our_flavour
== rsf
.sym_flavour
)
1793 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1794 bfd_get_target (abfd
));
1798 /* This function runs the load command of our current target. */
1801 load_command (const char *arg
, int from_tty
)
1803 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1807 /* The user might be reloading because the binary has changed. Take
1808 this opportunity to check. */
1809 reopen_exec_file ();
1817 parg
= arg
= get_exec_file (1);
1819 /* Count how many \ " ' tab space there are in the name. */
1820 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1828 /* We need to quote this string so buildargv can pull it apart. */
1829 char *temp
= (char *) xmalloc (strlen (arg
) + count
+ 1 );
1833 make_cleanup (xfree
, temp
);
1836 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1838 strncpy (ptemp
, prev
, parg
- prev
);
1839 ptemp
+= parg
- prev
;
1843 strcpy (ptemp
, prev
);
1849 target_load (arg
, from_tty
);
1851 /* After re-loading the executable, we don't really know which
1852 overlays are mapped any more. */
1853 overlay_cache_invalid
= 1;
1855 do_cleanups (cleanup
);
1858 /* This version of "load" should be usable for any target. Currently
1859 it is just used for remote targets, not inftarg.c or core files,
1860 on the theory that only in that case is it useful.
1862 Avoiding xmodem and the like seems like a win (a) because we don't have
1863 to worry about finding it, and (b) On VMS, fork() is very slow and so
1864 we don't want to run a subprocess. On the other hand, I'm not sure how
1865 performance compares. */
1867 static int validate_download
= 0;
1869 /* Callback service function for generic_load (bfd_map_over_sections). */
1872 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1874 bfd_size_type
*sum
= (bfd_size_type
*) data
;
1876 *sum
+= bfd_get_section_size (asec
);
1879 /* Opaque data for load_section_callback. */
1880 struct load_section_data
{
1881 CORE_ADDR load_offset
;
1882 struct load_progress_data
*progress_data
;
1883 VEC(memory_write_request_s
) *requests
;
1886 /* Opaque data for load_progress. */
1887 struct load_progress_data
{
1888 /* Cumulative data. */
1889 unsigned long write_count
;
1890 unsigned long data_count
;
1891 bfd_size_type total_size
;
1894 /* Opaque data for load_progress for a single section. */
1895 struct load_progress_section_data
{
1896 struct load_progress_data
*cumulative
;
1898 /* Per-section data. */
1899 const char *section_name
;
1900 ULONGEST section_sent
;
1901 ULONGEST section_size
;
1906 /* Target write callback routine for progress reporting. */
1909 load_progress (ULONGEST bytes
, void *untyped_arg
)
1911 struct load_progress_section_data
*args
1912 = (struct load_progress_section_data
*) untyped_arg
;
1913 struct load_progress_data
*totals
;
1916 /* Writing padding data. No easy way to get at the cumulative
1917 stats, so just ignore this. */
1920 totals
= args
->cumulative
;
1922 if (bytes
== 0 && args
->section_sent
== 0)
1924 /* The write is just starting. Let the user know we've started
1926 current_uiout
->message ("Loading section %s, size %s lma %s\n",
1928 hex_string (args
->section_size
),
1929 paddress (target_gdbarch (), args
->lma
));
1933 if (validate_download
)
1935 /* Broken memories and broken monitors manifest themselves here
1936 when bring new computers to life. This doubles already slow
1938 /* NOTE: cagney/1999-10-18: A more efficient implementation
1939 might add a verify_memory() method to the target vector and
1940 then use that. remote.c could implement that method using
1941 the ``qCRC'' packet. */
1942 gdb::byte_vector
check (bytes
);
1944 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1945 error (_("Download verify read failed at %s"),
1946 paddress (target_gdbarch (), args
->lma
));
1947 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1948 error (_("Download verify compare failed at %s"),
1949 paddress (target_gdbarch (), args
->lma
));
1951 totals
->data_count
+= bytes
;
1953 args
->buffer
+= bytes
;
1954 totals
->write_count
+= 1;
1955 args
->section_sent
+= bytes
;
1956 if (check_quit_flag ()
1957 || (deprecated_ui_load_progress_hook
!= NULL
1958 && deprecated_ui_load_progress_hook (args
->section_name
,
1959 args
->section_sent
)))
1960 error (_("Canceled the download"));
1962 if (deprecated_show_load_progress
!= NULL
)
1963 deprecated_show_load_progress (args
->section_name
,
1967 totals
->total_size
);
1970 /* Callback service function for generic_load (bfd_map_over_sections). */
1973 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1975 struct memory_write_request
*new_request
;
1976 struct load_section_data
*args
= (struct load_section_data
*) data
;
1977 struct load_progress_section_data
*section_data
;
1978 bfd_size_type size
= bfd_get_section_size (asec
);
1980 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1982 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1988 new_request
= VEC_safe_push (memory_write_request_s
,
1989 args
->requests
, NULL
);
1990 memset (new_request
, 0, sizeof (struct memory_write_request
));
1991 section_data
= XCNEW (struct load_progress_section_data
);
1992 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1993 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size
1995 new_request
->data
= (gdb_byte
*) xmalloc (size
);
1996 new_request
->baton
= section_data
;
1998 buffer
= new_request
->data
;
2000 section_data
->cumulative
= args
->progress_data
;
2001 section_data
->section_name
= sect_name
;
2002 section_data
->section_size
= size
;
2003 section_data
->lma
= new_request
->begin
;
2004 section_data
->buffer
= buffer
;
2006 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2009 /* Clean up an entire memory request vector, including load
2010 data and progress records. */
2013 clear_memory_write_data (void *arg
)
2015 VEC(memory_write_request_s
) **vec_p
= (VEC(memory_write_request_s
) **) arg
;
2016 VEC(memory_write_request_s
) *vec
= *vec_p
;
2018 struct memory_write_request
*mr
;
2020 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
2025 VEC_free (memory_write_request_s
, vec
);
2028 static void print_transfer_performance (struct ui_file
*stream
,
2029 unsigned long data_count
,
2030 unsigned long write_count
,
2031 std::chrono::steady_clock::duration d
);
2034 generic_load (const char *args
, int from_tty
)
2036 struct cleanup
*old_cleanups
;
2037 struct load_section_data cbdata
;
2038 struct load_progress_data total_progress
;
2039 struct ui_out
*uiout
= current_uiout
;
2043 memset (&cbdata
, 0, sizeof (cbdata
));
2044 memset (&total_progress
, 0, sizeof (total_progress
));
2045 cbdata
.progress_data
= &total_progress
;
2047 old_cleanups
= make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
2050 error_no_arg (_("file to load"));
2052 gdb_argv
argv (args
);
2054 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2056 if (argv
[1] != NULL
)
2060 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2062 /* If the last word was not a valid number then
2063 treat it as a file name with spaces in. */
2064 if (argv
[1] == endptr
)
2065 error (_("Invalid download offset:%s."), argv
[1]);
2067 if (argv
[2] != NULL
)
2068 error (_("Too many parameters."));
2071 /* Open the file for loading. */
2072 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
2073 if (loadfile_bfd
== NULL
)
2074 perror_with_name (filename
.get ());
2076 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
2078 error (_("\"%s\" is not an object file: %s"), filename
.get (),
2079 bfd_errmsg (bfd_get_error ()));
2082 bfd_map_over_sections (loadfile_bfd
.get (), add_section_size_callback
,
2083 (void *) &total_progress
.total_size
);
2085 bfd_map_over_sections (loadfile_bfd
.get (), load_section_callback
, &cbdata
);
2087 using namespace std::chrono
;
2089 steady_clock::time_point start_time
= steady_clock::now ();
2091 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2092 load_progress
) != 0)
2093 error (_("Load failed"));
2095 steady_clock::time_point end_time
= steady_clock::now ();
2097 entry
= bfd_get_start_address (loadfile_bfd
.get ());
2098 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2099 uiout
->text ("Start address ");
2100 uiout
->field_fmt ("address", "%s", paddress (target_gdbarch (), entry
));
2101 uiout
->text (", load size ");
2102 uiout
->field_fmt ("load-size", "%lu", total_progress
.data_count
);
2104 regcache_write_pc (get_current_regcache (), entry
);
2106 /* Reset breakpoints, now that we have changed the load image. For
2107 instance, breakpoints may have been set (or reset, by
2108 post_create_inferior) while connected to the target but before we
2109 loaded the program. In that case, the prologue analyzer could
2110 have read instructions from the target to find the right
2111 breakpoint locations. Loading has changed the contents of that
2114 breakpoint_re_set ();
2116 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2117 total_progress
.write_count
,
2118 end_time
- start_time
);
2120 do_cleanups (old_cleanups
);
2123 /* Report on STREAM the performance of a memory transfer operation,
2124 such as 'load'. DATA_COUNT is the number of bytes transferred.
2125 WRITE_COUNT is the number of separate write operations, or 0, if
2126 that information is not available. TIME is how long the operation
2130 print_transfer_performance (struct ui_file
*stream
,
2131 unsigned long data_count
,
2132 unsigned long write_count
,
2133 std::chrono::steady_clock::duration time
)
2135 using namespace std::chrono
;
2136 struct ui_out
*uiout
= current_uiout
;
2138 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2140 uiout
->text ("Transfer rate: ");
2141 if (ms
.count () > 0)
2143 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2145 if (uiout
->is_mi_like_p ())
2147 uiout
->field_fmt ("transfer-rate", "%lu", rate
* 8);
2148 uiout
->text (" bits/sec");
2150 else if (rate
< 1024)
2152 uiout
->field_fmt ("transfer-rate", "%lu", rate
);
2153 uiout
->text (" bytes/sec");
2157 uiout
->field_fmt ("transfer-rate", "%lu", rate
/ 1024);
2158 uiout
->text (" KB/sec");
2163 uiout
->field_fmt ("transferred-bits", "%lu", (data_count
* 8));
2164 uiout
->text (" bits in <1 sec");
2166 if (write_count
> 0)
2169 uiout
->field_fmt ("write-rate", "%lu", data_count
/ write_count
);
2170 uiout
->text (" bytes/write");
2172 uiout
->text (".\n");
2175 /* This function allows the addition of incrementally linked object files.
2176 It does not modify any state in the target, only in the debugger. */
2177 /* Note: ezannoni 2000-04-13 This function/command used to have a
2178 special case syntax for the rombug target (Rombug is the boot
2179 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2180 rombug case, the user doesn't need to supply a text address,
2181 instead a call to target_link() (in target.c) would supply the
2182 value to use. We are now discontinuing this type of ad hoc syntax. */
2185 add_symbol_file_command (const char *args
, int from_tty
)
2187 struct gdbarch
*gdbarch
= get_current_arch ();
2188 gdb::unique_xmalloc_ptr
<char> filename
;
2192 struct objfile
*objf
;
2193 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2194 symfile_add_flags add_flags
= 0;
2197 add_flags
|= SYMFILE_VERBOSE
;
2205 struct section_addr_info
*section_addrs
;
2206 std::vector
<sect_opt
> sect_opts
= { { ".text", NULL
} };
2207 bool stop_processing_options
= false;
2208 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2213 error (_("add-symbol-file takes a file name and an address"));
2215 bool seen_addr
= false;
2216 gdb_argv
argv (args
);
2218 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2220 if (stop_processing_options
|| *arg
!= '-')
2222 if (filename
== NULL
)
2224 /* First non-option argument is always the filename. */
2225 filename
.reset (tilde_expand (arg
));
2227 else if (!seen_addr
)
2229 /* The second non-option argument is always the text
2230 address at which to load the program. */
2231 sect_opts
[0].value
= arg
;
2235 error (_("Unrecognized argument \"%s\""), arg
);
2237 else if (strcmp (arg
, "-readnow") == 0)
2238 flags
|= OBJF_READNOW
;
2239 else if (strcmp (arg
, "-s") == 0)
2241 if (argv
[argcnt
+ 1] == NULL
)
2242 error (_("Missing section name after \"-s\""));
2243 else if (argv
[argcnt
+ 2] == NULL
)
2244 error (_("Missing section address after \"-s\""));
2246 sect_opt sect
= { argv
[argcnt
+ 1], argv
[argcnt
+ 2] };
2248 sect_opts
.push_back (sect
);
2251 else if (strcmp (arg
, "--") == 0)
2252 stop_processing_options
= true;
2254 error (_("Unrecognized argument \"%s\""), arg
);
2257 if (filename
== NULL
)
2258 error (_("You must provide a filename to be loaded."));
2260 /* This command takes at least two arguments. The first one is a
2261 filename, and the second is the address where this file has been
2262 loaded. Abort now if this address hasn't been provided by the
2265 error (_("The address where %s has been loaded is missing"),
2268 /* Print the prompt for the query below. And save the arguments into
2269 a sect_addr_info structure to be passed around to other
2270 functions. We have to split this up into separate print
2271 statements because hex_string returns a local static
2274 printf_unfiltered (_("add symbol table from file \"%s\" at\n"),
2276 section_addrs
= alloc_section_addr_info (sect_opts
.size ());
2277 make_cleanup (xfree
, section_addrs
);
2278 for (sect_opt
§
: sect_opts
)
2281 const char *val
= sect
.value
;
2282 const char *sec
= sect
.name
;
2284 addr
= parse_and_eval_address (val
);
2286 /* Here we store the section offsets in the order they were
2287 entered on the command line. */
2288 section_addrs
->other
[sec_num
].name
= (char *) sec
;
2289 section_addrs
->other
[sec_num
].addr
= addr
;
2290 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2291 paddress (gdbarch
, addr
));
2294 /* The object's sections are initialized when a
2295 call is made to build_objfile_section_table (objfile).
2296 This happens in reread_symbols.
2297 At this point, we don't know what file type this is,
2298 so we can't determine what section names are valid. */
2300 section_addrs
->num_sections
= sec_num
;
2302 if (from_tty
&& (!query ("%s", "")))
2303 error (_("Not confirmed."));
2305 objf
= symbol_file_add (filename
.get (), add_flags
, section_addrs
, flags
);
2307 add_target_sections_of_objfile (objf
);
2309 /* Getting new symbols may change our opinion about what is
2311 reinit_frame_cache ();
2312 do_cleanups (my_cleanups
);
2316 /* This function removes a symbol file that was added via add-symbol-file. */
2319 remove_symbol_file_command (const char *args
, int from_tty
)
2321 struct objfile
*objf
= NULL
;
2322 struct program_space
*pspace
= current_program_space
;
2327 error (_("remove-symbol-file: no symbol file provided"));
2329 gdb_argv
argv (args
);
2331 if (strcmp (argv
[0], "-a") == 0)
2333 /* Interpret the next argument as an address. */
2336 if (argv
[1] == NULL
)
2337 error (_("Missing address argument"));
2339 if (argv
[2] != NULL
)
2340 error (_("Junk after %s"), argv
[1]);
2342 addr
= parse_and_eval_address (argv
[1]);
2346 if ((objf
->flags
& OBJF_USERLOADED
) != 0
2347 && (objf
->flags
& OBJF_SHARED
) != 0
2348 && objf
->pspace
== pspace
&& is_addr_in_objfile (addr
, objf
))
2352 else if (argv
[0] != NULL
)
2354 /* Interpret the current argument as a file name. */
2356 if (argv
[1] != NULL
)
2357 error (_("Junk after %s"), argv
[0]);
2359 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2363 if ((objf
->flags
& OBJF_USERLOADED
) != 0
2364 && (objf
->flags
& OBJF_SHARED
) != 0
2365 && objf
->pspace
== pspace
2366 && filename_cmp (filename
.get (), objfile_name (objf
)) == 0)
2372 error (_("No symbol file found"));
2375 && !query (_("Remove symbol table from file \"%s\"? "),
2376 objfile_name (objf
)))
2377 error (_("Not confirmed."));
2380 clear_symtab_users (0);
2383 /* Re-read symbols if a symbol-file has changed. */
2386 reread_symbols (void)
2388 struct objfile
*objfile
;
2390 struct stat new_statbuf
;
2392 std::vector
<struct objfile
*> new_objfiles
;
2394 /* With the addition of shared libraries, this should be modified,
2395 the load time should be saved in the partial symbol tables, since
2396 different tables may come from different source files. FIXME.
2397 This routine should then walk down each partial symbol table
2398 and see if the symbol table that it originates from has been changed. */
2400 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2402 if (objfile
->obfd
== NULL
)
2405 /* Separate debug objfiles are handled in the main objfile. */
2406 if (objfile
->separate_debug_objfile_backlink
)
2409 /* If this object is from an archive (what you usually create with
2410 `ar', often called a `static library' on most systems, though
2411 a `shared library' on AIX is also an archive), then you should
2412 stat on the archive name, not member name. */
2413 if (objfile
->obfd
->my_archive
)
2414 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2416 res
= stat (objfile_name (objfile
), &new_statbuf
);
2419 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2420 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2421 objfile_name (objfile
));
2424 new_modtime
= new_statbuf
.st_mtime
;
2425 if (new_modtime
!= objfile
->mtime
)
2427 struct cleanup
*old_cleanups
;
2428 struct section_offsets
*offsets
;
2430 char *original_name
;
2432 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2433 objfile_name (objfile
));
2435 /* There are various functions like symbol_file_add,
2436 symfile_bfd_open, syms_from_objfile, etc., which might
2437 appear to do what we want. But they have various other
2438 effects which we *don't* want. So we just do stuff
2439 ourselves. We don't worry about mapped files (for one thing,
2440 any mapped file will be out of date). */
2442 /* If we get an error, blow away this objfile (not sure if
2443 that is the correct response for things like shared
2445 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
2447 /* We need to do this whenever any symbols go away. */
2448 old_cleanups
= make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2450 if (exec_bfd
!= NULL
2451 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2452 bfd_get_filename (exec_bfd
)) == 0)
2454 /* Reload EXEC_BFD without asking anything. */
2456 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2459 /* Keep the calls order approx. the same as in free_objfile. */
2461 /* Free the separate debug objfiles. It will be
2462 automatically recreated by sym_read. */
2463 free_objfile_separate_debug (objfile
);
2465 /* Remove any references to this objfile in the global
2467 preserve_values (objfile
);
2469 /* Nuke all the state that we will re-read. Much of the following
2470 code which sets things to NULL really is necessary to tell
2471 other parts of GDB that there is nothing currently there.
2473 Try to keep the freeing order compatible with free_objfile. */
2475 if (objfile
->sf
!= NULL
)
2477 (*objfile
->sf
->sym_finish
) (objfile
);
2480 clear_objfile_data (objfile
);
2482 /* Clean up any state BFD has sitting around. */
2484 gdb_bfd_ref_ptr
obfd (objfile
->obfd
);
2485 char *obfd_filename
;
2487 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2488 /* Open the new BFD before freeing the old one, so that
2489 the filename remains live. */
2490 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
, -1));
2491 objfile
->obfd
= temp
.release ();
2492 if (objfile
->obfd
== NULL
)
2493 error (_("Can't open %s to read symbols."), obfd_filename
);
2496 original_name
= xstrdup (objfile
->original_name
);
2497 make_cleanup (xfree
, original_name
);
2499 /* bfd_openr sets cacheable to true, which is what we want. */
2500 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2501 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2502 bfd_errmsg (bfd_get_error ()));
2504 /* Save the offsets, we will nuke them with the rest of the
2506 num_offsets
= objfile
->num_sections
;
2507 offsets
= ((struct section_offsets
*)
2508 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2509 memcpy (offsets
, objfile
->section_offsets
,
2510 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2512 /* FIXME: Do we have to free a whole linked list, or is this
2514 objfile
->global_psymbols
.clear ();
2515 objfile
->static_psymbols
.clear ();
2517 /* Free the obstacks for non-reusable objfiles. */
2518 psymbol_bcache_free (objfile
->psymbol_cache
);
2519 objfile
->psymbol_cache
= psymbol_bcache_init ();
2521 /* NB: after this call to obstack_free, objfiles_changed
2522 will need to be called (see discussion below). */
2523 obstack_free (&objfile
->objfile_obstack
, 0);
2524 objfile
->sections
= NULL
;
2525 objfile
->compunit_symtabs
= NULL
;
2526 objfile
->psymtabs
= NULL
;
2527 objfile
->psymtabs_addrmap
= NULL
;
2528 objfile
->free_psymtabs
= NULL
;
2529 objfile
->template_symbols
= NULL
;
2531 /* obstack_init also initializes the obstack so it is
2532 empty. We could use obstack_specify_allocation but
2533 gdb_obstack.h specifies the alloc/dealloc functions. */
2534 obstack_init (&objfile
->objfile_obstack
);
2536 /* set_objfile_per_bfd potentially allocates the per-bfd
2537 data on the objfile's obstack (if sharing data across
2538 multiple users is not possible), so it's important to
2539 do it *after* the obstack has been initialized. */
2540 set_objfile_per_bfd (objfile
);
2542 objfile
->original_name
2543 = (char *) obstack_copy0 (&objfile
->objfile_obstack
, original_name
,
2544 strlen (original_name
));
2546 /* Reset the sym_fns pointer. The ELF reader can change it
2547 based on whether .gdb_index is present, and we need it to
2548 start over. PR symtab/15885 */
2549 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
2551 build_objfile_section_table (objfile
);
2552 terminate_minimal_symbol_table (objfile
);
2554 /* We use the same section offsets as from last time. I'm not
2555 sure whether that is always correct for shared libraries. */
2556 objfile
->section_offsets
= (struct section_offsets
*)
2557 obstack_alloc (&objfile
->objfile_obstack
,
2558 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2559 memcpy (objfile
->section_offsets
, offsets
,
2560 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2561 objfile
->num_sections
= num_offsets
;
2563 /* What the hell is sym_new_init for, anyway? The concept of
2564 distinguishing between the main file and additional files
2565 in this way seems rather dubious. */
2566 if (objfile
== symfile_objfile
)
2568 (*objfile
->sf
->sym_new_init
) (objfile
);
2571 (*objfile
->sf
->sym_init
) (objfile
);
2572 clear_complaints (&symfile_complaints
, 1, 1);
2574 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2576 /* We are about to read new symbols and potentially also
2577 DWARF information. Some targets may want to pass addresses
2578 read from DWARF DIE's through an adjustment function before
2579 saving them, like MIPS, which may call into
2580 "find_pc_section". When called, that function will make
2581 use of per-objfile program space data.
2583 Since we discarded our section information above, we have
2584 dangling pointers in the per-objfile program space data
2585 structure. Force GDB to update the section mapping
2586 information by letting it know the objfile has changed,
2587 making the dangling pointers point to correct data
2590 objfiles_changed ();
2592 read_symbols (objfile
, 0);
2594 if (!objfile_has_symbols (objfile
))
2597 printf_unfiltered (_("(no debugging symbols found)\n"));
2601 /* We're done reading the symbol file; finish off complaints. */
2602 clear_complaints (&symfile_complaints
, 0, 1);
2604 /* Getting new symbols may change our opinion about what is
2607 reinit_frame_cache ();
2609 /* Discard cleanups as symbol reading was successful. */
2610 objfile_holder
.release ();
2611 discard_cleanups (old_cleanups
);
2613 /* If the mtime has changed between the time we set new_modtime
2614 and now, we *want* this to be out of date, so don't call stat
2616 objfile
->mtime
= new_modtime
;
2617 init_entry_point_info (objfile
);
2619 new_objfiles
.push_back (objfile
);
2623 if (!new_objfiles
.empty ())
2625 clear_symtab_users (0);
2627 /* clear_objfile_data for each objfile was called before freeing it and
2628 observer_notify_new_objfile (NULL) has been called by
2629 clear_symtab_users above. Notify the new files now. */
2630 for (auto iter
: new_objfiles
)
2631 observer_notify_new_objfile (iter
);
2633 /* At least one objfile has changed, so we can consider that
2634 the executable we're debugging has changed too. */
2635 observer_notify_executable_changed ();
2640 struct filename_language
2642 filename_language (const std::string
&ext_
, enum language lang_
)
2643 : ext (ext_
), lang (lang_
)
2650 static std::vector
<filename_language
> filename_language_table
;
2652 /* See symfile.h. */
2655 add_filename_language (const char *ext
, enum language lang
)
2657 filename_language_table
.emplace_back (ext
, lang
);
2660 static char *ext_args
;
2662 show_ext_args (struct ui_file
*file
, int from_tty
,
2663 struct cmd_list_element
*c
, const char *value
)
2665 fprintf_filtered (file
,
2666 _("Mapping between filename extension "
2667 "and source language is \"%s\".\n"),
2672 set_ext_lang_command (const char *args
,
2673 int from_tty
, struct cmd_list_element
*e
)
2675 char *cp
= ext_args
;
2678 /* First arg is filename extension, starting with '.' */
2680 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2682 /* Find end of first arg. */
2683 while (*cp
&& !isspace (*cp
))
2687 error (_("'%s': two arguments required -- "
2688 "filename extension and language"),
2691 /* Null-terminate first arg. */
2694 /* Find beginning of second arg, which should be a source language. */
2695 cp
= skip_spaces (cp
);
2698 error (_("'%s': two arguments required -- "
2699 "filename extension and language"),
2702 /* Lookup the language from among those we know. */
2703 lang
= language_enum (cp
);
2705 auto it
= filename_language_table
.begin ();
2706 /* Now lookup the filename extension: do we already know it? */
2707 for (; it
!= filename_language_table
.end (); it
++)
2709 if (it
->ext
== ext_args
)
2713 if (it
== filename_language_table
.end ())
2715 /* New file extension. */
2716 add_filename_language (ext_args
, lang
);
2720 /* Redefining a previously known filename extension. */
2723 /* query ("Really make files of type %s '%s'?", */
2724 /* ext_args, language_str (lang)); */
2731 info_ext_lang_command (const char *args
, int from_tty
)
2733 printf_filtered (_("Filename extensions and the languages they represent:"));
2734 printf_filtered ("\n\n");
2735 for (const filename_language
&entry
: filename_language_table
)
2736 printf_filtered ("\t%s\t- %s\n", entry
.ext
.c_str (),
2737 language_str (entry
.lang
));
2741 deduce_language_from_filename (const char *filename
)
2745 if (filename
!= NULL
)
2746 if ((cp
= strrchr (filename
, '.')) != NULL
)
2748 for (const filename_language
&entry
: filename_language_table
)
2749 if (entry
.ext
== cp
)
2753 return language_unknown
;
2756 /* Allocate and initialize a new symbol table.
2757 CUST is from the result of allocate_compunit_symtab. */
2760 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
)
2762 struct objfile
*objfile
= cust
->objfile
;
2763 struct symtab
*symtab
2764 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2767 = (const char *) bcache (filename
, strlen (filename
) + 1,
2768 objfile
->per_bfd
->filename_cache
);
2769 symtab
->fullname
= NULL
;
2770 symtab
->language
= deduce_language_from_filename (filename
);
2772 /* This can be very verbose with lots of headers.
2773 Only print at higher debug levels. */
2774 if (symtab_create_debug
>= 2)
2776 /* Be a bit clever with debugging messages, and don't print objfile
2777 every time, only when it changes. */
2778 static char *last_objfile_name
= NULL
;
2780 if (last_objfile_name
== NULL
2781 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
2783 xfree (last_objfile_name
);
2784 last_objfile_name
= xstrdup (objfile_name (objfile
));
2785 fprintf_unfiltered (gdb_stdlog
,
2786 "Creating one or more symtabs for objfile %s ...\n",
2789 fprintf_unfiltered (gdb_stdlog
,
2790 "Created symtab %s for module %s.\n",
2791 host_address_to_string (symtab
), filename
);
2794 /* Add it to CUST's list of symtabs. */
2795 if (cust
->filetabs
== NULL
)
2797 cust
->filetabs
= symtab
;
2798 cust
->last_filetab
= symtab
;
2802 cust
->last_filetab
->next
= symtab
;
2803 cust
->last_filetab
= symtab
;
2806 /* Backlink to the containing compunit symtab. */
2807 symtab
->compunit_symtab
= cust
;
2812 /* Allocate and initialize a new compunit.
2813 NAME is the name of the main source file, if there is one, or some
2814 descriptive text if there are no source files. */
2816 struct compunit_symtab
*
2817 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2819 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2820 struct compunit_symtab
);
2821 const char *saved_name
;
2823 cu
->objfile
= objfile
;
2825 /* The name we record here is only for display/debugging purposes.
2826 Just save the basename to avoid path issues (too long for display,
2827 relative vs absolute, etc.). */
2828 saved_name
= lbasename (name
);
2830 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
, saved_name
,
2831 strlen (saved_name
));
2833 COMPUNIT_DEBUGFORMAT (cu
) = "unknown";
2835 if (symtab_create_debug
)
2837 fprintf_unfiltered (gdb_stdlog
,
2838 "Created compunit symtab %s for %s.\n",
2839 host_address_to_string (cu
),
2846 /* Hook CU to the objfile it comes from. */
2849 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2851 cu
->next
= cu
->objfile
->compunit_symtabs
;
2852 cu
->objfile
->compunit_symtabs
= cu
;
2856 /* Reset all data structures in gdb which may contain references to
2857 symbol table data. */
2860 clear_symtab_users (symfile_add_flags add_flags
)
2862 /* Someday, we should do better than this, by only blowing away
2863 the things that really need to be blown. */
2865 /* Clear the "current" symtab first, because it is no longer valid.
2866 breakpoint_re_set may try to access the current symtab. */
2867 clear_current_source_symtab_and_line ();
2870 clear_last_displayed_sal ();
2871 clear_pc_function_cache ();
2872 observer_notify_new_objfile (NULL
);
2874 /* Clear globals which might have pointed into a removed objfile.
2875 FIXME: It's not clear which of these are supposed to persist
2876 between expressions and which ought to be reset each time. */
2877 expression_context_block
= NULL
;
2878 innermost_block
= NULL
;
2880 /* Varobj may refer to old symbols, perform a cleanup. */
2881 varobj_invalidate ();
2883 /* Now that the various caches have been cleared, we can re_set
2884 our breakpoints without risking it using stale data. */
2885 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2886 breakpoint_re_set ();
2890 clear_symtab_users_cleanup (void *ignore
)
2892 clear_symtab_users (0);
2896 The following code implements an abstraction for debugging overlay sections.
2898 The target model is as follows:
2899 1) The gnu linker will permit multiple sections to be mapped into the
2900 same VMA, each with its own unique LMA (or load address).
2901 2) It is assumed that some runtime mechanism exists for mapping the
2902 sections, one by one, from the load address into the VMA address.
2903 3) This code provides a mechanism for gdb to keep track of which
2904 sections should be considered to be mapped from the VMA to the LMA.
2905 This information is used for symbol lookup, and memory read/write.
2906 For instance, if a section has been mapped then its contents
2907 should be read from the VMA, otherwise from the LMA.
2909 Two levels of debugger support for overlays are available. One is
2910 "manual", in which the debugger relies on the user to tell it which
2911 overlays are currently mapped. This level of support is
2912 implemented entirely in the core debugger, and the information about
2913 whether a section is mapped is kept in the objfile->obj_section table.
2915 The second level of support is "automatic", and is only available if
2916 the target-specific code provides functionality to read the target's
2917 overlay mapping table, and translate its contents for the debugger
2918 (by updating the mapped state information in the obj_section tables).
2920 The interface is as follows:
2922 overlay map <name> -- tell gdb to consider this section mapped
2923 overlay unmap <name> -- tell gdb to consider this section unmapped
2924 overlay list -- list the sections that GDB thinks are mapped
2925 overlay read-target -- get the target's state of what's mapped
2926 overlay off/manual/auto -- set overlay debugging state
2927 Functional interface:
2928 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2929 section, return that section.
2930 find_pc_overlay(pc): find any overlay section that contains
2931 the pc, either in its VMA or its LMA
2932 section_is_mapped(sect): true if overlay is marked as mapped
2933 section_is_overlay(sect): true if section's VMA != LMA
2934 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2935 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2936 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2937 overlay_mapped_address(...): map an address from section's LMA to VMA
2938 overlay_unmapped_address(...): map an address from section's VMA to LMA
2939 symbol_overlayed_address(...): Return a "current" address for symbol:
2940 either in VMA or LMA depending on whether
2941 the symbol's section is currently mapped. */
2943 /* Overlay debugging state: */
2945 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2946 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2948 /* Function: section_is_overlay (SECTION)
2949 Returns true if SECTION has VMA not equal to LMA, ie.
2950 SECTION is loaded at an address different from where it will "run". */
2953 section_is_overlay (struct obj_section
*section
)
2955 if (overlay_debugging
&& section
)
2957 bfd
*abfd
= section
->objfile
->obfd
;
2958 asection
*bfd_section
= section
->the_bfd_section
;
2960 if (bfd_section_lma (abfd
, bfd_section
) != 0
2961 && bfd_section_lma (abfd
, bfd_section
)
2962 != bfd_section_vma (abfd
, bfd_section
))
2969 /* Function: overlay_invalidate_all (void)
2970 Invalidate the mapped state of all overlay sections (mark it as stale). */
2973 overlay_invalidate_all (void)
2975 struct objfile
*objfile
;
2976 struct obj_section
*sect
;
2978 ALL_OBJSECTIONS (objfile
, sect
)
2979 if (section_is_overlay (sect
))
2980 sect
->ovly_mapped
= -1;
2983 /* Function: section_is_mapped (SECTION)
2984 Returns true if section is an overlay, and is currently mapped.
2986 Access to the ovly_mapped flag is restricted to this function, so
2987 that we can do automatic update. If the global flag
2988 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2989 overlay_invalidate_all. If the mapped state of the particular
2990 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2993 section_is_mapped (struct obj_section
*osect
)
2995 struct gdbarch
*gdbarch
;
2997 if (osect
== 0 || !section_is_overlay (osect
))
3000 switch (overlay_debugging
)
3004 return 0; /* overlay debugging off */
3005 case ovly_auto
: /* overlay debugging automatic */
3006 /* Unles there is a gdbarch_overlay_update function,
3007 there's really nothing useful to do here (can't really go auto). */
3008 gdbarch
= get_objfile_arch (osect
->objfile
);
3009 if (gdbarch_overlay_update_p (gdbarch
))
3011 if (overlay_cache_invalid
)
3013 overlay_invalidate_all ();
3014 overlay_cache_invalid
= 0;
3016 if (osect
->ovly_mapped
== -1)
3017 gdbarch_overlay_update (gdbarch
, osect
);
3019 /* fall thru to manual case */
3020 case ovly_on
: /* overlay debugging manual */
3021 return osect
->ovly_mapped
== 1;
3025 /* Function: pc_in_unmapped_range
3026 If PC falls into the lma range of SECTION, return true, else false. */
3029 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3031 if (section_is_overlay (section
))
3033 bfd
*abfd
= section
->objfile
->obfd
;
3034 asection
*bfd_section
= section
->the_bfd_section
;
3036 /* We assume the LMA is relocated by the same offset as the VMA. */
3037 bfd_vma size
= bfd_get_section_size (bfd_section
);
3038 CORE_ADDR offset
= obj_section_offset (section
);
3040 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3041 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3048 /* Function: pc_in_mapped_range
3049 If PC falls into the vma range of SECTION, return true, else false. */
3052 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3054 if (section_is_overlay (section
))
3056 if (obj_section_addr (section
) <= pc
3057 && pc
< obj_section_endaddr (section
))
3064 /* Return true if the mapped ranges of sections A and B overlap, false
3068 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3070 CORE_ADDR a_start
= obj_section_addr (a
);
3071 CORE_ADDR a_end
= obj_section_endaddr (a
);
3072 CORE_ADDR b_start
= obj_section_addr (b
);
3073 CORE_ADDR b_end
= obj_section_endaddr (b
);
3075 return (a_start
< b_end
&& b_start
< a_end
);
3078 /* Function: overlay_unmapped_address (PC, SECTION)
3079 Returns the address corresponding to PC in the unmapped (load) range.
3080 May be the same as PC. */
3083 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3085 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3087 bfd
*abfd
= section
->objfile
->obfd
;
3088 asection
*bfd_section
= section
->the_bfd_section
;
3090 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3091 - bfd_section_vma (abfd
, bfd_section
);
3097 /* Function: overlay_mapped_address (PC, SECTION)
3098 Returns the address corresponding to PC in the mapped (runtime) range.
3099 May be the same as PC. */
3102 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3104 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3106 bfd
*abfd
= section
->objfile
->obfd
;
3107 asection
*bfd_section
= section
->the_bfd_section
;
3109 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3110 - bfd_section_lma (abfd
, bfd_section
);
3116 /* Function: symbol_overlayed_address
3117 Return one of two addresses (relative to the VMA or to the LMA),
3118 depending on whether the section is mapped or not. */
3121 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3123 if (overlay_debugging
)
3125 /* If the symbol has no section, just return its regular address. */
3128 /* If the symbol's section is not an overlay, just return its
3130 if (!section_is_overlay (section
))
3132 /* If the symbol's section is mapped, just return its address. */
3133 if (section_is_mapped (section
))
3136 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3137 * then return its LOADED address rather than its vma address!!
3139 return overlay_unmapped_address (address
, section
);
3144 /* Function: find_pc_overlay (PC)
3145 Return the best-match overlay section for PC:
3146 If PC matches a mapped overlay section's VMA, return that section.
3147 Else if PC matches an unmapped section's VMA, return that section.
3148 Else if PC matches an unmapped section's LMA, return that section. */
3150 struct obj_section
*
3151 find_pc_overlay (CORE_ADDR pc
)
3153 struct objfile
*objfile
;
3154 struct obj_section
*osect
, *best_match
= NULL
;
3156 if (overlay_debugging
)
3158 ALL_OBJSECTIONS (objfile
, osect
)
3159 if (section_is_overlay (osect
))
3161 if (pc_in_mapped_range (pc
, osect
))
3163 if (section_is_mapped (osect
))
3168 else if (pc_in_unmapped_range (pc
, osect
))
3175 /* Function: find_pc_mapped_section (PC)
3176 If PC falls into the VMA address range of an overlay section that is
3177 currently marked as MAPPED, return that section. Else return NULL. */
3179 struct obj_section
*
3180 find_pc_mapped_section (CORE_ADDR pc
)
3182 struct objfile
*objfile
;
3183 struct obj_section
*osect
;
3185 if (overlay_debugging
)
3187 ALL_OBJSECTIONS (objfile
, osect
)
3188 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3195 /* Function: list_overlays_command
3196 Print a list of mapped sections and their PC ranges. */
3199 list_overlays_command (const char *args
, int from_tty
)
3202 struct objfile
*objfile
;
3203 struct obj_section
*osect
;
3205 if (overlay_debugging
)
3207 ALL_OBJSECTIONS (objfile
, osect
)
3208 if (section_is_mapped (osect
))
3210 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3215 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3216 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3217 size
= bfd_get_section_size (osect
->the_bfd_section
);
3218 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3220 printf_filtered ("Section %s, loaded at ", name
);
3221 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3222 puts_filtered (" - ");
3223 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3224 printf_filtered (", mapped at ");
3225 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3226 puts_filtered (" - ");
3227 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3228 puts_filtered ("\n");
3234 printf_filtered (_("No sections are mapped.\n"));
3237 /* Function: map_overlay_command
3238 Mark the named section as mapped (ie. residing at its VMA address). */
3241 map_overlay_command (const char *args
, int from_tty
)
3243 struct objfile
*objfile
, *objfile2
;
3244 struct obj_section
*sec
, *sec2
;
3246 if (!overlay_debugging
)
3247 error (_("Overlay debugging not enabled. Use "
3248 "either the 'overlay auto' or\n"
3249 "the 'overlay manual' command."));
3251 if (args
== 0 || *args
== 0)
3252 error (_("Argument required: name of an overlay section"));
3254 /* First, find a section matching the user supplied argument. */
3255 ALL_OBJSECTIONS (objfile
, sec
)
3256 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3258 /* Now, check to see if the section is an overlay. */
3259 if (!section_is_overlay (sec
))
3260 continue; /* not an overlay section */
3262 /* Mark the overlay as "mapped". */
3263 sec
->ovly_mapped
= 1;
3265 /* Next, make a pass and unmap any sections that are
3266 overlapped by this new section: */
3267 ALL_OBJSECTIONS (objfile2
, sec2
)
3268 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3271 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3272 bfd_section_name (objfile
->obfd
,
3273 sec2
->the_bfd_section
));
3274 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3278 error (_("No overlay section called %s"), args
);
3281 /* Function: unmap_overlay_command
3282 Mark the overlay section as unmapped
3283 (ie. resident in its LMA address range, rather than the VMA range). */
3286 unmap_overlay_command (const char *args
, int from_tty
)
3288 struct objfile
*objfile
;
3289 struct obj_section
*sec
= NULL
;
3291 if (!overlay_debugging
)
3292 error (_("Overlay debugging not enabled. "
3293 "Use either the 'overlay auto' or\n"
3294 "the 'overlay manual' command."));
3296 if (args
== 0 || *args
== 0)
3297 error (_("Argument required: name of an overlay section"));
3299 /* First, find a section matching the user supplied argument. */
3300 ALL_OBJSECTIONS (objfile
, sec
)
3301 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3303 if (!sec
->ovly_mapped
)
3304 error (_("Section %s is not mapped"), args
);
3305 sec
->ovly_mapped
= 0;
3308 error (_("No overlay section called %s"), args
);
3311 /* Function: overlay_auto_command
3312 A utility command to turn on overlay debugging.
3313 Possibly this should be done via a set/show command. */
3316 overlay_auto_command (const char *args
, int from_tty
)
3318 overlay_debugging
= ovly_auto
;
3319 enable_overlay_breakpoints ();
3321 printf_unfiltered (_("Automatic overlay debugging enabled."));
3324 /* Function: overlay_manual_command
3325 A utility command to turn on overlay debugging.
3326 Possibly this should be done via a set/show command. */
3329 overlay_manual_command (const char *args
, int from_tty
)
3331 overlay_debugging
= ovly_on
;
3332 disable_overlay_breakpoints ();
3334 printf_unfiltered (_("Overlay debugging enabled."));
3337 /* Function: overlay_off_command
3338 A utility command to turn on overlay debugging.
3339 Possibly this should be done via a set/show command. */
3342 overlay_off_command (const char *args
, int from_tty
)
3344 overlay_debugging
= ovly_off
;
3345 disable_overlay_breakpoints ();
3347 printf_unfiltered (_("Overlay debugging disabled."));
3351 overlay_load_command (const char *args
, int from_tty
)
3353 struct gdbarch
*gdbarch
= get_current_arch ();
3355 if (gdbarch_overlay_update_p (gdbarch
))
3356 gdbarch_overlay_update (gdbarch
, NULL
);
3358 error (_("This target does not know how to read its overlay state."));
3361 /* Function: overlay_command
3362 A place-holder for a mis-typed command. */
3364 /* Command list chain containing all defined "overlay" subcommands. */
3365 static struct cmd_list_element
*overlaylist
;
3368 overlay_command (const char *args
, int from_tty
)
3371 ("\"overlay\" must be followed by the name of an overlay command.\n");
3372 help_list (overlaylist
, "overlay ", all_commands
, gdb_stdout
);
3375 /* Target Overlays for the "Simplest" overlay manager:
3377 This is GDB's default target overlay layer. It works with the
3378 minimal overlay manager supplied as an example by Cygnus. The
3379 entry point is via a function pointer "gdbarch_overlay_update",
3380 so targets that use a different runtime overlay manager can
3381 substitute their own overlay_update function and take over the
3384 The overlay_update function pokes around in the target's data structures
3385 to see what overlays are mapped, and updates GDB's overlay mapping with
3388 In this simple implementation, the target data structures are as follows:
3389 unsigned _novlys; /# number of overlay sections #/
3390 unsigned _ovly_table[_novlys][4] = {
3391 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3392 {..., ..., ..., ...},
3394 unsigned _novly_regions; /# number of overlay regions #/
3395 unsigned _ovly_region_table[_novly_regions][3] = {
3396 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3399 These functions will attempt to update GDB's mappedness state in the
3400 symbol section table, based on the target's mappedness state.
3402 To do this, we keep a cached copy of the target's _ovly_table, and
3403 attempt to detect when the cached copy is invalidated. The main
3404 entry point is "simple_overlay_update(SECT), which looks up SECT in
3405 the cached table and re-reads only the entry for that section from
3406 the target (whenever possible). */
3408 /* Cached, dynamically allocated copies of the target data structures: */
3409 static unsigned (*cache_ovly_table
)[4] = 0;
3410 static unsigned cache_novlys
= 0;
3411 static CORE_ADDR cache_ovly_table_base
= 0;
3414 VMA
, OSIZE
, LMA
, MAPPED
3417 /* Throw away the cached copy of _ovly_table. */
3420 simple_free_overlay_table (void)
3422 if (cache_ovly_table
)
3423 xfree (cache_ovly_table
);
3425 cache_ovly_table
= NULL
;
3426 cache_ovly_table_base
= 0;
3429 /* Read an array of ints of size SIZE from the target into a local buffer.
3430 Convert to host order. int LEN is number of ints. */
3433 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3434 int len
, int size
, enum bfd_endian byte_order
)
3436 /* FIXME (alloca): Not safe if array is very large. */
3437 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3440 read_memory (memaddr
, buf
, len
* size
);
3441 for (i
= 0; i
< len
; i
++)
3442 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3445 /* Find and grab a copy of the target _ovly_table
3446 (and _novlys, which is needed for the table's size). */
3449 simple_read_overlay_table (void)
3451 struct bound_minimal_symbol novlys_msym
;
3452 struct bound_minimal_symbol ovly_table_msym
;
3453 struct gdbarch
*gdbarch
;
3455 enum bfd_endian byte_order
;
3457 simple_free_overlay_table ();
3458 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3459 if (! novlys_msym
.minsym
)
3461 error (_("Error reading inferior's overlay table: "
3462 "couldn't find `_novlys' variable\n"
3463 "in inferior. Use `overlay manual' mode."));
3467 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3468 if (! ovly_table_msym
.minsym
)
3470 error (_("Error reading inferior's overlay table: couldn't find "
3471 "`_ovly_table' array\n"
3472 "in inferior. Use `overlay manual' mode."));
3476 gdbarch
= get_objfile_arch (ovly_table_msym
.objfile
);
3477 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3478 byte_order
= gdbarch_byte_order (gdbarch
);
3480 cache_novlys
= read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym
),
3483 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3484 cache_ovly_table_base
= BMSYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3485 read_target_long_array (cache_ovly_table_base
,
3486 (unsigned int *) cache_ovly_table
,
3487 cache_novlys
* 4, word_size
, byte_order
);
3489 return 1; /* SUCCESS */
3492 /* Function: simple_overlay_update_1
3493 A helper function for simple_overlay_update. Assuming a cached copy
3494 of _ovly_table exists, look through it to find an entry whose vma,
3495 lma and size match those of OSECT. Re-read the entry and make sure
3496 it still matches OSECT (else the table may no longer be valid).
3497 Set OSECT's mapped state to match the entry. Return: 1 for
3498 success, 0 for failure. */
3501 simple_overlay_update_1 (struct obj_section
*osect
)
3504 bfd
*obfd
= osect
->objfile
->obfd
;
3505 asection
*bsect
= osect
->the_bfd_section
;
3506 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3507 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3508 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3510 for (i
= 0; i
< cache_novlys
; i
++)
3511 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3512 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3514 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3515 (unsigned int *) cache_ovly_table
[i
],
3516 4, word_size
, byte_order
);
3517 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3518 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3520 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3523 else /* Warning! Warning! Target's ovly table has changed! */
3529 /* Function: simple_overlay_update
3530 If OSECT is NULL, then update all sections' mapped state
3531 (after re-reading the entire target _ovly_table).
3532 If OSECT is non-NULL, then try to find a matching entry in the
3533 cached ovly_table and update only OSECT's mapped state.
3534 If a cached entry can't be found or the cache isn't valid, then
3535 re-read the entire cache, and go ahead and update all sections. */
3538 simple_overlay_update (struct obj_section
*osect
)
3540 struct objfile
*objfile
;
3542 /* Were we given an osect to look up? NULL means do all of them. */
3544 /* Have we got a cached copy of the target's overlay table? */
3545 if (cache_ovly_table
!= NULL
)
3547 /* Does its cached location match what's currently in the
3549 struct bound_minimal_symbol minsym
3550 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3552 if (minsym
.minsym
== NULL
)
3553 error (_("Error reading inferior's overlay table: couldn't "
3554 "find `_ovly_table' array\n"
3555 "in inferior. Use `overlay manual' mode."));
3557 if (cache_ovly_table_base
== BMSYMBOL_VALUE_ADDRESS (minsym
))
3558 /* Then go ahead and try to look up this single section in
3560 if (simple_overlay_update_1 (osect
))
3561 /* Found it! We're done. */
3565 /* Cached table no good: need to read the entire table anew.
3566 Or else we want all the sections, in which case it's actually
3567 more efficient to read the whole table in one block anyway. */
3569 if (! simple_read_overlay_table ())
3572 /* Now may as well update all sections, even if only one was requested. */
3573 ALL_OBJSECTIONS (objfile
, osect
)
3574 if (section_is_overlay (osect
))
3577 bfd
*obfd
= osect
->objfile
->obfd
;
3578 asection
*bsect
= osect
->the_bfd_section
;
3580 for (i
= 0; i
< cache_novlys
; i
++)
3581 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3582 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3583 { /* obj_section matches i'th entry in ovly_table. */
3584 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3585 break; /* finished with inner for loop: break out. */
3590 /* Set the output sections and output offsets for section SECTP in
3591 ABFD. The relocation code in BFD will read these offsets, so we
3592 need to be sure they're initialized. We map each section to itself,
3593 with no offset; this means that SECTP->vma will be honored. */
3596 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3598 sectp
->output_section
= sectp
;
3599 sectp
->output_offset
= 0;
3602 /* Default implementation for sym_relocate. */
3605 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3608 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3610 bfd
*abfd
= sectp
->owner
;
3612 /* We're only interested in sections with relocation
3614 if ((sectp
->flags
& SEC_RELOC
) == 0)
3617 /* We will handle section offsets properly elsewhere, so relocate as if
3618 all sections begin at 0. */
3619 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3621 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3624 /* Relocate the contents of a debug section SECTP in ABFD. The
3625 contents are stored in BUF if it is non-NULL, or returned in a
3626 malloc'd buffer otherwise.
3628 For some platforms and debug info formats, shared libraries contain
3629 relocations against the debug sections (particularly for DWARF-2;
3630 one affected platform is PowerPC GNU/Linux, although it depends on
3631 the version of the linker in use). Also, ELF object files naturally
3632 have unresolved relocations for their debug sections. We need to apply
3633 the relocations in order to get the locations of symbols correct.
3634 Another example that may require relocation processing, is the
3635 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3639 symfile_relocate_debug_section (struct objfile
*objfile
,
3640 asection
*sectp
, bfd_byte
*buf
)
3642 gdb_assert (objfile
->sf
->sym_relocate
);
3644 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3647 struct symfile_segment_data
*
3648 get_symfile_segment_data (bfd
*abfd
)
3650 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3655 return sf
->sym_segments (abfd
);
3659 free_symfile_segment_data (struct symfile_segment_data
*data
)
3661 xfree (data
->segment_bases
);
3662 xfree (data
->segment_sizes
);
3663 xfree (data
->segment_info
);
3668 - DATA, containing segment addresses from the object file ABFD, and
3669 the mapping from ABFD's sections onto the segments that own them,
3671 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3672 segment addresses reported by the target,
3673 store the appropriate offsets for each section in OFFSETS.
3675 If there are fewer entries in SEGMENT_BASES than there are segments
3676 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3678 If there are more entries, then ignore the extra. The target may
3679 not be able to distinguish between an empty data segment and a
3680 missing data segment; a missing text segment is less plausible. */
3683 symfile_map_offsets_to_segments (bfd
*abfd
,
3684 const struct symfile_segment_data
*data
,
3685 struct section_offsets
*offsets
,
3686 int num_segment_bases
,
3687 const CORE_ADDR
*segment_bases
)
3692 /* It doesn't make sense to call this function unless you have some
3693 segment base addresses. */
3694 gdb_assert (num_segment_bases
> 0);
3696 /* If we do not have segment mappings for the object file, we
3697 can not relocate it by segments. */
3698 gdb_assert (data
!= NULL
);
3699 gdb_assert (data
->num_segments
> 0);
3701 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3703 int which
= data
->segment_info
[i
];
3705 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3707 /* Don't bother computing offsets for sections that aren't
3708 loaded as part of any segment. */
3712 /* Use the last SEGMENT_BASES entry as the address of any extra
3713 segments mentioned in DATA->segment_info. */
3714 if (which
> num_segment_bases
)
3715 which
= num_segment_bases
;
3717 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3718 - data
->segment_bases
[which
- 1]);
3725 symfile_find_segment_sections (struct objfile
*objfile
)
3727 bfd
*abfd
= objfile
->obfd
;
3730 struct symfile_segment_data
*data
;
3732 data
= get_symfile_segment_data (objfile
->obfd
);
3736 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3738 free_symfile_segment_data (data
);
3742 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3744 int which
= data
->segment_info
[i
];
3748 if (objfile
->sect_index_text
== -1)
3749 objfile
->sect_index_text
= sect
->index
;
3751 if (objfile
->sect_index_rodata
== -1)
3752 objfile
->sect_index_rodata
= sect
->index
;
3754 else if (which
== 2)
3756 if (objfile
->sect_index_data
== -1)
3757 objfile
->sect_index_data
= sect
->index
;
3759 if (objfile
->sect_index_bss
== -1)
3760 objfile
->sect_index_bss
= sect
->index
;
3764 free_symfile_segment_data (data
);
3767 /* Listen for free_objfile events. */
3770 symfile_free_objfile (struct objfile
*objfile
)
3772 /* Remove the target sections owned by this objfile. */
3773 if (objfile
!= NULL
)
3774 remove_target_sections ((void *) objfile
);
3777 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3778 Expand all symtabs that match the specified criteria.
3779 See quick_symbol_functions.expand_symtabs_matching for details. */
3782 expand_symtabs_matching
3783 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3784 const lookup_name_info
&lookup_name
,
3785 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3786 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3787 enum search_domain kind
)
3789 struct objfile
*objfile
;
3791 ALL_OBJFILES (objfile
)
3794 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, file_matcher
,
3797 expansion_notify
, kind
);
3801 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3802 Map function FUN over every file.
3803 See quick_symbol_functions.map_symbol_filenames for details. */
3806 map_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
3809 struct objfile
*objfile
;
3811 ALL_OBJFILES (objfile
)
3814 objfile
->sf
->qf
->map_symbol_filenames (objfile
, fun
, data
,
3821 namespace selftests
{
3822 namespace filename_language
{
3824 static void test_filename_language ()
3826 /* This test messes up the filename_language_table global. */
3827 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3829 /* Test deducing an unknown extension. */
3830 language lang
= deduce_language_from_filename ("myfile.blah");
3831 SELF_CHECK (lang
== language_unknown
);
3833 /* Test deducing a known extension. */
3834 lang
= deduce_language_from_filename ("myfile.c");
3835 SELF_CHECK (lang
== language_c
);
3837 /* Test adding a new extension using the internal API. */
3838 add_filename_language (".blah", language_pascal
);
3839 lang
= deduce_language_from_filename ("myfile.blah");
3840 SELF_CHECK (lang
== language_pascal
);
3844 test_set_ext_lang_command ()
3846 /* This test messes up the filename_language_table global. */
3847 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3849 /* Confirm that the .hello extension is not known. */
3850 language lang
= deduce_language_from_filename ("cake.hello");
3851 SELF_CHECK (lang
== language_unknown
);
3853 /* Test adding a new extension using the CLI command. */
3854 gdb::unique_xmalloc_ptr
<char> args_holder (xstrdup (".hello rust"));
3855 ext_args
= args_holder
.get ();
3856 set_ext_lang_command (NULL
, 1, NULL
);
3858 lang
= deduce_language_from_filename ("cake.hello");
3859 SELF_CHECK (lang
== language_rust
);
3861 /* Test overriding an existing extension using the CLI command. */
3862 int size_before
= filename_language_table
.size ();
3863 args_holder
.reset (xstrdup (".hello pascal"));
3864 ext_args
= args_holder
.get ();
3865 set_ext_lang_command (NULL
, 1, NULL
);
3866 int size_after
= filename_language_table
.size ();
3868 lang
= deduce_language_from_filename ("cake.hello");
3869 SELF_CHECK (lang
== language_pascal
);
3870 SELF_CHECK (size_before
== size_after
);
3873 } /* namespace filename_language */
3874 } /* namespace selftests */
3876 #endif /* GDB_SELF_TEST */
3879 _initialize_symfile (void)
3881 struct cmd_list_element
*c
;
3883 observer_attach_free_objfile (symfile_free_objfile
);
3885 #define READNOW_HELP \
3886 "The '-readnow' option will cause GDB to read the entire symbol file\n\
3887 immediately. This makes the command slower, but may make future operations\n\
3890 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3891 Load symbol table from executable file FILE.\n\
3892 Usage: symbol-file [-readnow] FILE\n\
3893 The `file' command can also load symbol tables, as well as setting the file\n\
3894 to execute.\n" READNOW_HELP
), &cmdlist
);
3895 set_cmd_completer (c
, filename_completer
);
3897 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3898 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3899 Usage: add-symbol-file FILE ADDR [-readnow | -s SECT-NAME SECT-ADDR]...\n\
3900 ADDR is the starting address of the file's text.\n\
3901 Each '-s' argument provides a section name and address, and\n\
3902 should be specified if the data and bss segments are not contiguous\n\
3903 with the text. SECT-NAME is a section name to be loaded at SECT-ADDR.\n"
3906 set_cmd_completer (c
, filename_completer
);
3908 c
= add_cmd ("remove-symbol-file", class_files
,
3909 remove_symbol_file_command
, _("\
3910 Remove a symbol file added via the add-symbol-file command.\n\
3911 Usage: remove-symbol-file FILENAME\n\
3912 remove-symbol-file -a ADDRESS\n\
3913 The file to remove can be identified by its filename or by an address\n\
3914 that lies within the boundaries of this symbol file in memory."),
3917 c
= add_cmd ("load", class_files
, load_command
, _("\
3918 Dynamically load FILE into the running program, and record its symbols\n\
3919 for access from GDB.\n\
3920 Usage: load [FILE] [OFFSET]\n\
3921 An optional load OFFSET may also be given as a literal address.\n\
3922 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3923 on its own."), &cmdlist
);
3924 set_cmd_completer (c
, filename_completer
);
3926 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3927 _("Commands for debugging overlays."), &overlaylist
,
3928 "overlay ", 0, &cmdlist
);
3930 add_com_alias ("ovly", "overlay", class_alias
, 1);
3931 add_com_alias ("ov", "overlay", class_alias
, 1);
3933 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3934 _("Assert that an overlay section is mapped."), &overlaylist
);
3936 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3937 _("Assert that an overlay section is unmapped."), &overlaylist
);
3939 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3940 _("List mappings of overlay sections."), &overlaylist
);
3942 add_cmd ("manual", class_support
, overlay_manual_command
,
3943 _("Enable overlay debugging."), &overlaylist
);
3944 add_cmd ("off", class_support
, overlay_off_command
,
3945 _("Disable overlay debugging."), &overlaylist
);
3946 add_cmd ("auto", class_support
, overlay_auto_command
,
3947 _("Enable automatic overlay debugging."), &overlaylist
);
3948 add_cmd ("load-target", class_support
, overlay_load_command
,
3949 _("Read the overlay mapping state from the target."), &overlaylist
);
3951 /* Filename extension to source language lookup table: */
3952 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3954 Set mapping between filename extension and source language."), _("\
3955 Show mapping between filename extension and source language."), _("\
3956 Usage: set extension-language .foo bar"),
3957 set_ext_lang_command
,
3959 &setlist
, &showlist
);
3961 add_info ("extensions", info_ext_lang_command
,
3962 _("All filename extensions associated with a source language."));
3964 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3965 &debug_file_directory
, _("\
3966 Set the directories where separate debug symbols are searched for."), _("\
3967 Show the directories where separate debug symbols are searched for."), _("\
3968 Separate debug symbols are first searched for in the same\n\
3969 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3970 and lastly at the path of the directory of the binary with\n\
3971 each global debug-file-directory component prepended."),
3973 show_debug_file_directory
,
3974 &setlist
, &showlist
);
3976 add_setshow_enum_cmd ("symbol-loading", no_class
,
3977 print_symbol_loading_enums
, &print_symbol_loading
,
3979 Set printing of symbol loading messages."), _("\
3980 Show printing of symbol loading messages."), _("\
3981 off == turn all messages off\n\
3982 brief == print messages for the executable,\n\
3983 and brief messages for shared libraries\n\
3984 full == print messages for the executable,\n\
3985 and messages for each shared library."),
3988 &setprintlist
, &showprintlist
);
3990 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
3991 &separate_debug_file_debug
, _("\
3992 Set printing of separate debug info file search debug."), _("\
3993 Show printing of separate debug info file search debug."), _("\
3994 When on, GDB prints the searched locations while looking for separate debug \
3995 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
3998 selftests::register_test
3999 ("filename_language", selftests::filename_language::test_filename_language
);
4000 selftests::register_test
4001 ("set_ext_lang_command",
4002 selftests::filename_language::test_set_ext_lang_command
);