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"
59 #include "cli/cli-utils.h"
61 #include <sys/types.h>
63 #include "gdb_string.h"
71 int (*deprecated_ui_load_progress_hook
) (const char *section
,
73 void (*deprecated_show_load_progress
) (const char *section
,
74 unsigned long section_sent
,
75 unsigned long section_size
,
76 unsigned long total_sent
,
77 unsigned long total_size
);
78 void (*deprecated_pre_add_symbol_hook
) (const char *);
79 void (*deprecated_post_add_symbol_hook
) (void);
81 static void clear_symtab_users_cleanup (void *ignore
);
83 /* Global variables owned by this file. */
84 int readnow_symbol_files
; /* Read full symbols immediately. */
86 /* Functions this file defines. */
88 static void load_command (char *, int);
90 static void symbol_file_add_main_1 (char *args
, int from_tty
, int flags
);
92 static void add_symbol_file_command (char *, int);
94 bfd
*symfile_bfd_open (char *);
96 int get_section_index (struct objfile
*, char *);
98 static const struct sym_fns
*find_sym_fns (bfd
*);
100 static void decrement_reading_symtab (void *);
102 static void overlay_invalidate_all (void);
104 static void overlay_auto_command (char *, int);
106 static void overlay_manual_command (char *, int);
108 static void overlay_off_command (char *, int);
110 static void overlay_load_command (char *, int);
112 static void overlay_command (char *, int);
114 static void simple_free_overlay_table (void);
116 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
119 static int simple_read_overlay_table (void);
121 static int simple_overlay_update_1 (struct obj_section
*);
123 static void add_filename_language (char *ext
, enum language lang
);
125 static void info_ext_lang_command (char *args
, int from_tty
);
127 static void init_filename_language_table (void);
129 static void symfile_find_segment_sections (struct objfile
*objfile
);
131 void _initialize_symfile (void);
133 /* List of all available sym_fns. On gdb startup, each object file reader
134 calls add_symtab_fns() to register information on each format it is
137 typedef const struct sym_fns
*sym_fns_ptr
;
138 DEF_VEC_P (sym_fns_ptr
);
140 static VEC (sym_fns_ptr
) *symtab_fns
= NULL
;
142 /* If non-zero, shared library symbols will be added automatically
143 when the inferior is created, new libraries are loaded, or when
144 attaching to the inferior. This is almost always what users will
145 want to have happen; but for very large programs, the startup time
146 will be excessive, and so if this is a problem, the user can clear
147 this flag and then add the shared library symbols as needed. Note
148 that there is a potential for confusion, since if the shared
149 library symbols are not loaded, commands like "info fun" will *not*
150 report all the functions that are actually present. */
152 int auto_solib_add
= 1;
155 /* True if we are reading a symbol table. */
157 int currently_reading_symtab
= 0;
160 decrement_reading_symtab (void *dummy
)
162 currently_reading_symtab
--;
163 gdb_assert (currently_reading_symtab
>= 0);
166 /* Increment currently_reading_symtab and return a cleanup that can be
167 used to decrement it. */
170 increment_reading_symtab (void)
172 ++currently_reading_symtab
;
173 gdb_assert (currently_reading_symtab
> 0);
174 return make_cleanup (decrement_reading_symtab
, NULL
);
177 /* Remember the lowest-addressed loadable section we've seen.
178 This function is called via bfd_map_over_sections.
180 In case of equal vmas, the section with the largest size becomes the
181 lowest-addressed loadable section.
183 If the vmas and sizes are equal, the last section is considered the
184 lowest-addressed loadable section. */
187 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
189 asection
**lowest
= (asection
**) obj
;
191 if (0 == (bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
)))
194 *lowest
= sect
; /* First loadable section */
195 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
196 *lowest
= sect
; /* A lower loadable section */
197 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
198 && (bfd_section_size (abfd
, (*lowest
))
199 <= bfd_section_size (abfd
, sect
)))
203 /* Create a new section_addr_info, with room for NUM_SECTIONS. The
204 new object's 'num_sections' field is set to 0; it must be updated
207 struct section_addr_info
*
208 alloc_section_addr_info (size_t num_sections
)
210 struct section_addr_info
*sap
;
213 size
= (sizeof (struct section_addr_info
)
214 + sizeof (struct other_sections
) * (num_sections
- 1));
215 sap
= (struct section_addr_info
*) xmalloc (size
);
216 memset (sap
, 0, size
);
221 /* Build (allocate and populate) a section_addr_info struct from
222 an existing section table. */
224 extern struct section_addr_info
*
225 build_section_addr_info_from_section_table (const struct target_section
*start
,
226 const struct target_section
*end
)
228 struct section_addr_info
*sap
;
229 const struct target_section
*stp
;
232 sap
= alloc_section_addr_info (end
- start
);
234 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
236 if (bfd_get_section_flags (stp
->bfd
,
237 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
238 && oidx
< end
- start
)
240 sap
->other
[oidx
].addr
= stp
->addr
;
241 sap
->other
[oidx
].name
242 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
243 sap
->other
[oidx
].sectindex
244 = gdb_bfd_section_index (stp
->bfd
, stp
->the_bfd_section
);
249 sap
->num_sections
= oidx
;
254 /* Create a section_addr_info from section offsets in ABFD. */
256 static struct section_addr_info
*
257 build_section_addr_info_from_bfd (bfd
*abfd
)
259 struct section_addr_info
*sap
;
261 struct bfd_section
*sec
;
263 sap
= alloc_section_addr_info (bfd_count_sections (abfd
));
264 for (i
= 0, sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
265 if (bfd_get_section_flags (abfd
, sec
) & (SEC_ALLOC
| SEC_LOAD
))
267 sap
->other
[i
].addr
= bfd_get_section_vma (abfd
, sec
);
268 sap
->other
[i
].name
= xstrdup (bfd_get_section_name (abfd
, sec
));
269 sap
->other
[i
].sectindex
= gdb_bfd_section_index (abfd
, sec
);
273 sap
->num_sections
= i
;
278 /* Create a section_addr_info from section offsets in OBJFILE. */
280 struct section_addr_info
*
281 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
283 struct section_addr_info
*sap
;
286 /* Before reread_symbols gets rewritten it is not safe to call:
287 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
289 sap
= build_section_addr_info_from_bfd (objfile
->obfd
);
290 for (i
= 0; i
< sap
->num_sections
; i
++)
292 int sectindex
= sap
->other
[i
].sectindex
;
294 sap
->other
[i
].addr
+= objfile
->section_offsets
->offsets
[sectindex
];
299 /* Free all memory allocated by build_section_addr_info_from_section_table. */
302 free_section_addr_info (struct section_addr_info
*sap
)
306 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
307 xfree (sap
->other
[idx
].name
);
311 /* Initialize OBJFILE's sect_index_* members. */
314 init_objfile_sect_indices (struct objfile
*objfile
)
319 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
321 objfile
->sect_index_text
= sect
->index
;
323 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
325 objfile
->sect_index_data
= sect
->index
;
327 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
329 objfile
->sect_index_bss
= sect
->index
;
331 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
333 objfile
->sect_index_rodata
= sect
->index
;
335 /* This is where things get really weird... We MUST have valid
336 indices for the various sect_index_* members or gdb will abort.
337 So if for example, there is no ".text" section, we have to
338 accomodate that. First, check for a file with the standard
339 one or two segments. */
341 symfile_find_segment_sections (objfile
);
343 /* Except when explicitly adding symbol files at some address,
344 section_offsets contains nothing but zeros, so it doesn't matter
345 which slot in section_offsets the individual sect_index_* members
346 index into. So if they are all zero, it is safe to just point
347 all the currently uninitialized indices to the first slot. But
348 beware: if this is the main executable, it may be relocated
349 later, e.g. by the remote qOffsets packet, and then this will
350 be wrong! That's why we try segments first. */
352 for (i
= 0; i
< objfile
->num_sections
; i
++)
354 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
359 if (i
== objfile
->num_sections
)
361 if (objfile
->sect_index_text
== -1)
362 objfile
->sect_index_text
= 0;
363 if (objfile
->sect_index_data
== -1)
364 objfile
->sect_index_data
= 0;
365 if (objfile
->sect_index_bss
== -1)
366 objfile
->sect_index_bss
= 0;
367 if (objfile
->sect_index_rodata
== -1)
368 objfile
->sect_index_rodata
= 0;
372 /* The arguments to place_section. */
374 struct place_section_arg
376 struct section_offsets
*offsets
;
380 /* Find a unique offset to use for loadable section SECT if
381 the user did not provide an offset. */
384 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
386 struct place_section_arg
*arg
= obj
;
387 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
389 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
391 /* We are only interested in allocated sections. */
392 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
395 /* If the user specified an offset, honor it. */
396 if (offsets
[gdb_bfd_section_index (abfd
, sect
)] != 0)
399 /* Otherwise, let's try to find a place for the section. */
400 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
407 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
409 int indx
= cur_sec
->index
;
411 /* We don't need to compare against ourself. */
415 /* We can only conflict with allocated sections. */
416 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
419 /* If the section offset is 0, either the section has not been placed
420 yet, or it was the lowest section placed (in which case LOWEST
421 will be past its end). */
422 if (offsets
[indx
] == 0)
425 /* If this section would overlap us, then we must move up. */
426 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
427 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
429 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
430 start_addr
= (start_addr
+ align
- 1) & -align
;
435 /* Otherwise, we appear to be OK. So far. */
440 offsets
[gdb_bfd_section_index (abfd
, sect
)] = start_addr
;
441 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
444 /* Store struct section_addr_info as prepared (made relative and with SECTINDEX
445 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
449 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
451 const struct section_addr_info
*addrs
)
455 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
457 /* Now calculate offsets for section that were specified by the caller. */
458 for (i
= 0; i
< addrs
->num_sections
; i
++)
460 const struct other_sections
*osp
;
462 osp
= &addrs
->other
[i
];
463 if (osp
->sectindex
== -1)
466 /* Record all sections in offsets. */
467 /* The section_offsets in the objfile are here filled in using
469 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
473 /* Transform section name S for a name comparison. prelink can split section
474 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
475 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
476 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
477 (`.sbss') section has invalid (increased) virtual address. */
480 addr_section_name (const char *s
)
482 if (strcmp (s
, ".dynbss") == 0)
484 if (strcmp (s
, ".sdynbss") == 0)
490 /* qsort comparator for addrs_section_sort. Sort entries in ascending order by
491 their (name, sectindex) pair. sectindex makes the sort by name stable. */
494 addrs_section_compar (const void *ap
, const void *bp
)
496 const struct other_sections
*a
= *((struct other_sections
**) ap
);
497 const struct other_sections
*b
= *((struct other_sections
**) bp
);
500 retval
= strcmp (addr_section_name (a
->name
), addr_section_name (b
->name
));
504 return a
->sectindex
- b
->sectindex
;
507 /* Provide sorted array of pointers to sections of ADDRS. The array is
508 terminated by NULL. Caller is responsible to call xfree for it. */
510 static struct other_sections
**
511 addrs_section_sort (struct section_addr_info
*addrs
)
513 struct other_sections
**array
;
516 /* `+ 1' for the NULL terminator. */
517 array
= xmalloc (sizeof (*array
) * (addrs
->num_sections
+ 1));
518 for (i
= 0; i
< addrs
->num_sections
; i
++)
519 array
[i
] = &addrs
->other
[i
];
522 qsort (array
, i
, sizeof (*array
), addrs_section_compar
);
527 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
528 also SECTINDEXes specific to ABFD there. This function can be used to
529 rebase ADDRS to start referencing different BFD than before. */
532 addr_info_make_relative (struct section_addr_info
*addrs
, bfd
*abfd
)
534 asection
*lower_sect
;
535 CORE_ADDR lower_offset
;
537 struct cleanup
*my_cleanup
;
538 struct section_addr_info
*abfd_addrs
;
539 struct other_sections
**addrs_sorted
, **abfd_addrs_sorted
;
540 struct other_sections
**addrs_to_abfd_addrs
;
542 /* Find lowest loadable section to be used as starting point for
543 continguous sections. */
545 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
546 if (lower_sect
== NULL
)
548 warning (_("no loadable sections found in added symbol-file %s"),
549 bfd_get_filename (abfd
));
553 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
555 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
556 in ABFD. Section names are not unique - there can be multiple sections of
557 the same name. Also the sections of the same name do not have to be
558 adjacent to each other. Some sections may be present only in one of the
559 files. Even sections present in both files do not have to be in the same
562 Use stable sort by name for the sections in both files. Then linearly
563 scan both lists matching as most of the entries as possible. */
565 addrs_sorted
= addrs_section_sort (addrs
);
566 my_cleanup
= make_cleanup (xfree
, addrs_sorted
);
568 abfd_addrs
= build_section_addr_info_from_bfd (abfd
);
569 make_cleanup_free_section_addr_info (abfd_addrs
);
570 abfd_addrs_sorted
= addrs_section_sort (abfd_addrs
);
571 make_cleanup (xfree
, abfd_addrs_sorted
);
573 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
574 ABFD_ADDRS_SORTED. */
576 addrs_to_abfd_addrs
= xzalloc (sizeof (*addrs_to_abfd_addrs
)
577 * addrs
->num_sections
);
578 make_cleanup (xfree
, addrs_to_abfd_addrs
);
580 while (*addrs_sorted
)
582 const char *sect_name
= addr_section_name ((*addrs_sorted
)->name
);
584 while (*abfd_addrs_sorted
585 && strcmp (addr_section_name ((*abfd_addrs_sorted
)->name
),
589 if (*abfd_addrs_sorted
590 && strcmp (addr_section_name ((*abfd_addrs_sorted
)->name
),
595 /* Make the found item directly addressable from ADDRS. */
596 index_in_addrs
= *addrs_sorted
- addrs
->other
;
597 gdb_assert (addrs_to_abfd_addrs
[index_in_addrs
] == NULL
);
598 addrs_to_abfd_addrs
[index_in_addrs
] = *abfd_addrs_sorted
;
600 /* Never use the same ABFD entry twice. */
607 /* Calculate offsets for the loadable sections.
608 FIXME! Sections must be in order of increasing loadable section
609 so that contiguous sections can use the lower-offset!!!
611 Adjust offsets if the segments are not contiguous.
612 If the section is contiguous, its offset should be set to
613 the offset of the highest loadable section lower than it
614 (the loadable section directly below it in memory).
615 this_offset = lower_offset = lower_addr - lower_orig_addr */
617 for (i
= 0; i
< addrs
->num_sections
; i
++)
619 struct other_sections
*sect
= addrs_to_abfd_addrs
[i
];
623 /* This is the index used by BFD. */
624 addrs
->other
[i
].sectindex
= sect
->sectindex
;
626 if (addrs
->other
[i
].addr
!= 0)
628 addrs
->other
[i
].addr
-= sect
->addr
;
629 lower_offset
= addrs
->other
[i
].addr
;
632 addrs
->other
[i
].addr
= lower_offset
;
636 /* addr_section_name transformation is not used for SECT_NAME. */
637 const char *sect_name
= addrs
->other
[i
].name
;
639 /* This section does not exist in ABFD, which is normally
640 unexpected and we want to issue a warning.
642 However, the ELF prelinker does create a few sections which are
643 marked in the main executable as loadable (they are loaded in
644 memory from the DYNAMIC segment) and yet are not present in
645 separate debug info files. This is fine, and should not cause
646 a warning. Shared libraries contain just the section
647 ".gnu.liblist" but it is not marked as loadable there. There is
648 no other way to identify them than by their name as the sections
649 created by prelink have no special flags.
651 For the sections `.bss' and `.sbss' see addr_section_name. */
653 if (!(strcmp (sect_name
, ".gnu.liblist") == 0
654 || strcmp (sect_name
, ".gnu.conflict") == 0
655 || (strcmp (sect_name
, ".bss") == 0
657 && strcmp (addrs
->other
[i
- 1].name
, ".dynbss") == 0
658 && addrs_to_abfd_addrs
[i
- 1] != NULL
)
659 || (strcmp (sect_name
, ".sbss") == 0
661 && strcmp (addrs
->other
[i
- 1].name
, ".sdynbss") == 0
662 && addrs_to_abfd_addrs
[i
- 1] != NULL
)))
663 warning (_("section %s not found in %s"), sect_name
,
664 bfd_get_filename (abfd
));
666 addrs
->other
[i
].addr
= 0;
667 addrs
->other
[i
].sectindex
= -1;
671 do_cleanups (my_cleanup
);
674 /* Parse the user's idea of an offset for dynamic linking, into our idea
675 of how to represent it for fast symbol reading. This is the default
676 version of the sym_fns.sym_offsets function for symbol readers that
677 don't need to do anything special. It allocates a section_offsets table
678 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
681 default_symfile_offsets (struct objfile
*objfile
,
682 const struct section_addr_info
*addrs
)
684 objfile
->num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
685 objfile
->section_offsets
= (struct section_offsets
*)
686 obstack_alloc (&objfile
->objfile_obstack
,
687 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
688 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
689 objfile
->num_sections
, addrs
);
691 /* For relocatable files, all loadable sections will start at zero.
692 The zero is meaningless, so try to pick arbitrary addresses such
693 that no loadable sections overlap. This algorithm is quadratic,
694 but the number of sections in a single object file is generally
696 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
698 struct place_section_arg arg
;
699 bfd
*abfd
= objfile
->obfd
;
702 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
703 /* We do not expect this to happen; just skip this step if the
704 relocatable file has a section with an assigned VMA. */
705 if (bfd_section_vma (abfd
, cur_sec
) != 0)
710 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
712 /* Pick non-overlapping offsets for sections the user did not
714 arg
.offsets
= objfile
->section_offsets
;
716 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
718 /* Correctly filling in the section offsets is not quite
719 enough. Relocatable files have two properties that
720 (most) shared objects do not:
722 - Their debug information will contain relocations. Some
723 shared libraries do also, but many do not, so this can not
726 - If there are multiple code sections they will be loaded
727 at different relative addresses in memory than they are
728 in the objfile, since all sections in the file will start
731 Because GDB has very limited ability to map from an
732 address in debug info to the correct code section,
733 it relies on adding SECT_OFF_TEXT to things which might be
734 code. If we clear all the section offsets, and set the
735 section VMAs instead, then symfile_relocate_debug_section
736 will return meaningful debug information pointing at the
739 GDB has too many different data structures for section
740 addresses - a bfd, objfile, and so_list all have section
741 tables, as does exec_ops. Some of these could probably
744 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
745 cur_sec
= cur_sec
->next
)
747 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
750 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
751 exec_set_section_address (bfd_get_filename (abfd
),
753 offsets
[cur_sec
->index
]);
754 offsets
[cur_sec
->index
] = 0;
759 /* Remember the bfd indexes for the .text, .data, .bss and
761 init_objfile_sect_indices (objfile
);
764 /* Divide the file into segments, which are individual relocatable units.
765 This is the default version of the sym_fns.sym_segments function for
766 symbol readers that do not have an explicit representation of segments.
767 It assumes that object files do not have segments, and fully linked
768 files have a single segment. */
770 struct symfile_segment_data
*
771 default_symfile_segments (bfd
*abfd
)
775 struct symfile_segment_data
*data
;
778 /* Relocatable files contain enough information to position each
779 loadable section independently; they should not be relocated
781 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
784 /* Make sure there is at least one loadable section in the file. */
785 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
787 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
795 low
= bfd_get_section_vma (abfd
, sect
);
796 high
= low
+ bfd_get_section_size (sect
);
798 data
= XZALLOC (struct symfile_segment_data
);
799 data
->num_segments
= 1;
800 data
->segment_bases
= XCALLOC (1, CORE_ADDR
);
801 data
->segment_sizes
= XCALLOC (1, CORE_ADDR
);
803 num_sections
= bfd_count_sections (abfd
);
804 data
->segment_info
= XCALLOC (num_sections
, int);
806 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
810 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
813 vma
= bfd_get_section_vma (abfd
, sect
);
816 if (vma
+ bfd_get_section_size (sect
) > high
)
817 high
= vma
+ bfd_get_section_size (sect
);
819 data
->segment_info
[i
] = 1;
822 data
->segment_bases
[0] = low
;
823 data
->segment_sizes
[0] = high
- low
;
828 /* This is a convenience function to call sym_read for OBJFILE and
829 possibly force the partial symbols to be read. */
832 read_symbols (struct objfile
*objfile
, int add_flags
)
834 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
836 /* find_separate_debug_file_in_section should be called only if there is
837 single binary with no existing separate debug info file. */
838 if (!objfile_has_partial_symbols (objfile
)
839 && objfile
->separate_debug_objfile
== NULL
840 && objfile
->separate_debug_objfile_backlink
== NULL
)
842 bfd
*abfd
= find_separate_debug_file_in_section (objfile
);
843 struct cleanup
*cleanup
= make_cleanup_bfd_unref (abfd
);
846 symbol_file_add_separate (abfd
, add_flags
, objfile
);
848 do_cleanups (cleanup
);
850 if ((add_flags
& SYMFILE_NO_READ
) == 0)
851 require_partial_symbols (objfile
, 0);
854 /* Initialize entry point information for this objfile. */
857 init_entry_point_info (struct objfile
*objfile
)
859 /* Save startup file's range of PC addresses to help blockframe.c
860 decide where the bottom of the stack is. */
862 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
864 /* Executable file -- record its entry point so we'll recognize
865 the startup file because it contains the entry point. */
866 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
867 objfile
->ei
.entry_point_p
= 1;
869 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
870 && bfd_get_start_address (objfile
->obfd
) != 0)
872 /* Some shared libraries may have entry points set and be
873 runnable. There's no clear way to indicate this, so just check
874 for values other than zero. */
875 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
876 objfile
->ei
.entry_point_p
= 1;
880 /* Examination of non-executable.o files. Short-circuit this stuff. */
881 objfile
->ei
.entry_point_p
= 0;
884 if (objfile
->ei
.entry_point_p
)
886 CORE_ADDR entry_point
= objfile
->ei
.entry_point
;
888 /* Make certain that the address points at real code, and not a
889 function descriptor. */
891 = gdbarch_convert_from_func_ptr_addr (objfile
->gdbarch
,
895 /* Remove any ISA markers, so that this matches entries in the
897 objfile
->ei
.entry_point
898 = gdbarch_addr_bits_remove (objfile
->gdbarch
, entry_point
);
902 /* Process a symbol file, as either the main file or as a dynamically
905 This function does not set the OBJFILE's entry-point info.
907 OBJFILE is where the symbols are to be read from.
909 ADDRS is the list of section load addresses. If the user has given
910 an 'add-symbol-file' command, then this is the list of offsets and
911 addresses he or she provided as arguments to the command; or, if
912 we're handling a shared library, these are the actual addresses the
913 sections are loaded at, according to the inferior's dynamic linker
914 (as gleaned by GDB's shared library code). We convert each address
915 into an offset from the section VMA's as it appears in the object
916 file, and then call the file's sym_offsets function to convert this
917 into a format-specific offset table --- a `struct section_offsets'.
918 If ADDRS is non-zero, OFFSETS must be zero.
920 OFFSETS is a table of section offsets already in the right
921 format-specific representation. NUM_OFFSETS is the number of
922 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
923 assume this is the proper table the call to sym_offsets described
924 above would produce. Instead of calling sym_offsets, we just dump
925 it right into objfile->section_offsets. (When we're re-reading
926 symbols from an objfile, we don't have the original load address
927 list any more; all we have is the section offset table.) If
928 OFFSETS is non-zero, ADDRS must be zero.
930 ADD_FLAGS encodes verbosity level, whether this is main symbol or
931 an extra symbol file such as dynamically loaded code, and wether
932 breakpoint reset should be deferred. */
935 syms_from_objfile_1 (struct objfile
*objfile
,
936 struct section_addr_info
*addrs
,
937 const struct section_offsets
*offsets
,
941 struct section_addr_info
*local_addr
= NULL
;
942 struct cleanup
*old_chain
;
943 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
945 gdb_assert (! (addrs
&& offsets
));
947 objfile
->sf
= find_sym_fns (objfile
->obfd
);
949 if (objfile
->sf
== NULL
)
951 /* No symbols to load, but we still need to make sure
952 that the section_offsets table is allocated. */
953 int num_sections
= gdb_bfd_count_sections (objfile
->obfd
);
954 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_sections
);
956 objfile
->num_sections
= num_sections
;
957 objfile
->section_offsets
958 = obstack_alloc (&objfile
->objfile_obstack
, size
);
959 memset (objfile
->section_offsets
, 0, size
);
963 /* Make sure that partially constructed symbol tables will be cleaned up
964 if an error occurs during symbol reading. */
965 old_chain
= make_cleanup_free_objfile (objfile
);
967 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
968 list. We now establish the convention that an addr of zero means
969 no load address was specified. */
970 if (! addrs
&& ! offsets
)
972 local_addr
= alloc_section_addr_info (1);
973 make_cleanup (xfree
, local_addr
);
977 /* Now either addrs or offsets is non-zero. */
981 /* We will modify the main symbol table, make sure that all its users
982 will be cleaned up if an error occurs during symbol reading. */
983 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
985 /* Since no error yet, throw away the old symbol table. */
987 if (symfile_objfile
!= NULL
)
989 free_objfile (symfile_objfile
);
990 gdb_assert (symfile_objfile
== NULL
);
993 /* Currently we keep symbols from the add-symbol-file command.
994 If the user wants to get rid of them, they should do "symbol-file"
995 without arguments first. Not sure this is the best behavior
998 (*objfile
->sf
->sym_new_init
) (objfile
);
1001 /* Convert addr into an offset rather than an absolute address.
1002 We find the lowest address of a loaded segment in the objfile,
1003 and assume that <addr> is where that got loaded.
1005 We no longer warn if the lowest section is not a text segment (as
1006 happens for the PA64 port. */
1007 if (addrs
&& addrs
->num_sections
> 0)
1008 addr_info_make_relative (addrs
, objfile
->obfd
);
1010 /* Initialize symbol reading routines for this objfile, allow complaints to
1011 appear for this new file, and record how verbose to be, then do the
1012 initial symbol reading for this file. */
1014 (*objfile
->sf
->sym_init
) (objfile
);
1015 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
1018 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
1021 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
1023 /* Just copy in the offset table directly as given to us. */
1024 objfile
->num_sections
= num_offsets
;
1025 objfile
->section_offsets
1026 = ((struct section_offsets
*)
1027 obstack_alloc (&objfile
->objfile_obstack
, size
));
1028 memcpy (objfile
->section_offsets
, offsets
, size
);
1030 init_objfile_sect_indices (objfile
);
1033 read_symbols (objfile
, add_flags
);
1035 /* Discard cleanups as symbol reading was successful. */
1037 discard_cleanups (old_chain
);
1041 /* Same as syms_from_objfile_1, but also initializes the objfile
1042 entry-point info. */
1045 syms_from_objfile (struct objfile
*objfile
,
1046 struct section_addr_info
*addrs
,
1047 const struct section_offsets
*offsets
,
1051 syms_from_objfile_1 (objfile
, addrs
, offsets
, num_offsets
, add_flags
);
1052 init_entry_point_info (objfile
);
1055 /* Perform required actions after either reading in the initial
1056 symbols for a new objfile, or mapping in the symbols from a reusable
1057 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
1060 new_symfile_objfile (struct objfile
*objfile
, int add_flags
)
1062 /* If this is the main symbol file we have to clean up all users of the
1063 old main symbol file. Otherwise it is sufficient to fixup all the
1064 breakpoints that may have been redefined by this symbol file. */
1065 if (add_flags
& SYMFILE_MAINLINE
)
1067 /* OK, make it the "real" symbol file. */
1068 symfile_objfile
= objfile
;
1070 clear_symtab_users (add_flags
);
1072 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
1074 breakpoint_re_set ();
1077 /* We're done reading the symbol file; finish off complaints. */
1078 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
1081 /* Process a symbol file, as either the main file or as a dynamically
1084 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1085 A new reference is acquired by this function.
1087 ADD_FLAGS encodes verbosity, whether this is main symbol file or
1088 extra, such as dynamically loaded code, and what to do with breakpoins.
1090 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
1091 syms_from_objfile, above.
1092 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
1094 PARENT is the original objfile if ABFD is a separate debug info file.
1095 Otherwise PARENT is NULL.
1097 Upon success, returns a pointer to the objfile that was added.
1098 Upon failure, jumps back to command level (never returns). */
1100 static struct objfile
*
1101 symbol_file_add_with_addrs_or_offsets (bfd
*abfd
,
1103 struct section_addr_info
*addrs
,
1104 const struct section_offsets
*offsets
,
1106 int flags
, struct objfile
*parent
)
1108 struct objfile
*objfile
;
1109 const char *name
= bfd_get_filename (abfd
);
1110 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
1111 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
1112 const int should_print
= ((from_tty
|| info_verbose
)
1113 && (readnow_symbol_files
1114 || (add_flags
& SYMFILE_NO_READ
) == 0));
1116 if (readnow_symbol_files
)
1118 flags
|= OBJF_READNOW
;
1119 add_flags
&= ~SYMFILE_NO_READ
;
1122 /* Give user a chance to burp if we'd be
1123 interactively wiping out any existing symbols. */
1125 if ((have_full_symbols () || have_partial_symbols ())
1128 && !query (_("Load new symbol table from \"%s\"? "), name
))
1129 error (_("Not confirmed."));
1131 objfile
= allocate_objfile (abfd
, flags
| (mainline
? OBJF_MAINLINE
: 0));
1134 add_separate_debug_objfile (objfile
, parent
);
1136 /* We either created a new mapped symbol table, mapped an existing
1137 symbol table file which has not had initial symbol reading
1138 performed, or need to read an unmapped symbol table. */
1141 if (deprecated_pre_add_symbol_hook
)
1142 deprecated_pre_add_symbol_hook (name
);
1145 printf_unfiltered (_("Reading symbols from %s..."), name
);
1147 gdb_flush (gdb_stdout
);
1150 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
1153 /* We now have at least a partial symbol table. Check to see if the
1154 user requested that all symbols be read on initial access via either
1155 the gdb startup command line or on a per symbol file basis. Expand
1156 all partial symbol tables for this objfile if so. */
1158 if ((flags
& OBJF_READNOW
))
1162 printf_unfiltered (_("expanding to full symbols..."));
1164 gdb_flush (gdb_stdout
);
1168 objfile
->sf
->qf
->expand_all_symtabs (objfile
);
1171 if (should_print
&& !objfile_has_symbols (objfile
))
1174 printf_unfiltered (_("(no debugging symbols found)..."));
1180 if (deprecated_post_add_symbol_hook
)
1181 deprecated_post_add_symbol_hook ();
1183 printf_unfiltered (_("done.\n"));
1186 /* We print some messages regardless of whether 'from_tty ||
1187 info_verbose' is true, so make sure they go out at the right
1189 gdb_flush (gdb_stdout
);
1191 if (objfile
->sf
== NULL
)
1193 observer_notify_new_objfile (objfile
);
1194 return objfile
; /* No symbols. */
1197 new_symfile_objfile (objfile
, add_flags
);
1199 observer_notify_new_objfile (objfile
);
1201 bfd_cache_close_all ();
1205 /* Add BFD as a separate debug file for OBJFILE. */
1208 symbol_file_add_separate (bfd
*bfd
, int symfile_flags
, struct objfile
*objfile
)
1210 struct objfile
*new_objfile
;
1211 struct section_addr_info
*sap
;
1212 struct cleanup
*my_cleanup
;
1214 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1215 because sections of BFD may not match sections of OBJFILE and because
1216 vma may have been modified by tools such as prelink. */
1217 sap
= build_section_addr_info_from_objfile (objfile
);
1218 my_cleanup
= make_cleanup_free_section_addr_info (sap
);
1220 new_objfile
= symbol_file_add_with_addrs_or_offsets
1221 (bfd
, symfile_flags
,
1223 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1227 do_cleanups (my_cleanup
);
1230 /* Process the symbol file ABFD, as either the main file or as a
1231 dynamically loaded file.
1233 See symbol_file_add_with_addrs_or_offsets's comments for
1237 symbol_file_add_from_bfd (bfd
*abfd
, int add_flags
,
1238 struct section_addr_info
*addrs
,
1239 int flags
, struct objfile
*parent
)
1241 return symbol_file_add_with_addrs_or_offsets (abfd
, add_flags
, addrs
, 0, 0,
1245 /* Process a symbol file, as either the main file or as a dynamically
1246 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1250 symbol_file_add (char *name
, int add_flags
, struct section_addr_info
*addrs
,
1253 bfd
*bfd
= symfile_bfd_open (name
);
1254 struct cleanup
*cleanup
= make_cleanup_bfd_unref (bfd
);
1255 struct objfile
*objf
;
1257 objf
= symbol_file_add_from_bfd (bfd
, add_flags
, addrs
, flags
, NULL
);
1258 do_cleanups (cleanup
);
1262 /* Call symbol_file_add() with default values and update whatever is
1263 affected by the loading of a new main().
1264 Used when the file is supplied in the gdb command line
1265 and by some targets with special loading requirements.
1266 The auxiliary function, symbol_file_add_main_1(), has the flags
1267 argument for the switches that can only be specified in the symbol_file
1271 symbol_file_add_main (char *args
, int from_tty
)
1273 symbol_file_add_main_1 (args
, from_tty
, 0);
1277 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1279 const int add_flags
= (current_inferior ()->symfile_flags
1280 | SYMFILE_MAINLINE
| (from_tty
? SYMFILE_VERBOSE
: 0));
1282 symbol_file_add (args
, add_flags
, NULL
, flags
);
1284 /* Getting new symbols may change our opinion about
1285 what is frameless. */
1286 reinit_frame_cache ();
1288 if ((flags
& SYMFILE_NO_READ
) == 0)
1289 set_initial_language ();
1293 symbol_file_clear (int from_tty
)
1295 if ((have_full_symbols () || have_partial_symbols ())
1298 ? !query (_("Discard symbol table from `%s'? "),
1299 symfile_objfile
->name
)
1300 : !query (_("Discard symbol table? "))))
1301 error (_("Not confirmed."));
1303 /* solib descriptors may have handles to objfiles. Wipe them before their
1304 objfiles get stale by free_all_objfiles. */
1305 no_shared_libraries (NULL
, from_tty
);
1307 free_all_objfiles ();
1309 gdb_assert (symfile_objfile
== NULL
);
1311 printf_unfiltered (_("No symbol file now.\n"));
1315 separate_debug_file_exists (const char *name
, unsigned long crc
,
1316 struct objfile
*parent_objfile
)
1318 unsigned long file_crc
;
1321 struct stat parent_stat
, abfd_stat
;
1322 int verified_as_different
;
1324 /* Find a separate debug info file as if symbols would be present in
1325 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1326 section can contain just the basename of PARENT_OBJFILE without any
1327 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1328 the separate debug infos with the same basename can exist. */
1330 if (filename_cmp (name
, parent_objfile
->name
) == 0)
1333 abfd
= gdb_bfd_open_maybe_remote (name
);
1338 /* Verify symlinks were not the cause of filename_cmp name difference above.
1340 Some operating systems, e.g. Windows, do not provide a meaningful
1341 st_ino; they always set it to zero. (Windows does provide a
1342 meaningful st_dev.) Do not indicate a duplicate library in that
1343 case. While there is no guarantee that a system that provides
1344 meaningful inode numbers will never set st_ino to zero, this is
1345 merely an optimization, so we do not need to worry about false
1348 if (bfd_stat (abfd
, &abfd_stat
) == 0
1349 && abfd_stat
.st_ino
!= 0
1350 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0)
1352 if (abfd_stat
.st_dev
== parent_stat
.st_dev
1353 && abfd_stat
.st_ino
== parent_stat
.st_ino
)
1355 gdb_bfd_unref (abfd
);
1358 verified_as_different
= 1;
1361 verified_as_different
= 0;
1363 file_crc_p
= gdb_bfd_crc (abfd
, &file_crc
);
1365 gdb_bfd_unref (abfd
);
1370 if (crc
!= file_crc
)
1372 unsigned long parent_crc
;
1374 /* If one (or both) the files are accessed for example the via "remote:"
1375 gdbserver way it does not support the bfd_stat operation. Verify
1376 whether those two files are not the same manually. */
1378 if (!verified_as_different
)
1380 if (!gdb_bfd_crc (parent_objfile
->obfd
, &parent_crc
))
1384 if (verified_as_different
|| parent_crc
!= file_crc
)
1385 warning (_("the debug information found in \"%s\""
1386 " does not match \"%s\" (CRC mismatch).\n"),
1387 name
, parent_objfile
->name
);
1395 char *debug_file_directory
= NULL
;
1397 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1398 struct cmd_list_element
*c
, const char *value
)
1400 fprintf_filtered (file
,
1401 _("The directory where separate debug "
1402 "symbols are searched for is \"%s\".\n"),
1406 #if ! defined (DEBUG_SUBDIRECTORY)
1407 #define DEBUG_SUBDIRECTORY ".debug"
1410 /* Find a separate debuginfo file for OBJFILE, using DIR as the directory
1411 where the original file resides (may not be the same as
1412 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
1413 looking for. CANON_DIR is the "realpath" form of DIR.
1414 DIR must contain a trailing '/'.
1415 Returns the path of the file with separate debug info, of NULL. */
1418 find_separate_debug_file (const char *dir
,
1419 const char *canon_dir
,
1420 const char *debuglink
,
1421 unsigned long crc32
, struct objfile
*objfile
)
1426 VEC (char_ptr
) *debugdir_vec
;
1427 struct cleanup
*back_to
;
1430 /* Set I to max (strlen (canon_dir), strlen (dir)). */
1432 if (canon_dir
!= NULL
&& strlen (canon_dir
) > i
)
1433 i
= strlen (canon_dir
);
1435 debugfile
= xmalloc (strlen (debug_file_directory
) + 1
1437 + strlen (DEBUG_SUBDIRECTORY
)
1439 + strlen (debuglink
)
1442 /* First try in the same directory as the original file. */
1443 strcpy (debugfile
, dir
);
1444 strcat (debugfile
, debuglink
);
1446 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1449 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1450 strcpy (debugfile
, dir
);
1451 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1452 strcat (debugfile
, "/");
1453 strcat (debugfile
, debuglink
);
1455 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1458 /* Then try in the global debugfile directories.
1460 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1461 cause "/..." lookups. */
1463 debugdir_vec
= dirnames_to_char_ptr_vec (debug_file_directory
);
1464 back_to
= make_cleanup_free_char_ptr_vec (debugdir_vec
);
1466 for (ix
= 0; VEC_iterate (char_ptr
, debugdir_vec
, ix
, debugdir
); ++ix
)
1468 strcpy (debugfile
, debugdir
);
1469 strcat (debugfile
, "/");
1470 strcat (debugfile
, dir
);
1471 strcat (debugfile
, debuglink
);
1473 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1476 /* If the file is in the sysroot, try using its base path in the
1477 global debugfile directory. */
1478 if (canon_dir
!= NULL
1479 && filename_ncmp (canon_dir
, gdb_sysroot
,
1480 strlen (gdb_sysroot
)) == 0
1481 && IS_DIR_SEPARATOR (canon_dir
[strlen (gdb_sysroot
)]))
1483 strcpy (debugfile
, debugdir
);
1484 strcat (debugfile
, canon_dir
+ strlen (gdb_sysroot
));
1485 strcat (debugfile
, "/");
1486 strcat (debugfile
, debuglink
);
1488 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1493 do_cleanups (back_to
);
1498 /* Modify PATH to contain only "[/]directory/" part of PATH.
1499 If there were no directory separators in PATH, PATH will be empty
1500 string on return. */
1503 terminate_after_last_dir_separator (char *path
)
1507 /* Strip off the final filename part, leaving the directory name,
1508 followed by a slash. The directory can be relative or absolute. */
1509 for (i
= strlen(path
) - 1; i
>= 0; i
--)
1510 if (IS_DIR_SEPARATOR (path
[i
]))
1513 /* If I is -1 then no directory is present there and DIR will be "". */
1517 /* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
1518 Returns pathname, or NULL. */
1521 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1524 char *dir
, *canon_dir
;
1526 unsigned long crc32
;
1527 struct cleanup
*cleanups
;
1529 debuglink
= bfd_get_debug_link_info (objfile
->obfd
, &crc32
);
1531 if (debuglink
== NULL
)
1533 /* There's no separate debug info, hence there's no way we could
1534 load it => no warning. */
1538 cleanups
= make_cleanup (xfree
, debuglink
);
1539 dir
= xstrdup (objfile
->name
);
1540 make_cleanup (xfree
, dir
);
1541 terminate_after_last_dir_separator (dir
);
1542 canon_dir
= lrealpath (dir
);
1544 debugfile
= find_separate_debug_file (dir
, canon_dir
, debuglink
,
1548 if (debugfile
== NULL
)
1551 /* For PR gdb/9538, try again with realpath (if different from the
1556 if (lstat (objfile
->name
, &st_buf
) == 0 && S_ISLNK(st_buf
.st_mode
))
1560 symlink_dir
= lrealpath (objfile
->name
);
1561 if (symlink_dir
!= NULL
)
1563 make_cleanup (xfree
, symlink_dir
);
1564 terminate_after_last_dir_separator (symlink_dir
);
1565 if (strcmp (dir
, symlink_dir
) != 0)
1567 /* Different directory, so try using it. */
1568 debugfile
= find_separate_debug_file (symlink_dir
,
1576 #endif /* HAVE_LSTAT */
1579 do_cleanups (cleanups
);
1583 /* This is the symbol-file command. Read the file, analyze its
1584 symbols, and add a struct symtab to a symtab list. The syntax of
1585 the command is rather bizarre:
1587 1. The function buildargv implements various quoting conventions
1588 which are undocumented and have little or nothing in common with
1589 the way things are quoted (or not quoted) elsewhere in GDB.
1591 2. Options are used, which are not generally used in GDB (perhaps
1592 "set mapped on", "set readnow on" would be better)
1594 3. The order of options matters, which is contrary to GNU
1595 conventions (because it is confusing and inconvenient). */
1598 symbol_file_command (char *args
, int from_tty
)
1604 symbol_file_clear (from_tty
);
1608 char **argv
= gdb_buildargv (args
);
1609 int flags
= OBJF_USERLOADED
;
1610 struct cleanup
*cleanups
;
1613 cleanups
= make_cleanup_freeargv (argv
);
1614 while (*argv
!= NULL
)
1616 if (strcmp (*argv
, "-readnow") == 0)
1617 flags
|= OBJF_READNOW
;
1618 else if (**argv
== '-')
1619 error (_("unknown option `%s'"), *argv
);
1622 symbol_file_add_main_1 (*argv
, from_tty
, flags
);
1630 error (_("no symbol file name was specified"));
1632 do_cleanups (cleanups
);
1636 /* Set the initial language.
1638 FIXME: A better solution would be to record the language in the
1639 psymtab when reading partial symbols, and then use it (if known) to
1640 set the language. This would be a win for formats that encode the
1641 language in an easily discoverable place, such as DWARF. For
1642 stabs, we can jump through hoops looking for specially named
1643 symbols or try to intuit the language from the specific type of
1644 stabs we find, but we can't do that until later when we read in
1648 set_initial_language (void)
1650 enum language lang
= language_unknown
;
1652 if (language_of_main
!= language_unknown
)
1653 lang
= language_of_main
;
1656 const char *filename
;
1658 filename
= find_main_filename ();
1659 if (filename
!= NULL
)
1660 lang
= deduce_language_from_filename (filename
);
1663 if (lang
== language_unknown
)
1665 /* Make C the default language */
1669 set_language (lang
);
1670 expected_language
= current_language
; /* Don't warn the user. */
1673 /* If NAME is a remote name open the file using remote protocol, otherwise
1674 open it normally. Returns a new reference to the BFD. On error,
1675 returns NULL with the BFD error set. */
1678 gdb_bfd_open_maybe_remote (const char *name
)
1682 if (remote_filename_p (name
))
1683 result
= remote_bfd_open (name
, gnutarget
);
1685 result
= gdb_bfd_open (name
, gnutarget
, -1);
1690 /* Open the file specified by NAME and hand it off to BFD for
1691 preliminary analysis. Return a newly initialized bfd *, which
1692 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1693 absolute). In case of trouble, error() is called. */
1696 symfile_bfd_open (char *name
)
1700 char *absolute_name
;
1701 struct cleanup
*back_to
;
1703 if (remote_filename_p (name
))
1705 sym_bfd
= remote_bfd_open (name
, gnutarget
);
1707 error (_("`%s': can't open to read symbols: %s."), name
,
1708 bfd_errmsg (bfd_get_error ()));
1710 if (!bfd_check_format (sym_bfd
, bfd_object
))
1712 make_cleanup_bfd_unref (sym_bfd
);
1713 error (_("`%s': can't read symbols: %s."), name
,
1714 bfd_errmsg (bfd_get_error ()));
1720 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy. */
1722 /* Look down path for it, allocate 2nd new malloc'd copy. */
1723 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, name
,
1724 O_RDONLY
| O_BINARY
, &absolute_name
);
1725 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1728 char *exename
= alloca (strlen (name
) + 5);
1730 strcat (strcpy (exename
, name
), ".exe");
1731 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
1732 O_RDONLY
| O_BINARY
, &absolute_name
);
1737 make_cleanup (xfree
, name
);
1738 perror_with_name (name
);
1742 name
= absolute_name
;
1743 back_to
= make_cleanup (xfree
, name
);
1745 sym_bfd
= gdb_bfd_open (name
, gnutarget
, desc
);
1747 error (_("`%s': can't open to read symbols: %s."), name
,
1748 bfd_errmsg (bfd_get_error ()));
1749 bfd_set_cacheable (sym_bfd
, 1);
1751 if (!bfd_check_format (sym_bfd
, bfd_object
))
1753 make_cleanup_bfd_unref (sym_bfd
);
1754 error (_("`%s': can't read symbols: %s."), name
,
1755 bfd_errmsg (bfd_get_error ()));
1758 do_cleanups (back_to
);
1763 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1764 the section was not found. */
1767 get_section_index (struct objfile
*objfile
, char *section_name
)
1769 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1777 /* Link SF into the global symtab_fns list. Called on startup by the
1778 _initialize routine in each object file format reader, to register
1779 information about each format the reader is prepared to handle. */
1782 add_symtab_fns (const struct sym_fns
*sf
)
1784 VEC_safe_push (sym_fns_ptr
, symtab_fns
, sf
);
1787 /* Initialize OBJFILE to read symbols from its associated BFD. It
1788 either returns or calls error(). The result is an initialized
1789 struct sym_fns in the objfile structure, that contains cached
1790 information about the symbol file. */
1792 static const struct sym_fns
*
1793 find_sym_fns (bfd
*abfd
)
1795 const struct sym_fns
*sf
;
1796 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1799 if (our_flavour
== bfd_target_srec_flavour
1800 || our_flavour
== bfd_target_ihex_flavour
1801 || our_flavour
== bfd_target_tekhex_flavour
)
1802 return NULL
; /* No symbols. */
1804 for (i
= 0; VEC_iterate (sym_fns_ptr
, symtab_fns
, i
, sf
); ++i
)
1805 if (our_flavour
== sf
->sym_flavour
)
1808 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1809 bfd_get_target (abfd
));
1813 /* This function runs the load command of our current target. */
1816 load_command (char *arg
, int from_tty
)
1820 /* The user might be reloading because the binary has changed. Take
1821 this opportunity to check. */
1822 reopen_exec_file ();
1830 parg
= arg
= get_exec_file (1);
1832 /* Count how many \ " ' tab space there are in the name. */
1833 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1841 /* We need to quote this string so buildargv can pull it apart. */
1842 char *temp
= xmalloc (strlen (arg
) + count
+ 1 );
1846 make_cleanup (xfree
, temp
);
1849 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1851 strncpy (ptemp
, prev
, parg
- prev
);
1852 ptemp
+= parg
- prev
;
1856 strcpy (ptemp
, prev
);
1862 target_load (arg
, from_tty
);
1864 /* After re-loading the executable, we don't really know which
1865 overlays are mapped any more. */
1866 overlay_cache_invalid
= 1;
1869 /* This version of "load" should be usable for any target. Currently
1870 it is just used for remote targets, not inftarg.c or core files,
1871 on the theory that only in that case is it useful.
1873 Avoiding xmodem and the like seems like a win (a) because we don't have
1874 to worry about finding it, and (b) On VMS, fork() is very slow and so
1875 we don't want to run a subprocess. On the other hand, I'm not sure how
1876 performance compares. */
1878 static int validate_download
= 0;
1880 /* Callback service function for generic_load (bfd_map_over_sections). */
1883 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1885 bfd_size_type
*sum
= data
;
1887 *sum
+= bfd_get_section_size (asec
);
1890 /* Opaque data for load_section_callback. */
1891 struct load_section_data
{
1892 CORE_ADDR load_offset
;
1893 struct load_progress_data
*progress_data
;
1894 VEC(memory_write_request_s
) *requests
;
1897 /* Opaque data for load_progress. */
1898 struct load_progress_data
{
1899 /* Cumulative data. */
1900 unsigned long write_count
;
1901 unsigned long data_count
;
1902 bfd_size_type total_size
;
1905 /* Opaque data for load_progress for a single section. */
1906 struct load_progress_section_data
{
1907 struct load_progress_data
*cumulative
;
1909 /* Per-section data. */
1910 const char *section_name
;
1911 ULONGEST section_sent
;
1912 ULONGEST section_size
;
1917 /* Target write callback routine for progress reporting. */
1920 load_progress (ULONGEST bytes
, void *untyped_arg
)
1922 struct load_progress_section_data
*args
= untyped_arg
;
1923 struct load_progress_data
*totals
;
1926 /* Writing padding data. No easy way to get at the cumulative
1927 stats, so just ignore this. */
1930 totals
= args
->cumulative
;
1932 if (bytes
== 0 && args
->section_sent
== 0)
1934 /* The write is just starting. Let the user know we've started
1936 ui_out_message (current_uiout
, 0, "Loading section %s, size %s lma %s\n",
1937 args
->section_name
, hex_string (args
->section_size
),
1938 paddress (target_gdbarch (), args
->lma
));
1942 if (validate_download
)
1944 /* Broken memories and broken monitors manifest themselves here
1945 when bring new computers to life. This doubles already slow
1947 /* NOTE: cagney/1999-10-18: A more efficient implementation
1948 might add a verify_memory() method to the target vector and
1949 then use that. remote.c could implement that method using
1950 the ``qCRC'' packet. */
1951 gdb_byte
*check
= xmalloc (bytes
);
1952 struct cleanup
*verify_cleanups
= make_cleanup (xfree
, check
);
1954 if (target_read_memory (args
->lma
, check
, bytes
) != 0)
1955 error (_("Download verify read failed at %s"),
1956 paddress (target_gdbarch (), args
->lma
));
1957 if (memcmp (args
->buffer
, check
, bytes
) != 0)
1958 error (_("Download verify compare failed at %s"),
1959 paddress (target_gdbarch (), args
->lma
));
1960 do_cleanups (verify_cleanups
);
1962 totals
->data_count
+= bytes
;
1964 args
->buffer
+= bytes
;
1965 totals
->write_count
+= 1;
1966 args
->section_sent
+= bytes
;
1967 if (check_quit_flag ()
1968 || (deprecated_ui_load_progress_hook
!= NULL
1969 && deprecated_ui_load_progress_hook (args
->section_name
,
1970 args
->section_sent
)))
1971 error (_("Canceled the download"));
1973 if (deprecated_show_load_progress
!= NULL
)
1974 deprecated_show_load_progress (args
->section_name
,
1978 totals
->total_size
);
1981 /* Callback service function for generic_load (bfd_map_over_sections). */
1984 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1986 struct memory_write_request
*new_request
;
1987 struct load_section_data
*args
= data
;
1988 struct load_progress_section_data
*section_data
;
1989 bfd_size_type size
= bfd_get_section_size (asec
);
1991 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1993 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1999 new_request
= VEC_safe_push (memory_write_request_s
,
2000 args
->requests
, NULL
);
2001 memset (new_request
, 0, sizeof (struct memory_write_request
));
2002 section_data
= xcalloc (1, sizeof (struct load_progress_section_data
));
2003 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
2004 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size
2006 new_request
->data
= xmalloc (size
);
2007 new_request
->baton
= section_data
;
2009 buffer
= new_request
->data
;
2011 section_data
->cumulative
= args
->progress_data
;
2012 section_data
->section_name
= sect_name
;
2013 section_data
->section_size
= size
;
2014 section_data
->lma
= new_request
->begin
;
2015 section_data
->buffer
= buffer
;
2017 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
2020 /* Clean up an entire memory request vector, including load
2021 data and progress records. */
2024 clear_memory_write_data (void *arg
)
2026 VEC(memory_write_request_s
) **vec_p
= arg
;
2027 VEC(memory_write_request_s
) *vec
= *vec_p
;
2029 struct memory_write_request
*mr
;
2031 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
2036 VEC_free (memory_write_request_s
, vec
);
2040 generic_load (char *args
, int from_tty
)
2043 struct timeval start_time
, end_time
;
2045 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, 0);
2046 struct load_section_data cbdata
;
2047 struct load_progress_data total_progress
;
2048 struct ui_out
*uiout
= current_uiout
;
2053 memset (&cbdata
, 0, sizeof (cbdata
));
2054 memset (&total_progress
, 0, sizeof (total_progress
));
2055 cbdata
.progress_data
= &total_progress
;
2057 make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
2060 error_no_arg (_("file to load"));
2062 argv
= gdb_buildargv (args
);
2063 make_cleanup_freeargv (argv
);
2065 filename
= tilde_expand (argv
[0]);
2066 make_cleanup (xfree
, filename
);
2068 if (argv
[1] != NULL
)
2072 cbdata
.load_offset
= strtoulst (argv
[1], &endptr
, 0);
2074 /* If the last word was not a valid number then
2075 treat it as a file name with spaces in. */
2076 if (argv
[1] == endptr
)
2077 error (_("Invalid download offset:%s."), argv
[1]);
2079 if (argv
[2] != NULL
)
2080 error (_("Too many parameters."));
2083 /* Open the file for loading. */
2084 loadfile_bfd
= gdb_bfd_open (filename
, gnutarget
, -1);
2085 if (loadfile_bfd
== NULL
)
2087 perror_with_name (filename
);
2091 make_cleanup_bfd_unref (loadfile_bfd
);
2093 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
2095 error (_("\"%s\" is not an object file: %s"), filename
,
2096 bfd_errmsg (bfd_get_error ()));
2099 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
2100 (void *) &total_progress
.total_size
);
2102 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
2104 gettimeofday (&start_time
, NULL
);
2106 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2107 load_progress
) != 0)
2108 error (_("Load failed"));
2110 gettimeofday (&end_time
, NULL
);
2112 entry
= bfd_get_start_address (loadfile_bfd
);
2113 entry
= gdbarch_addr_bits_remove (target_gdbarch (), entry
);
2114 ui_out_text (uiout
, "Start address ");
2115 ui_out_field_fmt (uiout
, "address", "%s", paddress (target_gdbarch (), entry
));
2116 ui_out_text (uiout
, ", load size ");
2117 ui_out_field_fmt (uiout
, "load-size", "%lu", total_progress
.data_count
);
2118 ui_out_text (uiout
, "\n");
2119 /* We were doing this in remote-mips.c, I suspect it is right
2120 for other targets too. */
2121 regcache_write_pc (get_current_regcache (), entry
);
2123 /* Reset breakpoints, now that we have changed the load image. For
2124 instance, breakpoints may have been set (or reset, by
2125 post_create_inferior) while connected to the target but before we
2126 loaded the program. In that case, the prologue analyzer could
2127 have read instructions from the target to find the right
2128 breakpoint locations. Loading has changed the contents of that
2131 breakpoint_re_set ();
2133 /* FIXME: are we supposed to call symbol_file_add or not? According
2134 to a comment from remote-mips.c (where a call to symbol_file_add
2135 was commented out), making the call confuses GDB if more than one
2136 file is loaded in. Some targets do (e.g., remote-vx.c) but
2137 others don't (or didn't - perhaps they have all been deleted). */
2139 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2140 total_progress
.write_count
,
2141 &start_time
, &end_time
);
2143 do_cleanups (old_cleanups
);
2146 /* Report how fast the transfer went. */
2149 print_transfer_performance (struct ui_file
*stream
,
2150 unsigned long data_count
,
2151 unsigned long write_count
,
2152 const struct timeval
*start_time
,
2153 const struct timeval
*end_time
)
2155 ULONGEST time_count
;
2156 struct ui_out
*uiout
= current_uiout
;
2158 /* Compute the elapsed time in milliseconds, as a tradeoff between
2159 accuracy and overflow. */
2160 time_count
= (end_time
->tv_sec
- start_time
->tv_sec
) * 1000;
2161 time_count
+= (end_time
->tv_usec
- start_time
->tv_usec
) / 1000;
2163 ui_out_text (uiout
, "Transfer rate: ");
2166 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / time_count
;
2168 if (ui_out_is_mi_like_p (uiout
))
2170 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
* 8);
2171 ui_out_text (uiout
, " bits/sec");
2173 else if (rate
< 1024)
2175 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
);
2176 ui_out_text (uiout
, " bytes/sec");
2180 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
/ 1024);
2181 ui_out_text (uiout
, " KB/sec");
2186 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
2187 ui_out_text (uiout
, " bits in <1 sec");
2189 if (write_count
> 0)
2191 ui_out_text (uiout
, ", ");
2192 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
2193 ui_out_text (uiout
, " bytes/write");
2195 ui_out_text (uiout
, ".\n");
2198 /* This function allows the addition of incrementally linked object files.
2199 It does not modify any state in the target, only in the debugger. */
2200 /* Note: ezannoni 2000-04-13 This function/command used to have a
2201 special case syntax for the rombug target (Rombug is the boot
2202 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2203 rombug case, the user doesn't need to supply a text address,
2204 instead a call to target_link() (in target.c) would supply the
2205 value to use. We are now discontinuing this type of ad hoc syntax. */
2208 add_symbol_file_command (char *args
, int from_tty
)
2210 struct gdbarch
*gdbarch
= get_current_arch ();
2211 char *filename
= NULL
;
2212 int flags
= OBJF_USERLOADED
;
2214 int section_index
= 0;
2218 int expecting_sec_name
= 0;
2219 int expecting_sec_addr
= 0;
2228 struct section_addr_info
*section_addrs
;
2229 struct sect_opt
*sect_opts
= NULL
;
2230 size_t num_sect_opts
= 0;
2231 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2234 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
2235 * sizeof (struct sect_opt
));
2240 error (_("add-symbol-file takes a file name and an address"));
2242 argv
= gdb_buildargv (args
);
2243 make_cleanup_freeargv (argv
);
2245 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2247 /* Process the argument. */
2250 /* The first argument is the file name. */
2251 filename
= tilde_expand (arg
);
2252 make_cleanup (xfree
, filename
);
2257 /* The second argument is always the text address at which
2258 to load the program. */
2259 sect_opts
[section_index
].name
= ".text";
2260 sect_opts
[section_index
].value
= arg
;
2261 if (++section_index
>= num_sect_opts
)
2264 sect_opts
= ((struct sect_opt
*)
2265 xrealloc (sect_opts
,
2267 * sizeof (struct sect_opt
)));
2272 /* It's an option (starting with '-') or it's an argument
2277 if (strcmp (arg
, "-readnow") == 0)
2278 flags
|= OBJF_READNOW
;
2279 else if (strcmp (arg
, "-s") == 0)
2281 expecting_sec_name
= 1;
2282 expecting_sec_addr
= 1;
2287 if (expecting_sec_name
)
2289 sect_opts
[section_index
].name
= arg
;
2290 expecting_sec_name
= 0;
2293 if (expecting_sec_addr
)
2295 sect_opts
[section_index
].value
= arg
;
2296 expecting_sec_addr
= 0;
2297 if (++section_index
>= num_sect_opts
)
2300 sect_opts
= ((struct sect_opt
*)
2301 xrealloc (sect_opts
,
2303 * sizeof (struct sect_opt
)));
2307 error (_("USAGE: add-symbol-file <filename> <textaddress>"
2308 " [-readnow] [-s <secname> <addr>]*"));
2313 /* This command takes at least two arguments. The first one is a
2314 filename, and the second is the address where this file has been
2315 loaded. Abort now if this address hasn't been provided by the
2317 if (section_index
< 1)
2318 error (_("The address where %s has been loaded is missing"), filename
);
2320 /* Print the prompt for the query below. And save the arguments into
2321 a sect_addr_info structure to be passed around to other
2322 functions. We have to split this up into separate print
2323 statements because hex_string returns a local static
2326 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
2327 section_addrs
= alloc_section_addr_info (section_index
);
2328 make_cleanup (xfree
, section_addrs
);
2329 for (i
= 0; i
< section_index
; i
++)
2332 char *val
= sect_opts
[i
].value
;
2333 char *sec
= sect_opts
[i
].name
;
2335 addr
= parse_and_eval_address (val
);
2337 /* Here we store the section offsets in the order they were
2338 entered on the command line. */
2339 section_addrs
->other
[sec_num
].name
= sec
;
2340 section_addrs
->other
[sec_num
].addr
= addr
;
2341 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2342 paddress (gdbarch
, addr
));
2345 /* The object's sections are initialized when a
2346 call is made to build_objfile_section_table (objfile).
2347 This happens in reread_symbols.
2348 At this point, we don't know what file type this is,
2349 so we can't determine what section names are valid. */
2351 section_addrs
->num_sections
= sec_num
;
2353 if (from_tty
&& (!query ("%s", "")))
2354 error (_("Not confirmed."));
2356 symbol_file_add (filename
, from_tty
? SYMFILE_VERBOSE
: 0,
2357 section_addrs
, flags
);
2359 /* Getting new symbols may change our opinion about what is
2361 reinit_frame_cache ();
2362 do_cleanups (my_cleanups
);
2366 typedef struct objfile
*objfilep
;
2368 DEF_VEC_P (objfilep
);
2370 /* Re-read symbols if a symbol-file has changed. */
2373 reread_symbols (void)
2375 struct objfile
*objfile
;
2377 struct stat new_statbuf
;
2379 VEC (objfilep
) *new_objfiles
= NULL
;
2380 struct cleanup
*all_cleanups
;
2382 all_cleanups
= make_cleanup (VEC_cleanup (objfilep
), &new_objfiles
);
2384 /* With the addition of shared libraries, this should be modified,
2385 the load time should be saved in the partial symbol tables, since
2386 different tables may come from different source files. FIXME.
2387 This routine should then walk down each partial symbol table
2388 and see if the symbol table that it originates from has been changed. */
2390 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2392 /* solib-sunos.c creates one objfile with obfd. */
2393 if (objfile
->obfd
== NULL
)
2396 /* Separate debug objfiles are handled in the main objfile. */
2397 if (objfile
->separate_debug_objfile_backlink
)
2400 /* If this object is from an archive (what you usually create with
2401 `ar', often called a `static library' on most systems, though
2402 a `shared library' on AIX is also an archive), then you should
2403 stat on the archive name, not member name. */
2404 if (objfile
->obfd
->my_archive
)
2405 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2407 res
= stat (objfile
->name
, &new_statbuf
);
2410 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2411 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2415 new_modtime
= new_statbuf
.st_mtime
;
2416 if (new_modtime
!= objfile
->mtime
)
2418 struct cleanup
*old_cleanups
;
2419 struct section_offsets
*offsets
;
2421 char *obfd_filename
;
2423 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2426 /* There are various functions like symbol_file_add,
2427 symfile_bfd_open, syms_from_objfile, etc., which might
2428 appear to do what we want. But they have various other
2429 effects which we *don't* want. So we just do stuff
2430 ourselves. We don't worry about mapped files (for one thing,
2431 any mapped file will be out of date). */
2433 /* If we get an error, blow away this objfile (not sure if
2434 that is the correct response for things like shared
2436 old_cleanups
= make_cleanup_free_objfile (objfile
);
2437 /* We need to do this whenever any symbols go away. */
2438 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2440 if (exec_bfd
!= NULL
2441 && filename_cmp (bfd_get_filename (objfile
->obfd
),
2442 bfd_get_filename (exec_bfd
)) == 0)
2444 /* Reload EXEC_BFD without asking anything. */
2446 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2449 /* Keep the calls order approx. the same as in free_objfile. */
2451 /* Free the separate debug objfiles. It will be
2452 automatically recreated by sym_read. */
2453 free_objfile_separate_debug (objfile
);
2455 /* Remove any references to this objfile in the global
2457 preserve_values (objfile
);
2459 /* Nuke all the state that we will re-read. Much of the following
2460 code which sets things to NULL really is necessary to tell
2461 other parts of GDB that there is nothing currently there.
2463 Try to keep the freeing order compatible with free_objfile. */
2465 if (objfile
->sf
!= NULL
)
2467 (*objfile
->sf
->sym_finish
) (objfile
);
2470 clear_objfile_data (objfile
);
2472 /* Clean up any state BFD has sitting around. */
2474 struct bfd
*obfd
= objfile
->obfd
;
2476 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2477 /* Open the new BFD before freeing the old one, so that
2478 the filename remains live. */
2479 objfile
->obfd
= gdb_bfd_open_maybe_remote (obfd_filename
);
2480 if (objfile
->obfd
== NULL
)
2482 /* We have to make a cleanup and error here, rather
2483 than erroring later, because once we unref OBFD,
2484 OBFD_FILENAME will be freed. */
2485 make_cleanup_bfd_unref (obfd
);
2486 error (_("Can't open %s to read symbols."), obfd_filename
);
2488 gdb_bfd_unref (obfd
);
2491 objfile
->name
= bfd_get_filename (objfile
->obfd
);
2492 /* bfd_openr sets cacheable to true, which is what we want. */
2493 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2494 error (_("Can't read symbols from %s: %s."), objfile
->name
,
2495 bfd_errmsg (bfd_get_error ()));
2497 /* Save the offsets, we will nuke them with the rest of the
2499 num_offsets
= objfile
->num_sections
;
2500 offsets
= ((struct section_offsets
*)
2501 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2502 memcpy (offsets
, objfile
->section_offsets
,
2503 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2505 /* FIXME: Do we have to free a whole linked list, or is this
2507 if (objfile
->global_psymbols
.list
)
2508 xfree (objfile
->global_psymbols
.list
);
2509 memset (&objfile
->global_psymbols
, 0,
2510 sizeof (objfile
->global_psymbols
));
2511 if (objfile
->static_psymbols
.list
)
2512 xfree (objfile
->static_psymbols
.list
);
2513 memset (&objfile
->static_psymbols
, 0,
2514 sizeof (objfile
->static_psymbols
));
2516 /* Free the obstacks for non-reusable objfiles. */
2517 psymbol_bcache_free (objfile
->psymbol_cache
);
2518 objfile
->psymbol_cache
= psymbol_bcache_init ();
2519 if (objfile
->demangled_names_hash
!= NULL
)
2521 htab_delete (objfile
->demangled_names_hash
);
2522 objfile
->demangled_names_hash
= NULL
;
2524 obstack_free (&objfile
->objfile_obstack
, 0);
2525 objfile
->sections
= NULL
;
2526 objfile
->symtabs
= NULL
;
2527 objfile
->psymtabs
= NULL
;
2528 objfile
->psymtabs_addrmap
= NULL
;
2529 objfile
->free_psymtabs
= NULL
;
2530 objfile
->template_symbols
= NULL
;
2531 objfile
->msymbols
= NULL
;
2532 objfile
->minimal_symbol_count
= 0;
2533 memset (&objfile
->msymbol_hash
, 0,
2534 sizeof (objfile
->msymbol_hash
));
2535 memset (&objfile
->msymbol_demangled_hash
, 0,
2536 sizeof (objfile
->msymbol_demangled_hash
));
2538 set_objfile_per_bfd (objfile
);
2540 /* obstack_init also initializes the obstack so it is
2541 empty. We could use obstack_specify_allocation but
2542 gdb_obstack.h specifies the alloc/dealloc functions. */
2543 obstack_init (&objfile
->objfile_obstack
);
2544 build_objfile_section_table (objfile
);
2545 terminate_minimal_symbol_table (objfile
);
2547 /* We use the same section offsets as from last time. I'm not
2548 sure whether that is always correct for shared libraries. */
2549 objfile
->section_offsets
= (struct section_offsets
*)
2550 obstack_alloc (&objfile
->objfile_obstack
,
2551 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2552 memcpy (objfile
->section_offsets
, offsets
,
2553 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2554 objfile
->num_sections
= num_offsets
;
2556 /* What the hell is sym_new_init for, anyway? The concept of
2557 distinguishing between the main file and additional files
2558 in this way seems rather dubious. */
2559 if (objfile
== symfile_objfile
)
2561 (*objfile
->sf
->sym_new_init
) (objfile
);
2564 (*objfile
->sf
->sym_init
) (objfile
);
2565 clear_complaints (&symfile_complaints
, 1, 1);
2567 objfile
->flags
&= ~OBJF_PSYMTABS_READ
;
2568 read_symbols (objfile
, 0);
2570 if (!objfile_has_symbols (objfile
))
2573 printf_unfiltered (_("(no debugging symbols found)\n"));
2577 /* We're done reading the symbol file; finish off complaints. */
2578 clear_complaints (&symfile_complaints
, 0, 1);
2580 /* Getting new symbols may change our opinion about what is
2583 reinit_frame_cache ();
2585 /* Discard cleanups as symbol reading was successful. */
2586 discard_cleanups (old_cleanups
);
2588 /* If the mtime has changed between the time we set new_modtime
2589 and now, we *want* this to be out of date, so don't call stat
2591 objfile
->mtime
= new_modtime
;
2592 init_entry_point_info (objfile
);
2594 VEC_safe_push (objfilep
, new_objfiles
, objfile
);
2602 /* Notify objfiles that we've modified objfile sections. */
2603 objfiles_changed ();
2605 clear_symtab_users (0);
2607 /* clear_objfile_data for each objfile was called before freeing it and
2608 observer_notify_new_objfile (NULL) has been called by
2609 clear_symtab_users above. Notify the new files now. */
2610 for (ix
= 0; VEC_iterate (objfilep
, new_objfiles
, ix
, objfile
); ix
++)
2611 observer_notify_new_objfile (objfile
);
2613 /* At least one objfile has changed, so we can consider that
2614 the executable we're debugging has changed too. */
2615 observer_notify_executable_changed ();
2618 do_cleanups (all_cleanups
);
2629 static filename_language
*filename_language_table
;
2630 static int fl_table_size
, fl_table_next
;
2633 add_filename_language (char *ext
, enum language lang
)
2635 if (fl_table_next
>= fl_table_size
)
2637 fl_table_size
+= 10;
2638 filename_language_table
=
2639 xrealloc (filename_language_table
,
2640 fl_table_size
* sizeof (*filename_language_table
));
2643 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2644 filename_language_table
[fl_table_next
].lang
= lang
;
2648 static char *ext_args
;
2650 show_ext_args (struct ui_file
*file
, int from_tty
,
2651 struct cmd_list_element
*c
, const char *value
)
2653 fprintf_filtered (file
,
2654 _("Mapping between filename extension "
2655 "and source language is \"%s\".\n"),
2660 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2663 char *cp
= ext_args
;
2666 /* First arg is filename extension, starting with '.' */
2668 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2670 /* Find end of first arg. */
2671 while (*cp
&& !isspace (*cp
))
2675 error (_("'%s': two arguments required -- "
2676 "filename extension and language"),
2679 /* Null-terminate first arg. */
2682 /* Find beginning of second arg, which should be a source language. */
2683 cp
= skip_spaces (cp
);
2686 error (_("'%s': two arguments required -- "
2687 "filename extension and language"),
2690 /* Lookup the language from among those we know. */
2691 lang
= language_enum (cp
);
2693 /* Now lookup the filename extension: do we already know it? */
2694 for (i
= 0; i
< fl_table_next
; i
++)
2695 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2698 if (i
>= fl_table_next
)
2700 /* New file extension. */
2701 add_filename_language (ext_args
, lang
);
2705 /* Redefining a previously known filename extension. */
2708 /* query ("Really make files of type %s '%s'?", */
2709 /* ext_args, language_str (lang)); */
2711 xfree (filename_language_table
[i
].ext
);
2712 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2713 filename_language_table
[i
].lang
= lang
;
2718 info_ext_lang_command (char *args
, int from_tty
)
2722 printf_filtered (_("Filename extensions and the languages they represent:"));
2723 printf_filtered ("\n\n");
2724 for (i
= 0; i
< fl_table_next
; i
++)
2725 printf_filtered ("\t%s\t- %s\n",
2726 filename_language_table
[i
].ext
,
2727 language_str (filename_language_table
[i
].lang
));
2731 init_filename_language_table (void)
2733 if (fl_table_size
== 0) /* Protect against repetition. */
2737 filename_language_table
=
2738 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2739 add_filename_language (".c", language_c
);
2740 add_filename_language (".d", language_d
);
2741 add_filename_language (".C", language_cplus
);
2742 add_filename_language (".cc", language_cplus
);
2743 add_filename_language (".cp", language_cplus
);
2744 add_filename_language (".cpp", language_cplus
);
2745 add_filename_language (".cxx", language_cplus
);
2746 add_filename_language (".c++", language_cplus
);
2747 add_filename_language (".java", language_java
);
2748 add_filename_language (".class", language_java
);
2749 add_filename_language (".m", language_objc
);
2750 add_filename_language (".f", language_fortran
);
2751 add_filename_language (".F", language_fortran
);
2752 add_filename_language (".for", language_fortran
);
2753 add_filename_language (".FOR", language_fortran
);
2754 add_filename_language (".ftn", language_fortran
);
2755 add_filename_language (".FTN", language_fortran
);
2756 add_filename_language (".fpp", language_fortran
);
2757 add_filename_language (".FPP", language_fortran
);
2758 add_filename_language (".f90", language_fortran
);
2759 add_filename_language (".F90", language_fortran
);
2760 add_filename_language (".f95", language_fortran
);
2761 add_filename_language (".F95", language_fortran
);
2762 add_filename_language (".f03", language_fortran
);
2763 add_filename_language (".F03", language_fortran
);
2764 add_filename_language (".f08", language_fortran
);
2765 add_filename_language (".F08", language_fortran
);
2766 add_filename_language (".s", language_asm
);
2767 add_filename_language (".sx", language_asm
);
2768 add_filename_language (".S", language_asm
);
2769 add_filename_language (".pas", language_pascal
);
2770 add_filename_language (".p", language_pascal
);
2771 add_filename_language (".pp", language_pascal
);
2772 add_filename_language (".adb", language_ada
);
2773 add_filename_language (".ads", language_ada
);
2774 add_filename_language (".a", language_ada
);
2775 add_filename_language (".ada", language_ada
);
2776 add_filename_language (".dg", language_ada
);
2781 deduce_language_from_filename (const char *filename
)
2786 if (filename
!= NULL
)
2787 if ((cp
= strrchr (filename
, '.')) != NULL
)
2788 for (i
= 0; i
< fl_table_next
; i
++)
2789 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2790 return filename_language_table
[i
].lang
;
2792 return language_unknown
;
2797 Allocate and partly initialize a new symbol table. Return a pointer
2798 to it. error() if no space.
2800 Caller must set these fields:
2809 allocate_symtab (const char *filename
, struct objfile
*objfile
)
2811 struct symtab
*symtab
;
2813 symtab
= (struct symtab
*)
2814 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2815 memset (symtab
, 0, sizeof (*symtab
));
2816 symtab
->filename
= (char *) bcache (filename
, strlen (filename
) + 1,
2817 objfile
->per_bfd
->filename_cache
);
2818 symtab
->fullname
= NULL
;
2819 symtab
->language
= deduce_language_from_filename (filename
);
2820 symtab
->debugformat
= "unknown";
2822 /* Hook it to the objfile it comes from. */
2824 symtab
->objfile
= objfile
;
2825 symtab
->next
= objfile
->symtabs
;
2826 objfile
->symtabs
= symtab
;
2828 if (symtab_create_debug
)
2830 /* Be a bit clever with debugging messages, and don't print objfile
2831 every time, only when it changes. */
2832 static char *last_objfile_name
= NULL
;
2834 if (last_objfile_name
== NULL
2835 || strcmp (last_objfile_name
, objfile
->name
) != 0)
2837 xfree (last_objfile_name
);
2838 last_objfile_name
= xstrdup (objfile
->name
);
2839 fprintf_unfiltered (gdb_stdlog
,
2840 "Creating one or more symtabs for objfile %s ...\n",
2843 fprintf_unfiltered (gdb_stdlog
,
2844 "Created symtab %s for module %s.\n",
2845 host_address_to_string (symtab
), filename
);
2852 /* Reset all data structures in gdb which may contain references to symbol
2853 table data. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
2856 clear_symtab_users (int add_flags
)
2858 /* Someday, we should do better than this, by only blowing away
2859 the things that really need to be blown. */
2861 /* Clear the "current" symtab first, because it is no longer valid.
2862 breakpoint_re_set may try to access the current symtab. */
2863 clear_current_source_symtab_and_line ();
2866 if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
2867 breakpoint_re_set ();
2868 clear_last_displayed_sal ();
2869 clear_pc_function_cache ();
2870 observer_notify_new_objfile (NULL
);
2872 /* Clear globals which might have pointed into a removed objfile.
2873 FIXME: It's not clear which of these are supposed to persist
2874 between expressions and which ought to be reset each time. */
2875 expression_context_block
= NULL
;
2876 innermost_block
= NULL
;
2878 /* Varobj may refer to old symbols, perform a cleanup. */
2879 varobj_invalidate ();
2884 clear_symtab_users_cleanup (void *ignore
)
2886 clear_symtab_users (0);
2890 The following code implements an abstraction for debugging overlay sections.
2892 The target model is as follows:
2893 1) The gnu linker will permit multiple sections to be mapped into the
2894 same VMA, each with its own unique LMA (or load address).
2895 2) It is assumed that some runtime mechanism exists for mapping the
2896 sections, one by one, from the load address into the VMA address.
2897 3) This code provides a mechanism for gdb to keep track of which
2898 sections should be considered to be mapped from the VMA to the LMA.
2899 This information is used for symbol lookup, and memory read/write.
2900 For instance, if a section has been mapped then its contents
2901 should be read from the VMA, otherwise from the LMA.
2903 Two levels of debugger support for overlays are available. One is
2904 "manual", in which the debugger relies on the user to tell it which
2905 overlays are currently mapped. This level of support is
2906 implemented entirely in the core debugger, and the information about
2907 whether a section is mapped is kept in the objfile->obj_section table.
2909 The second level of support is "automatic", and is only available if
2910 the target-specific code provides functionality to read the target's
2911 overlay mapping table, and translate its contents for the debugger
2912 (by updating the mapped state information in the obj_section tables).
2914 The interface is as follows:
2916 overlay map <name> -- tell gdb to consider this section mapped
2917 overlay unmap <name> -- tell gdb to consider this section unmapped
2918 overlay list -- list the sections that GDB thinks are mapped
2919 overlay read-target -- get the target's state of what's mapped
2920 overlay off/manual/auto -- set overlay debugging state
2921 Functional interface:
2922 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2923 section, return that section.
2924 find_pc_overlay(pc): find any overlay section that contains
2925 the pc, either in its VMA or its LMA
2926 section_is_mapped(sect): true if overlay is marked as mapped
2927 section_is_overlay(sect): true if section's VMA != LMA
2928 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2929 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2930 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2931 overlay_mapped_address(...): map an address from section's LMA to VMA
2932 overlay_unmapped_address(...): map an address from section's VMA to LMA
2933 symbol_overlayed_address(...): Return a "current" address for symbol:
2934 either in VMA or LMA depending on whether
2935 the symbol's section is currently mapped. */
2937 /* Overlay debugging state: */
2939 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2940 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state. */
2942 /* Function: section_is_overlay (SECTION)
2943 Returns true if SECTION has VMA not equal to LMA, ie.
2944 SECTION is loaded at an address different from where it will "run". */
2947 section_is_overlay (struct obj_section
*section
)
2949 if (overlay_debugging
&& section
)
2951 bfd
*abfd
= section
->objfile
->obfd
;
2952 asection
*bfd_section
= section
->the_bfd_section
;
2954 if (bfd_section_lma (abfd
, bfd_section
) != 0
2955 && bfd_section_lma (abfd
, bfd_section
)
2956 != bfd_section_vma (abfd
, bfd_section
))
2963 /* Function: overlay_invalidate_all (void)
2964 Invalidate the mapped state of all overlay sections (mark it as stale). */
2967 overlay_invalidate_all (void)
2969 struct objfile
*objfile
;
2970 struct obj_section
*sect
;
2972 ALL_OBJSECTIONS (objfile
, sect
)
2973 if (section_is_overlay (sect
))
2974 sect
->ovly_mapped
= -1;
2977 /* Function: section_is_mapped (SECTION)
2978 Returns true if section is an overlay, and is currently mapped.
2980 Access to the ovly_mapped flag is restricted to this function, so
2981 that we can do automatic update. If the global flag
2982 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2983 overlay_invalidate_all. If the mapped state of the particular
2984 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2987 section_is_mapped (struct obj_section
*osect
)
2989 struct gdbarch
*gdbarch
;
2991 if (osect
== 0 || !section_is_overlay (osect
))
2994 switch (overlay_debugging
)
2998 return 0; /* overlay debugging off */
2999 case ovly_auto
: /* overlay debugging automatic */
3000 /* Unles there is a gdbarch_overlay_update function,
3001 there's really nothing useful to do here (can't really go auto). */
3002 gdbarch
= get_objfile_arch (osect
->objfile
);
3003 if (gdbarch_overlay_update_p (gdbarch
))
3005 if (overlay_cache_invalid
)
3007 overlay_invalidate_all ();
3008 overlay_cache_invalid
= 0;
3010 if (osect
->ovly_mapped
== -1)
3011 gdbarch_overlay_update (gdbarch
, osect
);
3013 /* fall thru to manual case */
3014 case ovly_on
: /* overlay debugging manual */
3015 return osect
->ovly_mapped
== 1;
3019 /* Function: pc_in_unmapped_range
3020 If PC falls into the lma range of SECTION, return true, else false. */
3023 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3025 if (section_is_overlay (section
))
3027 bfd
*abfd
= section
->objfile
->obfd
;
3028 asection
*bfd_section
= section
->the_bfd_section
;
3030 /* We assume the LMA is relocated by the same offset as the VMA. */
3031 bfd_vma size
= bfd_get_section_size (bfd_section
);
3032 CORE_ADDR offset
= obj_section_offset (section
);
3034 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3035 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3042 /* Function: pc_in_mapped_range
3043 If PC falls into the vma range of SECTION, return true, else false. */
3046 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3048 if (section_is_overlay (section
))
3050 if (obj_section_addr (section
) <= pc
3051 && pc
< obj_section_endaddr (section
))
3058 /* Return true if the mapped ranges of sections A and B overlap, false
3062 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3064 CORE_ADDR a_start
= obj_section_addr (a
);
3065 CORE_ADDR a_end
= obj_section_endaddr (a
);
3066 CORE_ADDR b_start
= obj_section_addr (b
);
3067 CORE_ADDR b_end
= obj_section_endaddr (b
);
3069 return (a_start
< b_end
&& b_start
< a_end
);
3072 /* Function: overlay_unmapped_address (PC, SECTION)
3073 Returns the address corresponding to PC in the unmapped (load) range.
3074 May be the same as PC. */
3077 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3079 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3081 bfd
*abfd
= section
->objfile
->obfd
;
3082 asection
*bfd_section
= section
->the_bfd_section
;
3084 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3085 - bfd_section_vma (abfd
, bfd_section
);
3091 /* Function: overlay_mapped_address (PC, SECTION)
3092 Returns the address corresponding to PC in the mapped (runtime) range.
3093 May be the same as PC. */
3096 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3098 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3100 bfd
*abfd
= section
->objfile
->obfd
;
3101 asection
*bfd_section
= section
->the_bfd_section
;
3103 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3104 - bfd_section_lma (abfd
, bfd_section
);
3110 /* Function: symbol_overlayed_address
3111 Return one of two addresses (relative to the VMA or to the LMA),
3112 depending on whether the section is mapped or not. */
3115 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3117 if (overlay_debugging
)
3119 /* If the symbol has no section, just return its regular address. */
3122 /* If the symbol's section is not an overlay, just return its
3124 if (!section_is_overlay (section
))
3126 /* If the symbol's section is mapped, just return its address. */
3127 if (section_is_mapped (section
))
3130 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3131 * then return its LOADED address rather than its vma address!!
3133 return overlay_unmapped_address (address
, section
);
3138 /* Function: find_pc_overlay (PC)
3139 Return the best-match overlay section for PC:
3140 If PC matches a mapped overlay section's VMA, return that section.
3141 Else if PC matches an unmapped section's VMA, return that section.
3142 Else if PC matches an unmapped section's LMA, return that section. */
3144 struct obj_section
*
3145 find_pc_overlay (CORE_ADDR pc
)
3147 struct objfile
*objfile
;
3148 struct obj_section
*osect
, *best_match
= NULL
;
3150 if (overlay_debugging
)
3151 ALL_OBJSECTIONS (objfile
, osect
)
3152 if (section_is_overlay (osect
))
3154 if (pc_in_mapped_range (pc
, osect
))
3156 if (section_is_mapped (osect
))
3161 else if (pc_in_unmapped_range (pc
, osect
))
3167 /* Function: find_pc_mapped_section (PC)
3168 If PC falls into the VMA address range of an overlay section that is
3169 currently marked as MAPPED, return that section. Else return NULL. */
3171 struct obj_section
*
3172 find_pc_mapped_section (CORE_ADDR pc
)
3174 struct objfile
*objfile
;
3175 struct obj_section
*osect
;
3177 if (overlay_debugging
)
3178 ALL_OBJSECTIONS (objfile
, osect
)
3179 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3185 /* Function: list_overlays_command
3186 Print a list of mapped sections and their PC ranges. */
3189 list_overlays_command (char *args
, int from_tty
)
3192 struct objfile
*objfile
;
3193 struct obj_section
*osect
;
3195 if (overlay_debugging
)
3196 ALL_OBJSECTIONS (objfile
, osect
)
3197 if (section_is_mapped (osect
))
3199 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3204 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3205 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3206 size
= bfd_get_section_size (osect
->the_bfd_section
);
3207 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3209 printf_filtered ("Section %s, loaded at ", name
);
3210 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3211 puts_filtered (" - ");
3212 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3213 printf_filtered (", mapped at ");
3214 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3215 puts_filtered (" - ");
3216 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3217 puts_filtered ("\n");
3222 printf_filtered (_("No sections are mapped.\n"));
3225 /* Function: map_overlay_command
3226 Mark the named section as mapped (ie. residing at its VMA address). */
3229 map_overlay_command (char *args
, int from_tty
)
3231 struct objfile
*objfile
, *objfile2
;
3232 struct obj_section
*sec
, *sec2
;
3234 if (!overlay_debugging
)
3235 error (_("Overlay debugging not enabled. Use "
3236 "either the 'overlay auto' or\n"
3237 "the 'overlay manual' command."));
3239 if (args
== 0 || *args
== 0)
3240 error (_("Argument required: name of an overlay section"));
3242 /* First, find a section matching the user supplied argument. */
3243 ALL_OBJSECTIONS (objfile
, sec
)
3244 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3246 /* Now, check to see if the section is an overlay. */
3247 if (!section_is_overlay (sec
))
3248 continue; /* not an overlay section */
3250 /* Mark the overlay as "mapped". */
3251 sec
->ovly_mapped
= 1;
3253 /* Next, make a pass and unmap any sections that are
3254 overlapped by this new section: */
3255 ALL_OBJSECTIONS (objfile2
, sec2
)
3256 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3259 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3260 bfd_section_name (objfile
->obfd
,
3261 sec2
->the_bfd_section
));
3262 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2. */
3266 error (_("No overlay section called %s"), args
);
3269 /* Function: unmap_overlay_command
3270 Mark the overlay section as unmapped
3271 (ie. resident in its LMA address range, rather than the VMA range). */
3274 unmap_overlay_command (char *args
, int from_tty
)
3276 struct objfile
*objfile
;
3277 struct obj_section
*sec
;
3279 if (!overlay_debugging
)
3280 error (_("Overlay debugging not enabled. "
3281 "Use either the 'overlay auto' or\n"
3282 "the 'overlay manual' command."));
3284 if (args
== 0 || *args
== 0)
3285 error (_("Argument required: name of an overlay section"));
3287 /* First, find a section matching the user supplied argument. */
3288 ALL_OBJSECTIONS (objfile
, sec
)
3289 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3291 if (!sec
->ovly_mapped
)
3292 error (_("Section %s is not mapped"), args
);
3293 sec
->ovly_mapped
= 0;
3296 error (_("No overlay section called %s"), args
);
3299 /* Function: overlay_auto_command
3300 A utility command to turn on overlay debugging.
3301 Possibly this should be done via a set/show command. */
3304 overlay_auto_command (char *args
, int from_tty
)
3306 overlay_debugging
= ovly_auto
;
3307 enable_overlay_breakpoints ();
3309 printf_unfiltered (_("Automatic overlay debugging enabled."));
3312 /* Function: overlay_manual_command
3313 A utility command to turn on overlay debugging.
3314 Possibly this should be done via a set/show command. */
3317 overlay_manual_command (char *args
, int from_tty
)
3319 overlay_debugging
= ovly_on
;
3320 disable_overlay_breakpoints ();
3322 printf_unfiltered (_("Overlay debugging enabled."));
3325 /* Function: overlay_off_command
3326 A utility command to turn on overlay debugging.
3327 Possibly this should be done via a set/show command. */
3330 overlay_off_command (char *args
, int from_tty
)
3332 overlay_debugging
= ovly_off
;
3333 disable_overlay_breakpoints ();
3335 printf_unfiltered (_("Overlay debugging disabled."));
3339 overlay_load_command (char *args
, int from_tty
)
3341 struct gdbarch
*gdbarch
= get_current_arch ();
3343 if (gdbarch_overlay_update_p (gdbarch
))
3344 gdbarch_overlay_update (gdbarch
, NULL
);
3346 error (_("This target does not know how to read its overlay state."));
3349 /* Function: overlay_command
3350 A place-holder for a mis-typed command. */
3352 /* Command list chain containing all defined "overlay" subcommands. */
3353 static struct cmd_list_element
*overlaylist
;
3356 overlay_command (char *args
, int from_tty
)
3359 ("\"overlay\" must be followed by the name of an overlay command.\n");
3360 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3363 /* Target Overlays for the "Simplest" overlay manager:
3365 This is GDB's default target overlay layer. It works with the
3366 minimal overlay manager supplied as an example by Cygnus. The
3367 entry point is via a function pointer "gdbarch_overlay_update",
3368 so targets that use a different runtime overlay manager can
3369 substitute their own overlay_update function and take over the
3372 The overlay_update function pokes around in the target's data structures
3373 to see what overlays are mapped, and updates GDB's overlay mapping with
3376 In this simple implementation, the target data structures are as follows:
3377 unsigned _novlys; /# number of overlay sections #/
3378 unsigned _ovly_table[_novlys][4] = {
3379 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3380 {..., ..., ..., ...},
3382 unsigned _novly_regions; /# number of overlay regions #/
3383 unsigned _ovly_region_table[_novly_regions][3] = {
3384 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3387 These functions will attempt to update GDB's mappedness state in the
3388 symbol section table, based on the target's mappedness state.
3390 To do this, we keep a cached copy of the target's _ovly_table, and
3391 attempt to detect when the cached copy is invalidated. The main
3392 entry point is "simple_overlay_update(SECT), which looks up SECT in
3393 the cached table and re-reads only the entry for that section from
3394 the target (whenever possible). */
3396 /* Cached, dynamically allocated copies of the target data structures: */
3397 static unsigned (*cache_ovly_table
)[4] = 0;
3398 static unsigned cache_novlys
= 0;
3399 static CORE_ADDR cache_ovly_table_base
= 0;
3402 VMA
, SIZE
, LMA
, MAPPED
3405 /* Throw away the cached copy of _ovly_table. */
3408 simple_free_overlay_table (void)
3410 if (cache_ovly_table
)
3411 xfree (cache_ovly_table
);
3413 cache_ovly_table
= NULL
;
3414 cache_ovly_table_base
= 0;
3417 /* Read an array of ints of size SIZE from the target into a local buffer.
3418 Convert to host order. int LEN is number of ints. */
3421 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3422 int len
, int size
, enum bfd_endian byte_order
)
3424 /* FIXME (alloca): Not safe if array is very large. */
3425 gdb_byte
*buf
= alloca (len
* size
);
3428 read_memory (memaddr
, buf
, len
* size
);
3429 for (i
= 0; i
< len
; i
++)
3430 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3433 /* Find and grab a copy of the target _ovly_table
3434 (and _novlys, which is needed for the table's size). */
3437 simple_read_overlay_table (void)
3439 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3440 struct gdbarch
*gdbarch
;
3442 enum bfd_endian byte_order
;
3444 simple_free_overlay_table ();
3445 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3448 error (_("Error reading inferior's overlay table: "
3449 "couldn't find `_novlys' variable\n"
3450 "in inferior. Use `overlay manual' mode."));
3454 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3455 if (! ovly_table_msym
)
3457 error (_("Error reading inferior's overlay table: couldn't find "
3458 "`_ovly_table' array\n"
3459 "in inferior. Use `overlay manual' mode."));
3463 gdbarch
= get_objfile_arch (msymbol_objfile (ovly_table_msym
));
3464 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3465 byte_order
= gdbarch_byte_order (gdbarch
);
3467 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
),
3470 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3471 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3472 read_target_long_array (cache_ovly_table_base
,
3473 (unsigned int *) cache_ovly_table
,
3474 cache_novlys
* 4, word_size
, byte_order
);
3476 return 1; /* SUCCESS */
3479 /* Function: simple_overlay_update_1
3480 A helper function for simple_overlay_update. Assuming a cached copy
3481 of _ovly_table exists, look through it to find an entry whose vma,
3482 lma and size match those of OSECT. Re-read the entry and make sure
3483 it still matches OSECT (else the table may no longer be valid).
3484 Set OSECT's mapped state to match the entry. Return: 1 for
3485 success, 0 for failure. */
3488 simple_overlay_update_1 (struct obj_section
*osect
)
3491 bfd
*obfd
= osect
->objfile
->obfd
;
3492 asection
*bsect
= osect
->the_bfd_section
;
3493 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3494 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3495 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3497 size
= bfd_get_section_size (osect
->the_bfd_section
);
3498 for (i
= 0; i
< cache_novlys
; i
++)
3499 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3500 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3501 /* && cache_ovly_table[i][SIZE] == size */ )
3503 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3504 (unsigned int *) cache_ovly_table
[i
],
3505 4, word_size
, byte_order
);
3506 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3507 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3508 /* && cache_ovly_table[i][SIZE] == size */ )
3510 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3513 else /* Warning! Warning! Target's ovly table has changed! */
3519 /* Function: simple_overlay_update
3520 If OSECT is NULL, then update all sections' mapped state
3521 (after re-reading the entire target _ovly_table).
3522 If OSECT is non-NULL, then try to find a matching entry in the
3523 cached ovly_table and update only OSECT's mapped state.
3524 If a cached entry can't be found or the cache isn't valid, then
3525 re-read the entire cache, and go ahead and update all sections. */
3528 simple_overlay_update (struct obj_section
*osect
)
3530 struct objfile
*objfile
;
3532 /* Were we given an osect to look up? NULL means do all of them. */
3534 /* Have we got a cached copy of the target's overlay table? */
3535 if (cache_ovly_table
!= NULL
)
3537 /* Does its cached location match what's currently in the
3539 struct minimal_symbol
*minsym
3540 = lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3543 error (_("Error reading inferior's overlay table: couldn't "
3544 "find `_ovly_table' array\n"
3545 "in inferior. Use `overlay manual' mode."));
3547 if (cache_ovly_table_base
== SYMBOL_VALUE_ADDRESS (minsym
))
3548 /* Then go ahead and try to look up this single section in
3550 if (simple_overlay_update_1 (osect
))
3551 /* Found it! We're done. */
3555 /* Cached table no good: need to read the entire table anew.
3556 Or else we want all the sections, in which case it's actually
3557 more efficient to read the whole table in one block anyway. */
3559 if (! simple_read_overlay_table ())
3562 /* Now may as well update all sections, even if only one was requested. */
3563 ALL_OBJSECTIONS (objfile
, osect
)
3564 if (section_is_overlay (osect
))
3567 bfd
*obfd
= osect
->objfile
->obfd
;
3568 asection
*bsect
= osect
->the_bfd_section
;
3570 size
= bfd_get_section_size (bsect
);
3571 for (i
= 0; i
< cache_novlys
; i
++)
3572 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3573 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3574 /* && cache_ovly_table[i][SIZE] == size */ )
3575 { /* obj_section matches i'th entry in ovly_table. */
3576 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3577 break; /* finished with inner for loop: break out. */
3582 /* Set the output sections and output offsets for section SECTP in
3583 ABFD. The relocation code in BFD will read these offsets, so we
3584 need to be sure they're initialized. We map each section to itself,
3585 with no offset; this means that SECTP->vma will be honored. */
3588 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3590 sectp
->output_section
= sectp
;
3591 sectp
->output_offset
= 0;
3594 /* Default implementation for sym_relocate. */
3597 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3600 /* Use sectp->owner instead of objfile->obfd. sectp may point to a
3602 bfd
*abfd
= sectp
->owner
;
3604 /* We're only interested in sections with relocation
3606 if ((sectp
->flags
& SEC_RELOC
) == 0)
3609 /* We will handle section offsets properly elsewhere, so relocate as if
3610 all sections begin at 0. */
3611 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3613 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3616 /* Relocate the contents of a debug section SECTP in ABFD. The
3617 contents are stored in BUF if it is non-NULL, or returned in a
3618 malloc'd buffer otherwise.
3620 For some platforms and debug info formats, shared libraries contain
3621 relocations against the debug sections (particularly for DWARF-2;
3622 one affected platform is PowerPC GNU/Linux, although it depends on
3623 the version of the linker in use). Also, ELF object files naturally
3624 have unresolved relocations for their debug sections. We need to apply
3625 the relocations in order to get the locations of symbols correct.
3626 Another example that may require relocation processing, is the
3627 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3631 symfile_relocate_debug_section (struct objfile
*objfile
,
3632 asection
*sectp
, bfd_byte
*buf
)
3634 gdb_assert (objfile
->sf
->sym_relocate
);
3636 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3639 struct symfile_segment_data
*
3640 get_symfile_segment_data (bfd
*abfd
)
3642 const struct sym_fns
*sf
= find_sym_fns (abfd
);
3647 return sf
->sym_segments (abfd
);
3651 free_symfile_segment_data (struct symfile_segment_data
*data
)
3653 xfree (data
->segment_bases
);
3654 xfree (data
->segment_sizes
);
3655 xfree (data
->segment_info
);
3660 - DATA, containing segment addresses from the object file ABFD, and
3661 the mapping from ABFD's sections onto the segments that own them,
3663 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3664 segment addresses reported by the target,
3665 store the appropriate offsets for each section in OFFSETS.
3667 If there are fewer entries in SEGMENT_BASES than there are segments
3668 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3670 If there are more entries, then ignore the extra. The target may
3671 not be able to distinguish between an empty data segment and a
3672 missing data segment; a missing text segment is less plausible. */
3675 symfile_map_offsets_to_segments (bfd
*abfd
,
3676 const struct symfile_segment_data
*data
,
3677 struct section_offsets
*offsets
,
3678 int num_segment_bases
,
3679 const CORE_ADDR
*segment_bases
)
3684 /* It doesn't make sense to call this function unless you have some
3685 segment base addresses. */
3686 gdb_assert (num_segment_bases
> 0);
3688 /* If we do not have segment mappings for the object file, we
3689 can not relocate it by segments. */
3690 gdb_assert (data
!= NULL
);
3691 gdb_assert (data
->num_segments
> 0);
3693 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3695 int which
= data
->segment_info
[i
];
3697 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3699 /* Don't bother computing offsets for sections that aren't
3700 loaded as part of any segment. */
3704 /* Use the last SEGMENT_BASES entry as the address of any extra
3705 segments mentioned in DATA->segment_info. */
3706 if (which
> num_segment_bases
)
3707 which
= num_segment_bases
;
3709 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3710 - data
->segment_bases
[which
- 1]);
3717 symfile_find_segment_sections (struct objfile
*objfile
)
3719 bfd
*abfd
= objfile
->obfd
;
3722 struct symfile_segment_data
*data
;
3724 data
= get_symfile_segment_data (objfile
->obfd
);
3728 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3730 free_symfile_segment_data (data
);
3734 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3736 int which
= data
->segment_info
[i
];
3740 if (objfile
->sect_index_text
== -1)
3741 objfile
->sect_index_text
= sect
->index
;
3743 if (objfile
->sect_index_rodata
== -1)
3744 objfile
->sect_index_rodata
= sect
->index
;
3746 else if (which
== 2)
3748 if (objfile
->sect_index_data
== -1)
3749 objfile
->sect_index_data
= sect
->index
;
3751 if (objfile
->sect_index_bss
== -1)
3752 objfile
->sect_index_bss
= sect
->index
;
3756 free_symfile_segment_data (data
);
3760 _initialize_symfile (void)
3762 struct cmd_list_element
*c
;
3764 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3765 Load symbol table from executable file FILE.\n\
3766 The `file' command can also load symbol tables, as well as setting the file\n\
3767 to execute."), &cmdlist
);
3768 set_cmd_completer (c
, filename_completer
);
3770 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3771 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3772 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR>\
3773 ...]\nADDR is the starting address of the file's text.\n\
3774 The optional arguments are section-name section-address pairs and\n\
3775 should be specified if the data and bss segments are not contiguous\n\
3776 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3778 set_cmd_completer (c
, filename_completer
);
3780 c
= add_cmd ("load", class_files
, load_command
, _("\
3781 Dynamically load FILE into the running program, and record its symbols\n\
3782 for access from GDB.\n\
3783 A load OFFSET may also be given."), &cmdlist
);
3784 set_cmd_completer (c
, filename_completer
);
3786 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3787 _("Commands for debugging overlays."), &overlaylist
,
3788 "overlay ", 0, &cmdlist
);
3790 add_com_alias ("ovly", "overlay", class_alias
, 1);
3791 add_com_alias ("ov", "overlay", class_alias
, 1);
3793 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3794 _("Assert that an overlay section is mapped."), &overlaylist
);
3796 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3797 _("Assert that an overlay section is unmapped."), &overlaylist
);
3799 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3800 _("List mappings of overlay sections."), &overlaylist
);
3802 add_cmd ("manual", class_support
, overlay_manual_command
,
3803 _("Enable overlay debugging."), &overlaylist
);
3804 add_cmd ("off", class_support
, overlay_off_command
,
3805 _("Disable overlay debugging."), &overlaylist
);
3806 add_cmd ("auto", class_support
, overlay_auto_command
,
3807 _("Enable automatic overlay debugging."), &overlaylist
);
3808 add_cmd ("load-target", class_support
, overlay_load_command
,
3809 _("Read the overlay mapping state from the target."), &overlaylist
);
3811 /* Filename extension to source language lookup table: */
3812 init_filename_language_table ();
3813 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3815 Set mapping between filename extension and source language."), _("\
3816 Show mapping between filename extension and source language."), _("\
3817 Usage: set extension-language .foo bar"),
3818 set_ext_lang_command
,
3820 &setlist
, &showlist
);
3822 add_info ("extensions", info_ext_lang_command
,
3823 _("All filename extensions associated with a source language."));
3825 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3826 &debug_file_directory
, _("\
3827 Set the directories where separate debug symbols are searched for."), _("\
3828 Show the directories where separate debug symbols are searched for."), _("\
3829 Separate debug symbols are first searched for in the same\n\
3830 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3831 and lastly at the path of the directory of the binary with\n\
3832 each global debug-file-directory component prepended."),
3834 show_debug_file_directory
,
3835 &setlist
, &showlist
);