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 load_command (char *, int);
89 static void symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
92 static const struct sym_fns
*find_sym_fns (bfd
*);
94 static void overlay_invalidate_all (void);
96 static void simple_free_overlay_table (void);
98 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
101 static int simple_read_overlay_table (void);
103 static int simple_overlay_update_1 (struct obj_section
*);
105 static void info_ext_lang_command (char *args
, int from_tty
);
107 static void symfile_find_segment_sections (struct objfile
*objfile
);
109 /* List of all available sym_fns. On gdb startup, each object file reader
110 calls add_symtab_fns() to register information on each format it is
113 struct registered_sym_fns
115 registered_sym_fns (bfd_flavour sym_flavour_
, const struct sym_fns
*sym_fns_
)
116 : sym_flavour (sym_flavour_
), sym_fns (sym_fns_
)
119 /* BFD flavour that we handle. */
120 enum bfd_flavour sym_flavour
;
122 /* The "vtable" of symbol functions. */
123 const struct sym_fns
*sym_fns
;
126 static std::vector
<registered_sym_fns
> symtab_fns
;
128 /* Values for "set print symbol-loading". */
130 const char print_symbol_loading_off
[] = "off";
131 const char print_symbol_loading_brief
[] = "brief";
132 const char print_symbol_loading_full
[] = "full";
133 static const char *print_symbol_loading_enums
[] =
135 print_symbol_loading_off
,
136 print_symbol_loading_brief
,
137 print_symbol_loading_full
,
140 static const char *print_symbol_loading
= print_symbol_loading_full
;
142 /* If non-zero, shared library symbols will be added automatically
143 when the inferior is created, new libraries are loaded, or when
144 attaching to the inferior. This is almost always what users will
145 want to have happen; but for very large programs, the startup time
146 will be excessive, and so if this is a problem, the user can clear
147 this flag and then add the shared library symbols as needed. Note
148 that there is a potential for confusion, since if the shared
149 library symbols are not loaded, commands like "info fun" will *not*
150 report all the functions that are actually present. */
152 int auto_solib_add
= 1;
155 /* Return non-zero if symbol-loading messages should be printed.
156 FROM_TTY is the standard from_tty argument to gdb commands.
157 If EXEC is non-zero the messages are for the executable.
158 Otherwise, messages are for shared libraries.
159 If FULL is non-zero then the caller is printing a detailed message.
160 E.g., the message includes the shared library name.
161 Otherwise, the caller is printing a brief "summary" message. */
164 print_symbol_loading_p (int from_tty
, int exec
, int full
)
166 if (!from_tty
&& !info_verbose
)
171 /* We don't check FULL for executables, there are few such
172 messages, therefore brief == full. */
173 return print_symbol_loading
!= print_symbol_loading_off
;
176 return print_symbol_loading
== print_symbol_loading_full
;
177 return print_symbol_loading
== print_symbol_loading_brief
;
180 /* True if we are reading a symbol table. */
182 int currently_reading_symtab
= 0;
184 /* Increment currently_reading_symtab and return a cleanup that can be
185 used to decrement it. */
187 scoped_restore_tmpl
<int>
188 increment_reading_symtab (void)
190 gdb_assert (currently_reading_symtab
>= 0);
191 return make_scoped_restore (¤tly_reading_symtab
,
192 currently_reading_symtab
+ 1);
195 /* Remember the lowest-addressed loadable section we've seen.
196 This function is called via bfd_map_over_sections.
198 In case of equal vmas, the section with the largest size becomes the
199 lowest-addressed loadable section.
201 If the vmas and sizes are equal, the last section is considered the
202 lowest-addressed loadable section. */
205 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
207 asection
**lowest
= (asection
**) obj
;
209 if (0 == (bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
)))
212 *lowest
= sect
; /* First loadable section */
213 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
214 *lowest
= sect
; /* A lower loadable section */
215 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
216 && (bfd_section_size (abfd
, (*lowest
))
217 <= bfd_section_size (abfd
, sect
)))
221 /* Create a new section_addr_info, with room for NUM_SECTIONS. The
222 new object's 'num_sections' field is set to 0; it must be updated
225 struct section_addr_info
*
226 alloc_section_addr_info (size_t num_sections
)
228 struct section_addr_info
*sap
;
231 size
= (sizeof (struct section_addr_info
)
232 + sizeof (struct other_sections
) * (num_sections
- 1));
233 sap
= (struct section_addr_info
*) xmalloc (size
);
234 memset (sap
, 0, size
);
239 /* Build (allocate and populate) a section_addr_info struct from
240 an existing section table. */
242 extern struct section_addr_info
*
243 build_section_addr_info_from_section_table (const struct target_section
*start
,
244 const struct target_section
*end
)
246 struct section_addr_info
*sap
;
247 const struct target_section
*stp
;
250 sap
= alloc_section_addr_info (end
- start
);
252 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
254 struct bfd_section
*asect
= stp
->the_bfd_section
;
255 bfd
*abfd
= asect
->owner
;
257 if (bfd_get_section_flags (abfd
, asect
) & (SEC_ALLOC
| SEC_LOAD
)
258 && oidx
< end
- start
)
260 sap
->other
[oidx
].addr
= stp
->addr
;
261 sap
->other
[oidx
].name
= xstrdup (bfd_section_name (abfd
, asect
));
262 sap
->other
[oidx
].sectindex
= gdb_bfd_section_index (abfd
, asect
);
267 sap
->num_sections
= oidx
;
272 /* Create a section_addr_info from section offsets in ABFD. */
274 static struct section_addr_info
*
275 build_section_addr_info_from_bfd (bfd
*abfd
)
277 struct section_addr_info
*sap
;
279 struct bfd_section
*sec
;
281 sap
= alloc_section_addr_info (bfd_count_sections (abfd
));
282 for (i
= 0, sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
283 if (bfd_get_section_flags (abfd
, sec
) & (SEC_ALLOC
| SEC_LOAD
))
285 sap
->other
[i
].addr
= bfd_get_section_vma (abfd
, sec
);
286 sap
->other
[i
].name
= xstrdup (bfd_get_section_name (abfd
, sec
));
287 sap
->other
[i
].sectindex
= gdb_bfd_section_index (abfd
, sec
);
291 sap
->num_sections
= i
;
296 /* Create a section_addr_info from section offsets in OBJFILE. */
298 struct section_addr_info
*
299 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
301 struct section_addr_info
*sap
;
304 /* Before reread_symbols gets rewritten it is not safe to call:
305 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
307 sap
= build_section_addr_info_from_bfd (objfile
->obfd
);
308 for (i
= 0; i
< sap
->num_sections
; i
++)
310 int sectindex
= sap
->other
[i
].sectindex
;
312 sap
->other
[i
].addr
+= objfile
->section_offsets
->offsets
[sectindex
];
317 /* Free all memory allocated by build_section_addr_info_from_section_table. */
320 free_section_addr_info (struct section_addr_info
*sap
)
324 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
325 xfree (sap
->other
[idx
].name
);
329 /* Initialize OBJFILE's sect_index_* members. */
332 init_objfile_sect_indices (struct objfile
*objfile
)
337 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
339 objfile
->sect_index_text
= sect
->index
;
341 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
343 objfile
->sect_index_data
= sect
->index
;
345 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
347 objfile
->sect_index_bss
= sect
->index
;
349 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
351 objfile
->sect_index_rodata
= sect
->index
;
353 /* This is where things get really weird... We MUST have valid
354 indices for the various sect_index_* members or gdb will abort.
355 So if for example, there is no ".text" section, we have to
356 accomodate that. First, check for a file with the standard
357 one or two segments. */
359 symfile_find_segment_sections (objfile
);
361 /* Except when explicitly adding symbol files at some address,
362 section_offsets contains nothing but zeros, so it doesn't matter
363 which slot in section_offsets the individual sect_index_* members
364 index into. So if they are all zero, it is safe to just point
365 all the currently uninitialized indices to the first slot. But
366 beware: if this is the main executable, it may be relocated
367 later, e.g. by the remote qOffsets packet, and then this will
368 be wrong! That's why we try segments first. */
370 for (i
= 0; i
< objfile
->num_sections
; i
++)
372 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
377 if (i
== objfile
->num_sections
)
379 if (objfile
->sect_index_text
== -1)
380 objfile
->sect_index_text
= 0;
381 if (objfile
->sect_index_data
== -1)
382 objfile
->sect_index_data
= 0;
383 if (objfile
->sect_index_bss
== -1)
384 objfile
->sect_index_bss
= 0;
385 if (objfile
->sect_index_rodata
== -1)
386 objfile
->sect_index_rodata
= 0;
390 /* The arguments to place_section. */
392 struct place_section_arg
394 struct section_offsets
*offsets
;
398 /* Find a unique offset to use for loadable section SECT if
399 the user did not provide an offset. */
402 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
404 struct place_section_arg
*arg
= (struct place_section_arg
*) obj
;
405 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
407 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
409 /* We are only interested in allocated sections. */
410 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
413 /* If the user specified an offset, honor it. */
414 if (offsets
[gdb_bfd_section_index (abfd
, sect
)] != 0)
417 /* Otherwise, let's try to find a place for the section. */
418 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
425 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
427 int indx
= cur_sec
->index
;
429 /* We don't need to compare against ourself. */
433 /* We can only conflict with allocated sections. */
434 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
437 /* If the section offset is 0, either the section has not been placed
438 yet, or it was the lowest section placed (in which case LOWEST
439 will be past its end). */
440 if (offsets
[indx
] == 0)
443 /* If this section would overlap us, then we must move up. */
444 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
445 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
447 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
448 start_addr
= (start_addr
+ align
- 1) & -align
;
453 /* Otherwise, we appear to be OK. So far. */
458 offsets
[gdb_bfd_section_index (abfd
, sect
)] = start_addr
;
459 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
462 /* Store struct section_addr_info as prepared (made relative and with SECTINDEX
463 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
467 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
469 const struct section_addr_info
*addrs
)
473 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
475 /* Now calculate offsets for section that were specified by the caller. */
476 for (i
= 0; i
< addrs
->num_sections
; i
++)
478 const struct other_sections
*osp
;
480 osp
= &addrs
->other
[i
];
481 if (osp
->sectindex
== -1)
484 /* Record all sections in offsets. */
485 /* The section_offsets in the objfile are here filled in using
487 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
491 /* Transform section name S for a name comparison. prelink can split section
492 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
493 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
494 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
495 (`.sbss') section has invalid (increased) virtual address. */
498 addr_section_name (const char *s
)
500 if (strcmp (s
, ".dynbss") == 0)
502 if (strcmp (s
, ".sdynbss") == 0)
508 /* qsort comparator for addrs_section_sort. Sort entries in ascending order by
509 their (name, sectindex) pair. sectindex makes the sort by name stable. */
512 addrs_section_compar (const void *ap
, const void *bp
)
514 const struct other_sections
*a
= *((struct other_sections
**) ap
);
515 const struct other_sections
*b
= *((struct other_sections
**) bp
);
518 retval
= strcmp (addr_section_name (a
->name
), addr_section_name (b
->name
));
522 return a
->sectindex
- b
->sectindex
;
525 /* Provide sorted array of pointers to sections of ADDRS. The array is
526 terminated by NULL. Caller is responsible to call xfree for it. */
528 static struct other_sections
**
529 addrs_section_sort (struct section_addr_info
*addrs
)
531 struct other_sections
**array
;
534 /* `+ 1' for the NULL terminator. */
535 array
= XNEWVEC (struct other_sections
*, addrs
->num_sections
+ 1);
536 for (i
= 0; i
< addrs
->num_sections
; i
++)
537 array
[i
] = &addrs
->other
[i
];
540 qsort (array
, i
, sizeof (*array
), addrs_section_compar
);
545 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
546 also SECTINDEXes specific to ABFD there. This function can be used to
547 rebase ADDRS to start referencing different BFD than before. */
550 addr_info_make_relative (struct section_addr_info
*addrs
, bfd
*abfd
)
552 asection
*lower_sect
;
553 CORE_ADDR lower_offset
;
555 struct cleanup
*my_cleanup
;
556 struct section_addr_info
*abfd_addrs
;
557 struct other_sections
**addrs_sorted
, **abfd_addrs_sorted
;
558 struct other_sections
**addrs_to_abfd_addrs
;
560 /* Find lowest loadable section to be used as starting point for
561 continguous sections. */
563 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
564 if (lower_sect
== NULL
)
566 warning (_("no loadable sections found in added symbol-file %s"),
567 bfd_get_filename (abfd
));
571 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
573 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
574 in ABFD. Section names are not unique - there can be multiple sections of
575 the same name. Also the sections of the same name do not have to be
576 adjacent to each other. Some sections may be present only in one of the
577 files. Even sections present in both files do not have to be in the same
580 Use stable sort by name for the sections in both files. Then linearly
581 scan both lists matching as most of the entries as possible. */
583 addrs_sorted
= addrs_section_sort (addrs
);
584 my_cleanup
= make_cleanup (xfree
, addrs_sorted
);
586 abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
587 make_cleanup_free_section_addr_info (abfd_addrs
);
588 abfd_addrs_sorted
= addrs_section_sort (abfd_addrs
);
589 make_cleanup (xfree
, abfd_addrs_sorted
);
591 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
592 ABFD_ADDRS_SORTED. */
594 addrs_to_abfd_addrs
= XCNEWVEC (struct other_sections
*, addrs
->num_sections
);
595 make_cleanup (xfree
, addrs_to_abfd_addrs
);
597 while (*addrs_sorted
)
599 const char *sect_name
= addr_section_name ((*addrs_sorted
)->name
);
601 while (*abfd_addrs_sorted
602 && strcmp (addr_section_name ((*abfd_addrs_sorted
)->name
),
606 if (*abfd_addrs_sorted
607 && strcmp (addr_section_name ((*abfd_addrs_sorted
)->name
),
612 /* Make the found item directly addressable from ADDRS. */
613 index_in_addrs
= *addrs_sorted
- addrs
->other
;
614 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
615 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_addrs_sorted
;
617 /* Never use the same ABFD entry twice. */
624 /* Calculate offsets for the loadable sections.
625 FIXME! Sections must be in order of increasing loadable section
626 so that contiguous sections can use the lower-offset!!!
628 Adjust offsets if the segments are not contiguous.
629 If the section is contiguous, its offset should be set to
630 the offset of the highest loadable section lower than it
631 (the loadable section directly below it in memory).
632 this_offset = lower_offset = lower_addr - lower_orig_addr */
634 for (i
= 0; i
< addrs
->num_sections
; i
++)
636 struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
640 /* This is the index used by BFD. */
641 addrs
->other
[i
].sectindex
= sect
->sectindex
;
643 if (addrs
->other
[i
].addr
!= 0)
645 addrs
->other
[i
].addr
-= sect
->addr
;
646 lower_offset
= addrs
->other
[i
].addr
;
649 addrs
->other
[i
].addr
= lower_offset
;
653 /* addr_section_name transformation is not used for SECT_NAME. */
654 const char *sect_name
= addrs
->other
[i
].name
;
656 /* This section does not exist in ABFD, which is normally
657 unexpected and we want to issue a warning.
659 However, the ELF prelinker does create a few sections which are
660 marked in the main executable as loadable (they are loaded in
661 memory from the DYNAMIC segment) and yet are not present in
662 separate debug info files. This is fine, and should not cause
663 a warning. Shared libraries contain just the section
664 ".gnu.liblist" but it is not marked as loadable there. There is
665 no other way to identify them than by their name as the sections
666 created by prelink have no special flags.
668 For the sections `.bss' and `.sbss' see addr_section_name. */
670 if (!(strcmp (sect_name
, ".gnu.liblist") == 0
671 || strcmp (sect_name
, ".gnu.conflict") == 0
672 || (strcmp (sect_name
, ".bss") == 0
674 && strcmp (addrs
->other
[i
- 1].name
, ".dynbss") == 0
675 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
676 || (strcmp (sect_name
, ".sbss") == 0
678 && strcmp (addrs
->other
[i
- 1].name
, ".sdynbss") == 0
679 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
680 warning (_("section %s not found in %s"), sect_name
,
681 bfd_get_filename (abfd
));
683 addrs
->other
[i
].addr
= 0;
684 addrs
->other
[i
].sectindex
= -1;
688 do_cleanups (my_cleanup
);
691 /* Parse the user's idea of an offset for dynamic linking, into our idea
692 of how to represent it for fast symbol reading. This is the default
693 version of the sym_fns.sym_offsets function for symbol readers that
694 don't need to do anything special. It allocates a section_offsets table
695 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
698 default_symfile_offsets (struct objfile
*objfile
,
699 const struct section_addr_info
*addrs
)
701 objfile
->num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
702 objfile
->section_offsets
= (struct section_offsets
*)
703 obstack_alloc (&objfile
->objfile_obstack
,
704 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
705 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
706 objfile
->num_sections
, addrs
);
708 /* For relocatable files, all loadable sections will start at zero.
709 The zero is meaningless, so try to pick arbitrary addresses such
710 that no loadable sections overlap. This algorithm is quadratic,
711 but the number of sections in a single object file is generally
713 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
715 struct place_section_arg arg
;
716 bfd
*abfd
= objfile
->obfd
;
719 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
720 /* We do not expect this to happen; just skip this step if the
721 relocatable file has a section with an assigned VMA. */
722 if (bfd_section_vma (abfd
, cur_sec
) != 0)
727 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
729 /* Pick non-overlapping offsets for sections the user did not
731 arg
.offsets
= objfile
->section_offsets
;
733 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
735 /* Correctly filling in the section offsets is not quite
736 enough. Relocatable files have two properties that
737 (most) shared objects do not:
739 - Their debug information will contain relocations. Some
740 shared libraries do also, but many do not, so this can not
743 - If there are multiple code sections they will be loaded
744 at different relative addresses in memory than they are
745 in the objfile, since all sections in the file will start
748 Because GDB has very limited ability to map from an
749 address in debug info to the correct code section,
750 it relies on adding SECT_OFF_TEXT to things which might be
751 code. If we clear all the section offsets, and set the
752 section VMAs instead, then symfile_relocate_debug_section
753 will return meaningful debug information pointing at the
756 GDB has too many different data structures for section
757 addresses - a bfd, objfile, and so_list all have section
758 tables, as does exec_ops. Some of these could probably
761 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
762 cur_sec
= cur_sec
->next
)
764 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
767 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
768 exec_set_section_address (bfd_get_filename (abfd
),
770 offsets
[cur_sec
->index
]);
771 offsets
[cur_sec
->index
] = 0;
776 /* Remember the bfd indexes for the .text, .data, .bss and
778 init_objfile_sect_indices (objfile
);
781 /* Divide the file into segments, which are individual relocatable units.
782 This is the default version of the sym_fns.sym_segments function for
783 symbol readers that do not have an explicit representation of segments.
784 It assumes that object files do not have segments, and fully linked
785 files have a single segment. */
787 struct symfile_segment_data
*
788 default_symfile_segments (bfd
*abfd
)
792 struct symfile_segment_data
*data
;
795 /* Relocatable files contain enough information to position each
796 loadable section independently; they should not be relocated
798 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
801 /* Make sure there is at least one loadable section in the file. */
802 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
804 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
812 low
= bfd_get_section_vma (abfd
, sect
);
813 high
= low
+ bfd_get_section_size (sect
);
815 data
= XCNEW (struct symfile_segment_data
);
816 data
->num_segments
= 1;
817 data
->segment_bases
= XCNEW (CORE_ADDR
);
818 data
->segment_sizes
= XCNEW (CORE_ADDR
);
820 num_sections
= bfd_count_sections (abfd
);
821 data
->segment_info
= XCNEWVEC (int, num_sections
);
823 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
827 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
830 vma
= bfd_get_section_vma (abfd
, sect
);
833 if (vma
+ bfd_get_section_size (sect
) > high
)
834 high
= vma
+ bfd_get_section_size (sect
);
836 data
->segment_info
[i
] = 1;
839 data
->segment_bases
[0] = low
;
840 data
->segment_sizes
[0] = high
- low
;
845 /* This is a convenience function to call sym_read for OBJFILE and
846 possibly force the partial symbols to be read. */
849 read_symbols (struct objfile
*objfile
, symfile_add_flags add_flags
)
851 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
852 objfile
->per_bfd
->minsyms_read
= true;
854 /* find_separate_debug_file_in_section should be called only if there is
855 single binary with no existing separate debug info file. */
856 if (!objfile_has_partial_symbols (objfile
)
857 && objfile
->separate_debug_objfile
== NULL
858 && objfile
->separate_debug_objfile_backlink
== NULL
)
860 gdb_bfd_ref_ptr
abfd (find_separate_debug_file_in_section (objfile
));
864 /* find_separate_debug_file_in_section uses the same filename for the
865 virtual section-as-bfd like the bfd filename containing the
866 section. Therefore use also non-canonical name form for the same
867 file containing the section. */
868 symbol_file_add_separate (abfd
.get (), objfile
->original_name
,
872 if ((add_flags
& SYMFILE_NO_READ
) == 0)
873 require_partial_symbols (objfile
, 0);
876 /* Initialize entry point information for this objfile. */
879 init_entry_point_info (struct objfile
*objfile
)
881 struct entry_info
*ei
= &objfile
->per_bfd
->ei
;
887 /* Save startup file's range of PC addresses to help blockframe.c
888 decide where the bottom of the stack is. */
890 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
892 /* Executable file -- record its entry point so we'll recognize
893 the startup file because it contains the entry point. */
894 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
895 ei
->entry_point_p
= 1;
897 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
898 && bfd_get_start_address (objfile
->obfd
) != 0)
900 /* Some shared libraries may have entry points set and be
901 runnable. There's no clear way to indicate this, so just check
902 for values other than zero. */
903 ei
->entry_point
= bfd_get_start_address (objfile
->obfd
);
904 ei
->entry_point_p
= 1;
908 /* Examination of non-executable.o files. Short-circuit this stuff. */
909 ei
->entry_point_p
= 0;
912 if (ei
->entry_point_p
)
914 struct obj_section
*osect
;
915 CORE_ADDR entry_point
= ei
->entry_point
;
918 /* Make certain that the address points at real code, and not a
919 function descriptor. */
921 = gdbarch_convert_from_func_ptr_addr (get_objfile_arch (objfile
),
925 /* Remove any ISA markers, so that this matches entries in the
928 = gdbarch_addr_bits_remove (get_objfile_arch (objfile
), entry_point
);
931 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
933 struct bfd_section
*sect
= osect
->the_bfd_section
;
935 if (entry_point
>= bfd_get_section_vma (objfile
->obfd
, sect
)
936 && entry_point
< (bfd_get_section_vma (objfile
->obfd
, sect
)
937 + bfd_get_section_size (sect
)))
939 ei
->the_bfd_section_index
940 = gdb_bfd_section_index (objfile
->obfd
, sect
);
947 ei
->the_bfd_section_index
= SECT_OFF_TEXT (objfile
);
951 /* Process a symbol file, as either the main file or as a dynamically
954 This function does not set the OBJFILE's entry-point info.
956 OBJFILE is where the symbols are to be read from.
958 ADDRS is the list of section load addresses. If the user has given
959 an 'add-symbol-file' command, then this is the list of offsets and
960 addresses he or she provided as arguments to the command; or, if
961 we're handling a shared library, these are the actual addresses the
962 sections are loaded at, according to the inferior's dynamic linker
963 (as gleaned by GDB's shared library code). We convert each address
964 into an offset from the section VMA's as it appears in the object
965 file, and then call the file's sym_offsets function to convert this
966 into a format-specific offset table --- a `struct section_offsets'.
968 ADD_FLAGS encodes verbosity level, whether this is main symbol or
969 an extra symbol file such as dynamically loaded code, and wether
970 breakpoint reset should be deferred. */
973 syms_from_objfile_1 (struct objfile
*objfile
,
974 struct section_addr_info
*addrs
,
975 symfile_add_flags add_flags
)
977 struct section_addr_info
*local_addr
= NULL
;
978 struct cleanup
*old_chain
;
979 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
981 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
983 if (objfile
->sf
== NULL
)
985 /* No symbols to load, but we still need to make sure
986 that the section_offsets table is allocated. */
987 int num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
988 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_sections
);
990 objfile
->num_sections
= num_sections
;
991 objfile
->section_offsets
992 = (struct section_offsets
*) obstack_alloc (&objfile
->objfile_obstack
,
994 memset (objfile
->section_offsets
, 0, size
);
998 /* Make sure that partially constructed symbol tables will be cleaned up
999 if an error occurs during symbol reading. */
1000 old_chain
= make_cleanup (null_cleanup
, NULL
);
1001 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
1003 /* If ADDRS is NULL, put together a dummy address list.
1004 We now establish the convention that an addr of zero means
1005 no load address was specified. */
1008 local_addr
= alloc_section_addr_info (1);
1009 make_cleanup (xfree
, local_addr
);
1015 /* We will modify the main symbol table, make sure that all its users
1016 will be cleaned up if an error occurs during symbol reading. */
1017 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1019 /* Since no error yet, throw away the old symbol table. */
1021 if (symfile_objfile
!= NULL
)
1023 delete symfile_objfile
;
1024 gdb_assert (symfile_objfile
== NULL
);
1027 /* Currently we keep symbols from the add-symbol-file command.
1028 If the user wants to get rid of them, they should do "symbol-file"
1029 without arguments first. Not sure this is the best behavior
1032 (*objfile
->sf
->sym_new_init
) (objfile
);
1035 /* Convert addr into an offset rather than an absolute address.
1036 We find the lowest address of a loaded segment in the objfile,
1037 and assume that <addr> is where that got loaded.
1039 We no longer warn if the lowest section is not a text segment (as
1040 happens for the PA64 port. */
1041 if (addrs
->num_sections
> 0)
1042 addr_info_make_relative (addrs
, objfile
->obfd
);
1044 /* Initialize symbol reading routines for this objfile, allow complaints to
1045 appear for this new file, and record how verbose to be, then do the
1046 initial symbol reading for this file. */
1048 (*objfile
->sf
->sym_init
) (objfile
);
1049 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
1051 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
1053 read_symbols (objfile
, add_flags
);
1055 /* Discard cleanups as symbol reading was successful. */
1057 objfile_holder
.release ();
1058 discard_cleanups (old_chain
);
1062 /* Same as syms_from_objfile_1, but also initializes the objfile
1063 entry-point info. */
1066 syms_from_objfile (struct objfile
*objfile
,
1067 struct section_addr_info
*addrs
,
1068 symfile_add_flags add_flags
)
1070 syms_from_objfile_1 (objfile
, addrs
, add_flags
);
1071 init_entry_point_info (objfile
);
1074 /* Perform required actions after either reading in the initial
1075 symbols for a new objfile, or mapping in the symbols from a reusable
1076 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1079 finish_new_objfile (struct objfile
*objfile
, symfile_add_flags add_flags
)
1081 /* If this is the main symbol file we have to clean up all users of the
1082 old main symbol file. Otherwise it is sufficient to fixup all the
1083 breakpoints that may have been redefined by this symbol file. */
1084 if (add_flags
& SYMFILE_MAINLINE
)
1086 /* OK, make it the "real" symbol file. */
1087 symfile_objfile
= objfile
;
1089 clear_symtab_users (add_flags
);
1091 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1093 breakpoint_re_set ();
1096 /* We're done reading the symbol file; finish off complaints. */
1097 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
1100 /* Process a symbol file, as either the main file or as a dynamically
1103 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1104 A new reference is acquired by this function.
1106 For NAME description see the objfile constructor.
1108 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1109 extra, such as dynamically loaded code, and what to do with breakpoins.
1111 ADDRS is as described for syms_from_objfile_1, above.
1112 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1114 PARENT is the original objfile if ABFD is a separate debug info file.
1115 Otherwise PARENT is NULL.
1117 Upon success, returns a pointer to the objfile that was added.
1118 Upon failure, jumps back to command level (never returns). */
1120 static struct objfile
*
1121 symbol_file_add_with_addrs (bfd
*abfd
, const char *name
,
1122 symfile_add_flags add_flags
,
1123 struct section_addr_info
*addrs
,
1124 objfile_flags flags
, struct objfile
*parent
)
1126 struct objfile
*objfile
;
1127 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1128 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1129 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
1130 && (readnow_symbol_files
1131 || (add_flags
& SYMFILE_NO_READ
) == 0));
1133 if (readnow_symbol_files
)
1135 flags
|= OBJF_READNOW
;
1136 add_flags
&= ~SYMFILE_NO_READ
;
1139 /* Give user a chance to burp if we'd be
1140 interactively wiping out any existing symbols. */
1142 if ((have_full_symbols () || have_partial_symbols ())
1145 && !query (_("Load new symbol table from \"%s\"? "), name
))
1146 error (_("Not confirmed."));
1149 flags
|= OBJF_MAINLINE
;
1150 objfile
= new struct objfile (abfd
, name
, flags
);
1153 add_separate_debug_objfile (objfile
, parent
);
1155 /* We either created a new mapped symbol table, mapped an existing
1156 symbol table file which has not had initial symbol reading
1157 performed, or need to read an unmapped symbol table. */
1160 if (deprecated_pre_add_symbol_hook
)
1161 deprecated_pre_add_symbol_hook (name
);
1164 printf_unfiltered (_("Reading symbols from %s..."), name
);
1166 gdb_flush (gdb_stdout
);
1169 syms_from_objfile (objfile
, addrs
, add_flags
);
1171 /* We now have at least a partial symbol table. Check to see if the
1172 user requested that all symbols be read on initial access via either
1173 the gdb startup command line or on a per symbol file basis. Expand
1174 all partial symbol tables for this objfile if so. */
1176 if ((flags
& OBJF_READNOW
))
1180 printf_unfiltered (_("expanding to full symbols..."));
1182 gdb_flush (gdb_stdout
);
1186 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1189 if (should_print
&& !objfile_has_symbols (objfile
))
1192 printf_unfiltered (_("(no debugging symbols found)..."));
1198 if (deprecated_post_add_symbol_hook
)
1199 deprecated_post_add_symbol_hook ();
1201 printf_unfiltered (_("done.\n"));
1204 /* We print some messages regardless of whether 'from_tty ||
1205 info_verbose' is true, so make sure they go out at the right
1207 gdb_flush (gdb_stdout
);
1209 if (objfile
->sf
== NULL
)
1211 observer_notify_new_objfile (objfile
);
1212 return objfile
; /* No symbols. */
1215 finish_new_objfile (objfile
, add_flags
);
1217 observer_notify_new_objfile (objfile
);
1219 bfd_cache_close_all ();
1223 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1224 see the objfile constructor. */
1227 symbol_file_add_separate (bfd
*bfd
, const char *name
,
1228 symfile_add_flags symfile_flags
,
1229 struct objfile
*objfile
)
1231 struct section_addr_info
*sap
;
1232 struct cleanup
*my_cleanup
;
1234 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1235 because sections of BFD may not match sections of OBJFILE and because
1236 vma may have been modified by tools such as prelink. */
1237 sap
= build_section_addr_info_from_objfile (objfile
);
1238 my_cleanup
= make_cleanup_free_section_addr_info (sap
);
1240 symbol_file_add_with_addrs
1241 (bfd
, name
, symfile_flags
, sap
,
1242 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1246 do_cleanups (my_cleanup
);
1249 /* Process the symbol file ABFD, as either the main file or as a
1250 dynamically loaded file.
1251 See symbol_file_add_with_addrs's comments for details. */
1254 symbol_file_add_from_bfd (bfd
*abfd
, const char *name
,
1255 symfile_add_flags add_flags
,
1256 struct section_addr_info
*addrs
,
1257 objfile_flags flags
, struct objfile
*parent
)
1259 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1263 /* Process a symbol file, as either the main file or as a dynamically
1264 loaded file. See symbol_file_add_with_addrs's comments for details. */
1267 symbol_file_add (const char *name
, symfile_add_flags add_flags
,
1268 struct section_addr_info
*addrs
, objfile_flags flags
)
1270 gdb_bfd_ref_ptr
bfd (symfile_bfd_open (name
));
1272 return symbol_file_add_from_bfd (bfd
.get (), name
, add_flags
, addrs
,
1276 /* Call symbol_file_add() with default values and update whatever is
1277 affected by the loading of a new main().
1278 Used when the file is supplied in the gdb command line
1279 and by some targets with special loading requirements.
1280 The auxiliary function, symbol_file_add_main_1(), has the flags
1281 argument for the switches that can only be specified in the symbol_file
1285 symbol_file_add_main (const char *args
, symfile_add_flags add_flags
)
1287 symbol_file_add_main_1 (args
, add_flags
, 0);
1291 symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
1292 objfile_flags flags
)
1294 add_flags
|= current_inferior ()->symfile_flags
| SYMFILE_MAINLINE
;
1296 symbol_file_add (args
, add_flags
, NULL
, flags
);
1298 /* Getting new symbols may change our opinion about
1299 what is frameless. */
1300 reinit_frame_cache ();
1302 if ((add_flags
& SYMFILE_NO_READ
) == 0)
1303 set_initial_language ();
1307 symbol_file_clear (int from_tty
)
1309 if ((have_full_symbols () || have_partial_symbols ())
1312 ? !query (_("Discard symbol table from `%s'? "),
1313 objfile_name (symfile_objfile
))
1314 : !query (_("Discard symbol table? "))))
1315 error (_("Not confirmed."));
1317 /* solib descriptors may have handles to objfiles. Wipe them before their
1318 objfiles get stale by free_all_objfiles. */
1319 no_shared_libraries (NULL
, from_tty
);
1321 free_all_objfiles ();
1323 gdb_assert (symfile_objfile
== NULL
);
1325 printf_unfiltered (_("No symbol file now.\n"));
1328 /* See symfile.h. */
1330 int separate_debug_file_debug
= 0;
1333 separate_debug_file_exists (const char *name
, unsigned long crc
,
1334 struct objfile
*parent_objfile
)
1336 unsigned long file_crc
;
1338 struct stat parent_stat
, abfd_stat
;
1339 int verified_as_different
;
1341 /* Find a separate debug info file as if symbols would be present in
1342 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1343 section can contain just the basename of PARENT_OBJFILE without any
1344 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1345 the separate debug infos with the same basename can exist. */
1347 if (filename_cmp (name
, objfile_name (parent_objfile
)) == 0)
1350 if (separate_debug_file_debug
)
1351 printf_unfiltered (_(" Trying %s\n"), name
);
1353 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (name
, gnutarget
, -1));
1358 /* Verify symlinks were not the cause of filename_cmp name difference above.
1360 Some operating systems, e.g. Windows, do not provide a meaningful
1361 st_ino; they always set it to zero. (Windows does provide a
1362 meaningful st_dev.) Files accessed from gdbservers that do not
1363 support the vFile:fstat packet will also have st_ino set to zero.
1364 Do not indicate a duplicate library in either case. While there
1365 is no guarantee that a system that provides meaningful inode
1366 numbers will never set st_ino to zero, this is merely an
1367 optimization, so we do not need to worry about false negatives. */
1369 if (bfd_stat (abfd
.get (), &abfd_stat
) == 0
1370 && abfd_stat
.st_ino
!= 0
1371 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1373 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1374 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1376 verified_as_different
= 1;
1379 verified_as_different
= 0;
1381 file_crc_p
= gdb_bfd_crc (abfd
.get (), &file_crc
);
1386 if (crc
!= file_crc
)
1388 unsigned long parent_crc
;
1390 /* If the files could not be verified as different with
1391 bfd_stat then we need to calculate the parent's CRC
1392 to verify whether the files are different or not. */
1394 if (!verified_as_different
)
1396 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1400 if (verified_as_different
|| parent_crc
!= file_crc
)
1401 warning (_("the debug information found in \"%s\""
1402 " does not match \"%s\" (CRC mismatch).\n"),
1403 name
, objfile_name (parent_objfile
));
1411 char *debug_file_directory
= NULL
;
1413 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1414 struct cmd_list_element
*c
, const char *value
)
1416 fprintf_filtered (file
,
1417 _("The directory where separate debug "
1418 "symbols are searched for is \"%s\".\n"),
1422 #if ! defined (DEBUG_SUBDIRECTORY)
1423 #define DEBUG_SUBDIRECTORY ".debug"
1426 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1427 where the original file resides (may not be the same as
1428 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1429 looking for. CANON_DIR is the "realpath" form of DIR.
1430 DIR must contain a trailing '/'.
1431 Returns the path of the file with separate debug info, of NULL. */
1434 find_separate_debug_file (const char *dir
,
1435 const char *canon_dir
,
1436 const char *debuglink
,
1437 unsigned long crc32
, struct objfile
*objfile
)
1442 VEC (char_ptr
) *debugdir_vec
;
1443 struct cleanup
*back_to
;
1446 if (separate_debug_file_debug
)
1447 printf_unfiltered (_("\nLooking for separate debug info (debug link) for "
1448 "%s\n"), objfile_name (objfile
));
1450 /* Set I to std::max (strlen (canon_dir), strlen (dir)). */
1452 if (canon_dir
!= NULL
&& strlen (canon_dir
) > i
)
1453 i
= strlen (canon_dir
);
1456 = (char *) xmalloc (strlen (debug_file_directory
) + 1
1458 + strlen (DEBUG_SUBDIRECTORY
)
1460 + strlen (debuglink
)
1463 /* First try in the same directory as the original file. */
1464 strcpy (debugfile
, dir
);
1465 strcat (debugfile
, debuglink
);
1467 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1470 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1471 strcpy (debugfile
, dir
);
1472 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1473 strcat (debugfile
, "/");
1474 strcat (debugfile
, debuglink
);
1476 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1479 /* Then try in the global debugfile directories.
1481 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1482 cause "/..." lookups. */
1484 debugdir_vec
= dirnames_to_char_ptr_vec (debug_file_directory
);
1485 back_to
= make_cleanup_free_char_ptr_vec (debugdir_vec
);
1487 for (ix
= 0; VEC_iterate (char_ptr
, debugdir_vec
, ix
, debugdir
); ++ix
)
1489 strcpy (debugfile
, debugdir
);
1490 strcat (debugfile
, "/");
1491 strcat (debugfile
, dir
);
1492 strcat (debugfile
, debuglink
);
1494 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1496 do_cleanups (back_to
);
1500 /* If the file is in the sysroot, try using its base path in the
1501 global debugfile directory. */
1502 if (canon_dir
!= NULL
1503 && filename_ncmp (canon_dir
, gdb_sysroot
,
1504 strlen (gdb_sysroot
)) == 0
1505 && IS_DIR_SEPARATOR (canon_dir
[strlen (gdb_sysroot
)]))
1507 strcpy (debugfile
, debugdir
);
1508 strcat (debugfile
, canon_dir
+ strlen (gdb_sysroot
));
1509 strcat (debugfile
, "/");
1510 strcat (debugfile
, debuglink
);
1512 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1514 do_cleanups (back_to
);
1520 do_cleanups (back_to
);
1525 /* Modify PATH to contain only "[/]directory/" part of PATH.
1526 If there were no directory separators in PATH, PATH will be empty
1527 string on return. */
1530 terminate_after_last_dir_separator (char *path
)
1534 /* Strip off the final filename part, leaving the directory name,
1535 followed by a slash. The directory can be relative or absolute. */
1536 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1537 if (IS_DIR_SEPARATOR (path
[i
]))
1540 /* If I is -1 then no directory is present there and DIR will be "". */
1544 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1545 Returns pathname, or NULL. */
1548 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1551 unsigned long crc32
;
1553 gdb::unique_xmalloc_ptr
<char> debuglink
1554 (bfd_get_debug_link_info (objfile
->obfd
, &crc32
));
1556 if (debuglink
== NULL
)
1558 /* There's no separate debug info, hence there's no way we could
1559 load it => no warning. */
1563 std::string dir
= objfile_name (objfile
);
1564 terminate_after_last_dir_separator (&dir
[0]);
1565 gdb::unique_xmalloc_ptr
<char> canon_dir (lrealpath (dir
.c_str ()));
1567 debugfile
= find_separate_debug_file (dir
.c_str (), canon_dir
.get (),
1568 debuglink
.get (), crc32
, objfile
);
1570 if (debugfile
== NULL
)
1572 /* For PR gdb/9538, try again with realpath (if different from the
1577 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1578 && S_ISLNK (st_buf
.st_mode
))
1580 gdb::unique_xmalloc_ptr
<char> symlink_dir
1581 (lrealpath (objfile_name (objfile
)));
1582 if (symlink_dir
!= NULL
)
1584 terminate_after_last_dir_separator (symlink_dir
.get ());
1585 if (dir
!= symlink_dir
.get ())
1587 /* Different directory, so try using it. */
1588 debugfile
= find_separate_debug_file (symlink_dir
.get (),
1601 /* This is the symbol-file command. Read the file, analyze its
1602 symbols, and add a struct symtab to a symtab list. The syntax of
1603 the command is rather bizarre:
1605 1. The function buildargv implements various quoting conventions
1606 which are undocumented and have little or nothing in common with
1607 the way things are quoted (or not quoted) elsewhere in GDB.
1609 2. Options are used, which are not generally used in GDB (perhaps
1610 "set mapped on", "set readnow on" would be better)
1612 3. The order of options matters, which is contrary to GNU
1613 conventions (because it is confusing and inconvenient). */
1616 symbol_file_command (const char *args
, int from_tty
)
1622 symbol_file_clear (from_tty
);
1626 objfile_flags flags
= OBJF_USERLOADED
;
1627 symfile_add_flags add_flags
= 0;
1631 add_flags
|= SYMFILE_VERBOSE
;
1633 gdb_argv
built_argv (args
);
1634 for (char *arg
: built_argv
)
1636 if (strcmp (arg
, "-readnow") == 0)
1637 flags
|= OBJF_READNOW
;
1638 else if (*arg
== '-')
1639 error (_("unknown option `%s'"), arg
);
1642 symbol_file_add_main_1 (arg
, add_flags
, flags
);
1648 error (_("no symbol file name was specified"));
1652 /* Set the initial language.
1654 FIXME: A better solution would be to record the language in the
1655 psymtab when reading partial symbols, and then use it (if known) to
1656 set the language. This would be a win for formats that encode the
1657 language in an easily discoverable place, such as DWARF. For
1658 stabs, we can jump through hoops looking for specially named
1659 symbols or try to intuit the language from the specific type of
1660 stabs we find, but we can't do that until later when we read in
1664 set_initial_language (void)
1666 enum language lang
= main_language ();
1668 if (lang
== language_unknown
)
1670 char *name
= main_name ();
1671 struct symbol
*sym
= lookup_symbol (name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
1674 lang
= SYMBOL_LANGUAGE (sym
);
1677 if (lang
== language_unknown
)
1679 /* Make C the default language */
1683 set_language (lang
);
1684 expected_language
= current_language
; /* Don't warn the user. */
1687 /* Open the file specified by NAME and hand it off to BFD for
1688 preliminary analysis. Return a newly initialized bfd *, which
1689 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1690 absolute). In case of trouble, error() is called. */
1693 symfile_bfd_open (const char *name
)
1696 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1698 if (!is_target_filename (name
))
1700 char *absolute_name
;
1702 gdb::unique_xmalloc_ptr
<char> expanded_name (tilde_expand (name
));
1704 /* Look down path for it, allocate 2nd new malloc'd copy. */
1705 desc
= openp (getenv ("PATH"),
1706 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1707 expanded_name
.get (), O_RDONLY
| O_BINARY
, &absolute_name
);
1708 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1711 char *exename
= (char *) alloca (strlen (expanded_name
.get ()) + 5);
1713 strcat (strcpy (exename
, expanded_name
.get ()), ".exe");
1714 desc
= openp (getenv ("PATH"),
1715 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1716 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1720 perror_with_name (expanded_name
.get ());
1722 make_cleanup (xfree
, absolute_name
);
1723 name
= absolute_name
;
1726 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (name
, gnutarget
, desc
));
1727 if (sym_bfd
== NULL
)
1728 error (_("`%s': can't open to read symbols: %s."), name
,
1729 bfd_errmsg (bfd_get_error ()));
1731 if (!gdb_bfd_has_target_filename (sym_bfd
.get ()))
1732 bfd_set_cacheable (sym_bfd
.get (), 1);
1734 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
1735 error (_("`%s': can't read symbols: %s."), name
,
1736 bfd_errmsg (bfd_get_error ()));
1738 do_cleanups (back_to
);
1743 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1744 the section was not found. */
1747 get_section_index (struct objfile
*objfile
, const char *section_name
)
1749 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1757 /* Link SF into the global symtab_fns list.
1758 FLAVOUR is the file format that SF handles.
1759 Called on startup by the _initialize routine in each object file format
1760 reader, to register information about each format the reader is prepared
1764 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1766 symtab_fns
.emplace_back (flavour
, sf
);
1769 /* Initialize OBJFILE to read symbols from its associated BFD. It
1770 either returns or calls error(). The result is an initialized
1771 struct sym_fns in the objfile structure, that contains cached
1772 information about the symbol file. */
1774 static const struct sym_fns
*
1775 find_sym_fns (bfd
*abfd
)
1777 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1779 if (our_flavour
== bfd_target_srec_flavour
1780 || our_flavour
== bfd_target_ihex_flavour
1781 || our_flavour
== bfd_target_tekhex_flavour
)
1782 return NULL
; /* No symbols. */
1784 for (const registered_sym_fns
&rsf
: symtab_fns
)
1785 if (our_flavour
== rsf
.sym_flavour
)
1788 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1789 bfd_get_target (abfd
));
1793 /* This function runs the load command of our current target. */
1796 load_command (char *arg
, int from_tty
)
1798 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1802 /* The user might be reloading because the binary has changed. Take
1803 this opportunity to check. */
1804 reopen_exec_file ();
1812 parg
= arg
= get_exec_file (1);
1814 /* Count how many \ " ' tab space there are in the name. */
1815 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1823 /* We need to quote this string so buildargv can pull it apart. */
1824 char *temp
= (char *) xmalloc (strlen (arg
) + count
+ 1 );
1828 make_cleanup (xfree
, temp
);
1831 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1833 strncpy (ptemp
, prev
, parg
- prev
);
1834 ptemp
+= parg
- prev
;
1838 strcpy (ptemp
, prev
);
1844 target_load (arg
, from_tty
);
1846 /* After re-loading the executable, we don't really know which
1847 overlays are mapped any more. */
1848 overlay_cache_invalid
= 1;
1850 do_cleanups (cleanup
);
1853 /* This version of "load" should be usable for any target. Currently
1854 it is just used for remote targets, not inftarg.c or core files,
1855 on the theory that only in that case is it useful.
1857 Avoiding xmodem and the like seems like a win (a) because we don't have
1858 to worry about finding it, and (b) On VMS, fork() is very slow and so
1859 we don't want to run a subprocess. On the other hand, I'm not sure how
1860 performance compares. */
1862 static int validate_download
= 0;
1864 /* Callback service function for generic_load (bfd_map_over_sections). */
1867 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1869 bfd_size_type
*sum
= (bfd_size_type
*) data
;
1871 *sum
+= bfd_get_section_size (asec
);
1874 /* Opaque data for load_section_callback. */
1875 struct load_section_data
{
1876 CORE_ADDR load_offset
;
1877 struct load_progress_data
*progress_data
;
1878 VEC(memory_write_request_s
) *requests
;
1881 /* Opaque data for load_progress. */
1882 struct load_progress_data
{
1883 /* Cumulative data. */
1884 unsigned long write_count
;
1885 unsigned long data_count
;
1886 bfd_size_type total_size
;
1889 /* Opaque data for load_progress for a single section. */
1890 struct load_progress_section_data
{
1891 struct load_progress_data
*cumulative
;
1893 /* Per-section data. */
1894 const char *section_name
;
1895 ULONGEST section_sent
;
1896 ULONGEST section_size
;
1901 /* Target write callback routine for progress reporting. */
1904 load_progress (ULONGEST bytes
, void *untyped_arg
)
1906 struct load_progress_section_data
*args
1907 = (struct load_progress_section_data
*) untyped_arg
;
1908 struct load_progress_data
*totals
;
1911 /* Writing padding data. No easy way to get at the cumulative
1912 stats, so just ignore this. */
1915 totals
= args
->cumulative
;
1917 if (bytes
== 0 && args
->section_sent
== 0)
1919 /* The write is just starting. Let the user know we've started
1921 current_uiout
->message ("Loading section %s, size %s lma %s\n",
1923 hex_string (args
->section_size
),
1924 paddress (target_gdbarch (), args
->lma
));
1928 if (validate_download
)
1930 /* Broken memories and broken monitors manifest themselves here
1931 when bring new computers to life. This doubles already slow
1933 /* NOTE: cagney/1999-10-18: A more efficient implementation
1934 might add a verify_memory() method to the target vector and
1935 then use that. remote.c could implement that method using
1936 the ``qCRC'' packet. */
1937 gdb::byte_vector
check (bytes
);
1939 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1940 error (_("Download verify read failed at %s"),
1941 paddress (target_gdbarch (), args
->lma
));
1942 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1943 error (_("Download verify compare failed at %s"),
1944 paddress (target_gdbarch (), args
->lma
));
1946 totals
->data_count
+= bytes
;
1948 args
->buffer
+= bytes
;
1949 totals
->write_count
+= 1;
1950 args
->section_sent
+= bytes
;
1951 if (check_quit_flag ()
1952 || (deprecated_ui_load_progress_hook
!= NULL
1953 && deprecated_ui_load_progress_hook (args
->section_name
,
1954 args
->section_sent
)))
1955 error (_("Canceled the download"));
1957 if (deprecated_show_load_progress
!= NULL
)
1958 deprecated_show_load_progress (args
->section_name
,
1962 totals
->total_size
);
1965 /* Callback service function for generic_load (bfd_map_over_sections). */
1968 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1970 struct memory_write_request
*new_request
;
1971 struct load_section_data
*args
= (struct load_section_data
*) data
;
1972 struct load_progress_section_data
*section_data
;
1973 bfd_size_type size
= bfd_get_section_size (asec
);
1975 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1977 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1983 new_request
= VEC_safe_push (memory_write_request_s
,
1984 args
->requests
, NULL
);
1985 memset (new_request
, 0, sizeof (struct memory_write_request
));
1986 section_data
= XCNEW (struct load_progress_section_data
);
1987 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1988 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size
1990 new_request
->data
= (gdb_byte
*) xmalloc (size
);
1991 new_request
->baton
= section_data
;
1993 buffer
= new_request
->data
;
1995 section_data
->cumulative
= args
->progress_data
;
1996 section_data
->section_name
= sect_name
;
1997 section_data
->section_size
= size
;
1998 section_data
->lma
= new_request
->begin
;
1999 section_data
->buffer
= buffer
;
2001 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2004 /* Clean up an entire memory request vector, including load
2005 data and progress records. */
2008 clear_memory_write_data (void *arg
)
2010 VEC(memory_write_request_s
) **vec_p
= (VEC(memory_write_request_s
) **) arg
;
2011 VEC(memory_write_request_s
) *vec
= *vec_p
;
2013 struct memory_write_request
*mr
;
2015 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
2020 VEC_free (memory_write_request_s
, vec
);
2023 static void print_transfer_performance (struct ui_file
*stream
,
2024 unsigned long data_count
,
2025 unsigned long write_count
,
2026 std::chrono::steady_clock::duration d
);
2029 generic_load (const char *args
, int from_tty
)
2031 struct cleanup
*old_cleanups
;
2032 struct load_section_data cbdata
;
2033 struct load_progress_data total_progress
;
2034 struct ui_out
*uiout
= current_uiout
;
2038 memset (&cbdata
, 0, sizeof (cbdata
));
2039 memset (&total_progress
, 0, sizeof (total_progress
));
2040 cbdata
.progress_data
= &total_progress
;
2042 old_cleanups
= make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
2045 error_no_arg (_("file to load"));
2047 gdb_argv
argv (args
);
2049 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2051 if (argv
[1] != NULL
)
2055 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2057 /* If the last word was not a valid number then
2058 treat it as a file name with spaces in. */
2059 if (argv
[1] == endptr
)
2060 error (_("Invalid download offset:%s."), argv
[1]);
2062 if (argv
[2] != NULL
)
2063 error (_("Too many parameters."));
2066 /* Open the file for loading. */
2067 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
2068 if (loadfile_bfd
== NULL
)
2069 perror_with_name (filename
.get ());
2071 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
2073 error (_("\"%s\" is not an object file: %s"), filename
.get (),
2074 bfd_errmsg (bfd_get_error ()));
2077 bfd_map_over_sections (loadfile_bfd
.get (), add_section_size_callback
,
2078 (void *) &total_progress
.total_size
);
2080 bfd_map_over_sections (loadfile_bfd
.get (), load_section_callback
, &cbdata
);
2082 using namespace std::chrono
;
2084 steady_clock::time_point start_time
= steady_clock::now ();
2086 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2087 load_progress
) != 0)
2088 error (_("Load failed"));
2090 steady_clock::time_point end_time
= steady_clock::now ();
2092 entry
= bfd_get_start_address (loadfile_bfd
.get ());
2093 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2094 uiout
->text ("Start address ");
2095 uiout
->field_fmt ("address", "%s", paddress (target_gdbarch (), entry
));
2096 uiout
->text (", load size ");
2097 uiout
->field_fmt ("load-size", "%lu", total_progress
.data_count
);
2099 regcache_write_pc (get_current_regcache (), entry
);
2101 /* Reset breakpoints, now that we have changed the load image. For
2102 instance, breakpoints may have been set (or reset, by
2103 post_create_inferior) while connected to the target but before we
2104 loaded the program. In that case, the prologue analyzer could
2105 have read instructions from the target to find the right
2106 breakpoint locations. Loading has changed the contents of that
2109 breakpoint_re_set ();
2111 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2112 total_progress
.write_count
,
2113 end_time
- start_time
);
2115 do_cleanups (old_cleanups
);
2118 /* Report on STREAM the performance of a memory transfer operation,
2119 such as 'load'. DATA_COUNT is the number of bytes transferred.
2120 WRITE_COUNT is the number of separate write operations, or 0, if
2121 that information is not available. TIME is how long the operation
2125 print_transfer_performance (struct ui_file
*stream
,
2126 unsigned long data_count
,
2127 unsigned long write_count
,
2128 std::chrono::steady_clock::duration time
)
2130 using namespace std::chrono
;
2131 struct ui_out
*uiout
= current_uiout
;
2133 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2135 uiout
->text ("Transfer rate: ");
2136 if (ms
.count () > 0)
2138 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2140 if (uiout
->is_mi_like_p ())
2142 uiout
->field_fmt ("transfer-rate", "%lu", rate
* 8);
2143 uiout
->text (" bits/sec");
2145 else if (rate
< 1024)
2147 uiout
->field_fmt ("transfer-rate", "%lu", rate
);
2148 uiout
->text (" bytes/sec");
2152 uiout
->field_fmt ("transfer-rate", "%lu", rate
/ 1024);
2153 uiout
->text (" KB/sec");
2158 uiout
->field_fmt ("transferred-bits", "%lu", (data_count
* 8));
2159 uiout
->text (" bits in <1 sec");
2161 if (write_count
> 0)
2164 uiout
->field_fmt ("write-rate", "%lu", data_count
/ write_count
);
2165 uiout
->text (" bytes/write");
2167 uiout
->text (".\n");
2170 /* This function allows the addition of incrementally linked object files.
2171 It does not modify any state in the target, only in the debugger. */
2172 /* Note: ezannoni 2000-04-13 This function/command used to have a
2173 special case syntax for the rombug target (Rombug is the boot
2174 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2175 rombug case, the user doesn't need to supply a text address,
2176 instead a call to target_link() (in target.c) would supply the
2177 value to use. We are now discontinuing this type of ad hoc syntax. */
2180 add_symbol_file_command (const char *args
, int from_tty
)
2182 struct gdbarch
*gdbarch
= get_current_arch ();
2183 gdb::unique_xmalloc_ptr
<char> filename
;
2187 int expecting_sec_name
= 0;
2188 int expecting_sec_addr
= 0;
2189 struct objfile
*objf
;
2190 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2191 symfile_add_flags add_flags
= 0;
2194 add_flags
|= SYMFILE_VERBOSE
;
2202 struct section_addr_info
*section_addrs
;
2203 std::vector
<sect_opt
> sect_opts
;
2204 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2209 error (_("add-symbol-file takes a file name and an address"));
2211 gdb_argv
argv (args
);
2213 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2215 /* Process the argument. */
2218 /* The first argument is the file name. */
2219 filename
.reset (tilde_expand (arg
));
2221 else if (argcnt
== 1)
2223 /* The second argument is always the text address at which
2224 to load the program. */
2225 sect_opt sect
= { ".text", arg
};
2226 sect_opts
.push_back (sect
);
2230 /* It's an option (starting with '-') or it's an argument
2232 if (expecting_sec_name
)
2234 sect_opt sect
= { arg
, NULL
};
2235 sect_opts
.push_back (sect
);
2236 expecting_sec_name
= 0;
2238 else if (expecting_sec_addr
)
2240 sect_opts
.back ().value
= arg
;
2241 expecting_sec_addr
= 0;
2243 else if (strcmp (arg
, "-readnow") == 0)
2244 flags
|= OBJF_READNOW
;
2245 else if (strcmp (arg
, "-s") == 0)
2247 expecting_sec_name
= 1;
2248 expecting_sec_addr
= 1;
2251 error (_("USAGE: add-symbol-file <filename> <textaddress>"
2252 " [-readnow] [-s <secname> <addr>]*"));
2256 /* This command takes at least two arguments. The first one is a
2257 filename, and the second is the address where this file has been
2258 loaded. Abort now if this address hasn't been provided by the
2260 if (sect_opts
.empty ())
2261 error (_("The address where %s has been loaded is missing"),
2264 /* Print the prompt for the query below. And save the arguments into
2265 a sect_addr_info structure to be passed around to other
2266 functions. We have to split this up into separate print
2267 statements because hex_string returns a local static
2270 printf_unfiltered (_("add symbol table from file \"%s\" at\n"),
2272 section_addrs
= alloc_section_addr_info (sect_opts
.size ());
2273 make_cleanup (xfree
, section_addrs
);
2274 for (sect_opt
§
: sect_opts
)
2277 const char *val
= sect
.value
;
2278 const char *sec
= sect
.name
;
2280 addr
= parse_and_eval_address (val
);
2282 /* Here we store the section offsets in the order they were
2283 entered on the command line. */
2284 section_addrs
->other
[sec_num
].name
= (char *) sec
;
2285 section_addrs
->other
[sec_num
].addr
= addr
;
2286 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2287 paddress (gdbarch
, addr
));
2290 /* The object's sections are initialized when a
2291 call is made to build_objfile_section_table (objfile).
2292 This happens in reread_symbols.
2293 At this point, we don't know what file type this is,
2294 so we can't determine what section names are valid. */
2296 section_addrs
->num_sections
= sec_num
;
2298 if (from_tty
&& (!query ("%s", "")))
2299 error (_("Not confirmed."));
2301 objf
= symbol_file_add (filename
.get (), add_flags
, section_addrs
, flags
);
2303 add_target_sections_of_objfile (objf
);
2305 /* Getting new symbols may change our opinion about what is
2307 reinit_frame_cache ();
2308 do_cleanups (my_cleanups
);
2312 /* This function removes a symbol file that was added via add-symbol-file. */
2315 remove_symbol_file_command (const char *args
, int from_tty
)
2317 struct objfile
*objf
= NULL
;
2318 struct program_space
*pspace
= current_program_space
;
2323 error (_("remove-symbol-file: no symbol file provided"));
2325 gdb_argv
argv (args
);
2327 if (strcmp (argv
[0], "-a") == 0)
2329 /* Interpret the next argument as an address. */
2332 if (argv
[1] == NULL
)
2333 error (_("Missing address argument"));
2335 if (argv
[2] != NULL
)
2336 error (_("Junk after %s"), argv
[1]);
2338 addr
= parse_and_eval_address (argv
[1]);
2342 if ((objf
->flags
& OBJF_USERLOADED
) != 0
2343 && (objf
->flags
& OBJF_SHARED
) != 0
2344 && objf
->pspace
== pspace
&& is_addr_in_objfile (addr
, objf
))
2348 else if (argv
[0] != NULL
)
2350 /* Interpret the current argument as a file name. */
2352 if (argv
[1] != NULL
)
2353 error (_("Junk after %s"), argv
[0]);
2355 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2359 if ((objf
->flags
& OBJF_USERLOADED
) != 0
2360 && (objf
->flags
& OBJF_SHARED
) != 0
2361 && objf
->pspace
== pspace
2362 && filename_cmp (filename
.get (), objfile_name (objf
)) == 0)
2368 error (_("No symbol file found"));
2371 && !query (_("Remove symbol table from file \"%s\"? "),
2372 objfile_name (objf
)))
2373 error (_("Not confirmed."));
2376 clear_symtab_users (0);
2379 /* Re-read symbols if a symbol-file has changed. */
2382 reread_symbols (void)
2384 struct objfile
*objfile
;
2386 struct stat new_statbuf
;
2388 std::vector
<struct objfile
*> new_objfiles
;
2390 /* With the addition of shared libraries, this should be modified,
2391 the load time should be saved in the partial symbol tables, since
2392 different tables may come from different source files. FIXME.
2393 This routine should then walk down each partial symbol table
2394 and see if the symbol table that it originates from has been changed. */
2396 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2398 if (objfile
->obfd
== NULL
)
2401 /* Separate debug objfiles are handled in the main objfile. */
2402 if (objfile
->separate_debug_objfile_backlink
)
2405 /* If this object is from an archive (what you usually create with
2406 `ar', often called a `static library' on most systems, though
2407 a `shared library' on AIX is also an archive), then you should
2408 stat on the archive name, not member name. */
2409 if (objfile
->obfd
->my_archive
)
2410 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2412 res
= stat (objfile_name (objfile
), &new_statbuf
);
2415 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2416 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2417 objfile_name (objfile
));
2420 new_modtime
= new_statbuf
.st_mtime
;
2421 if (new_modtime
!= objfile
->mtime
)
2423 struct cleanup
*old_cleanups
;
2424 struct section_offsets
*offsets
;
2426 char *original_name
;
2428 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2429 objfile_name (objfile
));
2431 /* There are various functions like symbol_file_add,
2432 symfile_bfd_open, syms_from_objfile, etc., which might
2433 appear to do what we want. But they have various other
2434 effects which we *don't* want. So we just do stuff
2435 ourselves. We don't worry about mapped files (for one thing,
2436 any mapped file will be out of date). */
2438 /* If we get an error, blow away this objfile (not sure if
2439 that is the correct response for things like shared
2441 std::unique_ptr
<struct objfile
> objfile_holder (objfile
);
2443 /* We need to do this whenever any symbols go away. */
2444 old_cleanups
= make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2446 if (exec_bfd
!= NULL
2447 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2448 bfd_get_filename (exec_bfd
)) == 0)
2450 /* Reload EXEC_BFD without asking anything. */
2452 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2455 /* Keep the calls order approx. the same as in free_objfile. */
2457 /* Free the separate debug objfiles. It will be
2458 automatically recreated by sym_read. */
2459 free_objfile_separate_debug (objfile
);
2461 /* Remove any references to this objfile in the global
2463 preserve_values (objfile
);
2465 /* Nuke all the state that we will re-read. Much of the following
2466 code which sets things to NULL really is necessary to tell
2467 other parts of GDB that there is nothing currently there.
2469 Try to keep the freeing order compatible with free_objfile. */
2471 if (objfile
->sf
!= NULL
)
2473 (*objfile
->sf
->sym_finish
) (objfile
);
2476 clear_objfile_data (objfile
);
2478 /* Clean up any state BFD has sitting around. */
2480 gdb_bfd_ref_ptr
obfd (objfile
->obfd
);
2481 char *obfd_filename
;
2483 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2484 /* Open the new BFD before freeing the old one, so that
2485 the filename remains live. */
2486 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
, -1));
2487 objfile
->obfd
= temp
.release ();
2488 if (objfile
->obfd
== NULL
)
2489 error (_("Can't open %s to read symbols."), obfd_filename
);
2492 original_name
= xstrdup (objfile
->original_name
);
2493 make_cleanup (xfree
, original_name
);
2495 /* bfd_openr sets cacheable to true, which is what we want. */
2496 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2497 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2498 bfd_errmsg (bfd_get_error ()));
2500 /* Save the offsets, we will nuke them with the rest of the
2502 num_offsets
= objfile
->num_sections
;
2503 offsets
= ((struct section_offsets
*)
2504 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2505 memcpy (offsets
, objfile
->section_offsets
,
2506 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2508 /* FIXME: Do we have to free a whole linked list, or is this
2510 objfile
->global_psymbols
.clear ();
2511 objfile
->static_psymbols
.clear ();
2513 /* Free the obstacks for non-reusable objfiles. */
2514 psymbol_bcache_free (objfile
->psymbol_cache
);
2515 objfile
->psymbol_cache
= psymbol_bcache_init ();
2517 /* NB: after this call to obstack_free, objfiles_changed
2518 will need to be called (see discussion below). */
2519 obstack_free (&objfile
->objfile_obstack
, 0);
2520 objfile
->sections
= NULL
;
2521 objfile
->compunit_symtabs
= NULL
;
2522 objfile
->psymtabs
= NULL
;
2523 objfile
->psymtabs_addrmap
= NULL
;
2524 objfile
->free_psymtabs
= NULL
;
2525 objfile
->template_symbols
= NULL
;
2527 /* obstack_init also initializes the obstack so it is
2528 empty. We could use obstack_specify_allocation but
2529 gdb_obstack.h specifies the alloc/dealloc functions. */
2530 obstack_init (&objfile
->objfile_obstack
);
2532 /* set_objfile_per_bfd potentially allocates the per-bfd
2533 data on the objfile's obstack (if sharing data across
2534 multiple users is not possible), so it's important to
2535 do it *after* the obstack has been initialized. */
2536 set_objfile_per_bfd (objfile
);
2538 objfile
->original_name
2539 = (char *) obstack_copy0 (&objfile
->objfile_obstack
, original_name
,
2540 strlen (original_name
));
2542 /* Reset the sym_fns pointer. The ELF reader can change it
2543 based on whether .gdb_index is present, and we need it to
2544 start over. PR symtab/15885 */
2545 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
2547 build_objfile_section_table (objfile
);
2548 terminate_minimal_symbol_table (objfile
);
2550 /* We use the same section offsets as from last time. I'm not
2551 sure whether that is always correct for shared libraries. */
2552 objfile
->section_offsets
= (struct section_offsets
*)
2553 obstack_alloc (&objfile
->objfile_obstack
,
2554 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2555 memcpy (objfile
->section_offsets
, offsets
,
2556 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2557 objfile
->num_sections
= num_offsets
;
2559 /* What the hell is sym_new_init for, anyway? The concept of
2560 distinguishing between the main file and additional files
2561 in this way seems rather dubious. */
2562 if (objfile
== symfile_objfile
)
2564 (*objfile
->sf
->sym_new_init
) (objfile
);
2567 (*objfile
->sf
->sym_init
) (objfile
);
2568 clear_complaints (&symfile_complaints
, 1, 1);
2570 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2572 /* We are about to read new symbols and potentially also
2573 DWARF information. Some targets may want to pass addresses
2574 read from DWARF DIE's through an adjustment function before
2575 saving them, like MIPS, which may call into
2576 "find_pc_section". When called, that function will make
2577 use of per-objfile program space data.
2579 Since we discarded our section information above, we have
2580 dangling pointers in the per-objfile program space data
2581 structure. Force GDB to update the section mapping
2582 information by letting it know the objfile has changed,
2583 making the dangling pointers point to correct data
2586 objfiles_changed ();
2588 read_symbols (objfile
, 0);
2590 if (!objfile_has_symbols (objfile
))
2593 printf_unfiltered (_("(no debugging symbols found)\n"));
2597 /* We're done reading the symbol file; finish off complaints. */
2598 clear_complaints (&symfile_complaints
, 0, 1);
2600 /* Getting new symbols may change our opinion about what is
2603 reinit_frame_cache ();
2605 /* Discard cleanups as symbol reading was successful. */
2606 objfile_holder
.release ();
2607 discard_cleanups (old_cleanups
);
2609 /* If the mtime has changed between the time we set new_modtime
2610 and now, we *want* this to be out of date, so don't call stat
2612 objfile
->mtime
= new_modtime
;
2613 init_entry_point_info (objfile
);
2615 new_objfiles
.push_back (objfile
);
2619 if (!new_objfiles
.empty ())
2621 clear_symtab_users (0);
2623 /* clear_objfile_data for each objfile was called before freeing it and
2624 observer_notify_new_objfile (NULL) has been called by
2625 clear_symtab_users above. Notify the new files now. */
2626 for (auto iter
: new_objfiles
)
2627 observer_notify_new_objfile (iter
);
2629 /* At least one objfile has changed, so we can consider that
2630 the executable we're debugging has changed too. */
2631 observer_notify_executable_changed ();
2636 struct filename_language
2638 filename_language (const std::string
&ext_
, enum language lang_
)
2639 : ext (ext_
), lang (lang_
)
2646 static std::vector
<filename_language
> filename_language_table
;
2648 /* See symfile.h. */
2651 add_filename_language (const char *ext
, enum language lang
)
2653 filename_language_table
.emplace_back (ext
, lang
);
2656 static char *ext_args
;
2658 show_ext_args (struct ui_file
*file
, int from_tty
,
2659 struct cmd_list_element
*c
, const char *value
)
2661 fprintf_filtered (file
,
2662 _("Mapping between filename extension "
2663 "and source language is \"%s\".\n"),
2668 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2670 char *cp
= ext_args
;
2673 /* First arg is filename extension, starting with '.' */
2675 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2677 /* Find end of first arg. */
2678 while (*cp
&& !isspace (*cp
))
2682 error (_("'%s': two arguments required -- "
2683 "filename extension and language"),
2686 /* Null-terminate first arg. */
2689 /* Find beginning of second arg, which should be a source language. */
2690 cp
= skip_spaces (cp
);
2693 error (_("'%s': two arguments required -- "
2694 "filename extension and language"),
2697 /* Lookup the language from among those we know. */
2698 lang
= language_enum (cp
);
2700 auto it
= filename_language_table
.begin ();
2701 /* Now lookup the filename extension: do we already know it? */
2702 for (; it
!= filename_language_table
.end (); it
++)
2704 if (it
->ext
== ext_args
)
2708 if (it
== filename_language_table
.end ())
2710 /* New file extension. */
2711 add_filename_language (ext_args
, lang
);
2715 /* Redefining a previously known filename extension. */
2718 /* query ("Really make files of type %s '%s'?", */
2719 /* ext_args, language_str (lang)); */
2726 info_ext_lang_command (char *args
, int from_tty
)
2728 printf_filtered (_("Filename extensions and the languages they represent:"));
2729 printf_filtered ("\n\n");
2730 for (const filename_language
&entry
: filename_language_table
)
2731 printf_filtered ("\t%s\t- %s\n", entry
.ext
.c_str (),
2732 language_str (entry
.lang
));
2736 deduce_language_from_filename (const char *filename
)
2740 if (filename
!= NULL
)
2741 if ((cp
= strrchr (filename
, '.')) != NULL
)
2743 for (const filename_language
&entry
: filename_language_table
)
2744 if (entry
.ext
== cp
)
2748 return language_unknown
;
2751 /* Allocate and initialize a new symbol table.
2752 CUST is from the result of allocate_compunit_symtab. */
2755 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
)
2757 struct objfile
*objfile
= cust
->objfile
;
2758 struct symtab
*symtab
2759 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2762 = (const char *) bcache (filename
, strlen (filename
) + 1,
2763 objfile
->per_bfd
->filename_cache
);
2764 symtab
->fullname
= NULL
;
2765 symtab
->language
= deduce_language_from_filename (filename
);
2767 /* This can be very verbose with lots of headers.
2768 Only print at higher debug levels. */
2769 if (symtab_create_debug
>= 2)
2771 /* Be a bit clever with debugging messages, and don't print objfile
2772 every time, only when it changes. */
2773 static char *last_objfile_name
= NULL
;
2775 if (last_objfile_name
== NULL
2776 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
2778 xfree (last_objfile_name
);
2779 last_objfile_name
= xstrdup (objfile_name (objfile
));
2780 fprintf_unfiltered (gdb_stdlog
,
2781 "Creating one or more symtabs for objfile %s ...\n",
2784 fprintf_unfiltered (gdb_stdlog
,
2785 "Created symtab %s for module %s.\n",
2786 host_address_to_string (symtab
), filename
);
2789 /* Add it to CUST's list of symtabs. */
2790 if (cust
->filetabs
== NULL
)
2792 cust
->filetabs
= symtab
;
2793 cust
->last_filetab
= symtab
;
2797 cust
->last_filetab
->next
= symtab
;
2798 cust
->last_filetab
= symtab
;
2801 /* Backlink to the containing compunit symtab. */
2802 symtab
->compunit_symtab
= cust
;
2807 /* Allocate and initialize a new compunit.
2808 NAME is the name of the main source file, if there is one, or some
2809 descriptive text if there are no source files. */
2811 struct compunit_symtab
*
2812 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2814 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2815 struct compunit_symtab
);
2816 const char *saved_name
;
2818 cu
->objfile
= objfile
;
2820 /* The name we record here is only for display/debugging purposes.
2821 Just save the basename to avoid path issues (too long for display,
2822 relative vs absolute, etc.). */
2823 saved_name
= lbasename (name
);
2825 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
, saved_name
,
2826 strlen (saved_name
));
2828 COMPUNIT_DEBUGFORMAT (cu
) = "unknown";
2830 if (symtab_create_debug
)
2832 fprintf_unfiltered (gdb_stdlog
,
2833 "Created compunit symtab %s for %s.\n",
2834 host_address_to_string (cu
),
2841 /* Hook CU to the objfile it comes from. */
2844 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2846 cu
->next
= cu
->objfile
->compunit_symtabs
;
2847 cu
->objfile
->compunit_symtabs
= cu
;
2851 /* Reset all data structures in gdb which may contain references to
2852 symbol table data. */
2855 clear_symtab_users (symfile_add_flags add_flags
)
2857 /* Someday, we should do better than this, by only blowing away
2858 the things that really need to be blown. */
2860 /* Clear the "current" symtab first, because it is no longer valid.
2861 breakpoint_re_set may try to access the current symtab. */
2862 clear_current_source_symtab_and_line ();
2865 clear_last_displayed_sal ();
2866 clear_pc_function_cache ();
2867 observer_notify_new_objfile (NULL
);
2869 /* Clear globals which might have pointed into a removed objfile.
2870 FIXME: It's not clear which of these are supposed to persist
2871 between expressions and which ought to be reset each time. */
2872 expression_context_block
= NULL
;
2873 innermost_block
= NULL
;
2875 /* Varobj may refer to old symbols, perform a cleanup. */
2876 varobj_invalidate ();
2878 /* Now that the various caches have been cleared, we can re_set
2879 our breakpoints without risking it using stale data. */
2880 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2881 breakpoint_re_set ();
2885 clear_symtab_users_cleanup (void *ignore
)
2887 clear_symtab_users (0);
2891 The following code implements an abstraction for debugging overlay sections.
2893 The target model is as follows:
2894 1) The gnu linker will permit multiple sections to be mapped into the
2895 same VMA, each with its own unique LMA (or load address).
2896 2) It is assumed that some runtime mechanism exists for mapping the
2897 sections, one by one, from the load address into the VMA address.
2898 3) This code provides a mechanism for gdb to keep track of which
2899 sections should be considered to be mapped from the VMA to the LMA.
2900 This information is used for symbol lookup, and memory read/write.
2901 For instance, if a section has been mapped then its contents
2902 should be read from the VMA, otherwise from the LMA.
2904 Two levels of debugger support for overlays are available. One is
2905 "manual", in which the debugger relies on the user to tell it which
2906 overlays are currently mapped. This level of support is
2907 implemented entirely in the core debugger, and the information about
2908 whether a section is mapped is kept in the objfile->obj_section table.
2910 The second level of support is "automatic", and is only available if
2911 the target-specific code provides functionality to read the target's
2912 overlay mapping table, and translate its contents for the debugger
2913 (by updating the mapped state information in the obj_section tables).
2915 The interface is as follows:
2917 overlay map <name> -- tell gdb to consider this section mapped
2918 overlay unmap <name> -- tell gdb to consider this section unmapped
2919 overlay list -- list the sections that GDB thinks are mapped
2920 overlay read-target -- get the target's state of what's mapped
2921 overlay off/manual/auto -- set overlay debugging state
2922 Functional interface:
2923 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2924 section, return that section.
2925 find_pc_overlay(pc): find any overlay section that contains
2926 the pc, either in its VMA or its LMA
2927 section_is_mapped(sect): true if overlay is marked as mapped
2928 section_is_overlay(sect): true if section's VMA != LMA
2929 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2930 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2931 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2932 overlay_mapped_address(...): map an address from section's LMA to VMA
2933 overlay_unmapped_address(...): map an address from section's VMA to LMA
2934 symbol_overlayed_address(...): Return a "current" address for symbol:
2935 either in VMA or LMA depending on whether
2936 the symbol's section is currently mapped. */
2938 /* Overlay debugging state: */
2940 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2941 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2943 /* Function: section_is_overlay (SECTION)
2944 Returns true if SECTION has VMA not equal to LMA, ie.
2945 SECTION is loaded at an address different from where it will "run". */
2948 section_is_overlay (struct obj_section
*section
)
2950 if (overlay_debugging
&& section
)
2952 bfd
*abfd
= section
->objfile
->obfd
;
2953 asection
*bfd_section
= section
->the_bfd_section
;
2955 if (bfd_section_lma (abfd
, bfd_section
) != 0
2956 && bfd_section_lma (abfd
, bfd_section
)
2957 != bfd_section_vma (abfd
, bfd_section
))
2964 /* Function: overlay_invalidate_all (void)
2965 Invalidate the mapped state of all overlay sections (mark it as stale). */
2968 overlay_invalidate_all (void)
2970 struct objfile
*objfile
;
2971 struct obj_section
*sect
;
2973 ALL_OBJSECTIONS (objfile
, sect
)
2974 if (section_is_overlay (sect
))
2975 sect
->ovly_mapped
= -1;
2978 /* Function: section_is_mapped (SECTION)
2979 Returns true if section is an overlay, and is currently mapped.
2981 Access to the ovly_mapped flag is restricted to this function, so
2982 that we can do automatic update. If the global flag
2983 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2984 overlay_invalidate_all. If the mapped state of the particular
2985 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2988 section_is_mapped (struct obj_section
*osect
)
2990 struct gdbarch
*gdbarch
;
2992 if (osect
== 0 || !section_is_overlay (osect
))
2995 switch (overlay_debugging
)
2999 return 0; /* overlay debugging off */
3000 case ovly_auto
: /* overlay debugging automatic */
3001 /* Unles there is a gdbarch_overlay_update function,
3002 there's really nothing useful to do here (can't really go auto). */
3003 gdbarch
= get_objfile_arch (osect
->objfile
);
3004 if (gdbarch_overlay_update_p (gdbarch
))
3006 if (overlay_cache_invalid
)
3008 overlay_invalidate_all ();
3009 overlay_cache_invalid
= 0;
3011 if (osect
->ovly_mapped
== -1)
3012 gdbarch_overlay_update (gdbarch
, osect
);
3014 /* fall thru to manual case */
3015 case ovly_on
: /* overlay debugging manual */
3016 return osect
->ovly_mapped
== 1;
3020 /* Function: pc_in_unmapped_range
3021 If PC falls into the lma range of SECTION, return true, else false. */
3024 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3026 if (section_is_overlay (section
))
3028 bfd
*abfd
= section
->objfile
->obfd
;
3029 asection
*bfd_section
= section
->the_bfd_section
;
3031 /* We assume the LMA is relocated by the same offset as the VMA. */
3032 bfd_vma size
= bfd_get_section_size (bfd_section
);
3033 CORE_ADDR offset
= obj_section_offset (section
);
3035 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3036 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3043 /* Function: pc_in_mapped_range
3044 If PC falls into the vma range of SECTION, return true, else false. */
3047 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3049 if (section_is_overlay (section
))
3051 if (obj_section_addr (section
) <= pc
3052 && pc
< obj_section_endaddr (section
))
3059 /* Return true if the mapped ranges of sections A and B overlap, false
3063 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3065 CORE_ADDR a_start
= obj_section_addr (a
);
3066 CORE_ADDR a_end
= obj_section_endaddr (a
);
3067 CORE_ADDR b_start
= obj_section_addr (b
);
3068 CORE_ADDR b_end
= obj_section_endaddr (b
);
3070 return (a_start
< b_end
&& b_start
< a_end
);
3073 /* Function: overlay_unmapped_address (PC, SECTION)
3074 Returns the address corresponding to PC in the unmapped (load) range.
3075 May be the same as PC. */
3078 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3080 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3082 bfd
*abfd
= section
->objfile
->obfd
;
3083 asection
*bfd_section
= section
->the_bfd_section
;
3085 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3086 - bfd_section_vma (abfd
, bfd_section
);
3092 /* Function: overlay_mapped_address (PC, SECTION)
3093 Returns the address corresponding to PC in the mapped (runtime) range.
3094 May be the same as PC. */
3097 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3099 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3101 bfd
*abfd
= section
->objfile
->obfd
;
3102 asection
*bfd_section
= section
->the_bfd_section
;
3104 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3105 - bfd_section_lma (abfd
, bfd_section
);
3111 /* Function: symbol_overlayed_address
3112 Return one of two addresses (relative to the VMA or to the LMA),
3113 depending on whether the section is mapped or not. */
3116 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3118 if (overlay_debugging
)
3120 /* If the symbol has no section, just return its regular address. */
3123 /* If the symbol's section is not an overlay, just return its
3125 if (!section_is_overlay (section
))
3127 /* If the symbol's section is mapped, just return its address. */
3128 if (section_is_mapped (section
))
3131 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3132 * then return its LOADED address rather than its vma address!!
3134 return overlay_unmapped_address (address
, section
);
3139 /* Function: find_pc_overlay (PC)
3140 Return the best-match overlay section for PC:
3141 If PC matches a mapped overlay section's VMA, return that section.
3142 Else if PC matches an unmapped section's VMA, return that section.
3143 Else if PC matches an unmapped section's LMA, return that section. */
3145 struct obj_section
*
3146 find_pc_overlay (CORE_ADDR pc
)
3148 struct objfile
*objfile
;
3149 struct obj_section
*osect
, *best_match
= NULL
;
3151 if (overlay_debugging
)
3153 ALL_OBJSECTIONS (objfile
, osect
)
3154 if (section_is_overlay (osect
))
3156 if (pc_in_mapped_range (pc
, osect
))
3158 if (section_is_mapped (osect
))
3163 else if (pc_in_unmapped_range (pc
, osect
))
3170 /* Function: find_pc_mapped_section (PC)
3171 If PC falls into the VMA address range of an overlay section that is
3172 currently marked as MAPPED, return that section. Else return NULL. */
3174 struct obj_section
*
3175 find_pc_mapped_section (CORE_ADDR pc
)
3177 struct objfile
*objfile
;
3178 struct obj_section
*osect
;
3180 if (overlay_debugging
)
3182 ALL_OBJSECTIONS (objfile
, osect
)
3183 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3190 /* Function: list_overlays_command
3191 Print a list of mapped sections and their PC ranges. */
3194 list_overlays_command (const char *args
, int from_tty
)
3197 struct objfile
*objfile
;
3198 struct obj_section
*osect
;
3200 if (overlay_debugging
)
3202 ALL_OBJSECTIONS (objfile
, osect
)
3203 if (section_is_mapped (osect
))
3205 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3210 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3211 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3212 size
= bfd_get_section_size (osect
->the_bfd_section
);
3213 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3215 printf_filtered ("Section %s, loaded at ", name
);
3216 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3217 puts_filtered (" - ");
3218 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3219 printf_filtered (", mapped at ");
3220 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3221 puts_filtered (" - ");
3222 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3223 puts_filtered ("\n");
3229 printf_filtered (_("No sections are mapped.\n"));
3232 /* Function: map_overlay_command
3233 Mark the named section as mapped (ie. residing at its VMA address). */
3236 map_overlay_command (const char *args
, int from_tty
)
3238 struct objfile
*objfile
, *objfile2
;
3239 struct obj_section
*sec
, *sec2
;
3241 if (!overlay_debugging
)
3242 error (_("Overlay debugging not enabled. Use "
3243 "either the 'overlay auto' or\n"
3244 "the 'overlay manual' command."));
3246 if (args
== 0 || *args
== 0)
3247 error (_("Argument required: name of an overlay section"));
3249 /* First, find a section matching the user supplied argument. */
3250 ALL_OBJSECTIONS (objfile
, sec
)
3251 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3253 /* Now, check to see if the section is an overlay. */
3254 if (!section_is_overlay (sec
))
3255 continue; /* not an overlay section */
3257 /* Mark the overlay as "mapped". */
3258 sec
->ovly_mapped
= 1;
3260 /* Next, make a pass and unmap any sections that are
3261 overlapped by this new section: */
3262 ALL_OBJSECTIONS (objfile2
, sec2
)
3263 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3266 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3267 bfd_section_name (objfile
->obfd
,
3268 sec2
->the_bfd_section
));
3269 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3273 error (_("No overlay section called %s"), args
);
3276 /* Function: unmap_overlay_command
3277 Mark the overlay section as unmapped
3278 (ie. resident in its LMA address range, rather than the VMA range). */
3281 unmap_overlay_command (const char *args
, int from_tty
)
3283 struct objfile
*objfile
;
3284 struct obj_section
*sec
= NULL
;
3286 if (!overlay_debugging
)
3287 error (_("Overlay debugging not enabled. "
3288 "Use either the 'overlay auto' or\n"
3289 "the 'overlay manual' command."));
3291 if (args
== 0 || *args
== 0)
3292 error (_("Argument required: name of an overlay section"));
3294 /* First, find a section matching the user supplied argument. */
3295 ALL_OBJSECTIONS (objfile
, sec
)
3296 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3298 if (!sec
->ovly_mapped
)
3299 error (_("Section %s is not mapped"), args
);
3300 sec
->ovly_mapped
= 0;
3303 error (_("No overlay section called %s"), args
);
3306 /* Function: overlay_auto_command
3307 A utility command to turn on overlay debugging.
3308 Possibly this should be done via a set/show command. */
3311 overlay_auto_command (const char *args
, int from_tty
)
3313 overlay_debugging
= ovly_auto
;
3314 enable_overlay_breakpoints ();
3316 printf_unfiltered (_("Automatic overlay debugging enabled."));
3319 /* Function: overlay_manual_command
3320 A utility command to turn on overlay debugging.
3321 Possibly this should be done via a set/show command. */
3324 overlay_manual_command (const char *args
, int from_tty
)
3326 overlay_debugging
= ovly_on
;
3327 disable_overlay_breakpoints ();
3329 printf_unfiltered (_("Overlay debugging enabled."));
3332 /* Function: overlay_off_command
3333 A utility command to turn on overlay debugging.
3334 Possibly this should be done via a set/show command. */
3337 overlay_off_command (const char *args
, int from_tty
)
3339 overlay_debugging
= ovly_off
;
3340 disable_overlay_breakpoints ();
3342 printf_unfiltered (_("Overlay debugging disabled."));
3346 overlay_load_command (const char *args
, int from_tty
)
3348 struct gdbarch
*gdbarch
= get_current_arch ();
3350 if (gdbarch_overlay_update_p (gdbarch
))
3351 gdbarch_overlay_update (gdbarch
, NULL
);
3353 error (_("This target does not know how to read its overlay state."));
3356 /* Function: overlay_command
3357 A place-holder for a mis-typed command. */
3359 /* Command list chain containing all defined "overlay" subcommands. */
3360 static struct cmd_list_element
*overlaylist
;
3363 overlay_command (const char *args
, int from_tty
)
3366 ("\"overlay\" must be followed by the name of an overlay command.\n");
3367 help_list (overlaylist
, "overlay ", all_commands
, gdb_stdout
);
3370 /* Target Overlays for the "Simplest" overlay manager:
3372 This is GDB's default target overlay layer. It works with the
3373 minimal overlay manager supplied as an example by Cygnus. The
3374 entry point is via a function pointer "gdbarch_overlay_update",
3375 so targets that use a different runtime overlay manager can
3376 substitute their own overlay_update function and take over the
3379 The overlay_update function pokes around in the target's data structures
3380 to see what overlays are mapped, and updates GDB's overlay mapping with
3383 In this simple implementation, the target data structures are as follows:
3384 unsigned _novlys; /# number of overlay sections #/
3385 unsigned _ovly_table[_novlys][4] = {
3386 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3387 {..., ..., ..., ...},
3389 unsigned _novly_regions; /# number of overlay regions #/
3390 unsigned _ovly_region_table[_novly_regions][3] = {
3391 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3394 These functions will attempt to update GDB's mappedness state in the
3395 symbol section table, based on the target's mappedness state.
3397 To do this, we keep a cached copy of the target's _ovly_table, and
3398 attempt to detect when the cached copy is invalidated. The main
3399 entry point is "simple_overlay_update(SECT), which looks up SECT in
3400 the cached table and re-reads only the entry for that section from
3401 the target (whenever possible). */
3403 /* Cached, dynamically allocated copies of the target data structures: */
3404 static unsigned (*cache_ovly_table
)[4] = 0;
3405 static unsigned cache_novlys
= 0;
3406 static CORE_ADDR cache_ovly_table_base
= 0;
3409 VMA
, OSIZE
, LMA
, MAPPED
3412 /* Throw away the cached copy of _ovly_table. */
3415 simple_free_overlay_table (void)
3417 if (cache_ovly_table
)
3418 xfree (cache_ovly_table
);
3420 cache_ovly_table
= NULL
;
3421 cache_ovly_table_base
= 0;
3424 /* Read an array of ints of size SIZE from the target into a local buffer.
3425 Convert to host order. int LEN is number of ints. */
3428 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3429 int len
, int size
, enum bfd_endian byte_order
)
3431 /* FIXME (alloca): Not safe if array is very large. */
3432 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3435 read_memory (memaddr
, buf
, len
* size
);
3436 for (i
= 0; i
< len
; i
++)
3437 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3440 /* Find and grab a copy of the target _ovly_table
3441 (and _novlys, which is needed for the table's size). */
3444 simple_read_overlay_table (void)
3446 struct bound_minimal_symbol novlys_msym
;
3447 struct bound_minimal_symbol ovly_table_msym
;
3448 struct gdbarch
*gdbarch
;
3450 enum bfd_endian byte_order
;
3452 simple_free_overlay_table ();
3453 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3454 if (! novlys_msym
.minsym
)
3456 error (_("Error reading inferior's overlay table: "
3457 "couldn't find `_novlys' variable\n"
3458 "in inferior. Use `overlay manual' mode."));
3462 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3463 if (! ovly_table_msym
.minsym
)
3465 error (_("Error reading inferior's overlay table: couldn't find "
3466 "`_ovly_table' array\n"
3467 "in inferior. Use `overlay manual' mode."));
3471 gdbarch
= get_objfile_arch (ovly_table_msym
.objfile
);
3472 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3473 byte_order
= gdbarch_byte_order (gdbarch
);
3475 cache_novlys
= read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym
),
3478 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3479 cache_ovly_table_base
= BMSYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3480 read_target_long_array (cache_ovly_table_base
,
3481 (unsigned int *) cache_ovly_table
,
3482 cache_novlys
* 4, word_size
, byte_order
);
3484 return 1; /* SUCCESS */
3487 /* Function: simple_overlay_update_1
3488 A helper function for simple_overlay_update. Assuming a cached copy
3489 of _ovly_table exists, look through it to find an entry whose vma,
3490 lma and size match those of OSECT. Re-read the entry and make sure
3491 it still matches OSECT (else the table may no longer be valid).
3492 Set OSECT's mapped state to match the entry. Return: 1 for
3493 success, 0 for failure. */
3496 simple_overlay_update_1 (struct obj_section
*osect
)
3499 bfd
*obfd
= osect
->objfile
->obfd
;
3500 asection
*bsect
= osect
->the_bfd_section
;
3501 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3502 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3503 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3505 for (i
= 0; i
< cache_novlys
; i
++)
3506 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3507 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3509 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3510 (unsigned int *) cache_ovly_table
[i
],
3511 4, word_size
, byte_order
);
3512 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3513 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3515 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3518 else /* Warning! Warning! Target's ovly table has changed! */
3524 /* Function: simple_overlay_update
3525 If OSECT is NULL, then update all sections' mapped state
3526 (after re-reading the entire target _ovly_table).
3527 If OSECT is non-NULL, then try to find a matching entry in the
3528 cached ovly_table and update only OSECT's mapped state.
3529 If a cached entry can't be found or the cache isn't valid, then
3530 re-read the entire cache, and go ahead and update all sections. */
3533 simple_overlay_update (struct obj_section
*osect
)
3535 struct objfile
*objfile
;
3537 /* Were we given an osect to look up? NULL means do all of them. */
3539 /* Have we got a cached copy of the target's overlay table? */
3540 if (cache_ovly_table
!= NULL
)
3542 /* Does its cached location match what's currently in the
3544 struct bound_minimal_symbol minsym
3545 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3547 if (minsym
.minsym
== NULL
)
3548 error (_("Error reading inferior's overlay table: couldn't "
3549 "find `_ovly_table' array\n"
3550 "in inferior. Use `overlay manual' mode."));
3552 if (cache_ovly_table_base
== BMSYMBOL_VALUE_ADDRESS (minsym
))
3553 /* Then go ahead and try to look up this single section in
3555 if (simple_overlay_update_1 (osect
))
3556 /* Found it! We're done. */
3560 /* Cached table no good: need to read the entire table anew.
3561 Or else we want all the sections, in which case it's actually
3562 more efficient to read the whole table in one block anyway. */
3564 if (! simple_read_overlay_table ())
3567 /* Now may as well update all sections, even if only one was requested. */
3568 ALL_OBJSECTIONS (objfile
, osect
)
3569 if (section_is_overlay (osect
))
3572 bfd
*obfd
= osect
->objfile
->obfd
;
3573 asection
*bsect
= osect
->the_bfd_section
;
3575 for (i
= 0; i
< cache_novlys
; i
++)
3576 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3577 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3578 { /* obj_section matches i'th entry in ovly_table. */
3579 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3580 break; /* finished with inner for loop: break out. */
3585 /* Set the output sections and output offsets for section SECTP in
3586 ABFD. The relocation code in BFD will read these offsets, so we
3587 need to be sure they're initialized. We map each section to itself,
3588 with no offset; this means that SECTP->vma will be honored. */
3591 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3593 sectp
->output_section
= sectp
;
3594 sectp
->output_offset
= 0;
3597 /* Default implementation for sym_relocate. */
3600 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3603 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3605 bfd
*abfd
= sectp
->owner
;
3607 /* We're only interested in sections with relocation
3609 if ((sectp
->flags
& SEC_RELOC
) == 0)
3612 /* We will handle section offsets properly elsewhere, so relocate as if
3613 all sections begin at 0. */
3614 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3616 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3619 /* Relocate the contents of a debug section SECTP in ABFD. The
3620 contents are stored in BUF if it is non-NULL, or returned in a
3621 malloc'd buffer otherwise.
3623 For some platforms and debug info formats, shared libraries contain
3624 relocations against the debug sections (particularly for DWARF-2;
3625 one affected platform is PowerPC GNU/Linux, although it depends on
3626 the version of the linker in use). Also, ELF object files naturally
3627 have unresolved relocations for their debug sections. We need to apply
3628 the relocations in order to get the locations of symbols correct.
3629 Another example that may require relocation processing, is the
3630 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3634 symfile_relocate_debug_section (struct objfile
*objfile
,
3635 asection
*sectp
, bfd_byte
*buf
)
3637 gdb_assert (objfile
->sf
->sym_relocate
);
3639 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3642 struct symfile_segment_data
*
3643 get_symfile_segment_data (bfd
*abfd
)
3645 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3650 return sf
->sym_segments (abfd
);
3654 free_symfile_segment_data (struct symfile_segment_data
*data
)
3656 xfree (data
->segment_bases
);
3657 xfree (data
->segment_sizes
);
3658 xfree (data
->segment_info
);
3663 - DATA, containing segment addresses from the object file ABFD, and
3664 the mapping from ABFD's sections onto the segments that own them,
3666 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3667 segment addresses reported by the target,
3668 store the appropriate offsets for each section in OFFSETS.
3670 If there are fewer entries in SEGMENT_BASES than there are segments
3671 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3673 If there are more entries, then ignore the extra. The target may
3674 not be able to distinguish between an empty data segment and a
3675 missing data segment; a missing text segment is less plausible. */
3678 symfile_map_offsets_to_segments (bfd
*abfd
,
3679 const struct symfile_segment_data
*data
,
3680 struct section_offsets
*offsets
,
3681 int num_segment_bases
,
3682 const CORE_ADDR
*segment_bases
)
3687 /* It doesn't make sense to call this function unless you have some
3688 segment base addresses. */
3689 gdb_assert (num_segment_bases
> 0);
3691 /* If we do not have segment mappings for the object file, we
3692 can not relocate it by segments. */
3693 gdb_assert (data
!= NULL
);
3694 gdb_assert (data
->num_segments
> 0);
3696 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3698 int which
= data
->segment_info
[i
];
3700 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3702 /* Don't bother computing offsets for sections that aren't
3703 loaded as part of any segment. */
3707 /* Use the last SEGMENT_BASES entry as the address of any extra
3708 segments mentioned in DATA->segment_info. */
3709 if (which
> num_segment_bases
)
3710 which
= num_segment_bases
;
3712 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3713 - data
->segment_bases
[which
- 1]);
3720 symfile_find_segment_sections (struct objfile
*objfile
)
3722 bfd
*abfd
= objfile
->obfd
;
3725 struct symfile_segment_data
*data
;
3727 data
= get_symfile_segment_data (objfile
->obfd
);
3731 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3733 free_symfile_segment_data (data
);
3737 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3739 int which
= data
->segment_info
[i
];
3743 if (objfile
->sect_index_text
== -1)
3744 objfile
->sect_index_text
= sect
->index
;
3746 if (objfile
->sect_index_rodata
== -1)
3747 objfile
->sect_index_rodata
= sect
->index
;
3749 else if (which
== 2)
3751 if (objfile
->sect_index_data
== -1)
3752 objfile
->sect_index_data
= sect
->index
;
3754 if (objfile
->sect_index_bss
== -1)
3755 objfile
->sect_index_bss
= sect
->index
;
3759 free_symfile_segment_data (data
);
3762 /* Listen for free_objfile events. */
3765 symfile_free_objfile (struct objfile
*objfile
)
3767 /* Remove the target sections owned by this objfile. */
3768 if (objfile
!= NULL
)
3769 remove_target_sections ((void *) objfile
);
3772 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3773 Expand all symtabs that match the specified criteria.
3774 See quick_symbol_functions.expand_symtabs_matching for details. */
3777 expand_symtabs_matching
3778 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3779 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3780 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3781 enum search_domain kind
)
3783 struct objfile
*objfile
;
3785 ALL_OBJFILES (objfile
)
3788 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, file_matcher
,
3790 expansion_notify
, kind
);
3794 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3795 Map function FUN over every file.
3796 See quick_symbol_functions.map_symbol_filenames for details. */
3799 map_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
3802 struct objfile
*objfile
;
3804 ALL_OBJFILES (objfile
)
3807 objfile
->sf
->qf
->map_symbol_filenames (objfile
, fun
, data
,
3814 namespace selftests
{
3815 namespace filename_language
{
3817 static void test_filename_language ()
3819 /* This test messes up the filename_language_table global. */
3820 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3822 /* Test deducing an unknown extension. */
3823 language lang
= deduce_language_from_filename ("myfile.blah");
3824 SELF_CHECK (lang
== language_unknown
);
3826 /* Test deducing a known extension. */
3827 lang
= deduce_language_from_filename ("myfile.c");
3828 SELF_CHECK (lang
== language_c
);
3830 /* Test adding a new extension using the internal API. */
3831 add_filename_language (".blah", language_pascal
);
3832 lang
= deduce_language_from_filename ("myfile.blah");
3833 SELF_CHECK (lang
== language_pascal
);
3837 test_set_ext_lang_command ()
3839 /* This test messes up the filename_language_table global. */
3840 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3842 /* Confirm that the .hello extension is not known. */
3843 language lang
= deduce_language_from_filename ("cake.hello");
3844 SELF_CHECK (lang
== language_unknown
);
3846 /* Test adding a new extension using the CLI command. */
3847 gdb::unique_xmalloc_ptr
<char> args_holder (xstrdup (".hello rust"));
3848 ext_args
= args_holder
.get ();
3849 set_ext_lang_command (NULL
, 1, NULL
);
3851 lang
= deduce_language_from_filename ("cake.hello");
3852 SELF_CHECK (lang
== language_rust
);
3854 /* Test overriding an existing extension using the CLI command. */
3855 int size_before
= filename_language_table
.size ();
3856 args_holder
.reset (xstrdup (".hello pascal"));
3857 ext_args
= args_holder
.get ();
3858 set_ext_lang_command (NULL
, 1, NULL
);
3859 int size_after
= filename_language_table
.size ();
3861 lang
= deduce_language_from_filename ("cake.hello");
3862 SELF_CHECK (lang
== language_pascal
);
3863 SELF_CHECK (size_before
== size_after
);
3866 } /* namespace filename_language */
3867 } /* namespace selftests */
3869 #endif /* GDB_SELF_TEST */
3872 _initialize_symfile (void)
3874 struct cmd_list_element
*c
;
3876 observer_attach_free_objfile (symfile_free_objfile
);
3878 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3879 Load symbol table from executable file FILE.\n\
3880 The `file' command can also load symbol tables, as well as setting the file\n\
3881 to execute."), &cmdlist
);
3882 set_cmd_completer (c
, filename_completer
);
3884 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3885 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3886 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR>\
3887 ...]\nADDR is the starting address of the file's text.\n\
3888 The optional arguments are section-name section-address pairs and\n\
3889 should be specified if the data and bss segments are not contiguous\n\
3890 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3892 set_cmd_completer (c
, filename_completer
);
3894 c
= add_cmd ("remove-symbol-file", class_files
,
3895 remove_symbol_file_command
, _("\
3896 Remove a symbol file added via the add-symbol-file command.\n\
3897 Usage: remove-symbol-file FILENAME\n\
3898 remove-symbol-file -a ADDRESS\n\
3899 The file to remove can be identified by its filename or by an address\n\
3900 that lies within the boundaries of this symbol file in memory."),
3903 c
= add_cmd ("load", class_files
, load_command
, _("\
3904 Dynamically load FILE into the running program, and record its symbols\n\
3905 for access from GDB.\n\
3906 An optional load OFFSET may also be given as a literal address.\n\
3907 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3909 Usage: load [FILE] [OFFSET]"), &cmdlist
);
3910 set_cmd_completer (c
, filename_completer
);
3912 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3913 _("Commands for debugging overlays."), &overlaylist
,
3914 "overlay ", 0, &cmdlist
);
3916 add_com_alias ("ovly", "overlay", class_alias
, 1);
3917 add_com_alias ("ov", "overlay", class_alias
, 1);
3919 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3920 _("Assert that an overlay section is mapped."), &overlaylist
);
3922 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3923 _("Assert that an overlay section is unmapped."), &overlaylist
);
3925 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3926 _("List mappings of overlay sections."), &overlaylist
);
3928 add_cmd ("manual", class_support
, overlay_manual_command
,
3929 _("Enable overlay debugging."), &overlaylist
);
3930 add_cmd ("off", class_support
, overlay_off_command
,
3931 _("Disable overlay debugging."), &overlaylist
);
3932 add_cmd ("auto", class_support
, overlay_auto_command
,
3933 _("Enable automatic overlay debugging."), &overlaylist
);
3934 add_cmd ("load-target", class_support
, overlay_load_command
,
3935 _("Read the overlay mapping state from the target."), &overlaylist
);
3937 /* Filename extension to source language lookup table: */
3938 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3940 Set mapping between filename extension and source language."), _("\
3941 Show mapping between filename extension and source language."), _("\
3942 Usage: set extension-language .foo bar"),
3943 set_ext_lang_command
,
3945 &setlist
, &showlist
);
3947 add_info ("extensions", info_ext_lang_command
,
3948 _("All filename extensions associated with a source language."));
3950 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3951 &debug_file_directory
, _("\
3952 Set the directories where separate debug symbols are searched for."), _("\
3953 Show the directories where separate debug symbols are searched for."), _("\
3954 Separate debug symbols are first searched for in the same\n\
3955 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3956 and lastly at the path of the directory of the binary with\n\
3957 each global debug-file-directory component prepended."),
3959 show_debug_file_directory
,
3960 &setlist
, &showlist
);
3962 add_setshow_enum_cmd ("symbol-loading", no_class
,
3963 print_symbol_loading_enums
, &print_symbol_loading
,
3965 Set printing of symbol loading messages."), _("\
3966 Show printing of symbol loading messages."), _("\
3967 off == turn all messages off\n\
3968 brief == print messages for the executable,\n\
3969 and brief messages for shared libraries\n\
3970 full == print messages for the executable,\n\
3971 and messages for each shared library."),
3974 &setprintlist
, &showprintlist
);
3976 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
3977 &separate_debug_file_debug
, _("\
3978 Set printing of separate debug info file search debug."), _("\
3979 Show printing of separate debug info file search debug."), _("\
3980 When on, GDB prints the searched locations while looking for separate debug \
3981 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
3984 selftests::register_test
3985 ("filename_language", selftests::filename_language::test_filename_language
);
3986 selftests::register_test
3987 ("set_ext_lang_command",
3988 selftests::filename_language::test_set_ext_lang_command
);