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_free_objfile (objfile
);
1002 /* If ADDRS is NULL, put together a dummy address list.
1003 We now establish the convention that an addr of zero means
1004 no load address was specified. */
1007 local_addr
= alloc_section_addr_info (1);
1008 make_cleanup (xfree
, local_addr
);
1014 /* We will modify the main symbol table, make sure that all its users
1015 will be cleaned up if an error occurs during symbol reading. */
1016 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1018 /* Since no error yet, throw away the old symbol table. */
1020 if (symfile_objfile
!= NULL
)
1022 delete symfile_objfile
;
1023 gdb_assert (symfile_objfile
== NULL
);
1026 /* Currently we keep symbols from the add-symbol-file command.
1027 If the user wants to get rid of them, they should do "symbol-file"
1028 without arguments first. Not sure this is the best behavior
1031 (*objfile
->sf
->sym_new_init
) (objfile
);
1034 /* Convert addr into an offset rather than an absolute address.
1035 We find the lowest address of a loaded segment in the objfile,
1036 and assume that <addr> is where that got loaded.
1038 We no longer warn if the lowest section is not a text segment (as
1039 happens for the PA64 port. */
1040 if (addrs
->num_sections
> 0)
1041 addr_info_make_relative (addrs
, objfile
->obfd
);
1043 /* Initialize symbol reading routines for this objfile, allow complaints to
1044 appear for this new file, and record how verbose to be, then do the
1045 initial symbol reading for this file. */
1047 (*objfile
->sf
->sym_init
) (objfile
);
1048 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
1050 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
1052 read_symbols (objfile
, add_flags
);
1054 /* Discard cleanups as symbol reading was successful. */
1056 discard_cleanups (old_chain
);
1060 /* Same as syms_from_objfile_1, but also initializes the objfile
1061 entry-point info. */
1064 syms_from_objfile (struct objfile
*objfile
,
1065 struct section_addr_info
*addrs
,
1066 symfile_add_flags add_flags
)
1068 syms_from_objfile_1 (objfile
, addrs
, add_flags
);
1069 init_entry_point_info (objfile
);
1072 /* Perform required actions after either reading in the initial
1073 symbols for a new objfile, or mapping in the symbols from a reusable
1074 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1077 finish_new_objfile (struct objfile
*objfile
, symfile_add_flags add_flags
)
1079 /* If this is the main symbol file we have to clean up all users of the
1080 old main symbol file. Otherwise it is sufficient to fixup all the
1081 breakpoints that may have been redefined by this symbol file. */
1082 if (add_flags
& SYMFILE_MAINLINE
)
1084 /* OK, make it the "real" symbol file. */
1085 symfile_objfile
= objfile
;
1087 clear_symtab_users (add_flags
);
1089 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1091 breakpoint_re_set ();
1094 /* We're done reading the symbol file; finish off complaints. */
1095 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
1098 /* Process a symbol file, as either the main file or as a dynamically
1101 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1102 A new reference is acquired by this function.
1104 For NAME description see the objfile constructor.
1106 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1107 extra, such as dynamically loaded code, and what to do with breakpoins.
1109 ADDRS is as described for syms_from_objfile_1, above.
1110 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1112 PARENT is the original objfile if ABFD is a separate debug info file.
1113 Otherwise PARENT is NULL.
1115 Upon success, returns a pointer to the objfile that was added.
1116 Upon failure, jumps back to command level (never returns). */
1118 static struct objfile
*
1119 symbol_file_add_with_addrs (bfd
*abfd
, const char *name
,
1120 symfile_add_flags add_flags
,
1121 struct section_addr_info
*addrs
,
1122 objfile_flags flags
, struct objfile
*parent
)
1124 struct objfile
*objfile
;
1125 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1126 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1127 const int should_print
= (print_symbol_loading_p (from_tty
, mainline
, 1)
1128 && (readnow_symbol_files
1129 || (add_flags
& SYMFILE_NO_READ
) == 0));
1131 if (readnow_symbol_files
)
1133 flags
|= OBJF_READNOW
;
1134 add_flags
&= ~SYMFILE_NO_READ
;
1137 /* Give user a chance to burp if we'd be
1138 interactively wiping out any existing symbols. */
1140 if ((have_full_symbols () || have_partial_symbols ())
1143 && !query (_("Load new symbol table from \"%s\"? "), name
))
1144 error (_("Not confirmed."));
1147 flags
|= OBJF_MAINLINE
;
1148 objfile
= new struct objfile (abfd
, name
, flags
);
1151 add_separate_debug_objfile (objfile
, parent
);
1153 /* We either created a new mapped symbol table, mapped an existing
1154 symbol table file which has not had initial symbol reading
1155 performed, or need to read an unmapped symbol table. */
1158 if (deprecated_pre_add_symbol_hook
)
1159 deprecated_pre_add_symbol_hook (name
);
1162 printf_unfiltered (_("Reading symbols from %s..."), name
);
1164 gdb_flush (gdb_stdout
);
1167 syms_from_objfile (objfile
, addrs
, add_flags
);
1169 /* We now have at least a partial symbol table. Check to see if the
1170 user requested that all symbols be read on initial access via either
1171 the gdb startup command line or on a per symbol file basis. Expand
1172 all partial symbol tables for this objfile if so. */
1174 if ((flags
& OBJF_READNOW
))
1178 printf_unfiltered (_("expanding to full symbols..."));
1180 gdb_flush (gdb_stdout
);
1184 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1187 if (should_print
&& !objfile_has_symbols (objfile
))
1190 printf_unfiltered (_("(no debugging symbols found)..."));
1196 if (deprecated_post_add_symbol_hook
)
1197 deprecated_post_add_symbol_hook ();
1199 printf_unfiltered (_("done.\n"));
1202 /* We print some messages regardless of whether 'from_tty ||
1203 info_verbose' is true, so make sure they go out at the right
1205 gdb_flush (gdb_stdout
);
1207 if (objfile
->sf
== NULL
)
1209 observer_notify_new_objfile (objfile
);
1210 return objfile
; /* No symbols. */
1213 finish_new_objfile (objfile
, add_flags
);
1215 observer_notify_new_objfile (objfile
);
1217 bfd_cache_close_all ();
1221 /* Add BFD as a separate debug file for OBJFILE. For NAME description
1222 see the objfile constructor. */
1225 symbol_file_add_separate (bfd
*bfd
, const char *name
,
1226 symfile_add_flags symfile_flags
,
1227 struct objfile
*objfile
)
1229 struct section_addr_info
*sap
;
1230 struct cleanup
*my_cleanup
;
1232 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1233 because sections of BFD may not match sections of OBJFILE and because
1234 vma may have been modified by tools such as prelink. */
1235 sap
= build_section_addr_info_from_objfile (objfile
);
1236 my_cleanup
= make_cleanup_free_section_addr_info (sap
);
1238 symbol_file_add_with_addrs
1239 (bfd
, name
, symfile_flags
, sap
,
1240 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1244 do_cleanups (my_cleanup
);
1247 /* Process the symbol file ABFD, as either the main file or as a
1248 dynamically loaded file.
1249 See symbol_file_add_with_addrs's comments for details. */
1252 symbol_file_add_from_bfd (bfd
*abfd
, const char *name
,
1253 symfile_add_flags add_flags
,
1254 struct section_addr_info
*addrs
,
1255 objfile_flags flags
, struct objfile
*parent
)
1257 return symbol_file_add_with_addrs (abfd
, name
, add_flags
, addrs
, flags
,
1261 /* Process a symbol file, as either the main file or as a dynamically
1262 loaded file. See symbol_file_add_with_addrs's comments for details. */
1265 symbol_file_add (const char *name
, symfile_add_flags add_flags
,
1266 struct section_addr_info
*addrs
, objfile_flags flags
)
1268 gdb_bfd_ref_ptr
bfd (symfile_bfd_open (name
));
1270 return symbol_file_add_from_bfd (bfd
.get (), name
, add_flags
, addrs
,
1274 /* Call symbol_file_add() with default values and update whatever is
1275 affected by the loading of a new main().
1276 Used when the file is supplied in the gdb command line
1277 and by some targets with special loading requirements.
1278 The auxiliary function, symbol_file_add_main_1(), has the flags
1279 argument for the switches that can only be specified in the symbol_file
1283 symbol_file_add_main (const char *args
, symfile_add_flags add_flags
)
1285 symbol_file_add_main_1 (args
, add_flags
, 0);
1289 symbol_file_add_main_1 (const char *args
, symfile_add_flags add_flags
,
1290 objfile_flags flags
)
1292 add_flags
|= current_inferior ()->symfile_flags
| SYMFILE_MAINLINE
;
1294 symbol_file_add (args
, add_flags
, NULL
, flags
);
1296 /* Getting new symbols may change our opinion about
1297 what is frameless. */
1298 reinit_frame_cache ();
1300 if ((add_flags
& SYMFILE_NO_READ
) == 0)
1301 set_initial_language ();
1305 symbol_file_clear (int from_tty
)
1307 if ((have_full_symbols () || have_partial_symbols ())
1310 ? !query (_("Discard symbol table from `%s'? "),
1311 objfile_name (symfile_objfile
))
1312 : !query (_("Discard symbol table? "))))
1313 error (_("Not confirmed."));
1315 /* solib descriptors may have handles to objfiles. Wipe them before their
1316 objfiles get stale by free_all_objfiles. */
1317 no_shared_libraries (NULL
, from_tty
);
1319 free_all_objfiles ();
1321 gdb_assert (symfile_objfile
== NULL
);
1323 printf_unfiltered (_("No symbol file now.\n"));
1326 /* See symfile.h. */
1328 int separate_debug_file_debug
= 0;
1331 separate_debug_file_exists (const char *name
, unsigned long crc
,
1332 struct objfile
*parent_objfile
)
1334 unsigned long file_crc
;
1336 struct stat parent_stat
, abfd_stat
;
1337 int verified_as_different
;
1339 /* Find a separate debug info file as if symbols would be present in
1340 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1341 section can contain just the basename of PARENT_OBJFILE without any
1342 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1343 the separate debug infos with the same basename can exist. */
1345 if (filename_cmp (name
, objfile_name (parent_objfile
)) == 0)
1348 if (separate_debug_file_debug
)
1349 printf_unfiltered (_(" Trying %s\n"), name
);
1351 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (name
, gnutarget
, -1));
1356 /* Verify symlinks were not the cause of filename_cmp name difference above.
1358 Some operating systems, e.g. Windows, do not provide a meaningful
1359 st_ino; they always set it to zero. (Windows does provide a
1360 meaningful st_dev.) Files accessed from gdbservers that do not
1361 support the vFile:fstat packet will also have st_ino set to zero.
1362 Do not indicate a duplicate library in either case. While there
1363 is no guarantee that a system that provides meaningful inode
1364 numbers will never set st_ino to zero, this is merely an
1365 optimization, so we do not need to worry about false negatives. */
1367 if (bfd_stat (abfd
.get (), &abfd_stat
) == 0
1368 && abfd_stat
.st_ino
!= 0
1369 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1371 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1372 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1374 verified_as_different
= 1;
1377 verified_as_different
= 0;
1379 file_crc_p
= gdb_bfd_crc (abfd
.get (), &file_crc
);
1384 if (crc
!= file_crc
)
1386 unsigned long parent_crc
;
1388 /* If the files could not be verified as different with
1389 bfd_stat then we need to calculate the parent's CRC
1390 to verify whether the files are different or not. */
1392 if (!verified_as_different
)
1394 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1398 if (verified_as_different
|| parent_crc
!= file_crc
)
1399 warning (_("the debug information found in \"%s\""
1400 " does not match \"%s\" (CRC mismatch).\n"),
1401 name
, objfile_name (parent_objfile
));
1409 char *debug_file_directory
= NULL
;
1411 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1412 struct cmd_list_element
*c
, const char *value
)
1414 fprintf_filtered (file
,
1415 _("The directory where separate debug "
1416 "symbols are searched for is \"%s\".\n"),
1420 #if ! defined (DEBUG_SUBDIRECTORY)
1421 #define DEBUG_SUBDIRECTORY ".debug"
1424 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1425 where the original file resides (may not be the same as
1426 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1427 looking for. CANON_DIR is the "realpath" form of DIR.
1428 DIR must contain a trailing '/'.
1429 Returns the path of the file with separate debug info, of NULL. */
1432 find_separate_debug_file (const char *dir
,
1433 const char *canon_dir
,
1434 const char *debuglink
,
1435 unsigned long crc32
, struct objfile
*objfile
)
1440 VEC (char_ptr
) *debugdir_vec
;
1441 struct cleanup
*back_to
;
1444 if (separate_debug_file_debug
)
1445 printf_unfiltered (_("\nLooking for separate debug info (debug link) for "
1446 "%s\n"), objfile_name (objfile
));
1448 /* Set I to std::max (strlen (canon_dir), strlen (dir)). */
1450 if (canon_dir
!= NULL
&& strlen (canon_dir
) > i
)
1451 i
= strlen (canon_dir
);
1454 = (char *) xmalloc (strlen (debug_file_directory
) + 1
1456 + strlen (DEBUG_SUBDIRECTORY
)
1458 + strlen (debuglink
)
1461 /* First try in the same directory as the original file. */
1462 strcpy (debugfile
, dir
);
1463 strcat (debugfile
, debuglink
);
1465 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1468 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1469 strcpy (debugfile
, dir
);
1470 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1471 strcat (debugfile
, "/");
1472 strcat (debugfile
, debuglink
);
1474 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1477 /* Then try in the global debugfile directories.
1479 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1480 cause "/..." lookups. */
1482 debugdir_vec
= dirnames_to_char_ptr_vec (debug_file_directory
);
1483 back_to
= make_cleanup_free_char_ptr_vec (debugdir_vec
);
1485 for (ix
= 0; VEC_iterate (char_ptr
, debugdir_vec
, ix
, debugdir
); ++ix
)
1487 strcpy (debugfile
, debugdir
);
1488 strcat (debugfile
, "/");
1489 strcat (debugfile
, dir
);
1490 strcat (debugfile
, debuglink
);
1492 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1494 do_cleanups (back_to
);
1498 /* If the file is in the sysroot, try using its base path in the
1499 global debugfile directory. */
1500 if (canon_dir
!= NULL
1501 && filename_ncmp (canon_dir
, gdb_sysroot
,
1502 strlen (gdb_sysroot
)) == 0
1503 && IS_DIR_SEPARATOR (canon_dir
[strlen (gdb_sysroot
)]))
1505 strcpy (debugfile
, debugdir
);
1506 strcat (debugfile
, canon_dir
+ strlen (gdb_sysroot
));
1507 strcat (debugfile
, "/");
1508 strcat (debugfile
, debuglink
);
1510 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1512 do_cleanups (back_to
);
1518 do_cleanups (back_to
);
1523 /* Modify PATH to contain only "[/]directory/" part of PATH.
1524 If there were no directory separators in PATH, PATH will be empty
1525 string on return. */
1528 terminate_after_last_dir_separator (char *path
)
1532 /* Strip off the final filename part, leaving the directory name,
1533 followed by a slash. The directory can be relative or absolute. */
1534 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1535 if (IS_DIR_SEPARATOR (path
[i
]))
1538 /* If I is -1 then no directory is present there and DIR will be "". */
1542 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1543 Returns pathname, or NULL. */
1546 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1549 char *dir
, *canon_dir
;
1551 unsigned long crc32
;
1552 struct cleanup
*cleanups
;
1554 debuglink
= 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 cleanups
= make_cleanup (xfree
, debuglink
);
1564 dir
= xstrdup (objfile_name (objfile
));
1565 make_cleanup (xfree
, dir
);
1566 terminate_after_last_dir_separator (dir
);
1567 canon_dir
= lrealpath (dir
);
1569 debugfile
= find_separate_debug_file (dir
, canon_dir
, debuglink
,
1573 if (debugfile
== NULL
)
1575 /* For PR gdb/9538, try again with realpath (if different from the
1580 if (lstat (objfile_name (objfile
), &st_buf
) == 0
1581 && S_ISLNK (st_buf
.st_mode
))
1585 symlink_dir
= lrealpath (objfile_name (objfile
));
1586 if (symlink_dir
!= NULL
)
1588 make_cleanup (xfree
, symlink_dir
);
1589 terminate_after_last_dir_separator (symlink_dir
);
1590 if (strcmp (dir
, symlink_dir
) != 0)
1592 /* Different directory, so try using it. */
1593 debugfile
= find_separate_debug_file (symlink_dir
,
1603 do_cleanups (cleanups
);
1607 /* This is the symbol-file command. Read the file, analyze its
1608 symbols, and add a struct symtab to a symtab list. The syntax of
1609 the command is rather bizarre:
1611 1. The function buildargv implements various quoting conventions
1612 which are undocumented and have little or nothing in common with
1613 the way things are quoted (or not quoted) elsewhere in GDB.
1615 2. Options are used, which are not generally used in GDB (perhaps
1616 "set mapped on", "set readnow on" would be better)
1618 3. The order of options matters, which is contrary to GNU
1619 conventions (because it is confusing and inconvenient). */
1622 symbol_file_command (const char *args
, int from_tty
)
1628 symbol_file_clear (from_tty
);
1632 objfile_flags flags
= OBJF_USERLOADED
;
1633 symfile_add_flags add_flags
= 0;
1637 add_flags
|= SYMFILE_VERBOSE
;
1639 gdb_argv
built_argv (args
);
1640 for (char *arg
: built_argv
)
1642 if (strcmp (arg
, "-readnow") == 0)
1643 flags
|= OBJF_READNOW
;
1644 else if (*arg
== '-')
1645 error (_("unknown option `%s'"), arg
);
1648 symbol_file_add_main_1 (arg
, add_flags
, flags
);
1654 error (_("no symbol file name was specified"));
1658 /* Set the initial language.
1660 FIXME: A better solution would be to record the language in the
1661 psymtab when reading partial symbols, and then use it (if known) to
1662 set the language. This would be a win for formats that encode the
1663 language in an easily discoverable place, such as DWARF. For
1664 stabs, we can jump through hoops looking for specially named
1665 symbols or try to intuit the language from the specific type of
1666 stabs we find, but we can't do that until later when we read in
1670 set_initial_language (void)
1672 enum language lang
= main_language ();
1674 if (lang
== language_unknown
)
1676 char *name
= main_name ();
1677 struct symbol
*sym
= lookup_symbol (name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
1680 lang
= SYMBOL_LANGUAGE (sym
);
1683 if (lang
== language_unknown
)
1685 /* Make C the default language */
1689 set_language (lang
);
1690 expected_language
= current_language
; /* Don't warn the user. */
1693 /* Open the file specified by NAME and hand it off to BFD for
1694 preliminary analysis. Return a newly initialized bfd *, which
1695 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1696 absolute). In case of trouble, error() is called. */
1699 symfile_bfd_open (const char *name
)
1702 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1704 if (!is_target_filename (name
))
1706 char *absolute_name
;
1708 gdb::unique_xmalloc_ptr
<char> expanded_name (tilde_expand (name
));
1710 /* Look down path for it, allocate 2nd new malloc'd copy. */
1711 desc
= openp (getenv ("PATH"),
1712 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1713 expanded_name
.get (), O_RDONLY
| O_BINARY
, &absolute_name
);
1714 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1717 char *exename
= (char *) alloca (strlen (expanded_name
.get ()) + 5);
1719 strcat (strcpy (exename
, expanded_name
.get ()), ".exe");
1720 desc
= openp (getenv ("PATH"),
1721 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
1722 exename
, O_RDONLY
| O_BINARY
, &absolute_name
);
1726 perror_with_name (expanded_name
.get ());
1728 make_cleanup (xfree
, absolute_name
);
1729 name
= absolute_name
;
1732 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (name
, gnutarget
, desc
));
1733 if (sym_bfd
== NULL
)
1734 error (_("`%s': can't open to read symbols: %s."), name
,
1735 bfd_errmsg (bfd_get_error ()));
1737 if (!gdb_bfd_has_target_filename (sym_bfd
.get ()))
1738 bfd_set_cacheable (sym_bfd
.get (), 1);
1740 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
1741 error (_("`%s': can't read symbols: %s."), name
,
1742 bfd_errmsg (bfd_get_error ()));
1744 do_cleanups (back_to
);
1749 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1750 the section was not found. */
1753 get_section_index (struct objfile
*objfile
, const char *section_name
)
1755 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1763 /* Link SF into the global symtab_fns list.
1764 FLAVOUR is the file format that SF handles.
1765 Called on startup by the _initialize routine in each object file format
1766 reader, to register information about each format the reader is prepared
1770 add_symtab_fns (enum bfd_flavour flavour
, const struct sym_fns
*sf
)
1772 symtab_fns
.emplace_back (flavour
, sf
);
1775 /* Initialize OBJFILE to read symbols from its associated BFD. It
1776 either returns or calls error(). The result is an initialized
1777 struct sym_fns in the objfile structure, that contains cached
1778 information about the symbol file. */
1780 static const struct sym_fns
*
1781 find_sym_fns (bfd
*abfd
)
1783 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1785 if (our_flavour
== bfd_target_srec_flavour
1786 || our_flavour
== bfd_target_ihex_flavour
1787 || our_flavour
== bfd_target_tekhex_flavour
)
1788 return NULL
; /* No symbols. */
1790 for (const registered_sym_fns
&rsf
: symtab_fns
)
1791 if (our_flavour
== rsf
.sym_flavour
)
1794 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1795 bfd_get_target (abfd
));
1799 /* This function runs the load command of our current target. */
1802 load_command (char *arg
, int from_tty
)
1804 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1808 /* The user might be reloading because the binary has changed. Take
1809 this opportunity to check. */
1810 reopen_exec_file ();
1818 parg
= arg
= get_exec_file (1);
1820 /* Count how many \ " ' tab space there are in the name. */
1821 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1829 /* We need to quote this string so buildargv can pull it apart. */
1830 char *temp
= (char *) xmalloc (strlen (arg
) + count
+ 1 );
1834 make_cleanup (xfree
, temp
);
1837 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1839 strncpy (ptemp
, prev
, parg
- prev
);
1840 ptemp
+= parg
- prev
;
1844 strcpy (ptemp
, prev
);
1850 target_load (arg
, from_tty
);
1852 /* After re-loading the executable, we don't really know which
1853 overlays are mapped any more. */
1854 overlay_cache_invalid
= 1;
1856 do_cleanups (cleanup
);
1859 /* This version of "load" should be usable for any target. Currently
1860 it is just used for remote targets, not inftarg.c or core files,
1861 on the theory that only in that case is it useful.
1863 Avoiding xmodem and the like seems like a win (a) because we don't have
1864 to worry about finding it, and (b) On VMS, fork() is very slow and so
1865 we don't want to run a subprocess. On the other hand, I'm not sure how
1866 performance compares. */
1868 static int validate_download
= 0;
1870 /* Callback service function for generic_load (bfd_map_over_sections). */
1873 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1875 bfd_size_type
*sum
= (bfd_size_type
*) data
;
1877 *sum
+= bfd_get_section_size (asec
);
1880 /* Opaque data for load_section_callback. */
1881 struct load_section_data
{
1882 CORE_ADDR load_offset
;
1883 struct load_progress_data
*progress_data
;
1884 VEC(memory_write_request_s
) *requests
;
1887 /* Opaque data for load_progress. */
1888 struct load_progress_data
{
1889 /* Cumulative data. */
1890 unsigned long write_count
;
1891 unsigned long data_count
;
1892 bfd_size_type total_size
;
1895 /* Opaque data for load_progress for a single section. */
1896 struct load_progress_section_data
{
1897 struct load_progress_data
*cumulative
;
1899 /* Per-section data. */
1900 const char *section_name
;
1901 ULONGEST section_sent
;
1902 ULONGEST section_size
;
1907 /* Target write callback routine for progress reporting. */
1910 load_progress (ULONGEST bytes
, void *untyped_arg
)
1912 struct load_progress_section_data
*args
1913 = (struct load_progress_section_data
*) untyped_arg
;
1914 struct load_progress_data
*totals
;
1917 /* Writing padding data. No easy way to get at the cumulative
1918 stats, so just ignore this. */
1921 totals
= args
->cumulative
;
1923 if (bytes
== 0 && args
->section_sent
== 0)
1925 /* The write is just starting. Let the user know we've started
1927 current_uiout
->message ("Loading section %s, size %s lma %s\n",
1929 hex_string (args
->section_size
),
1930 paddress (target_gdbarch (), args
->lma
));
1934 if (validate_download
)
1936 /* Broken memories and broken monitors manifest themselves here
1937 when bring new computers to life. This doubles already slow
1939 /* NOTE: cagney/1999-10-18: A more efficient implementation
1940 might add a verify_memory() method to the target vector and
1941 then use that. remote.c could implement that method using
1942 the ``qCRC'' packet. */
1943 gdb::byte_vector
check (bytes
);
1945 if (target_read_memory (args
->lma
, check
.data (), bytes
) != 0)
1946 error (_("Download verify read failed at %s"),
1947 paddress (target_gdbarch (), args
->lma
));
1948 if (memcmp (args
->buffer
, check
.data (), bytes
) != 0)
1949 error (_("Download verify compare failed at %s"),
1950 paddress (target_gdbarch (), args
->lma
));
1952 totals
->data_count
+= bytes
;
1954 args
->buffer
+= bytes
;
1955 totals
->write_count
+= 1;
1956 args
->section_sent
+= bytes
;
1957 if (check_quit_flag ()
1958 || (deprecated_ui_load_progress_hook
!= NULL
1959 && deprecated_ui_load_progress_hook (args
->section_name
,
1960 args
->section_sent
)))
1961 error (_("Canceled the download"));
1963 if (deprecated_show_load_progress
!= NULL
)
1964 deprecated_show_load_progress (args
->section_name
,
1968 totals
->total_size
);
1971 /* Callback service function for generic_load (bfd_map_over_sections). */
1974 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1976 struct memory_write_request
*new_request
;
1977 struct load_section_data
*args
= (struct load_section_data
*) data
;
1978 struct load_progress_section_data
*section_data
;
1979 bfd_size_type size
= bfd_get_section_size (asec
);
1981 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1983 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1989 new_request
= VEC_safe_push (memory_write_request_s
,
1990 args
->requests
, NULL
);
1991 memset (new_request
, 0, sizeof (struct memory_write_request
));
1992 section_data
= XCNEW (struct load_progress_section_data
);
1993 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1994 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size
1996 new_request
->data
= (gdb_byte
*) xmalloc (size
);
1997 new_request
->baton
= section_data
;
1999 buffer
= new_request
->data
;
2001 section_data
->cumulative
= args
->progress_data
;
2002 section_data
->section_name
= sect_name
;
2003 section_data
->section_size
= size
;
2004 section_data
->lma
= new_request
->begin
;
2005 section_data
->buffer
= buffer
;
2007 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2010 /* Clean up an entire memory request vector, including load
2011 data and progress records. */
2014 clear_memory_write_data (void *arg
)
2016 VEC(memory_write_request_s
) **vec_p
= (VEC(memory_write_request_s
) **) arg
;
2017 VEC(memory_write_request_s
) *vec
= *vec_p
;
2019 struct memory_write_request
*mr
;
2021 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
2026 VEC_free (memory_write_request_s
, vec
);
2029 static void print_transfer_performance (struct ui_file
*stream
,
2030 unsigned long data_count
,
2031 unsigned long write_count
,
2032 std::chrono::steady_clock::duration d
);
2035 generic_load (const char *args
, int from_tty
)
2037 struct cleanup
*old_cleanups
;
2038 struct load_section_data cbdata
;
2039 struct load_progress_data total_progress
;
2040 struct ui_out
*uiout
= current_uiout
;
2044 memset (&cbdata
, 0, sizeof (cbdata
));
2045 memset (&total_progress
, 0, sizeof (total_progress
));
2046 cbdata
.progress_data
= &total_progress
;
2048 old_cleanups
= make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
2051 error_no_arg (_("file to load"));
2053 gdb_argv
argv (args
);
2055 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2057 if (argv
[1] != NULL
)
2061 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2063 /* If the last word was not a valid number then
2064 treat it as a file name with spaces in. */
2065 if (argv
[1] == endptr
)
2066 error (_("Invalid download offset:%s."), argv
[1]);
2068 if (argv
[2] != NULL
)
2069 error (_("Too many parameters."));
2072 /* Open the file for loading. */
2073 gdb_bfd_ref_ptr
loadfile_bfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
2074 if (loadfile_bfd
== NULL
)
2075 perror_with_name (filename
.get ());
2077 if (!bfd_check_format (loadfile_bfd
.get (), bfd_object
))
2079 error (_("\"%s\" is not an object file: %s"), filename
.get (),
2080 bfd_errmsg (bfd_get_error ()));
2083 bfd_map_over_sections (loadfile_bfd
.get (), add_section_size_callback
,
2084 (void *) &total_progress
.total_size
);
2086 bfd_map_over_sections (loadfile_bfd
.get (), load_section_callback
, &cbdata
);
2088 using namespace std::chrono
;
2090 steady_clock::time_point start_time
= steady_clock::now ();
2092 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2093 load_progress
) != 0)
2094 error (_("Load failed"));
2096 steady_clock::time_point end_time
= steady_clock::now ();
2098 entry
= bfd_get_start_address (loadfile_bfd
.get ());
2099 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2100 uiout
->text ("Start address ");
2101 uiout
->field_fmt ("address", "%s", paddress (target_gdbarch (), entry
));
2102 uiout
->text (", load size ");
2103 uiout
->field_fmt ("load-size", "%lu", total_progress
.data_count
);
2105 regcache_write_pc (get_current_regcache (), entry
);
2107 /* Reset breakpoints, now that we have changed the load image. For
2108 instance, breakpoints may have been set (or reset, by
2109 post_create_inferior) while connected to the target but before we
2110 loaded the program. In that case, the prologue analyzer could
2111 have read instructions from the target to find the right
2112 breakpoint locations. Loading has changed the contents of that
2115 breakpoint_re_set ();
2117 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2118 total_progress
.write_count
,
2119 end_time
- start_time
);
2121 do_cleanups (old_cleanups
);
2124 /* Report on STREAM the performance of a memory transfer operation,
2125 such as 'load'. DATA_COUNT is the number of bytes transferred.
2126 WRITE_COUNT is the number of separate write operations, or 0, if
2127 that information is not available. TIME is how long the operation
2131 print_transfer_performance (struct ui_file
*stream
,
2132 unsigned long data_count
,
2133 unsigned long write_count
,
2134 std::chrono::steady_clock::duration time
)
2136 using namespace std::chrono
;
2137 struct ui_out
*uiout
= current_uiout
;
2139 milliseconds ms
= duration_cast
<milliseconds
> (time
);
2141 uiout
->text ("Transfer rate: ");
2142 if (ms
.count () > 0)
2144 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / ms
.count ();
2146 if (uiout
->is_mi_like_p ())
2148 uiout
->field_fmt ("transfer-rate", "%lu", rate
* 8);
2149 uiout
->text (" bits/sec");
2151 else if (rate
< 1024)
2153 uiout
->field_fmt ("transfer-rate", "%lu", rate
);
2154 uiout
->text (" bytes/sec");
2158 uiout
->field_fmt ("transfer-rate", "%lu", rate
/ 1024);
2159 uiout
->text (" KB/sec");
2164 uiout
->field_fmt ("transferred-bits", "%lu", (data_count
* 8));
2165 uiout
->text (" bits in <1 sec");
2167 if (write_count
> 0)
2170 uiout
->field_fmt ("write-rate", "%lu", data_count
/ write_count
);
2171 uiout
->text (" bytes/write");
2173 uiout
->text (".\n");
2176 /* This function allows the addition of incrementally linked object files.
2177 It does not modify any state in the target, only in the debugger. */
2178 /* Note: ezannoni 2000-04-13 This function/command used to have a
2179 special case syntax for the rombug target (Rombug is the boot
2180 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2181 rombug case, the user doesn't need to supply a text address,
2182 instead a call to target_link() (in target.c) would supply the
2183 value to use. We are now discontinuing this type of ad hoc syntax. */
2186 add_symbol_file_command (const char *args
, int from_tty
)
2188 struct gdbarch
*gdbarch
= get_current_arch ();
2189 gdb::unique_xmalloc_ptr
<char> filename
;
2193 int expecting_sec_name
= 0;
2194 int expecting_sec_addr
= 0;
2195 struct objfile
*objf
;
2196 objfile_flags flags
= OBJF_USERLOADED
| OBJF_SHARED
;
2197 symfile_add_flags add_flags
= 0;
2200 add_flags
|= SYMFILE_VERBOSE
;
2208 struct section_addr_info
*section_addrs
;
2209 std::vector
<sect_opt
> sect_opts
;
2210 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2215 error (_("add-symbol-file takes a file name and an address"));
2217 gdb_argv
argv (args
);
2219 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2221 /* Process the argument. */
2224 /* The first argument is the file name. */
2225 filename
.reset (tilde_expand (arg
));
2227 else if (argcnt
== 1)
2229 /* The second argument is always the text address at which
2230 to load the program. */
2231 sect_opt sect
= { ".text", arg
};
2232 sect_opts
.push_back (sect
);
2236 /* It's an option (starting with '-') or it's an argument
2238 if (expecting_sec_name
)
2240 sect_opt sect
= { arg
, NULL
};
2241 sect_opts
.push_back (sect
);
2242 expecting_sec_name
= 0;
2244 else if (expecting_sec_addr
)
2246 sect_opts
.back ().value
= arg
;
2247 expecting_sec_addr
= 0;
2249 else if (strcmp (arg
, "-readnow") == 0)
2250 flags
|= OBJF_READNOW
;
2251 else if (strcmp (arg
, "-s") == 0)
2253 expecting_sec_name
= 1;
2254 expecting_sec_addr
= 1;
2257 error (_("USAGE: add-symbol-file <filename> <textaddress>"
2258 " [-readnow] [-s <secname> <addr>]*"));
2262 /* This command takes at least two arguments. The first one is a
2263 filename, and the second is the address where this file has been
2264 loaded. Abort now if this address hasn't been provided by the
2266 if (sect_opts
.empty ())
2267 error (_("The address where %s has been loaded is missing"),
2270 /* Print the prompt for the query below. And save the arguments into
2271 a sect_addr_info structure to be passed around to other
2272 functions. We have to split this up into separate print
2273 statements because hex_string returns a local static
2276 printf_unfiltered (_("add symbol table from file \"%s\" at\n"),
2278 section_addrs
= alloc_section_addr_info (sect_opts
.size ());
2279 make_cleanup (xfree
, section_addrs
);
2280 for (sect_opt
§
: sect_opts
)
2283 const char *val
= sect
.value
;
2284 const char *sec
= sect
.name
;
2286 addr
= parse_and_eval_address (val
);
2288 /* Here we store the section offsets in the order they were
2289 entered on the command line. */
2290 section_addrs
->other
[sec_num
].name
= (char *) sec
;
2291 section_addrs
->other
[sec_num
].addr
= addr
;
2292 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2293 paddress (gdbarch
, addr
));
2296 /* The object's sections are initialized when a
2297 call is made to build_objfile_section_table (objfile).
2298 This happens in reread_symbols.
2299 At this point, we don't know what file type this is,
2300 so we can't determine what section names are valid. */
2302 section_addrs
->num_sections
= sec_num
;
2304 if (from_tty
&& (!query ("%s", "")))
2305 error (_("Not confirmed."));
2307 objf
= symbol_file_add (filename
.get (), add_flags
, section_addrs
, flags
);
2309 add_target_sections_of_objfile (objf
);
2311 /* Getting new symbols may change our opinion about what is
2313 reinit_frame_cache ();
2314 do_cleanups (my_cleanups
);
2318 /* This function removes a symbol file that was added via add-symbol-file. */
2321 remove_symbol_file_command (const char *args
, int from_tty
)
2323 struct objfile
*objf
= NULL
;
2324 struct program_space
*pspace
= current_program_space
;
2329 error (_("remove-symbol-file: no symbol file provided"));
2331 gdb_argv
argv (args
);
2333 if (strcmp (argv
[0], "-a") == 0)
2335 /* Interpret the next argument as an address. */
2338 if (argv
[1] == NULL
)
2339 error (_("Missing address argument"));
2341 if (argv
[2] != NULL
)
2342 error (_("Junk after %s"), argv
[1]);
2344 addr
= parse_and_eval_address (argv
[1]);
2348 if ((objf
->flags
& OBJF_USERLOADED
) != 0
2349 && (objf
->flags
& OBJF_SHARED
) != 0
2350 && objf
->pspace
== pspace
&& is_addr_in_objfile (addr
, objf
))
2354 else if (argv
[0] != NULL
)
2356 /* Interpret the current argument as a file name. */
2358 if (argv
[1] != NULL
)
2359 error (_("Junk after %s"), argv
[0]);
2361 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (argv
[0]));
2365 if ((objf
->flags
& OBJF_USERLOADED
) != 0
2366 && (objf
->flags
& OBJF_SHARED
) != 0
2367 && objf
->pspace
== pspace
2368 && filename_cmp (filename
.get (), objfile_name (objf
)) == 0)
2374 error (_("No symbol file found"));
2377 && !query (_("Remove symbol table from file \"%s\"? "),
2378 objfile_name (objf
)))
2379 error (_("Not confirmed."));
2382 clear_symtab_users (0);
2385 /* Re-read symbols if a symbol-file has changed. */
2388 reread_symbols (void)
2390 struct objfile
*objfile
;
2392 struct stat new_statbuf
;
2394 std::vector
<struct objfile
*> new_objfiles
;
2396 /* With the addition of shared libraries, this should be modified,
2397 the load time should be saved in the partial symbol tables, since
2398 different tables may come from different source files. FIXME.
2399 This routine should then walk down each partial symbol table
2400 and see if the symbol table that it originates from has been changed. */
2402 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2404 if (objfile
->obfd
== NULL
)
2407 /* Separate debug objfiles are handled in the main objfile. */
2408 if (objfile
->separate_debug_objfile_backlink
)
2411 /* If this object is from an archive (what you usually create with
2412 `ar', often called a `static library' on most systems, though
2413 a `shared library' on AIX is also an archive), then you should
2414 stat on the archive name, not member name. */
2415 if (objfile
->obfd
->my_archive
)
2416 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2418 res
= stat (objfile_name (objfile
), &new_statbuf
);
2421 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2422 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2423 objfile_name (objfile
));
2426 new_modtime
= new_statbuf
.st_mtime
;
2427 if (new_modtime
!= objfile
->mtime
)
2429 struct cleanup
*old_cleanups
;
2430 struct section_offsets
*offsets
;
2432 char *original_name
;
2434 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2435 objfile_name (objfile
));
2437 /* There are various functions like symbol_file_add,
2438 symfile_bfd_open, syms_from_objfile, etc., which might
2439 appear to do what we want. But they have various other
2440 effects which we *don't* want. So we just do stuff
2441 ourselves. We don't worry about mapped files (for one thing,
2442 any mapped file will be out of date). */
2444 /* If we get an error, blow away this objfile (not sure if
2445 that is the correct response for things like shared
2447 old_cleanups
= make_cleanup_free_objfile (objfile
);
2448 /* We need to do this whenever any symbols go away. */
2449 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2451 if (exec_bfd
!= NULL
2452 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2453 bfd_get_filename (exec_bfd
)) == 0)
2455 /* Reload EXEC_BFD without asking anything. */
2457 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2460 /* Keep the calls order approx. the same as in free_objfile. */
2462 /* Free the separate debug objfiles. It will be
2463 automatically recreated by sym_read. */
2464 free_objfile_separate_debug (objfile
);
2466 /* Remove any references to this objfile in the global
2468 preserve_values (objfile
);
2470 /* Nuke all the state that we will re-read. Much of the following
2471 code which sets things to NULL really is necessary to tell
2472 other parts of GDB that there is nothing currently there.
2474 Try to keep the freeing order compatible with free_objfile. */
2476 if (objfile
->sf
!= NULL
)
2478 (*objfile
->sf
->sym_finish
) (objfile
);
2481 clear_objfile_data (objfile
);
2483 /* Clean up any state BFD has sitting around. */
2485 gdb_bfd_ref_ptr
obfd (objfile
->obfd
);
2486 char *obfd_filename
;
2488 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2489 /* Open the new BFD before freeing the old one, so that
2490 the filename remains live. */
2491 gdb_bfd_ref_ptr
temp (gdb_bfd_open (obfd_filename
, gnutarget
, -1));
2492 objfile
->obfd
= temp
.release ();
2493 if (objfile
->obfd
== NULL
)
2494 error (_("Can't open %s to read symbols."), obfd_filename
);
2497 original_name
= xstrdup (objfile
->original_name
);
2498 make_cleanup (xfree
, original_name
);
2500 /* bfd_openr sets cacheable to true, which is what we want. */
2501 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2502 error (_("Can't read symbols from %s: %s."), objfile_name (objfile
),
2503 bfd_errmsg (bfd_get_error ()));
2505 /* Save the offsets, we will nuke them with the rest of the
2507 num_offsets
= objfile
->num_sections
;
2508 offsets
= ((struct section_offsets
*)
2509 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2510 memcpy (offsets
, objfile
->section_offsets
,
2511 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2513 /* FIXME: Do we have to free a whole linked list, or is this
2515 objfile
->global_psymbols
.clear ();
2516 objfile
->static_psymbols
.clear ();
2518 /* Free the obstacks for non-reusable objfiles. */
2519 psymbol_bcache_free (objfile
->psymbol_cache
);
2520 objfile
->psymbol_cache
= psymbol_bcache_init ();
2522 /* NB: after this call to obstack_free, objfiles_changed
2523 will need to be called (see discussion below). */
2524 obstack_free (&objfile
->objfile_obstack
, 0);
2525 objfile
->sections
= NULL
;
2526 objfile
->compunit_symtabs
= NULL
;
2527 objfile
->psymtabs
= NULL
;
2528 objfile
->psymtabs_addrmap
= NULL
;
2529 objfile
->free_psymtabs
= NULL
;
2530 objfile
->template_symbols
= NULL
;
2532 /* obstack_init also initializes the obstack so it is
2533 empty. We could use obstack_specify_allocation but
2534 gdb_obstack.h specifies the alloc/dealloc functions. */
2535 obstack_init (&objfile
->objfile_obstack
);
2537 /* set_objfile_per_bfd potentially allocates the per-bfd
2538 data on the objfile's obstack (if sharing data across
2539 multiple users is not possible), so it's important to
2540 do it *after* the obstack has been initialized. */
2541 set_objfile_per_bfd (objfile
);
2543 objfile
->original_name
2544 = (char *) obstack_copy0 (&objfile
->objfile_obstack
, original_name
,
2545 strlen (original_name
));
2547 /* Reset the sym_fns pointer. The ELF reader can change it
2548 based on whether .gdb_index is present, and we need it to
2549 start over. PR symtab/15885 */
2550 objfile_set_sym_fns (objfile
, find_sym_fns (objfile
->obfd
));
2552 build_objfile_section_table (objfile
);
2553 terminate_minimal_symbol_table (objfile
);
2555 /* We use the same section offsets as from last time. I'm not
2556 sure whether that is always correct for shared libraries. */
2557 objfile
->section_offsets
= (struct section_offsets
*)
2558 obstack_alloc (&objfile
->objfile_obstack
,
2559 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2560 memcpy (objfile
->section_offsets
, offsets
,
2561 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2562 objfile
->num_sections
= num_offsets
;
2564 /* What the hell is sym_new_init for, anyway? The concept of
2565 distinguishing between the main file and additional files
2566 in this way seems rather dubious. */
2567 if (objfile
== symfile_objfile
)
2569 (*objfile
->sf
->sym_new_init
) (objfile
);
2572 (*objfile
->sf
->sym_init
) (objfile
);
2573 clear_complaints (&symfile_complaints
, 1, 1);
2575 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2577 /* We are about to read new symbols and potentially also
2578 DWARF information. Some targets may want to pass addresses
2579 read from DWARF DIE's through an adjustment function before
2580 saving them, like MIPS, which may call into
2581 "find_pc_section". When called, that function will make
2582 use of per-objfile program space data.
2584 Since we discarded our section information above, we have
2585 dangling pointers in the per-objfile program space data
2586 structure. Force GDB to update the section mapping
2587 information by letting it know the objfile has changed,
2588 making the dangling pointers point to correct data
2591 objfiles_changed ();
2593 read_symbols (objfile
, 0);
2595 if (!objfile_has_symbols (objfile
))
2598 printf_unfiltered (_("(no debugging symbols found)\n"));
2602 /* We're done reading the symbol file; finish off complaints. */
2603 clear_complaints (&symfile_complaints
, 0, 1);
2605 /* Getting new symbols may change our opinion about what is
2608 reinit_frame_cache ();
2610 /* Discard cleanups as symbol reading was successful. */
2611 discard_cleanups (old_cleanups
);
2613 /* If the mtime has changed between the time we set new_modtime
2614 and now, we *want* this to be out of date, so don't call stat
2616 objfile
->mtime
= new_modtime
;
2617 init_entry_point_info (objfile
);
2619 new_objfiles
.push_back (objfile
);
2623 if (!new_objfiles
.empty ())
2625 clear_symtab_users (0);
2627 /* clear_objfile_data for each objfile was called before freeing it and
2628 observer_notify_new_objfile (NULL) has been called by
2629 clear_symtab_users above. Notify the new files now. */
2630 for (auto iter
: new_objfiles
)
2631 observer_notify_new_objfile (iter
);
2633 /* At least one objfile has changed, so we can consider that
2634 the executable we're debugging has changed too. */
2635 observer_notify_executable_changed ();
2640 struct filename_language
2642 filename_language (const std::string
&ext_
, enum language lang_
)
2643 : ext (ext_
), lang (lang_
)
2650 static std::vector
<filename_language
> filename_language_table
;
2652 /* See symfile.h. */
2655 add_filename_language (const char *ext
, enum language lang
)
2657 filename_language_table
.emplace_back (ext
, lang
);
2660 static char *ext_args
;
2662 show_ext_args (struct ui_file
*file
, int from_tty
,
2663 struct cmd_list_element
*c
, const char *value
)
2665 fprintf_filtered (file
,
2666 _("Mapping between filename extension "
2667 "and source language is \"%s\".\n"),
2672 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2674 char *cp
= ext_args
;
2677 /* First arg is filename extension, starting with '.' */
2679 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2681 /* Find end of first arg. */
2682 while (*cp
&& !isspace (*cp
))
2686 error (_("'%s': two arguments required -- "
2687 "filename extension and language"),
2690 /* Null-terminate first arg. */
2693 /* Find beginning of second arg, which should be a source language. */
2694 cp
= skip_spaces (cp
);
2697 error (_("'%s': two arguments required -- "
2698 "filename extension and language"),
2701 /* Lookup the language from among those we know. */
2702 lang
= language_enum (cp
);
2704 auto it
= filename_language_table
.begin ();
2705 /* Now lookup the filename extension: do we already know it? */
2706 for (; it
!= filename_language_table
.end (); it
++)
2708 if (it
->ext
== ext_args
)
2712 if (it
== filename_language_table
.end ())
2714 /* New file extension. */
2715 add_filename_language (ext_args
, lang
);
2719 /* Redefining a previously known filename extension. */
2722 /* query ("Really make files of type %s '%s'?", */
2723 /* ext_args, language_str (lang)); */
2730 info_ext_lang_command (char *args
, int from_tty
)
2732 printf_filtered (_("Filename extensions and the languages they represent:"));
2733 printf_filtered ("\n\n");
2734 for (const filename_language
&entry
: filename_language_table
)
2735 printf_filtered ("\t%s\t- %s\n", entry
.ext
.c_str (),
2736 language_str (entry
.lang
));
2740 deduce_language_from_filename (const char *filename
)
2744 if (filename
!= NULL
)
2745 if ((cp
= strrchr (filename
, '.')) != NULL
)
2747 for (const filename_language
&entry
: filename_language_table
)
2748 if (entry
.ext
== cp
)
2752 return language_unknown
;
2755 /* Allocate and initialize a new symbol table.
2756 CUST is from the result of allocate_compunit_symtab. */
2759 allocate_symtab (struct compunit_symtab
*cust
, const char *filename
)
2761 struct objfile
*objfile
= cust
->objfile
;
2762 struct symtab
*symtab
2763 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symtab
);
2766 = (const char *) bcache (filename
, strlen (filename
) + 1,
2767 objfile
->per_bfd
->filename_cache
);
2768 symtab
->fullname
= NULL
;
2769 symtab
->language
= deduce_language_from_filename (filename
);
2771 /* This can be very verbose with lots of headers.
2772 Only print at higher debug levels. */
2773 if (symtab_create_debug
>= 2)
2775 /* Be a bit clever with debugging messages, and don't print objfile
2776 every time, only when it changes. */
2777 static char *last_objfile_name
= NULL
;
2779 if (last_objfile_name
== NULL
2780 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
2782 xfree (last_objfile_name
);
2783 last_objfile_name
= xstrdup (objfile_name (objfile
));
2784 fprintf_unfiltered (gdb_stdlog
,
2785 "Creating one or more symtabs for objfile %s ...\n",
2788 fprintf_unfiltered (gdb_stdlog
,
2789 "Created symtab %s for module %s.\n",
2790 host_address_to_string (symtab
), filename
);
2793 /* Add it to CUST's list of symtabs. */
2794 if (cust
->filetabs
== NULL
)
2796 cust
->filetabs
= symtab
;
2797 cust
->last_filetab
= symtab
;
2801 cust
->last_filetab
->next
= symtab
;
2802 cust
->last_filetab
= symtab
;
2805 /* Backlink to the containing compunit symtab. */
2806 symtab
->compunit_symtab
= cust
;
2811 /* Allocate and initialize a new compunit.
2812 NAME is the name of the main source file, if there is one, or some
2813 descriptive text if there are no source files. */
2815 struct compunit_symtab
*
2816 allocate_compunit_symtab (struct objfile
*objfile
, const char *name
)
2818 struct compunit_symtab
*cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2819 struct compunit_symtab
);
2820 const char *saved_name
;
2822 cu
->objfile
= objfile
;
2824 /* The name we record here is only for display/debugging purposes.
2825 Just save the basename to avoid path issues (too long for display,
2826 relative vs absolute, etc.). */
2827 saved_name
= lbasename (name
);
2829 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
, saved_name
,
2830 strlen (saved_name
));
2832 COMPUNIT_DEBUGFORMAT (cu
) = "unknown";
2834 if (symtab_create_debug
)
2836 fprintf_unfiltered (gdb_stdlog
,
2837 "Created compunit symtab %s for %s.\n",
2838 host_address_to_string (cu
),
2845 /* Hook CU to the objfile it comes from. */
2848 add_compunit_symtab_to_objfile (struct compunit_symtab
*cu
)
2850 cu
->next
= cu
->objfile
->compunit_symtabs
;
2851 cu
->objfile
->compunit_symtabs
= cu
;
2855 /* Reset all data structures in gdb which may contain references to
2856 symbol table data. */
2859 clear_symtab_users (symfile_add_flags add_flags
)
2861 /* Someday, we should do better than this, by only blowing away
2862 the things that really need to be blown. */
2864 /* Clear the "current" symtab first, because it is no longer valid.
2865 breakpoint_re_set may try to access the current symtab. */
2866 clear_current_source_symtab_and_line ();
2869 clear_last_displayed_sal ();
2870 clear_pc_function_cache ();
2871 observer_notify_new_objfile (NULL
);
2873 /* Clear globals which might have pointed into a removed objfile.
2874 FIXME: It's not clear which of these are supposed to persist
2875 between expressions and which ought to be reset each time. */
2876 expression_context_block
= NULL
;
2877 innermost_block
= NULL
;
2879 /* Varobj may refer to old symbols, perform a cleanup. */
2880 varobj_invalidate ();
2882 /* Now that the various caches have been cleared, we can re_set
2883 our breakpoints without risking it using stale data. */
2884 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2885 breakpoint_re_set ();
2889 clear_symtab_users_cleanup (void *ignore
)
2891 clear_symtab_users (0);
2895 The following code implements an abstraction for debugging overlay sections.
2897 The target model is as follows:
2898 1) The gnu linker will permit multiple sections to be mapped into the
2899 same VMA, each with its own unique LMA (or load address).
2900 2) It is assumed that some runtime mechanism exists for mapping the
2901 sections, one by one, from the load address into the VMA address.
2902 3) This code provides a mechanism for gdb to keep track of which
2903 sections should be considered to be mapped from the VMA to the LMA.
2904 This information is used for symbol lookup, and memory read/write.
2905 For instance, if a section has been mapped then its contents
2906 should be read from the VMA, otherwise from the LMA.
2908 Two levels of debugger support for overlays are available. One is
2909 "manual", in which the debugger relies on the user to tell it which
2910 overlays are currently mapped. This level of support is
2911 implemented entirely in the core debugger, and the information about
2912 whether a section is mapped is kept in the objfile->obj_section table.
2914 The second level of support is "automatic", and is only available if
2915 the target-specific code provides functionality to read the target's
2916 overlay mapping table, and translate its contents for the debugger
2917 (by updating the mapped state information in the obj_section tables).
2919 The interface is as follows:
2921 overlay map <name> -- tell gdb to consider this section mapped
2922 overlay unmap <name> -- tell gdb to consider this section unmapped
2923 overlay list -- list the sections that GDB thinks are mapped
2924 overlay read-target -- get the target's state of what's mapped
2925 overlay off/manual/auto -- set overlay debugging state
2926 Functional interface:
2927 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2928 section, return that section.
2929 find_pc_overlay(pc): find any overlay section that contains
2930 the pc, either in its VMA or its LMA
2931 section_is_mapped(sect): true if overlay is marked as mapped
2932 section_is_overlay(sect): true if section's VMA != LMA
2933 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2934 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2935 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2936 overlay_mapped_address(...): map an address from section's LMA to VMA
2937 overlay_unmapped_address(...): map an address from section's VMA to LMA
2938 symbol_overlayed_address(...): Return a "current" address for symbol:
2939 either in VMA or LMA depending on whether
2940 the symbol's section is currently mapped. */
2942 /* Overlay debugging state: */
2944 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2945 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2947 /* Function: section_is_overlay (SECTION)
2948 Returns true if SECTION has VMA not equal to LMA, ie.
2949 SECTION is loaded at an address different from where it will "run". */
2952 section_is_overlay (struct obj_section
*section
)
2954 if (overlay_debugging
&& section
)
2956 bfd
*abfd
= section
->objfile
->obfd
;
2957 asection
*bfd_section
= section
->the_bfd_section
;
2959 if (bfd_section_lma (abfd
, bfd_section
) != 0
2960 && bfd_section_lma (abfd
, bfd_section
)
2961 != bfd_section_vma (abfd
, bfd_section
))
2968 /* Function: overlay_invalidate_all (void)
2969 Invalidate the mapped state of all overlay sections (mark it as stale). */
2972 overlay_invalidate_all (void)
2974 struct objfile
*objfile
;
2975 struct obj_section
*sect
;
2977 ALL_OBJSECTIONS (objfile
, sect
)
2978 if (section_is_overlay (sect
))
2979 sect
->ovly_mapped
= -1;
2982 /* Function: section_is_mapped (SECTION)
2983 Returns true if section is an overlay, and is currently mapped.
2985 Access to the ovly_mapped flag is restricted to this function, so
2986 that we can do automatic update. If the global flag
2987 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2988 overlay_invalidate_all. If the mapped state of the particular
2989 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2992 section_is_mapped (struct obj_section
*osect
)
2994 struct gdbarch
*gdbarch
;
2996 if (osect
== 0 || !section_is_overlay (osect
))
2999 switch (overlay_debugging
)
3003 return 0; /* overlay debugging off */
3004 case ovly_auto
: /* overlay debugging automatic */
3005 /* Unles there is a gdbarch_overlay_update function,
3006 there's really nothing useful to do here (can't really go auto). */
3007 gdbarch
= get_objfile_arch (osect
->objfile
);
3008 if (gdbarch_overlay_update_p (gdbarch
))
3010 if (overlay_cache_invalid
)
3012 overlay_invalidate_all ();
3013 overlay_cache_invalid
= 0;
3015 if (osect
->ovly_mapped
== -1)
3016 gdbarch_overlay_update (gdbarch
, osect
);
3018 /* fall thru to manual case */
3019 case ovly_on
: /* overlay debugging manual */
3020 return osect
->ovly_mapped
== 1;
3024 /* Function: pc_in_unmapped_range
3025 If PC falls into the lma range of SECTION, return true, else false. */
3028 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3030 if (section_is_overlay (section
))
3032 bfd
*abfd
= section
->objfile
->obfd
;
3033 asection
*bfd_section
= section
->the_bfd_section
;
3035 /* We assume the LMA is relocated by the same offset as the VMA. */
3036 bfd_vma size
= bfd_get_section_size (bfd_section
);
3037 CORE_ADDR offset
= obj_section_offset (section
);
3039 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3040 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3047 /* Function: pc_in_mapped_range
3048 If PC falls into the vma range of SECTION, return true, else false. */
3051 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3053 if (section_is_overlay (section
))
3055 if (obj_section_addr (section
) <= pc
3056 && pc
< obj_section_endaddr (section
))
3063 /* Return true if the mapped ranges of sections A and B overlap, false
3067 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3069 CORE_ADDR a_start
= obj_section_addr (a
);
3070 CORE_ADDR a_end
= obj_section_endaddr (a
);
3071 CORE_ADDR b_start
= obj_section_addr (b
);
3072 CORE_ADDR b_end
= obj_section_endaddr (b
);
3074 return (a_start
< b_end
&& b_start
< a_end
);
3077 /* Function: overlay_unmapped_address (PC, SECTION)
3078 Returns the address corresponding to PC in the unmapped (load) range.
3079 May be the same as PC. */
3082 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3084 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3086 bfd
*abfd
= section
->objfile
->obfd
;
3087 asection
*bfd_section
= section
->the_bfd_section
;
3089 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3090 - bfd_section_vma (abfd
, bfd_section
);
3096 /* Function: overlay_mapped_address (PC, SECTION)
3097 Returns the address corresponding to PC in the mapped (runtime) range.
3098 May be the same as PC. */
3101 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3103 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3105 bfd
*abfd
= section
->objfile
->obfd
;
3106 asection
*bfd_section
= section
->the_bfd_section
;
3108 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3109 - bfd_section_lma (abfd
, bfd_section
);
3115 /* Function: symbol_overlayed_address
3116 Return one of two addresses (relative to the VMA or to the LMA),
3117 depending on whether the section is mapped or not. */
3120 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3122 if (overlay_debugging
)
3124 /* If the symbol has no section, just return its regular address. */
3127 /* If the symbol's section is not an overlay, just return its
3129 if (!section_is_overlay (section
))
3131 /* If the symbol's section is mapped, just return its address. */
3132 if (section_is_mapped (section
))
3135 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3136 * then return its LOADED address rather than its vma address!!
3138 return overlay_unmapped_address (address
, section
);
3143 /* Function: find_pc_overlay (PC)
3144 Return the best-match overlay section for PC:
3145 If PC matches a mapped overlay section's VMA, return that section.
3146 Else if PC matches an unmapped section's VMA, return that section.
3147 Else if PC matches an unmapped section's LMA, return that section. */
3149 struct obj_section
*
3150 find_pc_overlay (CORE_ADDR pc
)
3152 struct objfile
*objfile
;
3153 struct obj_section
*osect
, *best_match
= NULL
;
3155 if (overlay_debugging
)
3157 ALL_OBJSECTIONS (objfile
, osect
)
3158 if (section_is_overlay (osect
))
3160 if (pc_in_mapped_range (pc
, osect
))
3162 if (section_is_mapped (osect
))
3167 else if (pc_in_unmapped_range (pc
, osect
))
3174 /* Function: find_pc_mapped_section (PC)
3175 If PC falls into the VMA address range of an overlay section that is
3176 currently marked as MAPPED, return that section. Else return NULL. */
3178 struct obj_section
*
3179 find_pc_mapped_section (CORE_ADDR pc
)
3181 struct objfile
*objfile
;
3182 struct obj_section
*osect
;
3184 if (overlay_debugging
)
3186 ALL_OBJSECTIONS (objfile
, osect
)
3187 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3194 /* Function: list_overlays_command
3195 Print a list of mapped sections and their PC ranges. */
3198 list_overlays_command (const char *args
, int from_tty
)
3201 struct objfile
*objfile
;
3202 struct obj_section
*osect
;
3204 if (overlay_debugging
)
3206 ALL_OBJSECTIONS (objfile
, osect
)
3207 if (section_is_mapped (osect
))
3209 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3214 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3215 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3216 size
= bfd_get_section_size (osect
->the_bfd_section
);
3217 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3219 printf_filtered ("Section %s, loaded at ", name
);
3220 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3221 puts_filtered (" - ");
3222 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3223 printf_filtered (", mapped at ");
3224 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3225 puts_filtered (" - ");
3226 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3227 puts_filtered ("\n");
3233 printf_filtered (_("No sections are mapped.\n"));
3236 /* Function: map_overlay_command
3237 Mark the named section as mapped (ie. residing at its VMA address). */
3240 map_overlay_command (const char *args
, int from_tty
)
3242 struct objfile
*objfile
, *objfile2
;
3243 struct obj_section
*sec
, *sec2
;
3245 if (!overlay_debugging
)
3246 error (_("Overlay debugging not enabled. Use "
3247 "either the 'overlay auto' or\n"
3248 "the 'overlay manual' command."));
3250 if (args
== 0 || *args
== 0)
3251 error (_("Argument required: name of an overlay section"));
3253 /* First, find a section matching the user supplied argument. */
3254 ALL_OBJSECTIONS (objfile
, sec
)
3255 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3257 /* Now, check to see if the section is an overlay. */
3258 if (!section_is_overlay (sec
))
3259 continue; /* not an overlay section */
3261 /* Mark the overlay as "mapped". */
3262 sec
->ovly_mapped
= 1;
3264 /* Next, make a pass and unmap any sections that are
3265 overlapped by this new section: */
3266 ALL_OBJSECTIONS (objfile2
, sec2
)
3267 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3270 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3271 bfd_section_name (objfile
->obfd
,
3272 sec2
->the_bfd_section
));
3273 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3277 error (_("No overlay section called %s"), args
);
3280 /* Function: unmap_overlay_command
3281 Mark the overlay section as unmapped
3282 (ie. resident in its LMA address range, rather than the VMA range). */
3285 unmap_overlay_command (const char *args
, int from_tty
)
3287 struct objfile
*objfile
;
3288 struct obj_section
*sec
= NULL
;
3290 if (!overlay_debugging
)
3291 error (_("Overlay debugging not enabled. "
3292 "Use either the 'overlay auto' or\n"
3293 "the 'overlay manual' command."));
3295 if (args
== 0 || *args
== 0)
3296 error (_("Argument required: name of an overlay section"));
3298 /* First, find a section matching the user supplied argument. */
3299 ALL_OBJSECTIONS (objfile
, sec
)
3300 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3302 if (!sec
->ovly_mapped
)
3303 error (_("Section %s is not mapped"), args
);
3304 sec
->ovly_mapped
= 0;
3307 error (_("No overlay section called %s"), args
);
3310 /* Function: overlay_auto_command
3311 A utility command to turn on overlay debugging.
3312 Possibly this should be done via a set/show command. */
3315 overlay_auto_command (const char *args
, int from_tty
)
3317 overlay_debugging
= ovly_auto
;
3318 enable_overlay_breakpoints ();
3320 printf_unfiltered (_("Automatic overlay debugging enabled."));
3323 /* Function: overlay_manual_command
3324 A utility command to turn on overlay debugging.
3325 Possibly this should be done via a set/show command. */
3328 overlay_manual_command (const char *args
, int from_tty
)
3330 overlay_debugging
= ovly_on
;
3331 disable_overlay_breakpoints ();
3333 printf_unfiltered (_("Overlay debugging enabled."));
3336 /* Function: overlay_off_command
3337 A utility command to turn on overlay debugging.
3338 Possibly this should be done via a set/show command. */
3341 overlay_off_command (const char *args
, int from_tty
)
3343 overlay_debugging
= ovly_off
;
3344 disable_overlay_breakpoints ();
3346 printf_unfiltered (_("Overlay debugging disabled."));
3350 overlay_load_command (const char *args
, int from_tty
)
3352 struct gdbarch
*gdbarch
= get_current_arch ();
3354 if (gdbarch_overlay_update_p (gdbarch
))
3355 gdbarch_overlay_update (gdbarch
, NULL
);
3357 error (_("This target does not know how to read its overlay state."));
3360 /* Function: overlay_command
3361 A place-holder for a mis-typed command. */
3363 /* Command list chain containing all defined "overlay" subcommands. */
3364 static struct cmd_list_element
*overlaylist
;
3367 overlay_command (const char *args
, int from_tty
)
3370 ("\"overlay\" must be followed by the name of an overlay command.\n");
3371 help_list (overlaylist
, "overlay ", all_commands
, gdb_stdout
);
3374 /* Target Overlays for the "Simplest" overlay manager:
3376 This is GDB's default target overlay layer. It works with the
3377 minimal overlay manager supplied as an example by Cygnus. The
3378 entry point is via a function pointer "gdbarch_overlay_update",
3379 so targets that use a different runtime overlay manager can
3380 substitute their own overlay_update function and take over the
3383 The overlay_update function pokes around in the target's data structures
3384 to see what overlays are mapped, and updates GDB's overlay mapping with
3387 In this simple implementation, the target data structures are as follows:
3388 unsigned _novlys; /# number of overlay sections #/
3389 unsigned _ovly_table[_novlys][4] = {
3390 {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
3391 {..., ..., ..., ...},
3393 unsigned _novly_regions; /# number of overlay regions #/
3394 unsigned _ovly_region_table[_novly_regions][3] = {
3395 {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3398 These functions will attempt to update GDB's mappedness state in the
3399 symbol section table, based on the target's mappedness state.
3401 To do this, we keep a cached copy of the target's _ovly_table, and
3402 attempt to detect when the cached copy is invalidated. The main
3403 entry point is "simple_overlay_update(SECT), which looks up SECT in
3404 the cached table and re-reads only the entry for that section from
3405 the target (whenever possible). */
3407 /* Cached, dynamically allocated copies of the target data structures: */
3408 static unsigned (*cache_ovly_table
)[4] = 0;
3409 static unsigned cache_novlys
= 0;
3410 static CORE_ADDR cache_ovly_table_base
= 0;
3413 VMA
, OSIZE
, LMA
, MAPPED
3416 /* Throw away the cached copy of _ovly_table. */
3419 simple_free_overlay_table (void)
3421 if (cache_ovly_table
)
3422 xfree (cache_ovly_table
);
3424 cache_ovly_table
= NULL
;
3425 cache_ovly_table_base
= 0;
3428 /* Read an array of ints of size SIZE from the target into a local buffer.
3429 Convert to host order. int LEN is number of ints. */
3432 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3433 int len
, int size
, enum bfd_endian byte_order
)
3435 /* FIXME (alloca): Not safe if array is very large. */
3436 gdb_byte
*buf
= (gdb_byte
*) alloca (len
* size
);
3439 read_memory (memaddr
, buf
, len
* size
);
3440 for (i
= 0; i
< len
; i
++)
3441 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3444 /* Find and grab a copy of the target _ovly_table
3445 (and _novlys, which is needed for the table's size). */
3448 simple_read_overlay_table (void)
3450 struct bound_minimal_symbol novlys_msym
;
3451 struct bound_minimal_symbol ovly_table_msym
;
3452 struct gdbarch
*gdbarch
;
3454 enum bfd_endian byte_order
;
3456 simple_free_overlay_table ();
3457 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3458 if (! novlys_msym
.minsym
)
3460 error (_("Error reading inferior's overlay table: "
3461 "couldn't find `_novlys' variable\n"
3462 "in inferior. Use `overlay manual' mode."));
3466 ovly_table_msym
= lookup_bound_minimal_symbol ("_ovly_table");
3467 if (! ovly_table_msym
.minsym
)
3469 error (_("Error reading inferior's overlay table: couldn't find "
3470 "`_ovly_table' array\n"
3471 "in inferior. Use `overlay manual' mode."));
3475 gdbarch
= get_objfile_arch (ovly_table_msym
.objfile
);
3476 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3477 byte_order
= gdbarch_byte_order (gdbarch
);
3479 cache_novlys
= read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym
),
3482 = (unsigned int (*)[4]) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3483 cache_ovly_table_base
= BMSYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3484 read_target_long_array (cache_ovly_table_base
,
3485 (unsigned int *) cache_ovly_table
,
3486 cache_novlys
* 4, word_size
, byte_order
);
3488 return 1; /* SUCCESS */
3491 /* Function: simple_overlay_update_1
3492 A helper function for simple_overlay_update. Assuming a cached copy
3493 of _ovly_table exists, look through it to find an entry whose vma,
3494 lma and size match those of OSECT. Re-read the entry and make sure
3495 it still matches OSECT (else the table may no longer be valid).
3496 Set OSECT's mapped state to match the entry. Return: 1 for
3497 success, 0 for failure. */
3500 simple_overlay_update_1 (struct obj_section
*osect
)
3503 bfd
*obfd
= osect
->objfile
->obfd
;
3504 asection
*bsect
= osect
->the_bfd_section
;
3505 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3506 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3507 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3509 for (i
= 0; i
< cache_novlys
; i
++)
3510 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3511 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3513 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3514 (unsigned int *) cache_ovly_table
[i
],
3515 4, word_size
, byte_order
);
3516 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3517 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3519 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3522 else /* Warning! Warning! Target's ovly table has changed! */
3528 /* Function: simple_overlay_update
3529 If OSECT is NULL, then update all sections' mapped state
3530 (after re-reading the entire target _ovly_table).
3531 If OSECT is non-NULL, then try to find a matching entry in the
3532 cached ovly_table and update only OSECT's mapped state.
3533 If a cached entry can't be found or the cache isn't valid, then
3534 re-read the entire cache, and go ahead and update all sections. */
3537 simple_overlay_update (struct obj_section
*osect
)
3539 struct objfile
*objfile
;
3541 /* Were we given an osect to look up? NULL means do all of them. */
3543 /* Have we got a cached copy of the target's overlay table? */
3544 if (cache_ovly_table
!= NULL
)
3546 /* Does its cached location match what's currently in the
3548 struct bound_minimal_symbol minsym
3549 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3551 if (minsym
.minsym
== NULL
)
3552 error (_("Error reading inferior's overlay table: couldn't "
3553 "find `_ovly_table' array\n"
3554 "in inferior. Use `overlay manual' mode."));
3556 if (cache_ovly_table_base
== BMSYMBOL_VALUE_ADDRESS (minsym
))
3557 /* Then go ahead and try to look up this single section in
3559 if (simple_overlay_update_1 (osect
))
3560 /* Found it! We're done. */
3564 /* Cached table no good: need to read the entire table anew.
3565 Or else we want all the sections, in which case it's actually
3566 more efficient to read the whole table in one block anyway. */
3568 if (! simple_read_overlay_table ())
3571 /* Now may as well update all sections, even if only one was requested. */
3572 ALL_OBJSECTIONS (objfile
, osect
)
3573 if (section_is_overlay (osect
))
3576 bfd
*obfd
= osect
->objfile
->obfd
;
3577 asection
*bsect
= osect
->the_bfd_section
;
3579 for (i
= 0; i
< cache_novlys
; i
++)
3580 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3581 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
))
3582 { /* obj_section matches i'th entry in ovly_table. */
3583 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3584 break; /* finished with inner for loop: break out. */
3589 /* Set the output sections and output offsets for section SECTP in
3590 ABFD. The relocation code in BFD will read these offsets, so we
3591 need to be sure they're initialized. We map each section to itself,
3592 with no offset; this means that SECTP->vma will be honored. */
3595 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3597 sectp
->output_section
= sectp
;
3598 sectp
->output_offset
= 0;
3601 /* Default implementation for sym_relocate. */
3604 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3607 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3609 bfd
*abfd
= sectp
->owner
;
3611 /* We're only interested in sections with relocation
3613 if ((sectp
->flags
& SEC_RELOC
) == 0)
3616 /* We will handle section offsets properly elsewhere, so relocate as if
3617 all sections begin at 0. */
3618 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3620 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3623 /* Relocate the contents of a debug section SECTP in ABFD. The
3624 contents are stored in BUF if it is non-NULL, or returned in a
3625 malloc'd buffer otherwise.
3627 For some platforms and debug info formats, shared libraries contain
3628 relocations against the debug sections (particularly for DWARF-2;
3629 one affected platform is PowerPC GNU/Linux, although it depends on
3630 the version of the linker in use). Also, ELF object files naturally
3631 have unresolved relocations for their debug sections. We need to apply
3632 the relocations in order to get the locations of symbols correct.
3633 Another example that may require relocation processing, is the
3634 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3638 symfile_relocate_debug_section (struct objfile
*objfile
,
3639 asection
*sectp
, bfd_byte
*buf
)
3641 gdb_assert (objfile
->sf
->sym_relocate
);
3643 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3646 struct symfile_segment_data
*
3647 get_symfile_segment_data (bfd
*abfd
)
3649 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3654 return sf
->sym_segments (abfd
);
3658 free_symfile_segment_data (struct symfile_segment_data
*data
)
3660 xfree (data
->segment_bases
);
3661 xfree (data
->segment_sizes
);
3662 xfree (data
->segment_info
);
3667 - DATA, containing segment addresses from the object file ABFD, and
3668 the mapping from ABFD's sections onto the segments that own them,
3670 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3671 segment addresses reported by the target,
3672 store the appropriate offsets for each section in OFFSETS.
3674 If there are fewer entries in SEGMENT_BASES than there are segments
3675 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3677 If there are more entries, then ignore the extra. The target may
3678 not be able to distinguish between an empty data segment and a
3679 missing data segment; a missing text segment is less plausible. */
3682 symfile_map_offsets_to_segments (bfd
*abfd
,
3683 const struct symfile_segment_data
*data
,
3684 struct section_offsets
*offsets
,
3685 int num_segment_bases
,
3686 const CORE_ADDR
*segment_bases
)
3691 /* It doesn't make sense to call this function unless you have some
3692 segment base addresses. */
3693 gdb_assert (num_segment_bases
> 0);
3695 /* If we do not have segment mappings for the object file, we
3696 can not relocate it by segments. */
3697 gdb_assert (data
!= NULL
);
3698 gdb_assert (data
->num_segments
> 0);
3700 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3702 int which
= data
->segment_info
[i
];
3704 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3706 /* Don't bother computing offsets for sections that aren't
3707 loaded as part of any segment. */
3711 /* Use the last SEGMENT_BASES entry as the address of any extra
3712 segments mentioned in DATA->segment_info. */
3713 if (which
> num_segment_bases
)
3714 which
= num_segment_bases
;
3716 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3717 - data
->segment_bases
[which
- 1]);
3724 symfile_find_segment_sections (struct objfile
*objfile
)
3726 bfd
*abfd
= objfile
->obfd
;
3729 struct symfile_segment_data
*data
;
3731 data
= get_symfile_segment_data (objfile
->obfd
);
3735 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3737 free_symfile_segment_data (data
);
3741 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3743 int which
= data
->segment_info
[i
];
3747 if (objfile
->sect_index_text
== -1)
3748 objfile
->sect_index_text
= sect
->index
;
3750 if (objfile
->sect_index_rodata
== -1)
3751 objfile
->sect_index_rodata
= sect
->index
;
3753 else if (which
== 2)
3755 if (objfile
->sect_index_data
== -1)
3756 objfile
->sect_index_data
= sect
->index
;
3758 if (objfile
->sect_index_bss
== -1)
3759 objfile
->sect_index_bss
= sect
->index
;
3763 free_symfile_segment_data (data
);
3766 /* Listen for free_objfile events. */
3769 symfile_free_objfile (struct objfile
*objfile
)
3771 /* Remove the target sections owned by this objfile. */
3772 if (objfile
!= NULL
)
3773 remove_target_sections ((void *) objfile
);
3776 /* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
3777 Expand all symtabs that match the specified criteria.
3778 See quick_symbol_functions.expand_symtabs_matching for details. */
3781 expand_symtabs_matching
3782 (gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3783 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3784 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
3785 enum search_domain kind
)
3787 struct objfile
*objfile
;
3789 ALL_OBJFILES (objfile
)
3792 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, file_matcher
,
3794 expansion_notify
, kind
);
3798 /* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
3799 Map function FUN over every file.
3800 See quick_symbol_functions.map_symbol_filenames for details. */
3803 map_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
3806 struct objfile
*objfile
;
3808 ALL_OBJFILES (objfile
)
3811 objfile
->sf
->qf
->map_symbol_filenames (objfile
, fun
, data
,
3818 namespace selftests
{
3819 namespace filename_language
{
3821 static void test_filename_language ()
3823 /* This test messes up the filename_language_table global. */
3824 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3826 /* Test deducing an unknown extension. */
3827 language lang
= deduce_language_from_filename ("myfile.blah");
3828 SELF_CHECK (lang
== language_unknown
);
3830 /* Test deducing a known extension. */
3831 lang
= deduce_language_from_filename ("myfile.c");
3832 SELF_CHECK (lang
== language_c
);
3834 /* Test adding a new extension using the internal API. */
3835 add_filename_language (".blah", language_pascal
);
3836 lang
= deduce_language_from_filename ("myfile.blah");
3837 SELF_CHECK (lang
== language_pascal
);
3841 test_set_ext_lang_command ()
3843 /* This test messes up the filename_language_table global. */
3844 scoped_restore restore_flt
= make_scoped_restore (&filename_language_table
);
3846 /* Confirm that the .hello extension is not known. */
3847 language lang
= deduce_language_from_filename ("cake.hello");
3848 SELF_CHECK (lang
== language_unknown
);
3850 /* Test adding a new extension using the CLI command. */
3851 gdb::unique_xmalloc_ptr
<char> args_holder (xstrdup (".hello rust"));
3852 ext_args
= args_holder
.get ();
3853 set_ext_lang_command (NULL
, 1, NULL
);
3855 lang
= deduce_language_from_filename ("cake.hello");
3856 SELF_CHECK (lang
== language_rust
);
3858 /* Test overriding an existing extension using the CLI command. */
3859 int size_before
= filename_language_table
.size ();
3860 args_holder
.reset (xstrdup (".hello pascal"));
3861 ext_args
= args_holder
.get ();
3862 set_ext_lang_command (NULL
, 1, NULL
);
3863 int size_after
= filename_language_table
.size ();
3865 lang
= deduce_language_from_filename ("cake.hello");
3866 SELF_CHECK (lang
== language_pascal
);
3867 SELF_CHECK (size_before
== size_after
);
3870 } /* namespace filename_language */
3871 } /* namespace selftests */
3873 #endif /* GDB_SELF_TEST */
3876 _initialize_symfile (void)
3878 struct cmd_list_element
*c
;
3880 observer_attach_free_objfile (symfile_free_objfile
);
3882 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3883 Load symbol table from executable file FILE.\n\
3884 The `file' command can also load symbol tables, as well as setting the file\n\
3885 to execute."), &cmdlist
);
3886 set_cmd_completer (c
, filename_completer
);
3888 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3889 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3890 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR>\
3891 ...]\nADDR is the starting address of the file's text.\n\
3892 The optional arguments are section-name section-address pairs and\n\
3893 should be specified if the data and bss segments are not contiguous\n\
3894 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3896 set_cmd_completer (c
, filename_completer
);
3898 c
= add_cmd ("remove-symbol-file", class_files
,
3899 remove_symbol_file_command
, _("\
3900 Remove a symbol file added via the add-symbol-file command.\n\
3901 Usage: remove-symbol-file FILENAME\n\
3902 remove-symbol-file -a ADDRESS\n\
3903 The file to remove can be identified by its filename or by an address\n\
3904 that lies within the boundaries of this symbol file in memory."),
3907 c
= add_cmd ("load", class_files
, load_command
, _("\
3908 Dynamically load FILE into the running program, and record its symbols\n\
3909 for access from GDB.\n\
3910 An optional load OFFSET may also be given as a literal address.\n\
3911 When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
3913 Usage: load [FILE] [OFFSET]"), &cmdlist
);
3914 set_cmd_completer (c
, filename_completer
);
3916 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3917 _("Commands for debugging overlays."), &overlaylist
,
3918 "overlay ", 0, &cmdlist
);
3920 add_com_alias ("ovly", "overlay", class_alias
, 1);
3921 add_com_alias ("ov", "overlay", class_alias
, 1);
3923 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3924 _("Assert that an overlay section is mapped."), &overlaylist
);
3926 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3927 _("Assert that an overlay section is unmapped."), &overlaylist
);
3929 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3930 _("List mappings of overlay sections."), &overlaylist
);
3932 add_cmd ("manual", class_support
, overlay_manual_command
,
3933 _("Enable overlay debugging."), &overlaylist
);
3934 add_cmd ("off", class_support
, overlay_off_command
,
3935 _("Disable overlay debugging."), &overlaylist
);
3936 add_cmd ("auto", class_support
, overlay_auto_command
,
3937 _("Enable automatic overlay debugging."), &overlaylist
);
3938 add_cmd ("load-target", class_support
, overlay_load_command
,
3939 _("Read the overlay mapping state from the target."), &overlaylist
);
3941 /* Filename extension to source language lookup table: */
3942 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3944 Set mapping between filename extension and source language."), _("\
3945 Show mapping between filename extension and source language."), _("\
3946 Usage: set extension-language .foo bar"),
3947 set_ext_lang_command
,
3949 &setlist
, &showlist
);
3951 add_info ("extensions", info_ext_lang_command
,
3952 _("All filename extensions associated with a source language."));
3954 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3955 &debug_file_directory
, _("\
3956 Set the directories where separate debug symbols are searched for."), _("\
3957 Show the directories where separate debug symbols are searched for."), _("\
3958 Separate debug symbols are first searched for in the same\n\
3959 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3960 and lastly at the path of the directory of the binary with\n\
3961 each global debug-file-directory component prepended."),
3963 show_debug_file_directory
,
3964 &setlist
, &showlist
);
3966 add_setshow_enum_cmd ("symbol-loading", no_class
,
3967 print_symbol_loading_enums
, &print_symbol_loading
,
3969 Set printing of symbol loading messages."), _("\
3970 Show printing of symbol loading messages."), _("\
3971 off == turn all messages off\n\
3972 brief == print messages for the executable,\n\
3973 and brief messages for shared libraries\n\
3974 full == print messages for the executable,\n\
3975 and messages for each shared library."),
3978 &setprintlist
, &showprintlist
);
3980 add_setshow_boolean_cmd ("separate-debug-file", no_class
,
3981 &separate_debug_file_debug
, _("\
3982 Set printing of separate debug info file search debug."), _("\
3983 Show printing of separate debug info file search debug."), _("\
3984 When on, GDB prints the searched locations while looking for separate debug \
3985 info files."), NULL
, NULL
, &setdebuglist
, &showdebuglist
);
3988 selftests::register_test
3989 ("filename_language", selftests::filename_language::test_filename_language
);
3990 selftests::register_test
3991 ("set_ext_lang_command",
3992 selftests::filename_language::test_set_ext_lang_command
);