1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990-2013 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"
48 #include "gdb_assert.h"
52 #include "parser-defs.h"
60 #include <sys/types.h>
62 #include "gdb_string.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 (char *args
, int from_tty
, int flags
);
91 static void add_symbol_file_command (char *, int);
93 bfd
*symfile_bfd_open (char *);
95 int get_section_index (struct objfile
*, char *);
97 static const struct sym_fns
*find_sym_fns (bfd
*);
99 static void decrement_reading_symtab (void *);
101 static void overlay_invalidate_all (void);
103 static void overlay_auto_command (char *, int);
105 static void overlay_manual_command (char *, int);
107 static void overlay_off_command (char *, int);
109 static void overlay_load_command (char *, int);
111 static void overlay_command (char *, int);
113 static void simple_free_overlay_table (void);
115 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
118 static int simple_read_overlay_table (void);
120 static int simple_overlay_update_1 (struct obj_section
*);
122 static void add_filename_language (char *ext
, enum language lang
);
124 static void info_ext_lang_command (char *args
, int from_tty
);
126 static void init_filename_language_table (void);
128 static void symfile_find_segment_sections (struct objfile
*objfile
);
130 void _initialize_symfile (void);
132 /* List of all available sym_fns. On gdb startup, each object file reader
133 calls add_symtab_fns() to register information on each format it is
136 typedef const struct sym_fns
*sym_fns_ptr
;
137 DEF_VEC_P (sym_fns_ptr
);
139 static VEC (sym_fns_ptr
) *symtab_fns
= NULL
;
141 /* If non-zero, shared library symbols will be added automatically
142 when the inferior is created, new libraries are loaded, or when
143 attaching to the inferior. This is almost always what users will
144 want to have happen; but for very large programs, the startup time
145 will be excessive, and so if this is a problem, the user can clear
146 this flag and then add the shared library symbols as needed. Note
147 that there is a potential for confusion, since if the shared
148 library symbols are not loaded, commands like "info fun" will *not*
149 report all the functions that are actually present. */
151 int auto_solib_add
= 1;
154 /* True if we are reading a symbol table. */
156 int currently_reading_symtab
= 0;
159 decrement_reading_symtab (void *dummy
)
161 currently_reading_symtab
--;
164 /* Increment currently_reading_symtab and return a cleanup that can be
165 used to decrement it. */
167 increment_reading_symtab (void)
169 ++currently_reading_symtab
;
170 return make_cleanup (decrement_reading_symtab
, NULL
);
173 /* Remember the lowest-addressed loadable section we've seen.
174 This function is called via bfd_map_over_sections.
176 In case of equal vmas, the section with the largest size becomes the
177 lowest-addressed loadable section.
179 If the vmas and sizes are equal, the last section is considered the
180 lowest-addressed loadable section. */
183 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
185 asection
**lowest
= (asection
**) obj
;
187 if (0 == (bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
)))
190 *lowest
= sect
; /* First loadable section */
191 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
192 *lowest
= sect
; /* A lower loadable section */
193 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
194 && (bfd_section_size (abfd
, (*lowest
))
195 <= bfd_section_size (abfd
, sect
)))
199 /* Create a new section_addr_info, with room for NUM_SECTIONS. */
201 struct section_addr_info
*
202 alloc_section_addr_info (size_t num_sections
)
204 struct section_addr_info
*sap
;
207 size
= (sizeof (struct section_addr_info
)
208 + sizeof (struct other_sections
) * (num_sections
- 1));
209 sap
= (struct section_addr_info
*) xmalloc (size
);
210 memset (sap
, 0, size
);
211 sap
->num_sections
= num_sections
;
216 /* Build (allocate and populate) a section_addr_info struct from
217 an existing section table. */
219 extern struct section_addr_info
*
220 build_section_addr_info_from_section_table (const struct target_section
*start
,
221 const struct target_section
*end
)
223 struct section_addr_info
*sap
;
224 const struct target_section
*stp
;
227 sap
= alloc_section_addr_info (end
- start
);
229 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
231 if (bfd_get_section_flags (stp
->bfd
,
232 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
233 && oidx
< end
- start
)
235 sap
->other
[oidx
].addr
= stp
->addr
;
236 sap
->other
[oidx
].name
237 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
238 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
246 /* Create a section_addr_info from section offsets in ABFD. */
248 static struct section_addr_info
*
249 build_section_addr_info_from_bfd (bfd
*abfd
)
251 struct section_addr_info
*sap
;
253 struct bfd_section
*sec
;
255 sap
= alloc_section_addr_info (bfd_count_sections (abfd
));
256 for (i
= 0, sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
257 if (bfd_get_section_flags (abfd
, sec
) & (SEC_ALLOC
| SEC_LOAD
))
259 sap
->other
[i
].addr
= bfd_get_section_vma (abfd
, sec
);
260 sap
->other
[i
].name
= xstrdup (bfd_get_section_name (abfd
, sec
));
261 sap
->other
[i
].sectindex
= sec
->index
;
267 /* Create a section_addr_info from section offsets in OBJFILE. */
269 struct section_addr_info
*
270 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
272 struct section_addr_info
*sap
;
275 /* Before reread_symbols gets rewritten it is not safe to call:
276 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
278 sap
= build_section_addr_info_from_bfd (objfile
->obfd
);
279 for (i
= 0; i
< sap
->num_sections
&& sap
->other
[i
].name
; i
++)
281 int sectindex
= sap
->other
[i
].sectindex
;
283 sap
->other
[i
].addr
+= objfile
->section_offsets
->offsets
[sectindex
];
288 /* Free all memory allocated by build_section_addr_info_from_section_table. */
291 free_section_addr_info (struct section_addr_info
*sap
)
295 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
296 if (sap
->other
[idx
].name
)
297 xfree (sap
->other
[idx
].name
);
302 /* Initialize OBJFILE's sect_index_* members. */
304 init_objfile_sect_indices (struct objfile
*objfile
)
309 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
311 objfile
->sect_index_text
= sect
->index
;
313 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
315 objfile
->sect_index_data
= sect
->index
;
317 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
319 objfile
->sect_index_bss
= sect
->index
;
321 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
323 objfile
->sect_index_rodata
= sect
->index
;
325 /* This is where things get really weird... We MUST have valid
326 indices for the various sect_index_* members or gdb will abort.
327 So if for example, there is no ".text" section, we have to
328 accomodate that. First, check for a file with the standard
329 one or two segments. */
331 symfile_find_segment_sections (objfile
);
333 /* Except when explicitly adding symbol files at some address,
334 section_offsets contains nothing but zeros, so it doesn't matter
335 which slot in section_offsets the individual sect_index_* members
336 index into. So if they are all zero, it is safe to just point
337 all the currently uninitialized indices to the first slot. But
338 beware: if this is the main executable, it may be relocated
339 later, e.g. by the remote qOffsets packet, and then this will
340 be wrong! That's why we try segments first. */
342 for (i
= 0; i
< objfile
->num_sections
; i
++)
344 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
349 if (i
== objfile
->num_sections
)
351 if (objfile
->sect_index_text
== -1)
352 objfile
->sect_index_text
= 0;
353 if (objfile
->sect_index_data
== -1)
354 objfile
->sect_index_data
= 0;
355 if (objfile
->sect_index_bss
== -1)
356 objfile
->sect_index_bss
= 0;
357 if (objfile
->sect_index_rodata
== -1)
358 objfile
->sect_index_rodata
= 0;
362 /* The arguments to place_section. */
364 struct place_section_arg
366 struct section_offsets
*offsets
;
370 /* Find a unique offset to use for loadable section SECT if
371 the user did not provide an offset. */
374 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
376 struct place_section_arg
*arg
= obj
;
377 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
379 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
381 /* We are only interested in allocated sections. */
382 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
385 /* If the user specified an offset, honor it. */
386 if (offsets
[sect
->index
] != 0)
389 /* Otherwise, let's try to find a place for the section. */
390 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
397 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
399 int indx
= cur_sec
->index
;
401 /* We don't need to compare against ourself. */
405 /* We can only conflict with allocated sections. */
406 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
409 /* If the section offset is 0, either the section has not been placed
410 yet, or it was the lowest section placed (in which case LOWEST
411 will be past its end). */
412 if (offsets
[indx
] == 0)
415 /* If this section would overlap us, then we must move up. */
416 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
417 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
419 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
420 start_addr
= (start_addr
+ align
- 1) & -align
;
425 /* Otherwise, we appear to be OK. So far. */
430 offsets
[sect
->index
] = start_addr
;
431 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
434 /* Store struct section_addr_info as prepared (made relative and with SECTINDEX
435 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
439 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
441 struct section_addr_info
*addrs
)
445 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
447 /* Now calculate offsets for section that were specified by the caller. */
448 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
450 struct other_sections
*osp
;
452 osp
= &addrs
->other
[i
];
453 if (osp
->sectindex
== -1)
456 /* Record all sections in offsets. */
457 /* The section_offsets in the objfile are here filled in using
459 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
463 /* Transform section name S for a name comparison. prelink can split section
464 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
465 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
466 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
467 (`.sbss') section has invalid (increased) virtual address. */
470 addr_section_name (const char *s
)
472 if (strcmp (s
, ".dynbss") == 0)
474 if (strcmp (s
, ".sdynbss") == 0)
480 /* qsort comparator for addrs_section_sort. Sort entries in ascending order by
481 their (name, sectindex) pair. sectindex makes the sort by name stable. */
484 addrs_section_compar (const void *ap
, const void *bp
)
486 const struct other_sections
*a
= *((struct other_sections
**) ap
);
487 const struct other_sections
*b
= *((struct other_sections
**) bp
);
490 retval
= strcmp (addr_section_name (a
->name
), addr_section_name (b
->name
));
494 return a
->sectindex
- b
->sectindex
;
497 /* Provide sorted array of pointers to sections of ADDRS. The array is
498 terminated by NULL. Caller is responsible to call xfree for it. */
500 static struct other_sections
**
501 addrs_section_sort (struct section_addr_info
*addrs
)
503 struct other_sections
**array
;
506 /* `+ 1' for the NULL terminator. */
507 array
= xmalloc (sizeof (*array
) * (addrs
->num_sections
+ 1));
508 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
509 array
[i
] = &addrs
->other
[i
];
512 qsort (array
, i
, sizeof (*array
), addrs_section_compar
);
517 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
518 also SECTINDEXes specific to ABFD there. This function can be used to
519 rebase ADDRS to start referencing different BFD than before. */
522 addr_info_make_relative (struct section_addr_info
*addrs
, bfd
*abfd
)
524 asection
*lower_sect
;
525 CORE_ADDR lower_offset
;
527 struct cleanup
*my_cleanup
;
528 struct section_addr_info
*abfd_addrs
;
529 struct other_sections
**addrs_sorted
, **abfd_addrs_sorted
;
530 struct other_sections
**addrs_to_abfd_addrs
;
532 /* Find lowest loadable section to be used as starting point for
533 continguous sections. */
535 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
536 if (lower_sect
== NULL
)
538 warning (_("no loadable sections found in added symbol-file %s"),
539 bfd_get_filename (abfd
));
543 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
545 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
546 in ABFD. Section names are not unique - there can be multiple sections of
547 the same name. Also the sections of the same name do not have to be
548 adjacent to each other. Some sections may be present only in one of the
549 files. Even sections present in both files do not have to be in the same
552 Use stable sort by name for the sections in both files. Then linearly
553 scan both lists matching as most of the entries as possible. */
555 addrs_sorted
= addrs_section_sort (addrs
);
556 my_cleanup
= make_cleanup (xfree
, addrs_sorted
);
558 abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
559 make_cleanup_free_section_addr_info (abfd_addrs
);
560 abfd_addrs_sorted
= addrs_section_sort (abfd_addrs
);
561 make_cleanup (xfree
, abfd_addrs_sorted
);
563 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
564 ABFD_ADDRS_SORTED. */
566 addrs_to_abfd_addrs
= xzalloc (sizeof (*addrs_to_abfd_addrs
)
567 * addrs
->num_sections
);
568 make_cleanup (xfree
, addrs_to_abfd_addrs
);
570 while (*addrs_sorted
)
572 const char *sect_name
= addr_section_name ((*addrs_sorted
)->name
);
574 while (*abfd_addrs_sorted
575 && strcmp (addr_section_name ((*abfd_addrs_sorted
)->name
),
579 if (*abfd_addrs_sorted
580 && strcmp (addr_section_name ((*abfd_addrs_sorted
)->name
),
585 /* Make the found item directly addressable from ADDRS. */
586 index_in_addrs
= *addrs_sorted
- addrs
->other
;
587 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
588 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_addrs_sorted
;
590 /* Never use the same ABFD entry twice. */
597 /* Calculate offsets for the loadable sections.
598 FIXME! Sections must be in order of increasing loadable section
599 so that contiguous sections can use the lower-offset!!!
601 Adjust offsets if the segments are not contiguous.
602 If the section is contiguous, its offset should be set to
603 the offset of the highest loadable section lower than it
604 (the loadable section directly below it in memory).
605 this_offset = lower_offset = lower_addr - lower_orig_addr */
607 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
609 struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
613 /* This is the index used by BFD. */
614 addrs
->other
[i
].sectindex
= sect
->sectindex
;
616 if (addrs
->other
[i
].addr
!= 0)
618 addrs
->other
[i
].addr
-= sect
->addr
;
619 lower_offset
= addrs
->other
[i
].addr
;
622 addrs
->other
[i
].addr
= lower_offset
;
626 /* addr_section_name transformation is not used for SECT_NAME. */
627 const char *sect_name
= addrs
->other
[i
].name
;
629 /* This section does not exist in ABFD, which is normally
630 unexpected and we want to issue a warning.
632 However, the ELF prelinker does create a few sections which are
633 marked in the main executable as loadable (they are loaded in
634 memory from the DYNAMIC segment) and yet are not present in
635 separate debug info files. This is fine, and should not cause
636 a warning. Shared libraries contain just the section
637 ".gnu.liblist" but it is not marked as loadable there. There is
638 no other way to identify them than by their name as the sections
639 created by prelink have no special flags.
641 For the sections `.bss' and `.sbss' see addr_section_name. */
643 if (!(strcmp (sect_name
, ".gnu.liblist") == 0
644 || strcmp (sect_name
, ".gnu.conflict") == 0
645 || (strcmp (sect_name
, ".bss") == 0
647 && strcmp (addrs
->other
[i
- 1].name
, ".dynbss") == 0
648 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
649 || (strcmp (sect_name
, ".sbss") == 0
651 && strcmp (addrs
->other
[i
- 1].name
, ".sdynbss") == 0
652 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
653 warning (_("section %s not found in %s"), sect_name
,
654 bfd_get_filename (abfd
));
656 addrs
->other
[i
].addr
= 0;
657 addrs
->other
[i
].sectindex
= -1;
661 do_cleanups (my_cleanup
);
664 /* Parse the user's idea of an offset for dynamic linking, into our idea
665 of how to represent it for fast symbol reading. This is the default
666 version of the sym_fns.sym_offsets function for symbol readers that
667 don't need to do anything special. It allocates a section_offsets table
668 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
671 default_symfile_offsets (struct objfile
*objfile
,
672 struct section_addr_info
*addrs
)
674 objfile
->num_sections
= bfd_count_sections (objfile
->obfd
);
675 objfile
->section_offsets
= (struct section_offsets
*)
676 obstack_alloc (&objfile
->objfile_obstack
,
677 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
678 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
679 objfile
->num_sections
, addrs
);
681 /* For relocatable files, all loadable sections will start at zero.
682 The zero is meaningless, so try to pick arbitrary addresses such
683 that no loadable sections overlap. This algorithm is quadratic,
684 but the number of sections in a single object file is generally
686 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
688 struct place_section_arg arg
;
689 bfd
*abfd
= objfile
->obfd
;
692 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
693 /* We do not expect this to happen; just skip this step if the
694 relocatable file has a section with an assigned VMA. */
695 if (bfd_section_vma (abfd
, cur_sec
) != 0)
700 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
702 /* Pick non-overlapping offsets for sections the user did not
704 arg
.offsets
= objfile
->section_offsets
;
706 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
708 /* Correctly filling in the section offsets is not quite
709 enough. Relocatable files have two properties that
710 (most) shared objects do not:
712 - Their debug information will contain relocations. Some
713 shared libraries do also, but many do not, so this can not
716 - If there are multiple code sections they will be loaded
717 at different relative addresses in memory than they are
718 in the objfile, since all sections in the file will start
721 Because GDB has very limited ability to map from an
722 address in debug info to the correct code section,
723 it relies on adding SECT_OFF_TEXT to things which might be
724 code. If we clear all the section offsets, and set the
725 section VMAs instead, then symfile_relocate_debug_section
726 will return meaningful debug information pointing at the
729 GDB has too many different data structures for section
730 addresses - a bfd, objfile, and so_list all have section
731 tables, as does exec_ops. Some of these could probably
734 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
735 cur_sec
= cur_sec
->next
)
737 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
740 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
741 exec_set_section_address (bfd_get_filename (abfd
),
743 offsets
[cur_sec
->index
]);
744 offsets
[cur_sec
->index
] = 0;
749 /* Remember the bfd indexes for the .text, .data, .bss and
751 init_objfile_sect_indices (objfile
);
755 /* Divide the file into segments, which are individual relocatable units.
756 This is the default version of the sym_fns.sym_segments function for
757 symbol readers that do not have an explicit representation of segments.
758 It assumes that object files do not have segments, and fully linked
759 files have a single segment. */
761 struct symfile_segment_data
*
762 default_symfile_segments (bfd
*abfd
)
766 struct symfile_segment_data
*data
;
769 /* Relocatable files contain enough information to position each
770 loadable section independently; they should not be relocated
772 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
775 /* Make sure there is at least one loadable section in the file. */
776 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
778 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
786 low
= bfd_get_section_vma (abfd
, sect
);
787 high
= low
+ bfd_get_section_size (sect
);
789 data
= XZALLOC (struct symfile_segment_data
);
790 data
->num_segments
= 1;
791 data
->segment_bases
= XCALLOC (1, CORE_ADDR
);
792 data
->segment_sizes
= XCALLOC (1, CORE_ADDR
);
794 num_sections
= bfd_count_sections (abfd
);
795 data
->segment_info
= XCALLOC (num_sections
, int);
797 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
801 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
804 vma
= bfd_get_section_vma (abfd
, sect
);
807 if (vma
+ bfd_get_section_size (sect
) > high
)
808 high
= vma
+ bfd_get_section_size (sect
);
810 data
->segment_info
[i
] = 1;
813 data
->segment_bases
[0] = low
;
814 data
->segment_sizes
[0] = high
- low
;
819 /* This is a convenience function to call sym_read for OBJFILE and
820 possibly force the partial symbols to be read. */
823 read_symbols (struct objfile
*objfile
, int add_flags
)
825 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
826 if (!objfile_has_partial_symbols (objfile
))
828 bfd
*abfd
= find_separate_debug_file_in_section (objfile
);
829 struct cleanup
*cleanup
= make_cleanup_bfd_unref (abfd
);
832 symbol_file_add_separate (abfd
, add_flags
, objfile
);
834 do_cleanups (cleanup
);
836 if ((add_flags
& SYMFILE_NO_READ
) == 0)
837 require_partial_symbols (objfile
, 0);
840 /* Initialize entry point information for this objfile. */
843 init_entry_point_info (struct objfile
*objfile
)
845 /* Save startup file's range of PC addresses to help blockframe.c
846 decide where the bottom of the stack is. */
848 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
850 /* Executable file -- record its entry point so we'll recognize
851 the startup file because it contains the entry point. */
852 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
853 objfile
->ei
.entry_point_p
= 1;
855 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
856 && bfd_get_start_address (objfile
->obfd
) != 0)
858 /* Some shared libraries may have entry points set and be
859 runnable. There's no clear way to indicate this, so just check
860 for values other than zero. */
861 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
862 objfile
->ei
.entry_point_p
= 1;
866 /* Examination of non-executable.o files. Short-circuit this stuff. */
867 objfile
->ei
.entry_point_p
= 0;
870 if (objfile
->ei
.entry_point_p
)
872 CORE_ADDR entry_point
= objfile
->ei
.entry_point
;
874 /* Make certain that the address points at real code, and not a
875 function descriptor. */
877 = gdbarch_convert_from_func_ptr_addr (objfile
->gdbarch
,
881 /* Remove any ISA markers, so that this matches entries in the
883 objfile
->ei
.entry_point
884 = gdbarch_addr_bits_remove (objfile
->gdbarch
, entry_point
);
888 /* Process a symbol file, as either the main file or as a dynamically
891 This function does not set the OBJFILE's entry-point info.
893 OBJFILE is where the symbols are to be read from.
895 ADDRS is the list of section load addresses. If the user has given
896 an 'add-symbol-file' command, then this is the list of offsets and
897 addresses he or she provided as arguments to the command; or, if
898 we're handling a shared library, these are the actual addresses the
899 sections are loaded at, according to the inferior's dynamic linker
900 (as gleaned by GDB's shared library code). We convert each address
901 into an offset from the section VMA's as it appears in the object
902 file, and then call the file's sym_offsets function to convert this
903 into a format-specific offset table --- a `struct section_offsets'.
904 If ADDRS is non-zero, OFFSETS must be zero.
906 OFFSETS is a table of section offsets already in the right
907 format-specific representation. NUM_OFFSETS is the number of
908 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
909 assume this is the proper table the call to sym_offsets described
910 above would produce. Instead of calling sym_offsets, we just dump
911 it right into objfile->section_offsets. (When we're re-reading
912 symbols from an objfile, we don't have the original load address
913 list any more; all we have is the section offset table.) If
914 OFFSETS is non-zero, ADDRS must be zero.
916 ADD_FLAGS encodes verbosity level, whether this is main symbol or
917 an extra symbol file such as dynamically loaded code, and wether
918 breakpoint reset should be deferred. */
921 syms_from_objfile_1 (struct objfile
*objfile
,
922 struct section_addr_info
*addrs
,
923 struct section_offsets
*offsets
,
927 struct section_addr_info
*local_addr
= NULL
;
928 struct cleanup
*old_chain
;
929 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
931 gdb_assert (! (addrs
&& offsets
));
933 objfile
->sf
= find_sym_fns (objfile
->obfd
);
935 if (objfile
->sf
== NULL
)
937 /* No symbols to load, but we still need to make sure
938 that the section_offsets table is allocated. */
939 int num_sections
= bfd_count_sections (objfile
->obfd
);
940 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
942 objfile
->num_sections
= num_sections
;
943 objfile
->section_offsets
944 = obstack_alloc (&objfile
->objfile_obstack
, size
);
945 memset (objfile
->section_offsets
, 0, size
);
949 /* Make sure that partially constructed symbol tables will be cleaned up
950 if an error occurs during symbol reading. */
951 old_chain
= make_cleanup_free_objfile (objfile
);
953 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
954 list. We now establish the convention that an addr of zero means
955 no load address was specified. */
956 if (! addrs
&& ! offsets
)
959 = alloc_section_addr_info (bfd_count_sections (objfile
->obfd
));
960 make_cleanup (xfree
, local_addr
);
964 /* Now either addrs or offsets is non-zero. */
968 /* We will modify the main symbol table, make sure that all its users
969 will be cleaned up if an error occurs during symbol reading. */
970 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
972 /* Since no error yet, throw away the old symbol table. */
974 if (symfile_objfile
!= NULL
)
976 free_objfile (symfile_objfile
);
977 gdb_assert (symfile_objfile
== NULL
);
980 /* Currently we keep symbols from the add-symbol-file command.
981 If the user wants to get rid of them, they should do "symbol-file"
982 without arguments first. Not sure this is the best behavior
985 (*objfile
->sf
->sym_new_init
) (objfile
);
988 /* Convert addr into an offset rather than an absolute address.
989 We find the lowest address of a loaded segment in the objfile,
990 and assume that <addr> is where that got loaded.
992 We no longer warn if the lowest section is not a text segment (as
993 happens for the PA64 port. */
994 if (addrs
&& addrs
->other
[0].name
)
995 addr_info_make_relative (addrs
, objfile
->obfd
);
997 /* Initialize symbol reading routines for this objfile, allow complaints to
998 appear for this new file, and record how verbose to be, then do the
999 initial symbol reading for this file. */
1001 (*objfile
->sf
->sym_init
) (objfile
);
1002 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
1005 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
1008 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
1010 /* Just copy in the offset table directly as given to us. */
1011 objfile
->num_sections
= num_offsets
;
1012 objfile
->section_offsets
1013 = ((struct section_offsets
*)
1014 obstack_alloc (&objfile
->objfile_obstack
, size
));
1015 memcpy (objfile
->section_offsets
, offsets
, size
);
1017 init_objfile_sect_indices (objfile
);
1020 read_symbols (objfile
, add_flags
);
1022 /* Discard cleanups as symbol reading was successful. */
1024 discard_cleanups (old_chain
);
1028 /* Same as syms_from_objfile_1, but also initializes the objfile
1029 entry-point info. */
1032 syms_from_objfile (struct objfile
*objfile
,
1033 struct section_addr_info
*addrs
,
1034 struct section_offsets
*offsets
,
1038 syms_from_objfile_1 (objfile
, addrs
, offsets
, num_offsets
, add_flags
);
1039 init_entry_point_info (objfile
);
1042 /* Perform required actions after either reading in the initial
1043 symbols for a new objfile, or mapping in the symbols from a reusable
1044 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1047 new_symfile_objfile (struct objfile
*objfile
, int add_flags
)
1049 /* If this is the main symbol file we have to clean up all users of the
1050 old main symbol file. Otherwise it is sufficient to fixup all the
1051 breakpoints that may have been redefined by this symbol file. */
1052 if (add_flags
& SYMFILE_MAINLINE
)
1054 /* OK, make it the "real" symbol file. */
1055 symfile_objfile
= objfile
;
1057 clear_symtab_users (add_flags
);
1059 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1061 breakpoint_re_set ();
1064 /* We're done reading the symbol file; finish off complaints. */
1065 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
1068 /* Process a symbol file, as either the main file or as a dynamically
1071 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1072 A new reference is acquired by this function.
1074 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1075 extra, such as dynamically loaded code, and what to do with breakpoins.
1077 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
1078 syms_from_objfile, above.
1079 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1081 PARENT is the original objfile if ABFD is a separate debug info file.
1082 Otherwise PARENT is NULL.
1084 Upon success, returns a pointer to the objfile that was added.
1085 Upon failure, jumps back to command level (never returns). */
1087 static struct objfile
*
1088 symbol_file_add_with_addrs_or_offsets (bfd
*abfd
,
1090 struct section_addr_info
*addrs
,
1091 struct section_offsets
*offsets
,
1093 int flags
, struct objfile
*parent
)
1095 struct objfile
*objfile
;
1096 const char *name
= bfd_get_filename (abfd
);
1097 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1098 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1099 const int should_print
= ((from_tty
|| info_verbose
)
1100 && (readnow_symbol_files
1101 || (add_flags
& SYMFILE_NO_READ
) == 0));
1103 if (readnow_symbol_files
)
1105 flags
|= OBJF_READNOW
;
1106 add_flags
&= ~SYMFILE_NO_READ
;
1109 /* Give user a chance to burp if we'd be
1110 interactively wiping out any existing symbols. */
1112 if ((have_full_symbols () || have_partial_symbols ())
1115 && !query (_("Load new symbol table from \"%s\"? "), name
))
1116 error (_("Not confirmed."));
1118 objfile
= allocate_objfile (abfd
, flags
| (mainline
? OBJF_MAINLINE
: 0));
1121 add_separate_debug_objfile (objfile
, parent
);
1123 /* We either created a new mapped symbol table, mapped an existing
1124 symbol table file which has not had initial symbol reading
1125 performed, or need to read an unmapped symbol table. */
1128 if (deprecated_pre_add_symbol_hook
)
1129 deprecated_pre_add_symbol_hook (name
);
1132 printf_unfiltered (_("Reading symbols from %s..."), name
);
1134 gdb_flush (gdb_stdout
);
1137 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
1140 /* We now have at least a partial symbol table. Check to see if the
1141 user requested that all symbols be read on initial access via either
1142 the gdb startup command line or on a per symbol file basis. Expand
1143 all partial symbol tables for this objfile if so. */
1145 if ((flags
& OBJF_READNOW
))
1149 printf_unfiltered (_("expanding to full symbols..."));
1151 gdb_flush (gdb_stdout
);
1155 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1158 if (should_print
&& !objfile_has_symbols (objfile
))
1161 printf_unfiltered (_("(no debugging symbols found)..."));
1167 if (deprecated_post_add_symbol_hook
)
1168 deprecated_post_add_symbol_hook ();
1170 printf_unfiltered (_("done.\n"));
1173 /* We print some messages regardless of whether 'from_tty ||
1174 info_verbose' is true, so make sure they go out at the right
1176 gdb_flush (gdb_stdout
);
1178 if (objfile
->sf
== NULL
)
1180 observer_notify_new_objfile (objfile
);
1181 return objfile
; /* No symbols. */
1184 new_symfile_objfile (objfile
, add_flags
);
1186 observer_notify_new_objfile (objfile
);
1188 bfd_cache_close_all ();
1192 /* Add BFD as a separate debug file for OBJFILE. */
1195 symbol_file_add_separate (bfd
*bfd
, int symfile_flags
, struct objfile
*objfile
)
1197 struct objfile
*new_objfile
;
1198 struct section_addr_info
*sap
;
1199 struct cleanup
*my_cleanup
;
1201 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1202 because sections of BFD may not match sections of OBJFILE and because
1203 vma may have been modified by tools such as prelink. */
1204 sap
= build_section_addr_info_from_objfile (objfile
);
1205 my_cleanup
= make_cleanup_free_section_addr_info (sap
);
1207 new_objfile
= symbol_file_add_with_addrs_or_offsets
1208 (bfd
, symfile_flags
,
1210 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1214 do_cleanups (my_cleanup
);
1217 /* Process the symbol file ABFD, as either the main file or as a
1218 dynamically loaded file.
1220 See symbol_file_add_with_addrs_or_offsets's comments for
1223 symbol_file_add_from_bfd (bfd
*abfd
, int add_flags
,
1224 struct section_addr_info
*addrs
,
1225 int flags
, struct objfile
*parent
)
1227 return symbol_file_add_with_addrs_or_offsets (abfd
, add_flags
, addrs
, 0, 0,
1232 /* Process a symbol file, as either the main file or as a dynamically
1233 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1236 symbol_file_add (char *name
, int add_flags
, struct section_addr_info
*addrs
,
1239 bfd
*bfd
= symfile_bfd_open (name
);
1240 struct cleanup
*cleanup
= make_cleanup_bfd_unref (bfd
);
1241 struct objfile
*objf
;
1243 objf
= symbol_file_add_from_bfd (bfd
, add_flags
, addrs
, flags
, NULL
);
1244 do_cleanups (cleanup
);
1249 /* Call symbol_file_add() with default values and update whatever is
1250 affected by the loading of a new main().
1251 Used when the file is supplied in the gdb command line
1252 and by some targets with special loading requirements.
1253 The auxiliary function, symbol_file_add_main_1(), has the flags
1254 argument for the switches that can only be specified in the symbol_file
1258 symbol_file_add_main (char *args
, int from_tty
)
1260 symbol_file_add_main_1 (args
, from_tty
, 0);
1264 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1266 const int add_flags
= (current_inferior ()->symfile_flags
1267 | SYMFILE_MAINLINE
| (from_tty
? SYMFILE_VERBOSE
: 0));
1269 symbol_file_add (args
, add_flags
, NULL
, flags
);
1271 /* Getting new symbols may change our opinion about
1272 what is frameless. */
1273 reinit_frame_cache ();
1275 if ((flags
& SYMFILE_NO_READ
) == 0)
1276 set_initial_language ();
1280 symbol_file_clear (int from_tty
)
1282 if ((have_full_symbols () || have_partial_symbols ())
1285 ? !query (_("Discard symbol table from `%s'? "),
1286 symfile_objfile
->name
)
1287 : !query (_("Discard symbol table? "))))
1288 error (_("Not confirmed."));
1290 /* solib descriptors may have handles to objfiles. Wipe them before their
1291 objfiles get stale by free_all_objfiles. */
1292 no_shared_libraries (NULL
, from_tty
);
1294 free_all_objfiles ();
1296 gdb_assert (symfile_objfile
== NULL
);
1298 printf_unfiltered (_("No symbol file now.\n"));
1302 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1305 bfd_size_type debuglink_size
;
1306 unsigned long crc32
;
1310 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1315 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1317 contents
= xmalloc (debuglink_size
);
1318 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1319 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1321 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1322 crc_offset
= strlen (contents
) + 1;
1323 crc_offset
= (crc_offset
+ 3) & ~3;
1325 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1331 /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
1332 return 1. Otherwise print a warning and return 0. ABFD seek position is
1336 get_file_crc (bfd
*abfd
, unsigned long *file_crc_return
)
1338 unsigned long file_crc
= 0;
1340 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
1342 warning (_("Problem reading \"%s\" for CRC: %s"),
1343 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
1349 gdb_byte buffer
[8 * 1024];
1350 bfd_size_type count
;
1352 count
= bfd_bread (buffer
, sizeof (buffer
), abfd
);
1353 if (count
== (bfd_size_type
) -1)
1355 warning (_("Problem reading \"%s\" for CRC: %s"),
1356 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
1361 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1364 *file_crc_return
= file_crc
;
1369 separate_debug_file_exists (const char *name
, unsigned long crc
,
1370 struct objfile
*parent_objfile
)
1372 unsigned long file_crc
;
1375 struct stat parent_stat
, abfd_stat
;
1376 int verified_as_different
;
1378 /* Find a separate debug info file as if symbols would be present in
1379 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1380 section can contain just the basename of PARENT_OBJFILE without any
1381 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1382 the separate debug infos with the same basename can exist. */
1384 if (filename_cmp (name
, parent_objfile
->name
) == 0)
1387 abfd
= gdb_bfd_open_maybe_remote (name
);
1392 /* Verify symlinks were not the cause of filename_cmp name difference above.
1394 Some operating systems, e.g. Windows, do not provide a meaningful
1395 st_ino; they always set it to zero. (Windows does provide a
1396 meaningful st_dev.) Do not indicate a duplicate library in that
1397 case. While there is no guarantee that a system that provides
1398 meaningful inode numbers will never set st_ino to zero, this is
1399 merely an optimization, so we do not need to worry about false
1402 if (bfd_stat (abfd
, &abfd_stat
) == 0
1403 && abfd_stat
.st_ino
!= 0
1404 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1406 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1407 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1409 gdb_bfd_unref (abfd
);
1412 verified_as_different
= 1;
1415 verified_as_different
= 0;
1417 file_crc_p
= get_file_crc (abfd
, &file_crc
);
1419 gdb_bfd_unref (abfd
);
1424 if (crc
!= file_crc
)
1426 /* If one (or both) the files are accessed for example the via "remote:"
1427 gdbserver way it does not support the bfd_stat operation. Verify
1428 whether those two files are not the same manually. */
1430 if (!verified_as_different
&& !parent_objfile
->crc32_p
)
1432 parent_objfile
->crc32_p
= get_file_crc (parent_objfile
->obfd
,
1433 &parent_objfile
->crc32
);
1434 if (!parent_objfile
->crc32_p
)
1438 if (verified_as_different
|| parent_objfile
->crc32
!= file_crc
)
1439 warning (_("the debug information found in \"%s\""
1440 " does not match \"%s\" (CRC mismatch).\n"),
1441 name
, parent_objfile
->name
);
1449 char *debug_file_directory
= NULL
;
1451 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1452 struct cmd_list_element
*c
, const char *value
)
1454 fprintf_filtered (file
,
1455 _("The directory where separate debug "
1456 "symbols are searched for is \"%s\".\n"),
1460 #if ! defined (DEBUG_SUBDIRECTORY)
1461 #define DEBUG_SUBDIRECTORY ".debug"
1464 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1465 where the original file resides (may not be the same as
1466 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1467 looking for. Returns the name of the debuginfo, of NULL. */
1470 find_separate_debug_file (const char *dir
,
1471 const char *canon_dir
,
1472 const char *debuglink
,
1473 unsigned long crc32
, struct objfile
*objfile
)
1478 VEC (char_ptr
) *debugdir_vec
;
1479 struct cleanup
*back_to
;
1482 /* Set I to max (strlen (canon_dir), strlen (dir)). */
1484 if (canon_dir
!= NULL
&& strlen (canon_dir
) > i
)
1485 i
= strlen (canon_dir
);
1487 debugfile
= xmalloc (strlen (debug_file_directory
) + 1
1489 + strlen (DEBUG_SUBDIRECTORY
)
1491 + strlen (debuglink
)
1494 /* First try in the same directory as the original file. */
1495 strcpy (debugfile
, dir
);
1496 strcat (debugfile
, debuglink
);
1498 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1501 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1502 strcpy (debugfile
, dir
);
1503 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1504 strcat (debugfile
, "/");
1505 strcat (debugfile
, debuglink
);
1507 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1510 /* Then try in the global debugfile directories.
1512 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1513 cause "/..." lookups. */
1515 debugdir_vec
= dirnames_to_char_ptr_vec (debug_file_directory
);
1516 back_to
= make_cleanup_free_char_ptr_vec (debugdir_vec
);
1518 for (ix
= 0; VEC_iterate (char_ptr
, debugdir_vec
, ix
, debugdir
); ++ix
)
1520 strcpy (debugfile
, debugdir
);
1521 strcat (debugfile
, "/");
1522 strcat (debugfile
, dir
);
1523 strcat (debugfile
, debuglink
);
1525 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1528 /* If the file is in the sysroot, try using its base path in the
1529 global debugfile directory. */
1530 if (canon_dir
!= NULL
1531 && filename_ncmp (canon_dir
, gdb_sysroot
,
1532 strlen (gdb_sysroot
)) == 0
1533 && IS_DIR_SEPARATOR (canon_dir
[strlen (gdb_sysroot
)]))
1535 strcpy (debugfile
, debugdir
);
1536 strcat (debugfile
, canon_dir
+ strlen (gdb_sysroot
));
1537 strcat (debugfile
, "/");
1538 strcat (debugfile
, debuglink
);
1540 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1545 do_cleanups (back_to
);
1550 /* Modify PATH to contain only "directory/" part of PATH.
1551 If there were no directory separators in PATH, PATH will be empty
1552 string on return. */
1555 terminate_after_last_dir_separator (char *path
)
1559 /* Strip off the final filename part, leaving the directory name,
1560 followed by a slash. The directory can be relative or absolute. */
1561 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1562 if (IS_DIR_SEPARATOR (path
[i
]))
1565 /* If I is -1 then no directory is present there and DIR will be "". */
1569 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1570 Returns pathname, or NULL. */
1573 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1576 char *dir
, *canon_dir
;
1578 unsigned long crc32
;
1579 struct cleanup
*cleanups
;
1581 debuglink
= get_debug_link_info (objfile
, &crc32
);
1583 if (debuglink
== NULL
)
1585 /* There's no separate debug info, hence there's no way we could
1586 load it => no warning. */
1590 cleanups
= make_cleanup (xfree
, debuglink
);
1591 dir
= xstrdup (objfile
->name
);
1592 make_cleanup (xfree
, dir
);
1593 terminate_after_last_dir_separator (dir
);
1594 canon_dir
= lrealpath (dir
);
1596 debugfile
= find_separate_debug_file (dir
, canon_dir
, debuglink
,
1600 if (debugfile
== NULL
)
1603 /* For PR gdb/9538, try again with realpath (if different from the
1608 if (lstat (objfile
->name
, &st_buf
) == 0 && S_ISLNK(st_buf
.st_mode
))
1612 symlink_dir
= lrealpath (objfile
->name
);
1613 if (symlink_dir
!= NULL
)
1615 make_cleanup (xfree
, symlink_dir
);
1616 terminate_after_last_dir_separator (symlink_dir
);
1617 if (strcmp (dir
, symlink_dir
) != 0)
1619 /* Different directory, so try using it. */
1620 debugfile
= find_separate_debug_file (symlink_dir
,
1628 #endif /* HAVE_LSTAT */
1631 do_cleanups (cleanups
);
1636 /* This is the symbol-file command. Read the file, analyze its
1637 symbols, and add a struct symtab to a symtab list. The syntax of
1638 the command is rather bizarre:
1640 1. The function buildargv implements various quoting conventions
1641 which are undocumented and have little or nothing in common with
1642 the way things are quoted (or not quoted) elsewhere in GDB.
1644 2. Options are used, which are not generally used in GDB (perhaps
1645 "set mapped on", "set readnow on" would be better)
1647 3. The order of options matters, which is contrary to GNU
1648 conventions (because it is confusing and inconvenient). */
1651 symbol_file_command (char *args
, int from_tty
)
1657 symbol_file_clear (from_tty
);
1661 char **argv
= gdb_buildargv (args
);
1662 int flags
= OBJF_USERLOADED
;
1663 struct cleanup
*cleanups
;
1666 cleanups
= make_cleanup_freeargv (argv
);
1667 while (*argv
!= NULL
)
1669 if (strcmp (*argv
, "-readnow") == 0)
1670 flags
|= OBJF_READNOW
;
1671 else if (**argv
== '-')
1672 error (_("unknown option `%s'"), *argv
);
1675 symbol_file_add_main_1 (*argv
, from_tty
, flags
);
1683 error (_("no symbol file name was specified"));
1685 do_cleanups (cleanups
);
1689 /* Set the initial language.
1691 FIXME: A better solution would be to record the language in the
1692 psymtab when reading partial symbols, and then use it (if known) to
1693 set the language. This would be a win for formats that encode the
1694 language in an easily discoverable place, such as DWARF. For
1695 stabs, we can jump through hoops looking for specially named
1696 symbols or try to intuit the language from the specific type of
1697 stabs we find, but we can't do that until later when we read in
1701 set_initial_language (void)
1703 enum language lang
= language_unknown
;
1705 if (language_of_main
!= language_unknown
)
1706 lang
= language_of_main
;
1709 const char *filename
;
1711 filename
= find_main_filename ();
1712 if (filename
!= NULL
)
1713 lang
= deduce_language_from_filename (filename
);
1716 if (lang
== language_unknown
)
1718 /* Make C the default language */
1722 set_language (lang
);
1723 expected_language
= current_language
; /* Don't warn the user. */
1726 /* If NAME is a remote name open the file using remote protocol, otherwise
1727 open it normally. Returns a new reference to the BFD. On error,
1728 returns NULL with the BFD error set. */
1731 gdb_bfd_open_maybe_remote (const char *name
)
1735 if (remote_filename_p (name
))
1736 result
= remote_bfd_open (name
, gnutarget
);
1738 result
= gdb_bfd_open (name
, gnutarget
, -1);
1744 /* Open the file specified by NAME and hand it off to BFD for
1745 preliminary analysis. Return a newly initialized bfd *, which
1746 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1747 absolute). In case of trouble, error() is called. */
1750 symfile_bfd_open (char *name
)
1754 char *absolute_name
;
1756 if (remote_filename_p (name
))
1758 sym_bfd
= remote_bfd_open (name
, gnutarget
);
1760 error (_("`%s': can't open to read symbols: %s."), name
,
1761 bfd_errmsg (bfd_get_error ()));
1763 if (!bfd_check_format (sym_bfd
, bfd_object
))
1765 make_cleanup_bfd_unref (sym_bfd
);
1766 error (_("`%s': can't read symbols: %s."), name
,
1767 bfd_errmsg (bfd_get_error ()));
1773 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy. */
1775 /* Look down path for it, allocate 2nd new malloc'd copy. */
1776 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, name
,
1777 O_RDONLY
| O_BINARY
, &absolute_name
);
1778 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1781 char *exename
= alloca (strlen (name
) + 5);
1783 strcat (strcpy (exename
, name
), ".exe");
1784 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
1785 O_RDONLY
| O_BINARY
, &absolute_name
);
1790 make_cleanup (xfree
, name
);
1791 perror_with_name (name
);
1795 name
= absolute_name
;
1796 make_cleanup (xfree
, name
);
1798 sym_bfd
= gdb_bfd_open (name
, gnutarget
, desc
);
1801 make_cleanup (xfree
, name
);
1802 error (_("`%s': can't open to read symbols: %s."), name
,
1803 bfd_errmsg (bfd_get_error ()));
1805 bfd_set_cacheable (sym_bfd
, 1);
1807 if (!bfd_check_format (sym_bfd
, bfd_object
))
1809 make_cleanup_bfd_unref (sym_bfd
);
1810 error (_("`%s': can't read symbols: %s."), name
,
1811 bfd_errmsg (bfd_get_error ()));
1817 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1818 the section was not found. */
1821 get_section_index (struct objfile
*objfile
, char *section_name
)
1823 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1831 /* Link SF into the global symtab_fns list. Called on startup by the
1832 _initialize routine in each object file format reader, to register
1833 information about each format the reader is prepared to handle. */
1836 add_symtab_fns (const struct sym_fns
*sf
)
1838 VEC_safe_push (sym_fns_ptr
, symtab_fns
, sf
);
1841 /* Initialize OBJFILE to read symbols from its associated BFD. It
1842 either returns or calls error(). The result is an initialized
1843 struct sym_fns in the objfile structure, that contains cached
1844 information about the symbol file. */
1846 static const struct sym_fns
*
1847 find_sym_fns (bfd
*abfd
)
1849 const struct sym_fns
*sf
;
1850 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1853 if (our_flavour
== bfd_target_srec_flavour
1854 || our_flavour
== bfd_target_ihex_flavour
1855 || our_flavour
== bfd_target_tekhex_flavour
)
1856 return NULL
; /* No symbols. */
1858 for (i
= 0; VEC_iterate (sym_fns_ptr
, symtab_fns
, i
, sf
); ++i
)
1859 if (our_flavour
== sf
->sym_flavour
)
1862 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1863 bfd_get_target (abfd
));
1867 /* This function runs the load command of our current target. */
1870 load_command (char *arg
, int from_tty
)
1874 /* The user might be reloading because the binary has changed. Take
1875 this opportunity to check. */
1876 reopen_exec_file ();
1884 parg
= arg
= get_exec_file (1);
1886 /* Count how many \ " ' tab space there are in the name. */
1887 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1895 /* We need to quote this string so buildargv can pull it apart. */
1896 char *temp
= xmalloc (strlen (arg
) + count
+ 1 );
1900 make_cleanup (xfree
, temp
);
1903 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1905 strncpy (ptemp
, prev
, parg
- prev
);
1906 ptemp
+= parg
- prev
;
1910 strcpy (ptemp
, prev
);
1916 target_load (arg
, from_tty
);
1918 /* After re-loading the executable, we don't really know which
1919 overlays are mapped any more. */
1920 overlay_cache_invalid
= 1;
1923 /* This version of "load" should be usable for any target. Currently
1924 it is just used for remote targets, not inftarg.c or core files,
1925 on the theory that only in that case is it useful.
1927 Avoiding xmodem and the like seems like a win (a) because we don't have
1928 to worry about finding it, and (b) On VMS, fork() is very slow and so
1929 we don't want to run a subprocess. On the other hand, I'm not sure how
1930 performance compares. */
1932 static int validate_download
= 0;
1934 /* Callback service function for generic_load (bfd_map_over_sections). */
1937 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1939 bfd_size_type
*sum
= data
;
1941 *sum
+= bfd_get_section_size (asec
);
1944 /* Opaque data for load_section_callback. */
1945 struct load_section_data
{
1946 unsigned long load_offset
;
1947 struct load_progress_data
*progress_data
;
1948 VEC(memory_write_request_s
) *requests
;
1951 /* Opaque data for load_progress. */
1952 struct load_progress_data
{
1953 /* Cumulative data. */
1954 unsigned long write_count
;
1955 unsigned long data_count
;
1956 bfd_size_type total_size
;
1959 /* Opaque data for load_progress for a single section. */
1960 struct load_progress_section_data
{
1961 struct load_progress_data
*cumulative
;
1963 /* Per-section data. */
1964 const char *section_name
;
1965 ULONGEST section_sent
;
1966 ULONGEST section_size
;
1971 /* Target write callback routine for progress reporting. */
1974 load_progress (ULONGEST bytes
, void *untyped_arg
)
1976 struct load_progress_section_data
*args
= untyped_arg
;
1977 struct load_progress_data
*totals
;
1980 /* Writing padding data. No easy way to get at the cumulative
1981 stats, so just ignore this. */
1984 totals
= args
->cumulative
;
1986 if (bytes
== 0 && args
->section_sent
== 0)
1988 /* The write is just starting. Let the user know we've started
1990 ui_out_message (current_uiout
, 0, "Loading section %s, size %s lma %s\n",
1991 args
->section_name
, hex_string (args
->section_size
),
1992 paddress (target_gdbarch (), args
->lma
));
1996 if (validate_download
)
1998 /* Broken memories and broken monitors manifest themselves here
1999 when bring new computers to life. This doubles already slow
2001 /* NOTE: cagney/1999-10-18: A more efficient implementation
2002 might add a verify_memory() method to the target vector and
2003 then use that. remote.c could implement that method using
2004 the ``qCRC'' packet. */
2005 gdb_byte
*check
= xmalloc (bytes
);
2006 struct cleanup
*verify_cleanups
= make_cleanup (xfree
, check
);
2008 if (target_read_memory (args
->lma
, check
, bytes
) != 0)
2009 error (_("Download verify read failed at %s"),
2010 paddress (target_gdbarch (), args
->lma
));
2011 if (memcmp (args
->buffer
, check
, bytes
) != 0)
2012 error (_("Download verify compare failed at %s"),
2013 paddress (target_gdbarch (), args
->lma
));
2014 do_cleanups (verify_cleanups
);
2016 totals
->data_count
+= bytes
;
2018 args
->buffer
+= bytes
;
2019 totals
->write_count
+= 1;
2020 args
->section_sent
+= bytes
;
2021 if (check_quit_flag ()
2022 || (deprecated_ui_load_progress_hook
!= NULL
2023 && deprecated_ui_load_progress_hook (args
->section_name
,
2024 args
->section_sent
)))
2025 error (_("Canceled the download"));
2027 if (deprecated_show_load_progress
!= NULL
)
2028 deprecated_show_load_progress (args
->section_name
,
2032 totals
->total_size
);
2035 /* Callback service function for generic_load (bfd_map_over_sections). */
2038 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
2040 struct memory_write_request
*new_request
;
2041 struct load_section_data
*args
= data
;
2042 struct load_progress_section_data
*section_data
;
2043 bfd_size_type size
= bfd_get_section_size (asec
);
2045 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
2047 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
2053 new_request
= VEC_safe_push (memory_write_request_s
,
2054 args
->requests
, NULL
);
2055 memset (new_request
, 0, sizeof (struct memory_write_request
));
2056 section_data
= xcalloc (1, sizeof (struct load_progress_section_data
));
2057 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
2058 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size
2060 new_request
->data
= xmalloc (size
);
2061 new_request
->baton
= section_data
;
2063 buffer
= new_request
->data
;
2065 section_data
->cumulative
= args
->progress_data
;
2066 section_data
->section_name
= sect_name
;
2067 section_data
->section_size
= size
;
2068 section_data
->lma
= new_request
->begin
;
2069 section_data
->buffer
= buffer
;
2071 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2074 /* Clean up an entire memory request vector, including load
2075 data and progress records. */
2078 clear_memory_write_data (void *arg
)
2080 VEC(memory_write_request_s
) **vec_p
= arg
;
2081 VEC(memory_write_request_s
) *vec
= *vec_p
;
2083 struct memory_write_request
*mr
;
2085 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
2090 VEC_free (memory_write_request_s
, vec
);
2094 generic_load (char *args
, int from_tty
)
2097 struct timeval start_time
, end_time
;
2099 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, 0);
2100 struct load_section_data cbdata
;
2101 struct load_progress_data total_progress
;
2102 struct ui_out
*uiout
= current_uiout
;
2107 memset (&cbdata
, 0, sizeof (cbdata
));
2108 memset (&total_progress
, 0, sizeof (total_progress
));
2109 cbdata
.progress_data
= &total_progress
;
2111 make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
2114 error_no_arg (_("file to load"));
2116 argv
= gdb_buildargv (args
);
2117 make_cleanup_freeargv (argv
);
2119 filename
= tilde_expand (argv
[0]);
2120 make_cleanup (xfree
, filename
);
2122 if (argv
[1] != NULL
)
2126 cbdata
.load_offset
= strtoul (argv
[1], &endptr
, 0);
2128 /* If the last word was not a valid number then
2129 treat it as a file name with spaces in. */
2130 if (argv
[1] == endptr
)
2131 error (_("Invalid download offset:%s."), argv
[1]);
2133 if (argv
[2] != NULL
)
2134 error (_("Too many parameters."));
2137 /* Open the file for loading. */
2138 loadfile_bfd
= gdb_bfd_open (filename
, gnutarget
, -1);
2139 if (loadfile_bfd
== NULL
)
2141 perror_with_name (filename
);
2145 make_cleanup_bfd_unref (loadfile_bfd
);
2147 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
2149 error (_("\"%s\" is not an object file: %s"), filename
,
2150 bfd_errmsg (bfd_get_error ()));
2153 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
2154 (void *) &total_progress
.total_size
);
2156 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
2158 gettimeofday (&start_time
, NULL
);
2160 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2161 load_progress
) != 0)
2162 error (_("Load failed"));
2164 gettimeofday (&end_time
, NULL
);
2166 entry
= bfd_get_start_address (loadfile_bfd
);
2167 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2168 ui_out_text (uiout
, "Start address ");
2169 ui_out_field_fmt (uiout
, "address", "%s", paddress (target_gdbarch (), entry
));
2170 ui_out_text (uiout
, ", load size ");
2171 ui_out_field_fmt (uiout
, "load-size", "%lu", total_progress
.data_count
);
2172 ui_out_text (uiout
, "\n");
2173 /* We were doing this in remote-mips.c, I suspect it is right
2174 for other targets too. */
2175 regcache_write_pc (get_current_regcache (), entry
);
2177 /* Reset breakpoints, now that we have changed the load image. For
2178 instance, breakpoints may have been set (or reset, by
2179 post_create_inferior) while connected to the target but before we
2180 loaded the program. In that case, the prologue analyzer could
2181 have read instructions from the target to find the right
2182 breakpoint locations. Loading has changed the contents of that
2185 breakpoint_re_set ();
2187 /* FIXME: are we supposed to call symbol_file_add or not? According
2188 to a comment from remote-mips.c (where a call to symbol_file_add
2189 was commented out), making the call confuses GDB if more than one
2190 file is loaded in. Some targets do (e.g., remote-vx.c) but
2191 others don't (or didn't - perhaps they have all been deleted). */
2193 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2194 total_progress
.write_count
,
2195 &start_time
, &end_time
);
2197 do_cleanups (old_cleanups
);
2200 /* Report how fast the transfer went. */
2203 print_transfer_performance (struct ui_file
*stream
,
2204 unsigned long data_count
,
2205 unsigned long write_count
,
2206 const struct timeval
*start_time
,
2207 const struct timeval
*end_time
)
2209 ULONGEST time_count
;
2210 struct ui_out
*uiout
= current_uiout
;
2212 /* Compute the elapsed time in milliseconds, as a tradeoff between
2213 accuracy and overflow. */
2214 time_count
= (end_time
->tv_sec
- start_time
->tv_sec
) * 1000;
2215 time_count
+= (end_time
->tv_usec
- start_time
->tv_usec
) / 1000;
2217 ui_out_text (uiout
, "Transfer rate: ");
2220 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / time_count
;
2222 if (ui_out_is_mi_like_p (uiout
))
2224 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
* 8);
2225 ui_out_text (uiout
, " bits/sec");
2227 else if (rate
< 1024)
2229 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
);
2230 ui_out_text (uiout
, " bytes/sec");
2234 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
/ 1024);
2235 ui_out_text (uiout
, " KB/sec");
2240 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
2241 ui_out_text (uiout
, " bits in <1 sec");
2243 if (write_count
> 0)
2245 ui_out_text (uiout
, ", ");
2246 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
2247 ui_out_text (uiout
, " bytes/write");
2249 ui_out_text (uiout
, ".\n");
2252 /* This function allows the addition of incrementally linked object files.
2253 It does not modify any state in the target, only in the debugger. */
2254 /* Note: ezannoni 2000-04-13 This function/command used to have a
2255 special case syntax for the rombug target (Rombug is the boot
2256 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2257 rombug case, the user doesn't need to supply a text address,
2258 instead a call to target_link() (in target.c) would supply the
2259 value to use. We are now discontinuing this type of ad hoc syntax. */
2262 add_symbol_file_command (char *args
, int from_tty
)
2264 struct gdbarch
*gdbarch
= get_current_arch ();
2265 char *filename
= NULL
;
2266 int flags
= OBJF_USERLOADED
;
2268 int section_index
= 0;
2272 int expecting_sec_name
= 0;
2273 int expecting_sec_addr
= 0;
2282 struct section_addr_info
*section_addrs
;
2283 struct sect_opt
*sect_opts
= NULL
;
2284 size_t num_sect_opts
= 0;
2285 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2288 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
2289 * sizeof (struct sect_opt
));
2294 error (_("add-symbol-file takes a file name and an address"));
2296 argv
= gdb_buildargv (args
);
2297 make_cleanup_freeargv (argv
);
2299 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2301 /* Process the argument. */
2304 /* The first argument is the file name. */
2305 filename
= tilde_expand (arg
);
2306 make_cleanup (xfree
, filename
);
2311 /* The second argument is always the text address at which
2312 to load the program. */
2313 sect_opts
[section_index
].name
= ".text";
2314 sect_opts
[section_index
].value
= arg
;
2315 if (++section_index
>= num_sect_opts
)
2318 sect_opts
= ((struct sect_opt
*)
2319 xrealloc (sect_opts
,
2321 * sizeof (struct sect_opt
)));
2326 /* It's an option (starting with '-') or it's an argument
2331 if (strcmp (arg
, "-readnow") == 0)
2332 flags
|= OBJF_READNOW
;
2333 else if (strcmp (arg
, "-s") == 0)
2335 expecting_sec_name
= 1;
2336 expecting_sec_addr
= 1;
2341 if (expecting_sec_name
)
2343 sect_opts
[section_index
].name
= arg
;
2344 expecting_sec_name
= 0;
2347 if (expecting_sec_addr
)
2349 sect_opts
[section_index
].value
= arg
;
2350 expecting_sec_addr
= 0;
2351 if (++section_index
>= num_sect_opts
)
2354 sect_opts
= ((struct sect_opt
*)
2355 xrealloc (sect_opts
,
2357 * sizeof (struct sect_opt
)));
2361 error (_("USAGE: add-symbol-file <filename> <textaddress>"
2362 " [-readnow] [-s <secname> <addr>]*"));
2367 /* This command takes at least two arguments. The first one is a
2368 filename, and the second is the address where this file has been
2369 loaded. Abort now if this address hasn't been provided by the
2371 if (section_index
< 1)
2372 error (_("The address where %s has been loaded is missing"), filename
);
2374 /* Print the prompt for the query below. And save the arguments into
2375 a sect_addr_info structure to be passed around to other
2376 functions. We have to split this up into separate print
2377 statements because hex_string returns a local static
2380 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
2381 section_addrs
= alloc_section_addr_info (section_index
);
2382 make_cleanup (xfree
, section_addrs
);
2383 for (i
= 0; i
< section_index
; i
++)
2386 char *val
= sect_opts
[i
].value
;
2387 char *sec
= sect_opts
[i
].name
;
2389 addr
= parse_and_eval_address (val
);
2391 /* Here we store the section offsets in the order they were
2392 entered on the command line. */
2393 section_addrs
->other
[sec_num
].name
= sec
;
2394 section_addrs
->other
[sec_num
].addr
= addr
;
2395 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2396 paddress (gdbarch
, addr
));
2399 /* The object's sections are initialized when a
2400 call is made to build_objfile_section_table (objfile).
2401 This happens in reread_symbols.
2402 At this point, we don't know what file type this is,
2403 so we can't determine what section names are valid. */
2406 if (from_tty
&& (!query ("%s", "")))
2407 error (_("Not confirmed."));
2409 symbol_file_add (filename
, from_tty
? SYMFILE_VERBOSE
: 0,
2410 section_addrs
, flags
);
2412 /* Getting new symbols may change our opinion about what is
2414 reinit_frame_cache ();
2415 do_cleanups (my_cleanups
);
2419 typedef struct objfile
*objfilep
;
2421 DEF_VEC_P (objfilep
);
2423 /* Re-read symbols if a symbol-file has changed. */
2425 reread_symbols (void)
2427 struct objfile
*objfile
;
2429 struct stat new_statbuf
;
2431 VEC (objfilep
) *new_objfiles
= NULL
;
2432 struct cleanup
*all_cleanups
;
2434 all_cleanups
= make_cleanup (VEC_cleanup (objfilep
), &new_objfiles
);
2436 /* With the addition of shared libraries, this should be modified,
2437 the load time should be saved in the partial symbol tables, since
2438 different tables may come from different source files. FIXME.
2439 This routine should then walk down each partial symbol table
2440 and see if the symbol table that it originates from has been changed. */
2442 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2444 /* solib-sunos.c creates one objfile with obfd. */
2445 if (objfile
->obfd
== NULL
)
2448 /* Separate debug objfiles are handled in the main objfile. */
2449 if (objfile
->separate_debug_objfile_backlink
)
2452 /* If this object is from an archive (what you usually create with
2453 `ar', often called a `static library' on most systems, though
2454 a `shared library' on AIX is also an archive), then you should
2455 stat on the archive name, not member name. */
2456 if (objfile
->obfd
->my_archive
)
2457 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2459 res
= stat (objfile
->name
, &new_statbuf
);
2462 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2463 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2467 new_modtime
= new_statbuf
.st_mtime
;
2468 if (new_modtime
!= objfile
->mtime
)
2470 struct cleanup
*old_cleanups
;
2471 struct section_offsets
*offsets
;
2473 char *obfd_filename
;
2475 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2478 /* There are various functions like symbol_file_add,
2479 symfile_bfd_open, syms_from_objfile, etc., which might
2480 appear to do what we want. But they have various other
2481 effects which we *don't* want. So we just do stuff
2482 ourselves. We don't worry about mapped files (for one thing,
2483 any mapped file will be out of date). */
2485 /* If we get an error, blow away this objfile (not sure if
2486 that is the correct response for things like shared
2488 old_cleanups
= make_cleanup_free_objfile (objfile
);
2489 /* We need to do this whenever any symbols go away. */
2490 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2492 if (exec_bfd
!= NULL
2493 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2494 bfd_get_filename (exec_bfd
)) == 0)
2496 /* Reload EXEC_BFD without asking anything. */
2498 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2501 /* Keep the calls order approx. the same as in free_objfile. */
2503 /* Free the separate debug objfiles. It will be
2504 automatically recreated by sym_read. */
2505 free_objfile_separate_debug (objfile
);
2507 /* Remove any references to this objfile in the global
2509 preserve_values (objfile
);
2511 /* Nuke all the state that we will re-read. Much of the following
2512 code which sets things to NULL really is necessary to tell
2513 other parts of GDB that there is nothing currently there.
2515 Try to keep the freeing order compatible with free_objfile. */
2517 if (objfile
->sf
!= NULL
)
2519 (*objfile
->sf
->sym_finish
) (objfile
);
2522 clear_objfile_data (objfile
);
2524 /* Clean up any state BFD has sitting around. */
2526 struct bfd
*obfd
= objfile
->obfd
;
2528 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2529 /* Open the new BFD before freeing the old one, so that
2530 the filename remains live. */
2531 objfile
->obfd
= gdb_bfd_open_maybe_remote (obfd_filename
);
2532 if (objfile
->obfd
== NULL
)
2534 /* We have to make a cleanup and error here, rather
2535 than erroring later, because once we unref OBFD,
2536 OBFD_FILENAME will be freed. */
2537 make_cleanup_bfd_unref (obfd
);
2538 error (_("Can't open %s to read symbols."), obfd_filename
);
2540 gdb_bfd_unref (obfd
);
2543 objfile
->name
= bfd_get_filename (objfile
->obfd
);
2544 /* bfd_openr sets cacheable to true, which is what we want. */
2545 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2546 error (_("Can't read symbols from %s: %s."), objfile
->name
,
2547 bfd_errmsg (bfd_get_error ()));
2549 /* Save the offsets, we will nuke them with the rest of the
2551 num_offsets
= objfile
->num_sections
;
2552 offsets
= ((struct section_offsets
*)
2553 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2554 memcpy (offsets
, objfile
->section_offsets
,
2555 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2557 /* FIXME: Do we have to free a whole linked list, or is this
2559 if (objfile
->global_psymbols
.list
)
2560 xfree (objfile
->global_psymbols
.list
);
2561 memset (&objfile
->global_psymbols
, 0,
2562 sizeof (objfile
->global_psymbols
));
2563 if (objfile
->static_psymbols
.list
)
2564 xfree (objfile
->static_psymbols
.list
);
2565 memset (&objfile
->static_psymbols
, 0,
2566 sizeof (objfile
->static_psymbols
));
2568 /* Free the obstacks for non-reusable objfiles. */
2569 psymbol_bcache_free (objfile
->psymbol_cache
);
2570 objfile
->psymbol_cache
= psymbol_bcache_init ();
2571 if (objfile
->demangled_names_hash
!= NULL
)
2573 htab_delete (objfile
->demangled_names_hash
);
2574 objfile
->demangled_names_hash
= NULL
;
2576 obstack_free (&objfile
->objfile_obstack
, 0);
2577 objfile
->sections
= NULL
;
2578 objfile
->symtabs
= NULL
;
2579 objfile
->psymtabs
= NULL
;
2580 objfile
->psymtabs_addrmap
= NULL
;
2581 objfile
->free_psymtabs
= NULL
;
2582 objfile
->template_symbols
= NULL
;
2583 objfile
->msymbols
= NULL
;
2584 objfile
->minimal_symbol_count
= 0;
2585 memset (&objfile
->msymbol_hash
, 0,
2586 sizeof (objfile
->msymbol_hash
));
2587 memset (&objfile
->msymbol_demangled_hash
, 0,
2588 sizeof (objfile
->msymbol_demangled_hash
));
2590 set_objfile_per_bfd (objfile
);
2592 /* obstack_init also initializes the obstack so it is
2593 empty. We could use obstack_specify_allocation but
2594 gdb_obstack.h specifies the alloc/dealloc functions. */
2595 obstack_init (&objfile
->objfile_obstack
);
2596 build_objfile_section_table (objfile
);
2597 terminate_minimal_symbol_table (objfile
);
2599 /* We use the same section offsets as from last time. I'm not
2600 sure whether that is always correct for shared libraries. */
2601 objfile
->section_offsets
= (struct section_offsets
*)
2602 obstack_alloc (&objfile
->objfile_obstack
,
2603 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2604 memcpy (objfile
->section_offsets
, offsets
,
2605 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2606 objfile
->num_sections
= num_offsets
;
2608 /* What the hell is sym_new_init for, anyway? The concept of
2609 distinguishing between the main file and additional files
2610 in this way seems rather dubious. */
2611 if (objfile
== symfile_objfile
)
2613 (*objfile
->sf
->sym_new_init
) (objfile
);
2616 (*objfile
->sf
->sym_init
) (objfile
);
2617 clear_complaints (&symfile_complaints
, 1, 1);
2619 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2620 read_symbols (objfile
, 0);
2622 if (!objfile_has_symbols (objfile
))
2625 printf_unfiltered (_("(no debugging symbols found)\n"));
2629 /* We're done reading the symbol file; finish off complaints. */
2630 clear_complaints (&symfile_complaints
, 0, 1);
2632 /* Getting new symbols may change our opinion about what is
2635 reinit_frame_cache ();
2637 /* Discard cleanups as symbol reading was successful. */
2638 discard_cleanups (old_cleanups
);
2640 /* If the mtime has changed between the time we set new_modtime
2641 and now, we *want* this to be out of date, so don't call stat
2643 objfile
->mtime
= new_modtime
;
2644 init_entry_point_info (objfile
);
2646 VEC_safe_push (objfilep
, new_objfiles
, objfile
);
2654 /* Notify objfiles that we've modified objfile sections. */
2655 objfiles_changed ();
2657 clear_symtab_users (0);
2659 /* clear_objfile_data for each objfile was called before freeing it and
2660 observer_notify_new_objfile (NULL) has been called by
2661 clear_symtab_users above. Notify the new files now. */
2662 for (ix
= 0; VEC_iterate (objfilep
, new_objfiles
, ix
, objfile
); ix
++)
2663 observer_notify_new_objfile (objfile
);
2665 /* At least one objfile has changed, so we can consider that
2666 the executable we're debugging has changed too. */
2667 observer_notify_executable_changed ();
2670 do_cleanups (all_cleanups
);
2682 static filename_language
*filename_language_table
;
2683 static int fl_table_size
, fl_table_next
;
2686 add_filename_language (char *ext
, enum language lang
)
2688 if (fl_table_next
>= fl_table_size
)
2690 fl_table_size
+= 10;
2691 filename_language_table
=
2692 xrealloc (filename_language_table
,
2693 fl_table_size
* sizeof (*filename_language_table
));
2696 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2697 filename_language_table
[fl_table_next
].lang
= lang
;
2701 static char *ext_args
;
2703 show_ext_args (struct ui_file
*file
, int from_tty
,
2704 struct cmd_list_element
*c
, const char *value
)
2706 fprintf_filtered (file
,
2707 _("Mapping between filename extension "
2708 "and source language is \"%s\".\n"),
2713 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2716 char *cp
= ext_args
;
2719 /* First arg is filename extension, starting with '.' */
2721 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2723 /* Find end of first arg. */
2724 while (*cp
&& !isspace (*cp
))
2728 error (_("'%s': two arguments required -- "
2729 "filename extension and language"),
2732 /* Null-terminate first arg. */
2735 /* Find beginning of second arg, which should be a source language. */
2736 while (*cp
&& isspace (*cp
))
2740 error (_("'%s': two arguments required -- "
2741 "filename extension and language"),
2744 /* Lookup the language from among those we know. */
2745 lang
= language_enum (cp
);
2747 /* Now lookup the filename extension: do we already know it? */
2748 for (i
= 0; i
< fl_table_next
; i
++)
2749 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2752 if (i
>= fl_table_next
)
2754 /* New file extension. */
2755 add_filename_language (ext_args
, lang
);
2759 /* Redefining a previously known filename extension. */
2762 /* query ("Really make files of type %s '%s'?", */
2763 /* ext_args, language_str (lang)); */
2765 xfree (filename_language_table
[i
].ext
);
2766 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2767 filename_language_table
[i
].lang
= lang
;
2772 info_ext_lang_command (char *args
, int from_tty
)
2776 printf_filtered (_("Filename extensions and the languages they represent:"));
2777 printf_filtered ("\n\n");
2778 for (i
= 0; i
< fl_table_next
; i
++)
2779 printf_filtered ("\t%s\t- %s\n",
2780 filename_language_table
[i
].ext
,
2781 language_str (filename_language_table
[i
].lang
));
2785 init_filename_language_table (void)
2787 if (fl_table_size
== 0) /* Protect against repetition. */
2791 filename_language_table
=
2792 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2793 add_filename_language (".c", language_c
);
2794 add_filename_language (".d", language_d
);
2795 add_filename_language (".C", language_cplus
);
2796 add_filename_language (".cc", language_cplus
);
2797 add_filename_language (".cp", language_cplus
);
2798 add_filename_language (".cpp", language_cplus
);
2799 add_filename_language (".cxx", language_cplus
);
2800 add_filename_language (".c++", language_cplus
);
2801 add_filename_language (".java", language_java
);
2802 add_filename_language (".class", language_java
);
2803 add_filename_language (".m", language_objc
);
2804 add_filename_language (".f", language_fortran
);
2805 add_filename_language (".F", language_fortran
);
2806 add_filename_language (".for", language_fortran
);
2807 add_filename_language (".FOR", language_fortran
);
2808 add_filename_language (".ftn", language_fortran
);
2809 add_filename_language (".FTN", language_fortran
);
2810 add_filename_language (".fpp", language_fortran
);
2811 add_filename_language (".FPP", language_fortran
);
2812 add_filename_language (".f90", language_fortran
);
2813 add_filename_language (".F90", language_fortran
);
2814 add_filename_language (".f95", language_fortran
);
2815 add_filename_language (".F95", language_fortran
);
2816 add_filename_language (".f03", language_fortran
);
2817 add_filename_language (".F03", language_fortran
);
2818 add_filename_language (".f08", language_fortran
);
2819 add_filename_language (".F08", language_fortran
);
2820 add_filename_language (".s", language_asm
);
2821 add_filename_language (".sx", language_asm
);
2822 add_filename_language (".S", language_asm
);
2823 add_filename_language (".pas", language_pascal
);
2824 add_filename_language (".p", language_pascal
);
2825 add_filename_language (".pp", language_pascal
);
2826 add_filename_language (".adb", language_ada
);
2827 add_filename_language (".ads", language_ada
);
2828 add_filename_language (".a", language_ada
);
2829 add_filename_language (".ada", language_ada
);
2830 add_filename_language (".dg", language_ada
);
2835 deduce_language_from_filename (const char *filename
)
2840 if (filename
!= NULL
)
2841 if ((cp
= strrchr (filename
, '.')) != NULL
)
2842 for (i
= 0; i
< fl_table_next
; i
++)
2843 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2844 return filename_language_table
[i
].lang
;
2846 return language_unknown
;
2851 Allocate and partly initialize a new symbol table. Return a pointer
2852 to it. error() if no space.
2854 Caller must set these fields:
2863 allocate_symtab (const char *filename
, struct objfile
*objfile
)
2865 struct symtab
*symtab
;
2867 symtab
= (struct symtab
*)
2868 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2869 memset (symtab
, 0, sizeof (*symtab
));
2870 symtab
->filename
= (char *) bcache (filename
, strlen (filename
) + 1,
2871 objfile
->per_bfd
->filename_cache
);
2872 symtab
->fullname
= NULL
;
2873 symtab
->language
= deduce_language_from_filename (filename
);
2874 symtab
->debugformat
= "unknown";
2876 /* Hook it to the objfile it comes from. */
2878 symtab
->objfile
= objfile
;
2879 symtab
->next
= objfile
->symtabs
;
2880 objfile
->symtabs
= symtab
;
2882 if (symtab_create_debug
)
2884 /* Be a bit clever with debugging messages, and don't print objfile
2885 every time, only when it changes. */
2886 static char *last_objfile_name
= NULL
;
2888 if (last_objfile_name
== NULL
2889 || strcmp (last_objfile_name
, objfile
->name
) != 0)
2891 xfree (last_objfile_name
);
2892 last_objfile_name
= xstrdup (objfile
->name
);
2893 fprintf_unfiltered (gdb_stdlog
,
2894 "Creating one or more symtabs for objfile %s ...\n",
2897 fprintf_unfiltered (gdb_stdlog
,
2898 "Created symtab %s for module %s.\n",
2899 host_address_to_string (symtab
), filename
);
2906 /* Reset all data structures in gdb which may contain references to symbol
2907 table data. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
2910 clear_symtab_users (int add_flags
)
2912 /* Someday, we should do better than this, by only blowing away
2913 the things that really need to be blown. */
2915 /* Clear the "current" symtab first, because it is no longer valid.
2916 breakpoint_re_set may try to access the current symtab. */
2917 clear_current_source_symtab_and_line ();
2920 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2921 breakpoint_re_set ();
2922 clear_last_displayed_sal ();
2923 clear_pc_function_cache ();
2924 observer_notify_new_objfile (NULL
);
2926 /* Clear globals which might have pointed into a removed objfile.
2927 FIXME: It's not clear which of these are supposed to persist
2928 between expressions and which ought to be reset each time. */
2929 expression_context_block
= NULL
;
2930 innermost_block
= NULL
;
2932 /* Varobj may refer to old symbols, perform a cleanup. */
2933 varobj_invalidate ();
2938 clear_symtab_users_cleanup (void *ignore
)
2940 clear_symtab_users (0);
2944 The following code implements an abstraction for debugging overlay sections.
2946 The target model is as follows:
2947 1) The gnu linker will permit multiple sections to be mapped into the
2948 same VMA, each with its own unique LMA (or load address).
2949 2) It is assumed that some runtime mechanism exists for mapping the
2950 sections, one by one, from the load address into the VMA address.
2951 3) This code provides a mechanism for gdb to keep track of which
2952 sections should be considered to be mapped from the VMA to the LMA.
2953 This information is used for symbol lookup, and memory read/write.
2954 For instance, if a section has been mapped then its contents
2955 should be read from the VMA, otherwise from the LMA.
2957 Two levels of debugger support for overlays are available. One is
2958 "manual", in which the debugger relies on the user to tell it which
2959 overlays are currently mapped. This level of support is
2960 implemented entirely in the core debugger, and the information about
2961 whether a section is mapped is kept in the objfile->obj_section table.
2963 The second level of support is "automatic", and is only available if
2964 the target-specific code provides functionality to read the target's
2965 overlay mapping table, and translate its contents for the debugger
2966 (by updating the mapped state information in the obj_section tables).
2968 The interface is as follows:
2970 overlay map <name> -- tell gdb to consider this section mapped
2971 overlay unmap <name> -- tell gdb to consider this section unmapped
2972 overlay list -- list the sections that GDB thinks are mapped
2973 overlay read-target -- get the target's state of what's mapped
2974 overlay off/manual/auto -- set overlay debugging state
2975 Functional interface:
2976 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2977 section, return that section.
2978 find_pc_overlay(pc): find any overlay section that contains
2979 the pc, either in its VMA or its LMA
2980 section_is_mapped(sect): true if overlay is marked as mapped
2981 section_is_overlay(sect): true if section's VMA != LMA
2982 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2983 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2984 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2985 overlay_mapped_address(...): map an address from section's LMA to VMA
2986 overlay_unmapped_address(...): map an address from section's VMA to LMA
2987 symbol_overlayed_address(...): Return a "current" address for symbol:
2988 either in VMA or LMA depending on whether
2989 the symbol's section is currently mapped. */
2991 /* Overlay debugging state: */
2993 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2994 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2996 /* Function: section_is_overlay (SECTION)
2997 Returns true if SECTION has VMA not equal to LMA, ie.
2998 SECTION is loaded at an address different from where it will "run". */
3001 section_is_overlay (struct obj_section
*section
)
3003 if (overlay_debugging
&& section
)
3005 bfd
*abfd
= section
->objfile
->obfd
;
3006 asection
*bfd_section
= section
->the_bfd_section
;
3008 if (bfd_section_lma (abfd
, bfd_section
) != 0
3009 && bfd_section_lma (abfd
, bfd_section
)
3010 != bfd_section_vma (abfd
, bfd_section
))
3017 /* Function: overlay_invalidate_all (void)
3018 Invalidate the mapped state of all overlay sections (mark it as stale). */
3021 overlay_invalidate_all (void)
3023 struct objfile
*objfile
;
3024 struct obj_section
*sect
;
3026 ALL_OBJSECTIONS (objfile
, sect
)
3027 if (section_is_overlay (sect
))
3028 sect
->ovly_mapped
= -1;
3031 /* Function: section_is_mapped (SECTION)
3032 Returns true if section is an overlay, and is currently mapped.
3034 Access to the ovly_mapped flag is restricted to this function, so
3035 that we can do automatic update. If the global flag
3036 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3037 overlay_invalidate_all. If the mapped state of the particular
3038 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3041 section_is_mapped (struct obj_section
*osect
)
3043 struct gdbarch
*gdbarch
;
3045 if (osect
== 0 || !section_is_overlay (osect
))
3048 switch (overlay_debugging
)
3052 return 0; /* overlay debugging off */
3053 case ovly_auto
: /* overlay debugging automatic */
3054 /* Unles there is a gdbarch_overlay_update function,
3055 there's really nothing useful to do here (can't really go auto). */
3056 gdbarch
= get_objfile_arch (osect
->objfile
);
3057 if (gdbarch_overlay_update_p (gdbarch
))
3059 if (overlay_cache_invalid
)
3061 overlay_invalidate_all ();
3062 overlay_cache_invalid
= 0;
3064 if (osect
->ovly_mapped
== -1)
3065 gdbarch_overlay_update (gdbarch
, osect
);
3067 /* fall thru to manual case */
3068 case ovly_on
: /* overlay debugging manual */
3069 return osect
->ovly_mapped
== 1;
3073 /* Function: pc_in_unmapped_range
3074 If PC falls into the lma range of SECTION, return true, else false. */
3077 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3079 if (section_is_overlay (section
))
3081 bfd
*abfd
= section
->objfile
->obfd
;
3082 asection
*bfd_section
= section
->the_bfd_section
;
3084 /* We assume the LMA is relocated by the same offset as the VMA. */
3085 bfd_vma size
= bfd_get_section_size (bfd_section
);
3086 CORE_ADDR offset
= obj_section_offset (section
);
3088 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3089 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3096 /* Function: pc_in_mapped_range
3097 If PC falls into the vma range of SECTION, return true, else false. */
3100 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3102 if (section_is_overlay (section
))
3104 if (obj_section_addr (section
) <= pc
3105 && pc
< obj_section_endaddr (section
))
3113 /* Return true if the mapped ranges of sections A and B overlap, false
3116 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3118 CORE_ADDR a_start
= obj_section_addr (a
);
3119 CORE_ADDR a_end
= obj_section_endaddr (a
);
3120 CORE_ADDR b_start
= obj_section_addr (b
);
3121 CORE_ADDR b_end
= obj_section_endaddr (b
);
3123 return (a_start
< b_end
&& b_start
< a_end
);
3126 /* Function: overlay_unmapped_address (PC, SECTION)
3127 Returns the address corresponding to PC in the unmapped (load) range.
3128 May be the same as PC. */
3131 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3133 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3135 bfd
*abfd
= section
->objfile
->obfd
;
3136 asection
*bfd_section
= section
->the_bfd_section
;
3138 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3139 - bfd_section_vma (abfd
, bfd_section
);
3145 /* Function: overlay_mapped_address (PC, SECTION)
3146 Returns the address corresponding to PC in the mapped (runtime) range.
3147 May be the same as PC. */
3150 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3152 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3154 bfd
*abfd
= section
->objfile
->obfd
;
3155 asection
*bfd_section
= section
->the_bfd_section
;
3157 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3158 - bfd_section_lma (abfd
, bfd_section
);
3165 /* Function: symbol_overlayed_address
3166 Return one of two addresses (relative to the VMA or to the LMA),
3167 depending on whether the section is mapped or not. */
3170 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3172 if (overlay_debugging
)
3174 /* If the symbol has no section, just return its regular address. */
3177 /* If the symbol's section is not an overlay, just return its
3179 if (!section_is_overlay (section
))
3181 /* If the symbol's section is mapped, just return its address. */
3182 if (section_is_mapped (section
))
3185 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3186 * then return its LOADED address rather than its vma address!!
3188 return overlay_unmapped_address (address
, section
);
3193 /* Function: find_pc_overlay (PC)
3194 Return the best-match overlay section for PC:
3195 If PC matches a mapped overlay section's VMA, return that section.
3196 Else if PC matches an unmapped section's VMA, return that section.
3197 Else if PC matches an unmapped section's LMA, return that section. */
3199 struct obj_section
*
3200 find_pc_overlay (CORE_ADDR pc
)
3202 struct objfile
*objfile
;
3203 struct obj_section
*osect
, *best_match
= NULL
;
3205 if (overlay_debugging
)
3206 ALL_OBJSECTIONS (objfile
, osect
)
3207 if (section_is_overlay (osect
))
3209 if (pc_in_mapped_range (pc
, osect
))
3211 if (section_is_mapped (osect
))
3216 else if (pc_in_unmapped_range (pc
, osect
))
3222 /* Function: find_pc_mapped_section (PC)
3223 If PC falls into the VMA address range of an overlay section that is
3224 currently marked as MAPPED, return that section. Else return NULL. */
3226 struct obj_section
*
3227 find_pc_mapped_section (CORE_ADDR pc
)
3229 struct objfile
*objfile
;
3230 struct obj_section
*osect
;
3232 if (overlay_debugging
)
3233 ALL_OBJSECTIONS (objfile
, osect
)
3234 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3240 /* Function: list_overlays_command
3241 Print a list of mapped sections and their PC ranges. */
3244 list_overlays_command (char *args
, int from_tty
)
3247 struct objfile
*objfile
;
3248 struct obj_section
*osect
;
3250 if (overlay_debugging
)
3251 ALL_OBJSECTIONS (objfile
, osect
)
3252 if (section_is_mapped (osect
))
3254 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3259 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3260 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3261 size
= bfd_get_section_size (osect
->the_bfd_section
);
3262 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3264 printf_filtered ("Section %s, loaded at ", name
);
3265 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3266 puts_filtered (" - ");
3267 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3268 printf_filtered (", mapped at ");
3269 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3270 puts_filtered (" - ");
3271 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3272 puts_filtered ("\n");
3277 printf_filtered (_("No sections are mapped.\n"));
3280 /* Function: map_overlay_command
3281 Mark the named section as mapped (ie. residing at its VMA address). */
3284 map_overlay_command (char *args
, int from_tty
)
3286 struct objfile
*objfile
, *objfile2
;
3287 struct obj_section
*sec
, *sec2
;
3289 if (!overlay_debugging
)
3290 error (_("Overlay debugging not enabled. Use "
3291 "either the 'overlay auto' or\n"
3292 "the 'overlay manual' command."));
3294 if (args
== 0 || *args
== 0)
3295 error (_("Argument required: name of an overlay section"));
3297 /* First, find a section matching the user supplied argument. */
3298 ALL_OBJSECTIONS (objfile
, sec
)
3299 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3301 /* Now, check to see if the section is an overlay. */
3302 if (!section_is_overlay (sec
))
3303 continue; /* not an overlay section */
3305 /* Mark the overlay as "mapped". */
3306 sec
->ovly_mapped
= 1;
3308 /* Next, make a pass and unmap any sections that are
3309 overlapped by this new section: */
3310 ALL_OBJSECTIONS (objfile2
, sec2
)
3311 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3314 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3315 bfd_section_name (objfile
->obfd
,
3316 sec2
->the_bfd_section
));
3317 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3321 error (_("No overlay section called %s"), args
);
3324 /* Function: unmap_overlay_command
3325 Mark the overlay section as unmapped
3326 (ie. resident in its LMA address range, rather than the VMA range). */
3329 unmap_overlay_command (char *args
, int from_tty
)
3331 struct objfile
*objfile
;
3332 struct obj_section
*sec
;
3334 if (!overlay_debugging
)
3335 error (_("Overlay debugging not enabled. "
3336 "Use either the 'overlay auto' or\n"
3337 "the 'overlay manual' command."));
3339 if (args
== 0 || *args
== 0)
3340 error (_("Argument required: name of an overlay section"));
3342 /* First, find a section matching the user supplied argument. */
3343 ALL_OBJSECTIONS (objfile
, sec
)
3344 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3346 if (!sec
->ovly_mapped
)
3347 error (_("Section %s is not mapped"), args
);
3348 sec
->ovly_mapped
= 0;
3351 error (_("No overlay section called %s"), args
);
3354 /* Function: overlay_auto_command
3355 A utility command to turn on overlay debugging.
3356 Possibly this should be done via a set/show command. */
3359 overlay_auto_command (char *args
, int from_tty
)
3361 overlay_debugging
= ovly_auto
;
3362 enable_overlay_breakpoints ();
3364 printf_unfiltered (_("Automatic overlay debugging enabled."));
3367 /* Function: overlay_manual_command
3368 A utility command to turn on overlay debugging.
3369 Possibly this should be done via a set/show command. */
3372 overlay_manual_command (char *args
, int from_tty
)
3374 overlay_debugging
= ovly_on
;
3375 disable_overlay_breakpoints ();
3377 printf_unfiltered (_("Overlay debugging enabled."));
3380 /* Function: overlay_off_command
3381 A utility command to turn on overlay debugging.
3382 Possibly this should be done via a set/show command. */
3385 overlay_off_command (char *args
, int from_tty
)
3387 overlay_debugging
= ovly_off
;
3388 disable_overlay_breakpoints ();
3390 printf_unfiltered (_("Overlay debugging disabled."));
3394 overlay_load_command (char *args
, int from_tty
)
3396 struct gdbarch
*gdbarch
= get_current_arch ();
3398 if (gdbarch_overlay_update_p (gdbarch
))
3399 gdbarch_overlay_update (gdbarch
, NULL
);
3401 error (_("This target does not know how to read its overlay state."));
3404 /* Function: overlay_command
3405 A place-holder for a mis-typed command. */
3407 /* Command list chain containing all defined "overlay" subcommands. */
3408 static struct cmd_list_element
*overlaylist
;
3411 overlay_command (char *args
, int from_tty
)
3414 ("\"overlay\" must be followed by the name of an overlay command.\n");
3415 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3419 /* Target Overlays for the "Simplest" overlay manager:
3421 This is GDB's default target overlay layer. It works with the
3422 minimal overlay manager supplied as an example by Cygnus. The
3423 entry point is via a function pointer "gdbarch_overlay_update",
3424 so targets that use a different runtime overlay manager can
3425 substitute their own overlay_update function and take over the
3428 The overlay_update function pokes around in the target's data structures
3429 to see what overlays are mapped, and updates GDB's overlay mapping with
3432 In this simple implementation, the target data structures are as follows:
3433 unsigned _novlys; /# number of overlay sections #/
3434 unsigned _ovly_table[_novlys][4] = {
3435 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3436 {..., ..., ..., ...},
3438 unsigned _novly_regions; /# number of overlay regions #/
3439 unsigned _ovly_region_table[_novly_regions][3] = {
3440 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3443 These functions will attempt to update GDB's mappedness state in the
3444 symbol section table, based on the target's mappedness state.
3446 To do this, we keep a cached copy of the target's _ovly_table, and
3447 attempt to detect when the cached copy is invalidated. The main
3448 entry point is "simple_overlay_update(SECT), which looks up SECT in
3449 the cached table and re-reads only the entry for that section from
3450 the target (whenever possible). */
3452 /* Cached, dynamically allocated copies of the target data structures: */
3453 static unsigned (*cache_ovly_table
)[4] = 0;
3454 static unsigned cache_novlys
= 0;
3455 static CORE_ADDR cache_ovly_table_base
= 0;
3458 VMA
, SIZE
, LMA
, MAPPED
3461 /* Throw away the cached copy of _ovly_table. */
3463 simple_free_overlay_table (void)
3465 if (cache_ovly_table
)
3466 xfree (cache_ovly_table
);
3468 cache_ovly_table
= NULL
;
3469 cache_ovly_table_base
= 0;
3472 /* Read an array of ints of size SIZE from the target into a local buffer.
3473 Convert to host order. int LEN is number of ints. */
3475 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3476 int len
, int size
, enum bfd_endian byte_order
)
3478 /* FIXME (alloca): Not safe if array is very large. */
3479 gdb_byte
*buf
= alloca (len
* size
);
3482 read_memory (memaddr
, buf
, len
* size
);
3483 for (i
= 0; i
< len
; i
++)
3484 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3487 /* Find and grab a copy of the target _ovly_table
3488 (and _novlys, which is needed for the table's size). */
3490 simple_read_overlay_table (void)
3492 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3493 struct gdbarch
*gdbarch
;
3495 enum bfd_endian byte_order
;
3497 simple_free_overlay_table ();
3498 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3501 error (_("Error reading inferior's overlay table: "
3502 "couldn't find `_novlys' variable\n"
3503 "in inferior. Use `overlay manual' mode."));
3507 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3508 if (! ovly_table_msym
)
3510 error (_("Error reading inferior's overlay table: couldn't find "
3511 "`_ovly_table' array\n"
3512 "in inferior. Use `overlay manual' mode."));
3516 gdbarch
= get_objfile_arch (msymbol_objfile (ovly_table_msym
));
3517 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3518 byte_order
= gdbarch_byte_order (gdbarch
);
3520 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
),
3523 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3524 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3525 read_target_long_array (cache_ovly_table_base
,
3526 (unsigned int *) cache_ovly_table
,
3527 cache_novlys
* 4, word_size
, byte_order
);
3529 return 1; /* SUCCESS */
3532 /* Function: simple_overlay_update_1
3533 A helper function for simple_overlay_update. Assuming a cached copy
3534 of _ovly_table exists, look through it to find an entry whose vma,
3535 lma and size match those of OSECT. Re-read the entry and make sure
3536 it still matches OSECT (else the table may no longer be valid).
3537 Set OSECT's mapped state to match the entry. Return: 1 for
3538 success, 0 for failure. */
3541 simple_overlay_update_1 (struct obj_section
*osect
)
3544 bfd
*obfd
= osect
->objfile
->obfd
;
3545 asection
*bsect
= osect
->the_bfd_section
;
3546 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3547 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3548 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3550 size
= bfd_get_section_size (osect
->the_bfd_section
);
3551 for (i
= 0; i
< cache_novlys
; i
++)
3552 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3553 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3554 /* && cache_ovly_table[i][SIZE] == size */ )
3556 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3557 (unsigned int *) cache_ovly_table
[i
],
3558 4, word_size
, byte_order
);
3559 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3560 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3561 /* && cache_ovly_table[i][SIZE] == size */ )
3563 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3566 else /* Warning! Warning! Target's ovly table has changed! */
3572 /* Function: simple_overlay_update
3573 If OSECT is NULL, then update all sections' mapped state
3574 (after re-reading the entire target _ovly_table).
3575 If OSECT is non-NULL, then try to find a matching entry in the
3576 cached ovly_table and update only OSECT's mapped state.
3577 If a cached entry can't be found or the cache isn't valid, then
3578 re-read the entire cache, and go ahead and update all sections. */
3581 simple_overlay_update (struct obj_section
*osect
)
3583 struct objfile
*objfile
;
3585 /* Were we given an osect to look up? NULL means do all of them. */
3587 /* Have we got a cached copy of the target's overlay table? */
3588 if (cache_ovly_table
!= NULL
)
3590 /* Does its cached location match what's currently in the
3592 struct minimal_symbol
*minsym
3593 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3596 error (_("Error reading inferior's overlay table: couldn't "
3597 "find `_ovly_table' array\n"
3598 "in inferior. Use `overlay manual' mode."));
3600 if (cache_ovly_table_base
== SYMBOL_VALUE_ADDRESS (minsym
))
3601 /* Then go ahead and try to look up this single section in
3603 if (simple_overlay_update_1 (osect
))
3604 /* Found it! We're done. */
3608 /* Cached table no good: need to read the entire table anew.
3609 Or else we want all the sections, in which case it's actually
3610 more efficient to read the whole table in one block anyway. */
3612 if (! simple_read_overlay_table ())
3615 /* Now may as well update all sections, even if only one was requested. */
3616 ALL_OBJSECTIONS (objfile
, osect
)
3617 if (section_is_overlay (osect
))
3620 bfd
*obfd
= osect
->objfile
->obfd
;
3621 asection
*bsect
= osect
->the_bfd_section
;
3623 size
= bfd_get_section_size (bsect
);
3624 for (i
= 0; i
< cache_novlys
; i
++)
3625 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3626 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3627 /* && cache_ovly_table[i][SIZE] == size */ )
3628 { /* obj_section matches i'th entry in ovly_table. */
3629 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3630 break; /* finished with inner for loop: break out. */
3635 /* Set the output sections and output offsets for section SECTP in
3636 ABFD. The relocation code in BFD will read these offsets, so we
3637 need to be sure they're initialized. We map each section to itself,
3638 with no offset; this means that SECTP->vma will be honored. */
3641 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3643 sectp
->output_section
= sectp
;
3644 sectp
->output_offset
= 0;
3647 /* Default implementation for sym_relocate. */
3651 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3654 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3656 bfd
*abfd
= sectp
->owner
;
3658 /* We're only interested in sections with relocation
3660 if ((sectp
->flags
& SEC_RELOC
) == 0)
3663 /* We will handle section offsets properly elsewhere, so relocate as if
3664 all sections begin at 0. */
3665 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3667 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3670 /* Relocate the contents of a debug section SECTP in ABFD. The
3671 contents are stored in BUF if it is non-NULL, or returned in a
3672 malloc'd buffer otherwise.
3674 For some platforms and debug info formats, shared libraries contain
3675 relocations against the debug sections (particularly for DWARF-2;
3676 one affected platform is PowerPC GNU/Linux, although it depends on
3677 the version of the linker in use). Also, ELF object files naturally
3678 have unresolved relocations for their debug sections. We need to apply
3679 the relocations in order to get the locations of symbols correct.
3680 Another example that may require relocation processing, is the
3681 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3685 symfile_relocate_debug_section (struct objfile
*objfile
,
3686 asection
*sectp
, bfd_byte
*buf
)
3688 gdb_assert (objfile
->sf
->sym_relocate
);
3690 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3693 struct symfile_segment_data
*
3694 get_symfile_segment_data (bfd
*abfd
)
3696 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3701 return sf
->sym_segments (abfd
);
3705 free_symfile_segment_data (struct symfile_segment_data
*data
)
3707 xfree (data
->segment_bases
);
3708 xfree (data
->segment_sizes
);
3709 xfree (data
->segment_info
);
3715 - DATA, containing segment addresses from the object file ABFD, and
3716 the mapping from ABFD's sections onto the segments that own them,
3718 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3719 segment addresses reported by the target,
3720 store the appropriate offsets for each section in OFFSETS.
3722 If there are fewer entries in SEGMENT_BASES than there are segments
3723 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3725 If there are more entries, then ignore the extra. The target may
3726 not be able to distinguish between an empty data segment and a
3727 missing data segment; a missing text segment is less plausible. */
3729 symfile_map_offsets_to_segments (bfd
*abfd
, struct symfile_segment_data
*data
,
3730 struct section_offsets
*offsets
,
3731 int num_segment_bases
,
3732 const CORE_ADDR
*segment_bases
)
3737 /* It doesn't make sense to call this function unless you have some
3738 segment base addresses. */
3739 gdb_assert (num_segment_bases
> 0);
3741 /* If we do not have segment mappings for the object file, we
3742 can not relocate it by segments. */
3743 gdb_assert (data
!= NULL
);
3744 gdb_assert (data
->num_segments
> 0);
3746 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3748 int which
= data
->segment_info
[i
];
3750 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3752 /* Don't bother computing offsets for sections that aren't
3753 loaded as part of any segment. */
3757 /* Use the last SEGMENT_BASES entry as the address of any extra
3758 segments mentioned in DATA->segment_info. */
3759 if (which
> num_segment_bases
)
3760 which
= num_segment_bases
;
3762 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3763 - data
->segment_bases
[which
- 1]);
3770 symfile_find_segment_sections (struct objfile
*objfile
)
3772 bfd
*abfd
= objfile
->obfd
;
3775 struct symfile_segment_data
*data
;
3777 data
= get_symfile_segment_data (objfile
->obfd
);
3781 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3783 free_symfile_segment_data (data
);
3787 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3789 int which
= data
->segment_info
[i
];
3793 if (objfile
->sect_index_text
== -1)
3794 objfile
->sect_index_text
= sect
->index
;
3796 if (objfile
->sect_index_rodata
== -1)
3797 objfile
->sect_index_rodata
= sect
->index
;
3799 else if (which
== 2)
3801 if (objfile
->sect_index_data
== -1)
3802 objfile
->sect_index_data
= sect
->index
;
3804 if (objfile
->sect_index_bss
== -1)
3805 objfile
->sect_index_bss
= sect
->index
;
3809 free_symfile_segment_data (data
);
3813 _initialize_symfile (void)
3815 struct cmd_list_element
*c
;
3817 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3818 Load symbol table from executable file FILE.\n\
3819 The `file' command can also load symbol tables, as well as setting the file\n\
3820 to execute."), &cmdlist
);
3821 set_cmd_completer (c
, filename_completer
);
3823 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3824 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3825 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR>\
3826 ...]\nADDR is the starting address of the file's text.\n\
3827 The optional arguments are section-name section-address pairs and\n\
3828 should be specified if the data and bss segments are not contiguous\n\
3829 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3831 set_cmd_completer (c
, filename_completer
);
3833 c
= add_cmd ("load", class_files
, load_command
, _("\
3834 Dynamically load FILE into the running program, and record its symbols\n\
3835 for access from GDB.\n\
3836 A load OFFSET may also be given."), &cmdlist
);
3837 set_cmd_completer (c
, filename_completer
);
3839 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3840 _("Commands for debugging overlays."), &overlaylist
,
3841 "overlay ", 0, &cmdlist
);
3843 add_com_alias ("ovly", "overlay", class_alias
, 1);
3844 add_com_alias ("ov", "overlay", class_alias
, 1);
3846 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3847 _("Assert that an overlay section is mapped."), &overlaylist
);
3849 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3850 _("Assert that an overlay section is unmapped."), &overlaylist
);
3852 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3853 _("List mappings of overlay sections."), &overlaylist
);
3855 add_cmd ("manual", class_support
, overlay_manual_command
,
3856 _("Enable overlay debugging."), &overlaylist
);
3857 add_cmd ("off", class_support
, overlay_off_command
,
3858 _("Disable overlay debugging."), &overlaylist
);
3859 add_cmd ("auto", class_support
, overlay_auto_command
,
3860 _("Enable automatic overlay debugging."), &overlaylist
);
3861 add_cmd ("load-target", class_support
, overlay_load_command
,
3862 _("Read the overlay mapping state from the target."), &overlaylist
);
3864 /* Filename extension to source language lookup table: */
3865 init_filename_language_table ();
3866 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3868 Set mapping between filename extension and source language."), _("\
3869 Show mapping between filename extension and source language."), _("\
3870 Usage: set extension-language .foo bar"),
3871 set_ext_lang_command
,
3873 &setlist
, &showlist
);
3875 add_info ("extensions", info_ext_lang_command
,
3876 _("All filename extensions associated with a source language."));
3878 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3879 &debug_file_directory
, _("\
3880 Set the directories where separate debug symbols are searched for."), _("\
3881 Show the directories where separate debug symbols are searched for."), _("\
3882 Separate debug symbols are first searched for in the same\n\
3883 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3884 and lastly at the path of the directory of the binary with\n\
3885 each global debug-file-directory component prepended."),
3887 show_debug_file_directory
,
3888 &setlist
, &showlist
);