1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support, using pieces from other GDB modules.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "arch-utils.h"
37 #include "breakpoint.h"
39 #include "complaints.h"
43 #include "filenames.h" /* for DOSish file names */
44 #include "gdb-stabs.h"
45 #include "gdb_obstack.h"
46 #include "completer.h"
49 #include "readline/readline.h"
50 #include "gdb_assert.h"
54 #include "parser-defs.h"
60 #include <sys/types.h>
62 #include "gdb_string.h"
69 int (*deprecated_ui_load_progress_hook
) (const char *section
, unsigned long num
);
70 void (*deprecated_show_load_progress
) (const char *section
,
71 unsigned long section_sent
,
72 unsigned long section_size
,
73 unsigned long total_sent
,
74 unsigned long total_size
);
75 void (*deprecated_pre_add_symbol_hook
) (const char *);
76 void (*deprecated_post_add_symbol_hook
) (void);
78 static void clear_symtab_users_cleanup (void *ignore
);
80 /* Global variables owned by this file */
81 int readnow_symbol_files
; /* Read full symbols immediately */
83 /* External variables and functions referenced. */
85 extern void report_transfer_performance (unsigned long, time_t, time_t);
87 /* Functions this file defines */
90 static int simple_read_overlay_region_table (void);
91 static void simple_free_overlay_region_table (void);
94 static void load_command (char *, int);
96 static void symbol_file_add_main_1 (char *args
, int from_tty
, int flags
);
98 static void add_symbol_file_command (char *, int);
100 bfd
*symfile_bfd_open (char *);
102 int get_section_index (struct objfile
*, char *);
104 static struct sym_fns
*find_sym_fns (bfd
*);
106 static void decrement_reading_symtab (void *);
108 static void overlay_invalidate_all (void);
110 void list_overlays_command (char *, int);
112 void map_overlay_command (char *, int);
114 void unmap_overlay_command (char *, int);
116 static void overlay_auto_command (char *, int);
118 static void overlay_manual_command (char *, int);
120 static void overlay_off_command (char *, int);
122 static void overlay_load_command (char *, int);
124 static void overlay_command (char *, int);
126 static void simple_free_overlay_table (void);
128 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
131 static int simple_read_overlay_table (void);
133 static int simple_overlay_update_1 (struct obj_section
*);
135 static void add_filename_language (char *ext
, enum language lang
);
137 static void info_ext_lang_command (char *args
, int from_tty
);
139 static void init_filename_language_table (void);
141 static void symfile_find_segment_sections (struct objfile
*objfile
);
143 void _initialize_symfile (void);
145 /* List of all available sym_fns. On gdb startup, each object file reader
146 calls add_symtab_fns() to register information on each format it is
149 static struct sym_fns
*symtab_fns
= NULL
;
151 /* Flag for whether user will be reloading symbols multiple times.
152 Defaults to ON for VxWorks, otherwise OFF. */
154 #ifdef SYMBOL_RELOADING_DEFAULT
155 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
157 int symbol_reloading
= 0;
160 show_symbol_reloading (struct ui_file
*file
, int from_tty
,
161 struct cmd_list_element
*c
, const char *value
)
163 fprintf_filtered (file
, _("\
164 Dynamic symbol table reloading multiple times in one run is %s.\n"),
168 /* If non-zero, shared library symbols will be added automatically
169 when the inferior is created, new libraries are loaded, or when
170 attaching to the inferior. This is almost always what users will
171 want to have happen; but for very large programs, the startup time
172 will be excessive, and so if this is a problem, the user can clear
173 this flag and then add the shared library symbols as needed. Note
174 that there is a potential for confusion, since if the shared
175 library symbols are not loaded, commands like "info fun" will *not*
176 report all the functions that are actually present. */
178 int auto_solib_add
= 1;
180 /* For systems that support it, a threshold size in megabytes. If
181 automatically adding a new library's symbol table to those already
182 known to the debugger would cause the total shared library symbol
183 size to exceed this threshhold, then the shlib's symbols are not
184 added. The threshold is ignored if the user explicitly asks for a
185 shlib to be added, such as when using the "sharedlibrary"
188 int auto_solib_limit
;
191 /* This compares two partial symbols by names, using strcmp_iw_ordered
192 for the comparison. */
195 compare_psymbols (const void *s1p
, const void *s2p
)
197 struct partial_symbol
*const *s1
= s1p
;
198 struct partial_symbol
*const *s2
= s2p
;
200 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1
),
201 SYMBOL_SEARCH_NAME (*s2
));
205 sort_pst_symbols (struct partial_symtab
*pst
)
207 /* Sort the global list; don't sort the static list */
209 qsort (pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
,
210 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
214 /* Make a null terminated copy of the string at PTR with SIZE characters in
215 the obstack pointed to by OBSTACKP . Returns the address of the copy.
216 Note that the string at PTR does not have to be null terminated, I.E. it
217 may be part of a larger string and we are only saving a substring. */
220 obsavestring (const char *ptr
, int size
, struct obstack
*obstackp
)
222 char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
223 /* Open-coded memcpy--saves function call time. These strings are usually
224 short. FIXME: Is this really still true with a compiler that can
227 const char *p1
= ptr
;
229 const char *end
= ptr
+ size
;
237 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
238 in the obstack pointed to by OBSTACKP. */
241 obconcat (struct obstack
*obstackp
, const char *s1
, const char *s2
,
244 int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
245 char *val
= (char *) obstack_alloc (obstackp
, len
);
252 /* True if we are nested inside psymtab_to_symtab. */
254 int currently_reading_symtab
= 0;
257 decrement_reading_symtab (void *dummy
)
259 currently_reading_symtab
--;
262 /* Get the symbol table that corresponds to a partial_symtab.
263 This is fast after the first time you do it. In fact, there
264 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
268 psymtab_to_symtab (struct partial_symtab
*pst
)
270 /* If it's been looked up before, return it. */
274 /* If it has not yet been read in, read it. */
277 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
278 currently_reading_symtab
++;
279 (*pst
->read_symtab
) (pst
);
280 do_cleanups (back_to
);
286 /* Remember the lowest-addressed loadable section we've seen.
287 This function is called via bfd_map_over_sections.
289 In case of equal vmas, the section with the largest size becomes the
290 lowest-addressed loadable section.
292 If the vmas and sizes are equal, the last section is considered the
293 lowest-addressed loadable section. */
296 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
298 asection
**lowest
= (asection
**) obj
;
300 if (0 == (bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
)))
303 *lowest
= sect
; /* First loadable section */
304 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
305 *lowest
= sect
; /* A lower loadable section */
306 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
307 && (bfd_section_size (abfd
, (*lowest
))
308 <= bfd_section_size (abfd
, sect
)))
312 /* Create a new section_addr_info, with room for NUM_SECTIONS. */
314 struct section_addr_info
*
315 alloc_section_addr_info (size_t num_sections
)
317 struct section_addr_info
*sap
;
320 size
= (sizeof (struct section_addr_info
)
321 + sizeof (struct other_sections
) * (num_sections
- 1));
322 sap
= (struct section_addr_info
*) xmalloc (size
);
323 memset (sap
, 0, size
);
324 sap
->num_sections
= num_sections
;
329 /* Build (allocate and populate) a section_addr_info struct from
330 an existing section table. */
332 extern struct section_addr_info
*
333 build_section_addr_info_from_section_table (const struct target_section
*start
,
334 const struct target_section
*end
)
336 struct section_addr_info
*sap
;
337 const struct target_section
*stp
;
340 sap
= alloc_section_addr_info (end
- start
);
342 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
344 if (bfd_get_section_flags (stp
->bfd
,
345 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
346 && oidx
< end
- start
)
348 sap
->other
[oidx
].addr
= stp
->addr
;
349 sap
->other
[oidx
].name
350 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
351 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
359 /* Create a section_addr_info from section offsets in OBJFILE. */
361 struct section_addr_info
*
362 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
364 struct section_addr_info
*sap
;
366 struct bfd_section
*sec
;
367 int addr_bit
= gdbarch_addr_bit (objfile
->gdbarch
);
368 CORE_ADDR mask
= CORE_ADDR_MAX
;
370 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
371 mask
= ((CORE_ADDR
) 1 << addr_bit
) - 1;
373 sap
= alloc_section_addr_info (objfile
->num_sections
);
374 for (i
= 0, sec
= objfile
->obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
375 if (bfd_get_section_flags (objfile
->obfd
, sec
) & (SEC_ALLOC
| SEC_LOAD
))
377 sap
->other
[i
].addr
= (bfd_get_section_vma (objfile
->obfd
, sec
)
378 + objfile
->section_offsets
->offsets
[i
]) & mask
;
379 sap
->other
[i
].name
= xstrdup (bfd_get_section_name (objfile
->obfd
,
381 sap
->other
[i
].sectindex
= sec
->index
;
388 /* Free all memory allocated by build_section_addr_info_from_section_table. */
391 free_section_addr_info (struct section_addr_info
*sap
)
395 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
396 if (sap
->other
[idx
].name
)
397 xfree (sap
->other
[idx
].name
);
402 /* Initialize OBJFILE's sect_index_* members. */
404 init_objfile_sect_indices (struct objfile
*objfile
)
409 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
411 objfile
->sect_index_text
= sect
->index
;
413 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
415 objfile
->sect_index_data
= sect
->index
;
417 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
419 objfile
->sect_index_bss
= sect
->index
;
421 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
423 objfile
->sect_index_rodata
= sect
->index
;
425 /* This is where things get really weird... We MUST have valid
426 indices for the various sect_index_* members or gdb will abort.
427 So if for example, there is no ".text" section, we have to
428 accomodate that. First, check for a file with the standard
429 one or two segments. */
431 symfile_find_segment_sections (objfile
);
433 /* Except when explicitly adding symbol files at some address,
434 section_offsets contains nothing but zeros, so it doesn't matter
435 which slot in section_offsets the individual sect_index_* members
436 index into. So if they are all zero, it is safe to just point
437 all the currently uninitialized indices to the first slot. But
438 beware: if this is the main executable, it may be relocated
439 later, e.g. by the remote qOffsets packet, and then this will
440 be wrong! That's why we try segments first. */
442 for (i
= 0; i
< objfile
->num_sections
; i
++)
444 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
449 if (i
== objfile
->num_sections
)
451 if (objfile
->sect_index_text
== -1)
452 objfile
->sect_index_text
= 0;
453 if (objfile
->sect_index_data
== -1)
454 objfile
->sect_index_data
= 0;
455 if (objfile
->sect_index_bss
== -1)
456 objfile
->sect_index_bss
= 0;
457 if (objfile
->sect_index_rodata
== -1)
458 objfile
->sect_index_rodata
= 0;
462 /* The arguments to place_section. */
464 struct place_section_arg
466 struct section_offsets
*offsets
;
470 /* Find a unique offset to use for loadable section SECT if
471 the user did not provide an offset. */
474 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
476 struct place_section_arg
*arg
= obj
;
477 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
479 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
481 /* We are only interested in allocated sections. */
482 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
485 /* If the user specified an offset, honor it. */
486 if (offsets
[sect
->index
] != 0)
489 /* Otherwise, let's try to find a place for the section. */
490 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
497 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
499 int indx
= cur_sec
->index
;
500 CORE_ADDR cur_offset
;
502 /* We don't need to compare against ourself. */
506 /* We can only conflict with allocated sections. */
507 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
510 /* If the section offset is 0, either the section has not been placed
511 yet, or it was the lowest section placed (in which case LOWEST
512 will be past its end). */
513 if (offsets
[indx
] == 0)
516 /* If this section would overlap us, then we must move up. */
517 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
518 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
520 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
521 start_addr
= (start_addr
+ align
- 1) & -align
;
526 /* Otherwise, we appear to be OK. So far. */
531 offsets
[sect
->index
] = start_addr
;
532 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
535 /* Store struct section_addr_info as prepared (made relative and with SECTINDEX
536 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
540 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
542 struct section_addr_info
*addrs
)
546 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
548 /* Now calculate offsets for section that were specified by the caller. */
549 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
551 struct other_sections
*osp
;
553 osp
= &addrs
->other
[i
];
557 /* Record all sections in offsets */
558 /* The section_offsets in the objfile are here filled in using
560 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
564 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
565 also SECTINDEXes specific to ABFD there. This function can be used to
566 rebase ADDRS to start referencing different BFD than before. */
569 addr_info_make_relative (struct section_addr_info
*addrs
, bfd
*abfd
)
571 asection
*lower_sect
;
572 CORE_ADDR lower_offset
;
575 /* Find lowest loadable section to be used as starting point for
576 continguous sections. */
578 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
579 if (lower_sect
== NULL
)
581 warning (_("no loadable sections found in added symbol-file %s"),
582 bfd_get_filename (abfd
));
586 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
588 /* Calculate offsets for the loadable sections.
589 FIXME! Sections must be in order of increasing loadable section
590 so that contiguous sections can use the lower-offset!!!
592 Adjust offsets if the segments are not contiguous.
593 If the section is contiguous, its offset should be set to
594 the offset of the highest loadable section lower than it
595 (the loadable section directly below it in memory).
596 this_offset = lower_offset = lower_addr - lower_orig_addr */
598 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
600 asection
*sect
= bfd_get_section_by_name (abfd
, addrs
->other
[i
].name
);
604 /* This is the index used by BFD. */
605 addrs
->other
[i
].sectindex
= sect
->index
;
607 if (addrs
->other
[i
].addr
!= 0)
609 addrs
->other
[i
].addr
-= bfd_section_vma (abfd
, sect
);
610 lower_offset
= addrs
->other
[i
].addr
;
613 addrs
->other
[i
].addr
= lower_offset
;
617 warning (_("section %s not found in %s"), addrs
->other
[i
].name
,
618 bfd_get_filename (abfd
));
619 addrs
->other
[i
].addr
= 0;
621 /* SECTINDEX is invalid if ADDR is zero. */
626 /* Parse the user's idea of an offset for dynamic linking, into our idea
627 of how to represent it for fast symbol reading. This is the default
628 version of the sym_fns.sym_offsets function for symbol readers that
629 don't need to do anything special. It allocates a section_offsets table
630 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
633 default_symfile_offsets (struct objfile
*objfile
,
634 struct section_addr_info
*addrs
)
636 objfile
->num_sections
= bfd_count_sections (objfile
->obfd
);
637 objfile
->section_offsets
= (struct section_offsets
*)
638 obstack_alloc (&objfile
->objfile_obstack
,
639 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
640 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
641 objfile
->num_sections
, addrs
);
643 /* For relocatable files, all loadable sections will start at zero.
644 The zero is meaningless, so try to pick arbitrary addresses such
645 that no loadable sections overlap. This algorithm is quadratic,
646 but the number of sections in a single object file is generally
648 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
650 struct place_section_arg arg
;
651 bfd
*abfd
= objfile
->obfd
;
653 CORE_ADDR lowest
= 0;
655 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
656 /* We do not expect this to happen; just skip this step if the
657 relocatable file has a section with an assigned VMA. */
658 if (bfd_section_vma (abfd
, cur_sec
) != 0)
663 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
665 /* Pick non-overlapping offsets for sections the user did not
667 arg
.offsets
= objfile
->section_offsets
;
669 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
671 /* Correctly filling in the section offsets is not quite
672 enough. Relocatable files have two properties that
673 (most) shared objects do not:
675 - Their debug information will contain relocations. Some
676 shared libraries do also, but many do not, so this can not
679 - If there are multiple code sections they will be loaded
680 at different relative addresses in memory than they are
681 in the objfile, since all sections in the file will start
684 Because GDB has very limited ability to map from an
685 address in debug info to the correct code section,
686 it relies on adding SECT_OFF_TEXT to things which might be
687 code. If we clear all the section offsets, and set the
688 section VMAs instead, then symfile_relocate_debug_section
689 will return meaningful debug information pointing at the
692 GDB has too many different data structures for section
693 addresses - a bfd, objfile, and so_list all have section
694 tables, as does exec_ops. Some of these could probably
697 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
698 cur_sec
= cur_sec
->next
)
700 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
703 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
704 exec_set_section_address (bfd_get_filename (abfd
), cur_sec
->index
,
705 offsets
[cur_sec
->index
]);
706 offsets
[cur_sec
->index
] = 0;
711 /* Remember the bfd indexes for the .text, .data, .bss and
713 init_objfile_sect_indices (objfile
);
717 /* Divide the file into segments, which are individual relocatable units.
718 This is the default version of the sym_fns.sym_segments function for
719 symbol readers that do not have an explicit representation of segments.
720 It assumes that object files do not have segments, and fully linked
721 files have a single segment. */
723 struct symfile_segment_data
*
724 default_symfile_segments (bfd
*abfd
)
728 struct symfile_segment_data
*data
;
731 /* Relocatable files contain enough information to position each
732 loadable section independently; they should not be relocated
734 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
737 /* Make sure there is at least one loadable section in the file. */
738 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
740 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
748 low
= bfd_get_section_vma (abfd
, sect
);
749 high
= low
+ bfd_get_section_size (sect
);
751 data
= XZALLOC (struct symfile_segment_data
);
752 data
->num_segments
= 1;
753 data
->segment_bases
= XCALLOC (1, CORE_ADDR
);
754 data
->segment_sizes
= XCALLOC (1, CORE_ADDR
);
756 num_sections
= bfd_count_sections (abfd
);
757 data
->segment_info
= XCALLOC (num_sections
, int);
759 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
763 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
766 vma
= bfd_get_section_vma (abfd
, sect
);
769 if (vma
+ bfd_get_section_size (sect
) > high
)
770 high
= vma
+ bfd_get_section_size (sect
);
772 data
->segment_info
[i
] = 1;
775 data
->segment_bases
[0] = low
;
776 data
->segment_sizes
[0] = high
- low
;
781 /* Process a symbol file, as either the main file or as a dynamically
784 OBJFILE is where the symbols are to be read from.
786 ADDRS is the list of section load addresses. If the user has given
787 an 'add-symbol-file' command, then this is the list of offsets and
788 addresses he or she provided as arguments to the command; or, if
789 we're handling a shared library, these are the actual addresses the
790 sections are loaded at, according to the inferior's dynamic linker
791 (as gleaned by GDB's shared library code). We convert each address
792 into an offset from the section VMA's as it appears in the object
793 file, and then call the file's sym_offsets function to convert this
794 into a format-specific offset table --- a `struct section_offsets'.
795 If ADDRS is non-zero, OFFSETS must be zero.
797 OFFSETS is a table of section offsets already in the right
798 format-specific representation. NUM_OFFSETS is the number of
799 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
800 assume this is the proper table the call to sym_offsets described
801 above would produce. Instead of calling sym_offsets, we just dump
802 it right into objfile->section_offsets. (When we're re-reading
803 symbols from an objfile, we don't have the original load address
804 list any more; all we have is the section offset table.) If
805 OFFSETS is non-zero, ADDRS must be zero.
807 ADD_FLAGS encodes verbosity level, whether this is main symbol or
808 an extra symbol file such as dynamically loaded code, and wether
809 breakpoint reset should be deferred. */
812 syms_from_objfile (struct objfile
*objfile
,
813 struct section_addr_info
*addrs
,
814 struct section_offsets
*offsets
,
818 struct section_addr_info
*local_addr
= NULL
;
819 struct cleanup
*old_chain
;
820 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
822 gdb_assert (! (addrs
&& offsets
));
824 init_entry_point_info (objfile
);
825 objfile
->sf
= find_sym_fns (objfile
->obfd
);
827 if (objfile
->sf
== NULL
)
828 return; /* No symbols. */
830 /* Make sure that partially constructed symbol tables will be cleaned up
831 if an error occurs during symbol reading. */
832 old_chain
= make_cleanup_free_objfile (objfile
);
834 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
835 list. We now establish the convention that an addr of zero means
836 no load address was specified. */
837 if (! addrs
&& ! offsets
)
840 = alloc_section_addr_info (bfd_count_sections (objfile
->obfd
));
841 make_cleanup (xfree
, local_addr
);
845 /* Now either addrs or offsets is non-zero. */
849 /* We will modify the main symbol table, make sure that all its users
850 will be cleaned up if an error occurs during symbol reading. */
851 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
853 /* Since no error yet, throw away the old symbol table. */
855 if (symfile_objfile
!= NULL
)
857 free_objfile (symfile_objfile
);
858 gdb_assert (symfile_objfile
== NULL
);
861 /* Currently we keep symbols from the add-symbol-file command.
862 If the user wants to get rid of them, they should do "symbol-file"
863 without arguments first. Not sure this is the best behavior
866 (*objfile
->sf
->sym_new_init
) (objfile
);
869 /* Convert addr into an offset rather than an absolute address.
870 We find the lowest address of a loaded segment in the objfile,
871 and assume that <addr> is where that got loaded.
873 We no longer warn if the lowest section is not a text segment (as
874 happens for the PA64 port. */
875 if (addrs
&& addrs
->other
[0].name
)
876 addr_info_make_relative (addrs
, objfile
->obfd
);
878 /* Initialize symbol reading routines for this objfile, allow complaints to
879 appear for this new file, and record how verbose to be, then do the
880 initial symbol reading for this file. */
882 (*objfile
->sf
->sym_init
) (objfile
);
883 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
886 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
889 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
891 /* Just copy in the offset table directly as given to us. */
892 objfile
->num_sections
= num_offsets
;
893 objfile
->section_offsets
894 = ((struct section_offsets
*)
895 obstack_alloc (&objfile
->objfile_obstack
, size
));
896 memcpy (objfile
->section_offsets
, offsets
, size
);
898 init_objfile_sect_indices (objfile
);
901 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
903 /* Discard cleanups as symbol reading was successful. */
905 discard_cleanups (old_chain
);
909 /* Perform required actions after either reading in the initial
910 symbols for a new objfile, or mapping in the symbols from a reusable
914 new_symfile_objfile (struct objfile
*objfile
, int add_flags
)
917 /* If this is the main symbol file we have to clean up all users of the
918 old main symbol file. Otherwise it is sufficient to fixup all the
919 breakpoints that may have been redefined by this symbol file. */
920 if (add_flags
& SYMFILE_MAINLINE
)
922 /* OK, make it the "real" symbol file. */
923 symfile_objfile
= objfile
;
925 clear_symtab_users ();
927 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
929 breakpoint_re_set ();
932 /* We're done reading the symbol file; finish off complaints. */
933 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
936 /* Process a symbol file, as either the main file or as a dynamically
939 ABFD is a BFD already open on the file, as from symfile_bfd_open.
940 This BFD will be closed on error, and is always consumed by this function.
942 ADD_FLAGS encodes verbosity, whether this is main symbol file or
943 extra, such as dynamically loaded code, and what to do with breakpoins.
945 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
946 syms_from_objfile, above.
947 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
949 Upon success, returns a pointer to the objfile that was added.
950 Upon failure, jumps back to command level (never returns). */
952 static struct objfile
*
953 symbol_file_add_with_addrs_or_offsets (bfd
*abfd
,
955 struct section_addr_info
*addrs
,
956 struct section_offsets
*offsets
,
960 struct objfile
*objfile
;
961 struct partial_symtab
*psymtab
;
962 struct cleanup
*my_cleanups
;
963 const char *name
= bfd_get_filename (abfd
);
964 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
966 my_cleanups
= make_cleanup_bfd_close (abfd
);
968 /* Give user a chance to burp if we'd be
969 interactively wiping out any existing symbols. */
971 if ((have_full_symbols () || have_partial_symbols ())
972 && (add_flags
& SYMFILE_MAINLINE
)
974 && !query (_("Load new symbol table from \"%s\"? "), name
))
975 error (_("Not confirmed."));
977 objfile
= allocate_objfile (abfd
, flags
);
978 discard_cleanups (my_cleanups
);
980 /* We either created a new mapped symbol table, mapped an existing
981 symbol table file which has not had initial symbol reading
982 performed, or need to read an unmapped symbol table. */
983 if (from_tty
|| info_verbose
)
985 if (deprecated_pre_add_symbol_hook
)
986 deprecated_pre_add_symbol_hook (name
);
989 printf_unfiltered (_("Reading symbols from %s..."), name
);
991 gdb_flush (gdb_stdout
);
994 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
997 /* We now have at least a partial symbol table. Check to see if the
998 user requested that all symbols be read on initial access via either
999 the gdb startup command line or on a per symbol file basis. Expand
1000 all partial symbol tables for this objfile if so. */
1002 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
1004 if (from_tty
|| info_verbose
)
1006 printf_unfiltered (_("expanding to full symbols..."));
1008 gdb_flush (gdb_stdout
);
1011 for (psymtab
= objfile
->psymtabs
;
1013 psymtab
= psymtab
->next
)
1015 psymtab_to_symtab (psymtab
);
1019 if ((from_tty
|| info_verbose
)
1020 && !objfile_has_symbols (objfile
))
1023 printf_unfiltered (_("(no debugging symbols found)..."));
1027 if (from_tty
|| info_verbose
)
1029 if (deprecated_post_add_symbol_hook
)
1030 deprecated_post_add_symbol_hook ();
1032 printf_unfiltered (_("done.\n"));
1035 /* We print some messages regardless of whether 'from_tty ||
1036 info_verbose' is true, so make sure they go out at the right
1038 gdb_flush (gdb_stdout
);
1040 do_cleanups (my_cleanups
);
1042 if (objfile
->sf
== NULL
)
1044 observer_notify_new_objfile (objfile
);
1045 return objfile
; /* No symbols. */
1048 new_symfile_objfile (objfile
, add_flags
);
1050 observer_notify_new_objfile (objfile
);
1052 bfd_cache_close_all ();
1056 /* Add BFD as a separate debug file for OBJFILE. */
1059 symbol_file_add_separate (bfd
*bfd
, int symfile_flags
, struct objfile
*objfile
)
1061 struct objfile
*new_objfile
;
1062 struct section_addr_info
*sap
;
1063 struct cleanup
*my_cleanup
;
1065 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1066 because sections of BFD may not match sections of OBJFILE and because
1067 vma may have been modified by tools such as prelink. */
1068 sap
= build_section_addr_info_from_objfile (objfile
);
1069 my_cleanup
= make_cleanup_free_section_addr_info (sap
);
1071 new_objfile
= symbol_file_add_with_addrs_or_offsets
1072 (bfd
, symfile_flags
,
1074 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1075 | OBJF_USERLOADED
));
1077 do_cleanups (my_cleanup
);
1079 add_separate_debug_objfile (new_objfile
, objfile
);
1082 /* Process the symbol file ABFD, as either the main file or as a
1083 dynamically loaded file.
1085 See symbol_file_add_with_addrs_or_offsets's comments for
1088 symbol_file_add_from_bfd (bfd
*abfd
, int add_flags
,
1089 struct section_addr_info
*addrs
,
1092 return symbol_file_add_with_addrs_or_offsets (abfd
, add_flags
, addrs
, 0, 0,
1097 /* Process a symbol file, as either the main file or as a dynamically
1098 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1101 symbol_file_add (char *name
, int add_flags
, struct section_addr_info
*addrs
,
1104 return symbol_file_add_from_bfd (symfile_bfd_open (name
), add_flags
, addrs
,
1109 /* Call symbol_file_add() with default values and update whatever is
1110 affected by the loading of a new main().
1111 Used when the file is supplied in the gdb command line
1112 and by some targets with special loading requirements.
1113 The auxiliary function, symbol_file_add_main_1(), has the flags
1114 argument for the switches that can only be specified in the symbol_file
1118 symbol_file_add_main (char *args
, int from_tty
)
1120 symbol_file_add_main_1 (args
, from_tty
, 0);
1124 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1126 const int add_flags
= SYMFILE_MAINLINE
| (from_tty
? SYMFILE_VERBOSE
: 0);
1127 symbol_file_add (args
, add_flags
, NULL
, flags
);
1129 /* Getting new symbols may change our opinion about
1130 what is frameless. */
1131 reinit_frame_cache ();
1133 set_initial_language ();
1137 symbol_file_clear (int from_tty
)
1139 if ((have_full_symbols () || have_partial_symbols ())
1142 ? !query (_("Discard symbol table from `%s'? "),
1143 symfile_objfile
->name
)
1144 : !query (_("Discard symbol table? "))))
1145 error (_("Not confirmed."));
1147 free_all_objfiles ();
1149 /* solib descriptors may have handles to objfiles. Since their
1150 storage has just been released, we'd better wipe the solib
1151 descriptors as well. */
1152 no_shared_libraries (NULL
, from_tty
);
1154 gdb_assert (symfile_objfile
== NULL
);
1156 printf_unfiltered (_("No symbol file now.\n"));
1160 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1163 bfd_size_type debuglink_size
;
1164 unsigned long crc32
;
1169 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1174 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1176 contents
= xmalloc (debuglink_size
);
1177 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1178 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1180 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1181 crc_offset
= strlen (contents
) + 1;
1182 crc_offset
= (crc_offset
+ 3) & ~3;
1184 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1191 separate_debug_file_exists (const char *name
, unsigned long crc
,
1192 struct objfile
*parent_objfile
)
1194 unsigned long file_crc
= 0;
1196 gdb_byte buffer
[8*1024];
1198 struct stat parent_stat
, abfd_stat
;
1200 /* Find a separate debug info file as if symbols would be present in
1201 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1202 section can contain just the basename of PARENT_OBJFILE without any
1203 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1204 the separate debug infos with the same basename can exist. */
1206 if (strcmp (name
, parent_objfile
->name
) == 0)
1209 abfd
= bfd_open_maybe_remote (name
);
1214 /* Verify symlinks were not the cause of strcmp name difference above.
1216 Some operating systems, e.g. Windows, do not provide a meaningful
1217 st_ino; they always set it to zero. (Windows does provide a
1218 meaningful st_dev.) Do not indicate a duplicate library in that
1219 case. While there is no guarantee that a system that provides
1220 meaningful inode numbers will never set st_ino to zero, this is
1221 merely an optimization, so we do not need to worry about false
1224 if (bfd_stat (abfd
, &abfd_stat
) == 0
1225 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0
1226 && abfd_stat
.st_dev
== parent_stat
.st_dev
1227 && abfd_stat
.st_ino
== parent_stat
.st_ino
1228 && abfd_stat
.st_ino
!= 0)
1234 while ((count
= bfd_bread (buffer
, sizeof (buffer
), abfd
)) > 0)
1235 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1239 if (crc
!= file_crc
)
1241 warning (_("the debug information found in \"%s\""
1242 " does not match \"%s\" (CRC mismatch).\n"),
1243 name
, parent_objfile
->name
);
1250 char *debug_file_directory
= NULL
;
1252 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1253 struct cmd_list_element
*c
, const char *value
)
1255 fprintf_filtered (file
, _("\
1256 The directory where separate debug symbols are searched for is \"%s\".\n"),
1260 #if ! defined (DEBUG_SUBDIRECTORY)
1261 #define DEBUG_SUBDIRECTORY ".debug"
1265 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1268 char *basename
, *name_copy
, *debugdir
;
1270 char *debugfile
= NULL
;
1271 char *canon_name
= NULL
;
1272 bfd_size_type debuglink_size
;
1273 unsigned long crc32
;
1276 basename
= get_debug_link_info (objfile
, &crc32
);
1278 if (basename
== NULL
)
1279 /* There's no separate debug info, hence there's no way we could
1280 load it => no warning. */
1281 goto cleanup_return_debugfile
;
1283 dir
= xstrdup (objfile
->name
);
1285 /* Strip off the final filename part, leaving the directory name,
1286 followed by a slash. Objfile names should always be absolute and
1287 tilde-expanded, so there should always be a slash in there
1289 for (i
= strlen(dir
) - 1; i
>= 0; i
--)
1291 if (IS_DIR_SEPARATOR (dir
[i
]))
1294 gdb_assert (i
>= 0 && IS_DIR_SEPARATOR (dir
[i
]));
1297 /* Set I to max (strlen (canon_name), strlen (dir)). */
1298 canon_name
= lrealpath (dir
);
1300 if (canon_name
&& strlen (canon_name
) > i
)
1301 i
= strlen (canon_name
);
1303 debugfile
= xmalloc (strlen (debug_file_directory
) + 1
1305 + strlen (DEBUG_SUBDIRECTORY
)
1310 /* First try in the same directory as the original file. */
1311 strcpy (debugfile
, dir
);
1312 strcat (debugfile
, basename
);
1314 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1315 goto cleanup_return_debugfile
;
1317 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1318 strcpy (debugfile
, dir
);
1319 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1320 strcat (debugfile
, "/");
1321 strcat (debugfile
, basename
);
1323 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1324 goto cleanup_return_debugfile
;
1326 /* Then try in the global debugfile directories.
1328 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1329 cause "/..." lookups. */
1331 debugdir
= debug_file_directory
;
1336 while (*debugdir
== DIRNAME_SEPARATOR
)
1339 debugdir_end
= strchr (debugdir
, DIRNAME_SEPARATOR
);
1340 if (debugdir_end
== NULL
)
1341 debugdir_end
= &debugdir
[strlen (debugdir
)];
1343 memcpy (debugfile
, debugdir
, debugdir_end
- debugdir
);
1344 debugfile
[debugdir_end
- debugdir
] = 0;
1345 strcat (debugfile
, "/");
1346 strcat (debugfile
, dir
);
1347 strcat (debugfile
, basename
);
1349 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1350 goto cleanup_return_debugfile
;
1352 /* If the file is in the sysroot, try using its base path in the
1353 global debugfile directory. */
1355 && strncmp (canon_name
, gdb_sysroot
, strlen (gdb_sysroot
)) == 0
1356 && IS_DIR_SEPARATOR (canon_name
[strlen (gdb_sysroot
)]))
1358 memcpy (debugfile
, debugdir
, debugdir_end
- debugdir
);
1359 debugfile
[debugdir_end
- debugdir
] = 0;
1360 strcat (debugfile
, canon_name
+ strlen (gdb_sysroot
));
1361 strcat (debugfile
, "/");
1362 strcat (debugfile
, basename
);
1364 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1365 goto cleanup_return_debugfile
;
1368 debugdir
= debugdir_end
;
1370 while (*debugdir
!= 0);
1375 cleanup_return_debugfile
:
1383 /* This is the symbol-file command. Read the file, analyze its
1384 symbols, and add a struct symtab to a symtab list. The syntax of
1385 the command is rather bizarre:
1387 1. The function buildargv implements various quoting conventions
1388 which are undocumented and have little or nothing in common with
1389 the way things are quoted (or not quoted) elsewhere in GDB.
1391 2. Options are used, which are not generally used in GDB (perhaps
1392 "set mapped on", "set readnow on" would be better)
1394 3. The order of options matters, which is contrary to GNU
1395 conventions (because it is confusing and inconvenient). */
1398 symbol_file_command (char *args
, int from_tty
)
1404 symbol_file_clear (from_tty
);
1408 char **argv
= gdb_buildargv (args
);
1409 int flags
= OBJF_USERLOADED
;
1410 struct cleanup
*cleanups
;
1413 cleanups
= make_cleanup_freeargv (argv
);
1414 while (*argv
!= NULL
)
1416 if (strcmp (*argv
, "-readnow") == 0)
1417 flags
|= OBJF_READNOW
;
1418 else if (**argv
== '-')
1419 error (_("unknown option `%s'"), *argv
);
1422 symbol_file_add_main_1 (*argv
, from_tty
, flags
);
1430 error (_("no symbol file name was specified"));
1432 do_cleanups (cleanups
);
1436 /* Set the initial language.
1438 FIXME: A better solution would be to record the language in the
1439 psymtab when reading partial symbols, and then use it (if known) to
1440 set the language. This would be a win for formats that encode the
1441 language in an easily discoverable place, such as DWARF. For
1442 stabs, we can jump through hoops looking for specially named
1443 symbols or try to intuit the language from the specific type of
1444 stabs we find, but we can't do that until later when we read in
1448 set_initial_language (void)
1450 struct partial_symtab
*pst
;
1451 enum language lang
= language_unknown
;
1453 pst
= find_main_psymtab ();
1456 if (pst
->filename
!= NULL
)
1457 lang
= deduce_language_from_filename (pst
->filename
);
1459 if (lang
== language_unknown
)
1461 /* Make C the default language */
1465 set_language (lang
);
1466 expected_language
= current_language
; /* Don't warn the user. */
1470 /* If NAME is a remote name open the file using remote protocol, otherwise
1471 open it normally. */
1474 bfd_open_maybe_remote (const char *name
)
1476 if (remote_filename_p (name
))
1477 return remote_bfd_open (name
, gnutarget
);
1479 return bfd_openr (name
, gnutarget
);
1483 /* Open the file specified by NAME and hand it off to BFD for
1484 preliminary analysis. Return a newly initialized bfd *, which
1485 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1486 absolute). In case of trouble, error() is called. */
1489 symfile_bfd_open (char *name
)
1493 char *absolute_name
;
1495 if (remote_filename_p (name
))
1497 name
= xstrdup (name
);
1498 sym_bfd
= remote_bfd_open (name
, gnutarget
);
1501 make_cleanup (xfree
, name
);
1502 error (_("`%s': can't open to read symbols: %s."), name
,
1503 bfd_errmsg (bfd_get_error ()));
1506 if (!bfd_check_format (sym_bfd
, bfd_object
))
1508 bfd_close (sym_bfd
);
1509 make_cleanup (xfree
, name
);
1510 error (_("`%s': can't read symbols: %s."), name
,
1511 bfd_errmsg (bfd_get_error ()));
1517 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy. */
1519 /* Look down path for it, allocate 2nd new malloc'd copy. */
1520 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, name
,
1521 O_RDONLY
| O_BINARY
, &absolute_name
);
1522 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1525 char *exename
= alloca (strlen (name
) + 5);
1526 strcat (strcpy (exename
, name
), ".exe");
1527 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
1528 O_RDONLY
| O_BINARY
, &absolute_name
);
1533 make_cleanup (xfree
, name
);
1534 perror_with_name (name
);
1537 /* Free 1st new malloc'd copy, but keep the 2nd malloc'd copy in
1538 bfd. It'll be freed in free_objfile(). */
1540 name
= absolute_name
;
1542 sym_bfd
= bfd_fopen (name
, gnutarget
, FOPEN_RB
, desc
);
1546 make_cleanup (xfree
, name
);
1547 error (_("`%s': can't open to read symbols: %s."), name
,
1548 bfd_errmsg (bfd_get_error ()));
1550 bfd_set_cacheable (sym_bfd
, 1);
1552 if (!bfd_check_format (sym_bfd
, bfd_object
))
1554 /* FIXME: should be checking for errors from bfd_close (for one
1555 thing, on error it does not free all the storage associated
1557 bfd_close (sym_bfd
); /* This also closes desc. */
1558 make_cleanup (xfree
, name
);
1559 error (_("`%s': can't read symbols: %s."), name
,
1560 bfd_errmsg (bfd_get_error ()));
1563 /* bfd_usrdata exists for applications and libbfd must not touch it. */
1564 gdb_assert (bfd_usrdata (sym_bfd
) == NULL
);
1569 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1570 the section was not found. */
1573 get_section_index (struct objfile
*objfile
, char *section_name
)
1575 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1583 /* Link SF into the global symtab_fns list. Called on startup by the
1584 _initialize routine in each object file format reader, to register
1585 information about each format the the reader is prepared to
1589 add_symtab_fns (struct sym_fns
*sf
)
1591 sf
->next
= symtab_fns
;
1595 /* Initialize OBJFILE to read symbols from its associated BFD. It
1596 either returns or calls error(). The result is an initialized
1597 struct sym_fns in the objfile structure, that contains cached
1598 information about the symbol file. */
1600 static struct sym_fns
*
1601 find_sym_fns (bfd
*abfd
)
1604 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1606 if (our_flavour
== bfd_target_srec_flavour
1607 || our_flavour
== bfd_target_ihex_flavour
1608 || our_flavour
== bfd_target_tekhex_flavour
)
1609 return NULL
; /* No symbols. */
1611 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1612 if (our_flavour
== sf
->sym_flavour
)
1615 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1616 bfd_get_target (abfd
));
1620 /* This function runs the load command of our current target. */
1623 load_command (char *arg
, int from_tty
)
1625 /* The user might be reloading because the binary has changed. Take
1626 this opportunity to check. */
1627 reopen_exec_file ();
1635 parg
= arg
= get_exec_file (1);
1637 /* Count how many \ " ' tab space there are in the name. */
1638 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1646 /* We need to quote this string so buildargv can pull it apart. */
1647 char *temp
= xmalloc (strlen (arg
) + count
+ 1 );
1651 make_cleanup (xfree
, temp
);
1654 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1656 strncpy (ptemp
, prev
, parg
- prev
);
1657 ptemp
+= parg
- prev
;
1661 strcpy (ptemp
, prev
);
1667 target_load (arg
, from_tty
);
1669 /* After re-loading the executable, we don't really know which
1670 overlays are mapped any more. */
1671 overlay_cache_invalid
= 1;
1674 /* This version of "load" should be usable for any target. Currently
1675 it is just used for remote targets, not inftarg.c or core files,
1676 on the theory that only in that case is it useful.
1678 Avoiding xmodem and the like seems like a win (a) because we don't have
1679 to worry about finding it, and (b) On VMS, fork() is very slow and so
1680 we don't want to run a subprocess. On the other hand, I'm not sure how
1681 performance compares. */
1683 static int validate_download
= 0;
1685 /* Callback service function for generic_load (bfd_map_over_sections). */
1688 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1690 bfd_size_type
*sum
= data
;
1692 *sum
+= bfd_get_section_size (asec
);
1695 /* Opaque data for load_section_callback. */
1696 struct load_section_data
{
1697 unsigned long load_offset
;
1698 struct load_progress_data
*progress_data
;
1699 VEC(memory_write_request_s
) *requests
;
1702 /* Opaque data for load_progress. */
1703 struct load_progress_data
{
1704 /* Cumulative data. */
1705 unsigned long write_count
;
1706 unsigned long data_count
;
1707 bfd_size_type total_size
;
1710 /* Opaque data for load_progress for a single section. */
1711 struct load_progress_section_data
{
1712 struct load_progress_data
*cumulative
;
1714 /* Per-section data. */
1715 const char *section_name
;
1716 ULONGEST section_sent
;
1717 ULONGEST section_size
;
1722 /* Target write callback routine for progress reporting. */
1725 load_progress (ULONGEST bytes
, void *untyped_arg
)
1727 struct load_progress_section_data
*args
= untyped_arg
;
1728 struct load_progress_data
*totals
;
1731 /* Writing padding data. No easy way to get at the cumulative
1732 stats, so just ignore this. */
1735 totals
= args
->cumulative
;
1737 if (bytes
== 0 && args
->section_sent
== 0)
1739 /* The write is just starting. Let the user know we've started
1741 ui_out_message (uiout
, 0, "Loading section %s, size %s lma %s\n",
1742 args
->section_name
, hex_string (args
->section_size
),
1743 paddress (target_gdbarch
, args
->lma
));
1747 if (validate_download
)
1749 /* Broken memories and broken monitors manifest themselves here
1750 when bring new computers to life. This doubles already slow
1752 /* NOTE: cagney/1999-10-18: A more efficient implementation
1753 might add a verify_memory() method to the target vector and
1754 then use that. remote.c could implement that method using
1755 the ``qCRC'' packet. */
1756 gdb_byte
*check
= xmalloc (bytes
);
1757 struct cleanup
*verify_cleanups
= make_cleanup (xfree
, check
);
1759 if (target_read_memory (args
->lma
, check
, bytes
) != 0)
1760 error (_("Download verify read failed at %s"),
1761 paddress (target_gdbarch
, args
->lma
));
1762 if (memcmp (args
->buffer
, check
, bytes
) != 0)
1763 error (_("Download verify compare failed at %s"),
1764 paddress (target_gdbarch
, args
->lma
));
1765 do_cleanups (verify_cleanups
);
1767 totals
->data_count
+= bytes
;
1769 args
->buffer
+= bytes
;
1770 totals
->write_count
+= 1;
1771 args
->section_sent
+= bytes
;
1773 || (deprecated_ui_load_progress_hook
!= NULL
1774 && deprecated_ui_load_progress_hook (args
->section_name
,
1775 args
->section_sent
)))
1776 error (_("Canceled the download"));
1778 if (deprecated_show_load_progress
!= NULL
)
1779 deprecated_show_load_progress (args
->section_name
,
1783 totals
->total_size
);
1786 /* Callback service function for generic_load (bfd_map_over_sections). */
1789 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1791 struct memory_write_request
*new_request
;
1792 struct load_section_data
*args
= data
;
1793 struct load_progress_section_data
*section_data
;
1794 bfd_size_type size
= bfd_get_section_size (asec
);
1796 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1798 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1804 new_request
= VEC_safe_push (memory_write_request_s
,
1805 args
->requests
, NULL
);
1806 memset (new_request
, 0, sizeof (struct memory_write_request
));
1807 section_data
= xcalloc (1, sizeof (struct load_progress_section_data
));
1808 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1809 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size be in instead? */
1810 new_request
->data
= xmalloc (size
);
1811 new_request
->baton
= section_data
;
1813 buffer
= new_request
->data
;
1815 section_data
->cumulative
= args
->progress_data
;
1816 section_data
->section_name
= sect_name
;
1817 section_data
->section_size
= size
;
1818 section_data
->lma
= new_request
->begin
;
1819 section_data
->buffer
= buffer
;
1821 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1824 /* Clean up an entire memory request vector, including load
1825 data and progress records. */
1828 clear_memory_write_data (void *arg
)
1830 VEC(memory_write_request_s
) **vec_p
= arg
;
1831 VEC(memory_write_request_s
) *vec
= *vec_p
;
1833 struct memory_write_request
*mr
;
1835 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
1840 VEC_free (memory_write_request_s
, vec
);
1844 generic_load (char *args
, int from_tty
)
1847 struct timeval start_time
, end_time
;
1849 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, 0);
1850 struct load_section_data cbdata
;
1851 struct load_progress_data total_progress
;
1856 memset (&cbdata
, 0, sizeof (cbdata
));
1857 memset (&total_progress
, 0, sizeof (total_progress
));
1858 cbdata
.progress_data
= &total_progress
;
1860 make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
1863 error_no_arg (_("file to load"));
1865 argv
= gdb_buildargv (args
);
1866 make_cleanup_freeargv (argv
);
1868 filename
= tilde_expand (argv
[0]);
1869 make_cleanup (xfree
, filename
);
1871 if (argv
[1] != NULL
)
1875 cbdata
.load_offset
= strtoul (argv
[1], &endptr
, 0);
1877 /* If the last word was not a valid number then
1878 treat it as a file name with spaces in. */
1879 if (argv
[1] == endptr
)
1880 error (_("Invalid download offset:%s."), argv
[1]);
1882 if (argv
[2] != NULL
)
1883 error (_("Too many parameters."));
1886 /* Open the file for loading. */
1887 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1888 if (loadfile_bfd
== NULL
)
1890 perror_with_name (filename
);
1894 /* FIXME: should be checking for errors from bfd_close (for one thing,
1895 on error it does not free all the storage associated with the
1897 make_cleanup_bfd_close (loadfile_bfd
);
1899 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1901 error (_("\"%s\" is not an object file: %s"), filename
,
1902 bfd_errmsg (bfd_get_error ()));
1905 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1906 (void *) &total_progress
.total_size
);
1908 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1910 gettimeofday (&start_time
, NULL
);
1912 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
1913 load_progress
) != 0)
1914 error (_("Load failed"));
1916 gettimeofday (&end_time
, NULL
);
1918 entry
= bfd_get_start_address (loadfile_bfd
);
1919 ui_out_text (uiout
, "Start address ");
1920 ui_out_field_fmt (uiout
, "address", "%s", paddress (target_gdbarch
, entry
));
1921 ui_out_text (uiout
, ", load size ");
1922 ui_out_field_fmt (uiout
, "load-size", "%lu", total_progress
.data_count
);
1923 ui_out_text (uiout
, "\n");
1924 /* We were doing this in remote-mips.c, I suspect it is right
1925 for other targets too. */
1926 regcache_write_pc (get_current_regcache (), entry
);
1928 /* FIXME: are we supposed to call symbol_file_add or not? According
1929 to a comment from remote-mips.c (where a call to symbol_file_add
1930 was commented out), making the call confuses GDB if more than one
1931 file is loaded in. Some targets do (e.g., remote-vx.c) but
1932 others don't (or didn't - perhaps they have all been deleted). */
1934 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
1935 total_progress
.write_count
,
1936 &start_time
, &end_time
);
1938 do_cleanups (old_cleanups
);
1941 /* Report how fast the transfer went. */
1943 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1944 replaced by print_transfer_performance (with a very different
1945 function signature). */
1948 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1951 struct timeval start
, end
;
1953 start
.tv_sec
= start_time
;
1955 end
.tv_sec
= end_time
;
1958 print_transfer_performance (gdb_stdout
, data_count
, 0, &start
, &end
);
1962 print_transfer_performance (struct ui_file
*stream
,
1963 unsigned long data_count
,
1964 unsigned long write_count
,
1965 const struct timeval
*start_time
,
1966 const struct timeval
*end_time
)
1968 ULONGEST time_count
;
1970 /* Compute the elapsed time in milliseconds, as a tradeoff between
1971 accuracy and overflow. */
1972 time_count
= (end_time
->tv_sec
- start_time
->tv_sec
) * 1000;
1973 time_count
+= (end_time
->tv_usec
- start_time
->tv_usec
) / 1000;
1975 ui_out_text (uiout
, "Transfer rate: ");
1978 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / time_count
;
1980 if (ui_out_is_mi_like_p (uiout
))
1982 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
* 8);
1983 ui_out_text (uiout
, " bits/sec");
1985 else if (rate
< 1024)
1987 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
);
1988 ui_out_text (uiout
, " bytes/sec");
1992 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
/ 1024);
1993 ui_out_text (uiout
, " KB/sec");
1998 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
1999 ui_out_text (uiout
, " bits in <1 sec");
2001 if (write_count
> 0)
2003 ui_out_text (uiout
, ", ");
2004 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
2005 ui_out_text (uiout
, " bytes/write");
2007 ui_out_text (uiout
, ".\n");
2010 /* This function allows the addition of incrementally linked object files.
2011 It does not modify any state in the target, only in the debugger. */
2012 /* Note: ezannoni 2000-04-13 This function/command used to have a
2013 special case syntax for the rombug target (Rombug is the boot
2014 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2015 rombug case, the user doesn't need to supply a text address,
2016 instead a call to target_link() (in target.c) would supply the
2017 value to use. We are now discontinuing this type of ad hoc syntax. */
2020 add_symbol_file_command (char *args
, int from_tty
)
2022 struct gdbarch
*gdbarch
= get_current_arch ();
2023 char *filename
= NULL
;
2024 int flags
= OBJF_USERLOADED
;
2026 int expecting_option
= 0;
2027 int section_index
= 0;
2031 int expecting_sec_name
= 0;
2032 int expecting_sec_addr
= 0;
2041 struct section_addr_info
*section_addrs
;
2042 struct sect_opt
*sect_opts
= NULL
;
2043 size_t num_sect_opts
= 0;
2044 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2047 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
2048 * sizeof (struct sect_opt
));
2053 error (_("add-symbol-file takes a file name and an address"));
2055 argv
= gdb_buildargv (args
);
2056 make_cleanup_freeargv (argv
);
2058 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2060 /* Process the argument. */
2063 /* The first argument is the file name. */
2064 filename
= tilde_expand (arg
);
2065 make_cleanup (xfree
, filename
);
2070 /* The second argument is always the text address at which
2071 to load the program. */
2072 sect_opts
[section_index
].name
= ".text";
2073 sect_opts
[section_index
].value
= arg
;
2074 if (++section_index
>= num_sect_opts
)
2077 sect_opts
= ((struct sect_opt
*)
2078 xrealloc (sect_opts
,
2080 * sizeof (struct sect_opt
)));
2085 /* It's an option (starting with '-') or it's an argument
2090 if (strcmp (arg
, "-readnow") == 0)
2091 flags
|= OBJF_READNOW
;
2092 else if (strcmp (arg
, "-s") == 0)
2094 expecting_sec_name
= 1;
2095 expecting_sec_addr
= 1;
2100 if (expecting_sec_name
)
2102 sect_opts
[section_index
].name
= arg
;
2103 expecting_sec_name
= 0;
2106 if (expecting_sec_addr
)
2108 sect_opts
[section_index
].value
= arg
;
2109 expecting_sec_addr
= 0;
2110 if (++section_index
>= num_sect_opts
)
2113 sect_opts
= ((struct sect_opt
*)
2114 xrealloc (sect_opts
,
2116 * sizeof (struct sect_opt
)));
2120 error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
2125 /* This command takes at least two arguments. The first one is a
2126 filename, and the second is the address where this file has been
2127 loaded. Abort now if this address hasn't been provided by the
2129 if (section_index
< 1)
2130 error (_("The address where %s has been loaded is missing"), filename
);
2132 /* Print the prompt for the query below. And save the arguments into
2133 a sect_addr_info structure to be passed around to other
2134 functions. We have to split this up into separate print
2135 statements because hex_string returns a local static
2138 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
2139 section_addrs
= alloc_section_addr_info (section_index
);
2140 make_cleanup (xfree
, section_addrs
);
2141 for (i
= 0; i
< section_index
; i
++)
2144 char *val
= sect_opts
[i
].value
;
2145 char *sec
= sect_opts
[i
].name
;
2147 addr
= parse_and_eval_address (val
);
2149 /* Here we store the section offsets in the order they were
2150 entered on the command line. */
2151 section_addrs
->other
[sec_num
].name
= sec
;
2152 section_addrs
->other
[sec_num
].addr
= addr
;
2153 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2154 paddress (gdbarch
, addr
));
2157 /* The object's sections are initialized when a
2158 call is made to build_objfile_section_table (objfile).
2159 This happens in reread_symbols.
2160 At this point, we don't know what file type this is,
2161 so we can't determine what section names are valid. */
2164 if (from_tty
&& (!query ("%s", "")))
2165 error (_("Not confirmed."));
2167 symbol_file_add (filename
, from_tty
? SYMFILE_VERBOSE
: 0,
2168 section_addrs
, flags
);
2170 /* Getting new symbols may change our opinion about what is
2172 reinit_frame_cache ();
2173 do_cleanups (my_cleanups
);
2177 /* Re-read symbols if a symbol-file has changed. */
2179 reread_symbols (void)
2181 struct objfile
*objfile
;
2184 struct stat new_statbuf
;
2187 /* With the addition of shared libraries, this should be modified,
2188 the load time should be saved in the partial symbol tables, since
2189 different tables may come from different source files. FIXME.
2190 This routine should then walk down each partial symbol table
2191 and see if the symbol table that it originates from has been changed */
2193 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2195 /* solib-sunos.c creates one objfile with obfd. */
2196 if (objfile
->obfd
== NULL
)
2199 /* Separate debug objfiles are handled in the main objfile. */
2200 if (objfile
->separate_debug_objfile_backlink
)
2203 #ifdef DEPRECATED_IBM6000_TARGET
2204 /* If this object is from a shared library, then you should
2205 stat on the library name, not member name. */
2207 if (objfile
->obfd
->my_archive
)
2208 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2211 res
= stat (objfile
->name
, &new_statbuf
);
2214 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2215 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2219 new_modtime
= new_statbuf
.st_mtime
;
2220 if (new_modtime
!= objfile
->mtime
)
2222 struct cleanup
*old_cleanups
;
2223 struct section_offsets
*offsets
;
2225 char *obfd_filename
;
2227 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2230 /* There are various functions like symbol_file_add,
2231 symfile_bfd_open, syms_from_objfile, etc., which might
2232 appear to do what we want. But they have various other
2233 effects which we *don't* want. So we just do stuff
2234 ourselves. We don't worry about mapped files (for one thing,
2235 any mapped file will be out of date). */
2237 /* If we get an error, blow away this objfile (not sure if
2238 that is the correct response for things like shared
2240 old_cleanups
= make_cleanup_free_objfile (objfile
);
2241 /* We need to do this whenever any symbols go away. */
2242 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2244 if (exec_bfd
!= NULL
&& strcmp (bfd_get_filename (objfile
->obfd
),
2245 bfd_get_filename (exec_bfd
)) == 0)
2247 /* Reload EXEC_BFD without asking anything. */
2249 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2252 /* Clean up any state BFD has sitting around. We don't need
2253 to close the descriptor but BFD lacks a way of closing the
2254 BFD without closing the descriptor. */
2255 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2256 if (!bfd_close (objfile
->obfd
))
2257 error (_("Can't close BFD for %s: %s"), objfile
->name
,
2258 bfd_errmsg (bfd_get_error ()));
2259 objfile
->obfd
= bfd_open_maybe_remote (obfd_filename
);
2260 if (objfile
->obfd
== NULL
)
2261 error (_("Can't open %s to read symbols."), objfile
->name
);
2263 objfile
->obfd
= gdb_bfd_ref (objfile
->obfd
);
2264 /* bfd_openr sets cacheable to true, which is what we want. */
2265 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2266 error (_("Can't read symbols from %s: %s."), objfile
->name
,
2267 bfd_errmsg (bfd_get_error ()));
2269 /* Save the offsets, we will nuke them with the rest of the
2271 num_offsets
= objfile
->num_sections
;
2272 offsets
= ((struct section_offsets
*)
2273 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2274 memcpy (offsets
, objfile
->section_offsets
,
2275 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2277 /* Remove any references to this objfile in the global
2279 preserve_values (objfile
);
2281 /* Nuke all the state that we will re-read. Much of the following
2282 code which sets things to NULL really is necessary to tell
2283 other parts of GDB that there is nothing currently there.
2285 Try to keep the freeing order compatible with free_objfile. */
2287 if (objfile
->sf
!= NULL
)
2289 (*objfile
->sf
->sym_finish
) (objfile
);
2292 clear_objfile_data (objfile
);
2294 /* Free the separate debug objfiles. It will be
2295 automatically recreated by sym_read. */
2296 free_objfile_separate_debug (objfile
);
2298 /* FIXME: Do we have to free a whole linked list, or is this
2300 if (objfile
->global_psymbols
.list
)
2301 xfree (objfile
->global_psymbols
.list
);
2302 memset (&objfile
->global_psymbols
, 0,
2303 sizeof (objfile
->global_psymbols
));
2304 if (objfile
->static_psymbols
.list
)
2305 xfree (objfile
->static_psymbols
.list
);
2306 memset (&objfile
->static_psymbols
, 0,
2307 sizeof (objfile
->static_psymbols
));
2309 /* Free the obstacks for non-reusable objfiles */
2310 bcache_xfree (objfile
->psymbol_cache
);
2311 objfile
->psymbol_cache
= bcache_xmalloc ();
2312 bcache_xfree (objfile
->macro_cache
);
2313 objfile
->macro_cache
= bcache_xmalloc ();
2314 bcache_xfree (objfile
->filename_cache
);
2315 objfile
->filename_cache
= bcache_xmalloc ();
2316 if (objfile
->demangled_names_hash
!= NULL
)
2318 htab_delete (objfile
->demangled_names_hash
);
2319 objfile
->demangled_names_hash
= NULL
;
2321 obstack_free (&objfile
->objfile_obstack
, 0);
2322 objfile
->sections
= NULL
;
2323 objfile
->symtabs
= NULL
;
2324 objfile
->psymtabs
= NULL
;
2325 objfile
->psymtabs_addrmap
= NULL
;
2326 objfile
->free_psymtabs
= NULL
;
2327 objfile
->cp_namespace_symtab
= NULL
;
2328 objfile
->msymbols
= NULL
;
2329 objfile
->deprecated_sym_private
= NULL
;
2330 objfile
->minimal_symbol_count
= 0;
2331 memset (&objfile
->msymbol_hash
, 0,
2332 sizeof (objfile
->msymbol_hash
));
2333 memset (&objfile
->msymbol_demangled_hash
, 0,
2334 sizeof (objfile
->msymbol_demangled_hash
));
2336 objfile
->psymbol_cache
= bcache_xmalloc ();
2337 objfile
->macro_cache
= bcache_xmalloc ();
2338 objfile
->filename_cache
= bcache_xmalloc ();
2339 /* obstack_init also initializes the obstack so it is
2340 empty. We could use obstack_specify_allocation but
2341 gdb_obstack.h specifies the alloc/dealloc
2343 obstack_init (&objfile
->objfile_obstack
);
2344 if (build_objfile_section_table (objfile
))
2346 error (_("Can't find the file sections in `%s': %s"),
2347 objfile
->name
, bfd_errmsg (bfd_get_error ()));
2349 terminate_minimal_symbol_table (objfile
);
2351 /* We use the same section offsets as from last time. I'm not
2352 sure whether that is always correct for shared libraries. */
2353 objfile
->section_offsets
= (struct section_offsets
*)
2354 obstack_alloc (&objfile
->objfile_obstack
,
2355 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2356 memcpy (objfile
->section_offsets
, offsets
,
2357 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2358 objfile
->num_sections
= num_offsets
;
2360 /* What the hell is sym_new_init for, anyway? The concept of
2361 distinguishing between the main file and additional files
2362 in this way seems rather dubious. */
2363 if (objfile
== symfile_objfile
)
2365 (*objfile
->sf
->sym_new_init
) (objfile
);
2368 (*objfile
->sf
->sym_init
) (objfile
);
2369 clear_complaints (&symfile_complaints
, 1, 1);
2370 /* Do not set flags as this is safe and we don't want to be
2372 (*objfile
->sf
->sym_read
) (objfile
, 0);
2373 if (!objfile_has_symbols (objfile
))
2376 printf_unfiltered (_("(no debugging symbols found)\n"));
2380 /* We're done reading the symbol file; finish off complaints. */
2381 clear_complaints (&symfile_complaints
, 0, 1);
2383 /* Getting new symbols may change our opinion about what is
2386 reinit_frame_cache ();
2388 /* Discard cleanups as symbol reading was successful. */
2389 discard_cleanups (old_cleanups
);
2391 /* If the mtime has changed between the time we set new_modtime
2392 and now, we *want* this to be out of date, so don't call stat
2394 objfile
->mtime
= new_modtime
;
2396 init_entry_point_info (objfile
);
2402 /* Notify objfiles that we've modified objfile sections. */
2403 objfiles_changed ();
2405 clear_symtab_users ();
2406 /* At least one objfile has changed, so we can consider that
2407 the executable we're debugging has changed too. */
2408 observer_notify_executable_changed ();
2421 static filename_language
*filename_language_table
;
2422 static int fl_table_size
, fl_table_next
;
2425 add_filename_language (char *ext
, enum language lang
)
2427 if (fl_table_next
>= fl_table_size
)
2429 fl_table_size
+= 10;
2430 filename_language_table
=
2431 xrealloc (filename_language_table
,
2432 fl_table_size
* sizeof (*filename_language_table
));
2435 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2436 filename_language_table
[fl_table_next
].lang
= lang
;
2440 static char *ext_args
;
2442 show_ext_args (struct ui_file
*file
, int from_tty
,
2443 struct cmd_list_element
*c
, const char *value
)
2445 fprintf_filtered (file
, _("\
2446 Mapping between filename extension and source language is \"%s\".\n"),
2451 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2454 char *cp
= ext_args
;
2457 /* First arg is filename extension, starting with '.' */
2459 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2461 /* Find end of first arg. */
2462 while (*cp
&& !isspace (*cp
))
2466 error (_("'%s': two arguments required -- filename extension and language"),
2469 /* Null-terminate first arg */
2472 /* Find beginning of second arg, which should be a source language. */
2473 while (*cp
&& isspace (*cp
))
2477 error (_("'%s': two arguments required -- filename extension and language"),
2480 /* Lookup the language from among those we know. */
2481 lang
= language_enum (cp
);
2483 /* Now lookup the filename extension: do we already know it? */
2484 for (i
= 0; i
< fl_table_next
; i
++)
2485 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2488 if (i
>= fl_table_next
)
2490 /* new file extension */
2491 add_filename_language (ext_args
, lang
);
2495 /* redefining a previously known filename extension */
2498 /* query ("Really make files of type %s '%s'?", */
2499 /* ext_args, language_str (lang)); */
2501 xfree (filename_language_table
[i
].ext
);
2502 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2503 filename_language_table
[i
].lang
= lang
;
2508 info_ext_lang_command (char *args
, int from_tty
)
2512 printf_filtered (_("Filename extensions and the languages they represent:"));
2513 printf_filtered ("\n\n");
2514 for (i
= 0; i
< fl_table_next
; i
++)
2515 printf_filtered ("\t%s\t- %s\n",
2516 filename_language_table
[i
].ext
,
2517 language_str (filename_language_table
[i
].lang
));
2521 init_filename_language_table (void)
2523 if (fl_table_size
== 0) /* protect against repetition */
2527 filename_language_table
=
2528 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2529 add_filename_language (".c", language_c
);
2530 add_filename_language (".C", language_cplus
);
2531 add_filename_language (".cc", language_cplus
);
2532 add_filename_language (".cp", language_cplus
);
2533 add_filename_language (".cpp", language_cplus
);
2534 add_filename_language (".cxx", language_cplus
);
2535 add_filename_language (".c++", language_cplus
);
2536 add_filename_language (".java", language_java
);
2537 add_filename_language (".class", language_java
);
2538 add_filename_language (".m", language_objc
);
2539 add_filename_language (".f", language_fortran
);
2540 add_filename_language (".F", language_fortran
);
2541 add_filename_language (".s", language_asm
);
2542 add_filename_language (".sx", language_asm
);
2543 add_filename_language (".S", language_asm
);
2544 add_filename_language (".pas", language_pascal
);
2545 add_filename_language (".p", language_pascal
);
2546 add_filename_language (".pp", language_pascal
);
2547 add_filename_language (".adb", language_ada
);
2548 add_filename_language (".ads", language_ada
);
2549 add_filename_language (".a", language_ada
);
2550 add_filename_language (".ada", language_ada
);
2555 deduce_language_from_filename (char *filename
)
2560 if (filename
!= NULL
)
2561 if ((cp
= strrchr (filename
, '.')) != NULL
)
2562 for (i
= 0; i
< fl_table_next
; i
++)
2563 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2564 return filename_language_table
[i
].lang
;
2566 return language_unknown
;
2571 Allocate and partly initialize a new symbol table. Return a pointer
2572 to it. error() if no space.
2574 Caller must set these fields:
2583 allocate_symtab (char *filename
, struct objfile
*objfile
)
2585 struct symtab
*symtab
;
2587 symtab
= (struct symtab
*)
2588 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2589 memset (symtab
, 0, sizeof (*symtab
));
2590 symtab
->filename
= (char *) bcache (filename
, strlen (filename
) + 1,
2591 objfile
->filename_cache
);
2592 symtab
->fullname
= NULL
;
2593 symtab
->language
= deduce_language_from_filename (filename
);
2594 symtab
->debugformat
= "unknown";
2596 /* Hook it to the objfile it comes from */
2598 symtab
->objfile
= objfile
;
2599 symtab
->next
= objfile
->symtabs
;
2600 objfile
->symtabs
= symtab
;
2605 struct partial_symtab
*
2606 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
2608 struct partial_symtab
*psymtab
;
2610 if (objfile
->free_psymtabs
)
2612 psymtab
= objfile
->free_psymtabs
;
2613 objfile
->free_psymtabs
= psymtab
->next
;
2616 psymtab
= (struct partial_symtab
*)
2617 obstack_alloc (&objfile
->objfile_obstack
,
2618 sizeof (struct partial_symtab
));
2620 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2621 psymtab
->filename
= (char *) bcache (filename
, strlen (filename
) + 1,
2622 objfile
->filename_cache
);
2623 psymtab
->symtab
= NULL
;
2625 /* Prepend it to the psymtab list for the objfile it belongs to.
2626 Psymtabs are searched in most recent inserted -> least recent
2629 psymtab
->objfile
= objfile
;
2630 psymtab
->next
= objfile
->psymtabs
;
2631 objfile
->psymtabs
= psymtab
;
2634 struct partial_symtab
**prev_pst
;
2635 psymtab
->objfile
= objfile
;
2636 psymtab
->next
= NULL
;
2637 prev_pst
= &(objfile
->psymtabs
);
2638 while ((*prev_pst
) != NULL
)
2639 prev_pst
= &((*prev_pst
)->next
);
2640 (*prev_pst
) = psymtab
;
2648 discard_psymtab (struct partial_symtab
*pst
)
2650 struct partial_symtab
**prev_pst
;
2653 Empty psymtabs happen as a result of header files which don't
2654 have any symbols in them. There can be a lot of them. But this
2655 check is wrong, in that a psymtab with N_SLINE entries but
2656 nothing else is not empty, but we don't realize that. Fixing
2657 that without slowing things down might be tricky. */
2659 /* First, snip it out of the psymtab chain */
2661 prev_pst
= &(pst
->objfile
->psymtabs
);
2662 while ((*prev_pst
) != pst
)
2663 prev_pst
= &((*prev_pst
)->next
);
2664 (*prev_pst
) = pst
->next
;
2666 /* Next, put it on a free list for recycling */
2668 pst
->next
= pst
->objfile
->free_psymtabs
;
2669 pst
->objfile
->free_psymtabs
= pst
;
2673 /* Reset all data structures in gdb which may contain references to symbol
2677 clear_symtab_users (void)
2679 /* Someday, we should do better than this, by only blowing away
2680 the things that really need to be blown. */
2682 /* Clear the "current" symtab first, because it is no longer valid.
2683 breakpoint_re_set may try to access the current symtab. */
2684 clear_current_source_symtab_and_line ();
2687 breakpoint_re_set ();
2688 set_default_breakpoint (0, NULL
, 0, 0, 0);
2689 clear_pc_function_cache ();
2690 observer_notify_new_objfile (NULL
);
2692 /* Clear globals which might have pointed into a removed objfile.
2693 FIXME: It's not clear which of these are supposed to persist
2694 between expressions and which ought to be reset each time. */
2695 expression_context_block
= NULL
;
2696 innermost_block
= NULL
;
2698 /* Varobj may refer to old symbols, perform a cleanup. */
2699 varobj_invalidate ();
2704 clear_symtab_users_cleanup (void *ignore
)
2706 clear_symtab_users ();
2709 /* Allocate and partially fill a partial symtab. It will be
2710 completely filled at the end of the symbol list.
2712 FILENAME is the name of the symbol-file we are reading from. */
2714 struct partial_symtab
*
2715 start_psymtab_common (struct objfile
*objfile
,
2716 struct section_offsets
*section_offsets
,
2717 const char *filename
,
2718 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2719 struct partial_symbol
**static_syms
)
2721 struct partial_symtab
*psymtab
;
2723 psymtab
= allocate_psymtab (filename
, objfile
);
2724 psymtab
->section_offsets
= section_offsets
;
2725 psymtab
->textlow
= textlow
;
2726 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2727 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2728 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2732 /* Helper function, initialises partial symbol structure and stashes
2733 it into objfile's bcache. Note that our caching mechanism will
2734 use all fields of struct partial_symbol to determine hash value of the
2735 structure. In other words, having two symbols with the same name but
2736 different domain (or address) is possible and correct. */
2738 static const struct partial_symbol
*
2739 add_psymbol_to_bcache (char *name
, int namelength
, int copy_name
,
2741 enum address_class
class,
2742 long val
, /* Value as a long */
2743 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2744 enum language language
, struct objfile
*objfile
,
2747 /* psymbol is static so that there will be no uninitialized gaps in the
2748 structure which might contain random data, causing cache misses in
2750 static struct partial_symbol psymbol
;
2752 /* However, we must ensure that the entire 'value' field has been
2753 zeroed before assigning to it, because an assignment may not
2754 write the entire field. */
2755 memset (&psymbol
.ginfo
.value
, 0, sizeof (psymbol
.ginfo
.value
));
2756 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2759 SYMBOL_VALUE (&psymbol
) = val
;
2763 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2765 SYMBOL_SECTION (&psymbol
) = 0;
2766 SYMBOL_LANGUAGE (&psymbol
) = language
;
2767 PSYMBOL_DOMAIN (&psymbol
) = domain
;
2768 PSYMBOL_CLASS (&psymbol
) = class;
2770 SYMBOL_SET_NAMES (&psymbol
, name
, namelength
, copy_name
, objfile
);
2772 /* Stash the partial symbol away in the cache */
2773 return bcache_full (&psymbol
, sizeof (struct partial_symbol
),
2774 objfile
->psymbol_cache
, added
);
2777 /* Helper function, adds partial symbol to the given partial symbol
2781 append_psymbol_to_list (struct psymbol_allocation_list
*list
,
2782 const struct partial_symbol
*psym
,
2783 struct objfile
*objfile
)
2785 if (list
->next
>= list
->list
+ list
->size
)
2786 extend_psymbol_list (list
, objfile
);
2787 *list
->next
++ = (struct partial_symbol
*) psym
;
2788 OBJSTAT (objfile
, n_psyms
++);
2791 /* Add a symbol with a long value to a psymtab.
2792 Since one arg is a struct, we pass in a ptr and deref it (sigh).
2793 Return the partial symbol that has been added. */
2795 /* NOTE: carlton/2003-09-11: The reason why we return the partial
2796 symbol is so that callers can get access to the symbol's demangled
2797 name, which they don't have any cheap way to determine otherwise.
2798 (Currenly, dwarf2read.c is the only file who uses that information,
2799 though it's possible that other readers might in the future.)
2800 Elena wasn't thrilled about that, and I don't blame her, but we
2801 couldn't come up with a better way to get that information. If
2802 it's needed in other situations, we could consider breaking up
2803 SYMBOL_SET_NAMES to provide access to the demangled name lookup
2806 const struct partial_symbol
*
2807 add_psymbol_to_list (char *name
, int namelength
, int copy_name
,
2809 enum address_class
class,
2810 struct psymbol_allocation_list
*list
,
2811 long val
, /* Value as a long */
2812 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2813 enum language language
, struct objfile
*objfile
)
2815 const struct partial_symbol
*psym
;
2819 /* Stash the partial symbol away in the cache */
2820 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, class,
2821 val
, coreaddr
, language
, objfile
, &added
);
2823 /* Do not duplicate global partial symbols. */
2824 if (list
== &objfile
->global_psymbols
2828 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2829 append_psymbol_to_list (list
, psym
, objfile
);
2833 /* Initialize storage for partial symbols. */
2836 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
2838 /* Free any previously allocated psymbol lists. */
2840 if (objfile
->global_psymbols
.list
)
2842 xfree (objfile
->global_psymbols
.list
);
2844 if (objfile
->static_psymbols
.list
)
2846 xfree (objfile
->static_psymbols
.list
);
2849 /* Current best guess is that approximately a twentieth
2850 of the total symbols (in a debugging file) are global or static
2853 objfile
->global_psymbols
.size
= total_symbols
/ 10;
2854 objfile
->static_psymbols
.size
= total_symbols
/ 10;
2856 if (objfile
->global_psymbols
.size
> 0)
2858 objfile
->global_psymbols
.next
=
2859 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
2860 xmalloc ((objfile
->global_psymbols
.size
2861 * sizeof (struct partial_symbol
*)));
2863 if (objfile
->static_psymbols
.size
> 0)
2865 objfile
->static_psymbols
.next
=
2866 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
2867 xmalloc ((objfile
->static_psymbols
.size
2868 * sizeof (struct partial_symbol
*)));
2873 The following code implements an abstraction for debugging overlay sections.
2875 The target model is as follows:
2876 1) The gnu linker will permit multiple sections to be mapped into the
2877 same VMA, each with its own unique LMA (or load address).
2878 2) It is assumed that some runtime mechanism exists for mapping the
2879 sections, one by one, from the load address into the VMA address.
2880 3) This code provides a mechanism for gdb to keep track of which
2881 sections should be considered to be mapped from the VMA to the LMA.
2882 This information is used for symbol lookup, and memory read/write.
2883 For instance, if a section has been mapped then its contents
2884 should be read from the VMA, otherwise from the LMA.
2886 Two levels of debugger support for overlays are available. One is
2887 "manual", in which the debugger relies on the user to tell it which
2888 overlays are currently mapped. This level of support is
2889 implemented entirely in the core debugger, and the information about
2890 whether a section is mapped is kept in the objfile->obj_section table.
2892 The second level of support is "automatic", and is only available if
2893 the target-specific code provides functionality to read the target's
2894 overlay mapping table, and translate its contents for the debugger
2895 (by updating the mapped state information in the obj_section tables).
2897 The interface is as follows:
2899 overlay map <name> -- tell gdb to consider this section mapped
2900 overlay unmap <name> -- tell gdb to consider this section unmapped
2901 overlay list -- list the sections that GDB thinks are mapped
2902 overlay read-target -- get the target's state of what's mapped
2903 overlay off/manual/auto -- set overlay debugging state
2904 Functional interface:
2905 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2906 section, return that section.
2907 find_pc_overlay(pc): find any overlay section that contains
2908 the pc, either in its VMA or its LMA
2909 section_is_mapped(sect): true if overlay is marked as mapped
2910 section_is_overlay(sect): true if section's VMA != LMA
2911 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2912 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2913 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2914 overlay_mapped_address(...): map an address from section's LMA to VMA
2915 overlay_unmapped_address(...): map an address from section's VMA to LMA
2916 symbol_overlayed_address(...): Return a "current" address for symbol:
2917 either in VMA or LMA depending on whether
2918 the symbol's section is currently mapped
2921 /* Overlay debugging state: */
2923 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2924 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
2926 /* Function: section_is_overlay (SECTION)
2927 Returns true if SECTION has VMA not equal to LMA, ie.
2928 SECTION is loaded at an address different from where it will "run". */
2931 section_is_overlay (struct obj_section
*section
)
2933 if (overlay_debugging
&& section
)
2935 bfd
*abfd
= section
->objfile
->obfd
;
2936 asection
*bfd_section
= section
->the_bfd_section
;
2938 if (bfd_section_lma (abfd
, bfd_section
) != 0
2939 && bfd_section_lma (abfd
, bfd_section
)
2940 != bfd_section_vma (abfd
, bfd_section
))
2947 /* Function: overlay_invalidate_all (void)
2948 Invalidate the mapped state of all overlay sections (mark it as stale). */
2951 overlay_invalidate_all (void)
2953 struct objfile
*objfile
;
2954 struct obj_section
*sect
;
2956 ALL_OBJSECTIONS (objfile
, sect
)
2957 if (section_is_overlay (sect
))
2958 sect
->ovly_mapped
= -1;
2961 /* Function: section_is_mapped (SECTION)
2962 Returns true if section is an overlay, and is currently mapped.
2964 Access to the ovly_mapped flag is restricted to this function, so
2965 that we can do automatic update. If the global flag
2966 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2967 overlay_invalidate_all. If the mapped state of the particular
2968 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2971 section_is_mapped (struct obj_section
*osect
)
2973 struct gdbarch
*gdbarch
;
2975 if (osect
== 0 || !section_is_overlay (osect
))
2978 switch (overlay_debugging
)
2982 return 0; /* overlay debugging off */
2983 case ovly_auto
: /* overlay debugging automatic */
2984 /* Unles there is a gdbarch_overlay_update function,
2985 there's really nothing useful to do here (can't really go auto) */
2986 gdbarch
= get_objfile_arch (osect
->objfile
);
2987 if (gdbarch_overlay_update_p (gdbarch
))
2989 if (overlay_cache_invalid
)
2991 overlay_invalidate_all ();
2992 overlay_cache_invalid
= 0;
2994 if (osect
->ovly_mapped
== -1)
2995 gdbarch_overlay_update (gdbarch
, osect
);
2997 /* fall thru to manual case */
2998 case ovly_on
: /* overlay debugging manual */
2999 return osect
->ovly_mapped
== 1;
3003 /* Function: pc_in_unmapped_range
3004 If PC falls into the lma range of SECTION, return true, else false. */
3007 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3009 if (section_is_overlay (section
))
3011 bfd
*abfd
= section
->objfile
->obfd
;
3012 asection
*bfd_section
= section
->the_bfd_section
;
3014 /* We assume the LMA is relocated by the same offset as the VMA. */
3015 bfd_vma size
= bfd_get_section_size (bfd_section
);
3016 CORE_ADDR offset
= obj_section_offset (section
);
3018 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3019 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3026 /* Function: pc_in_mapped_range
3027 If PC falls into the vma range of SECTION, return true, else false. */
3030 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3032 if (section_is_overlay (section
))
3034 if (obj_section_addr (section
) <= pc
3035 && pc
< obj_section_endaddr (section
))
3043 /* Return true if the mapped ranges of sections A and B overlap, false
3046 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3048 CORE_ADDR a_start
= obj_section_addr (a
);
3049 CORE_ADDR a_end
= obj_section_endaddr (a
);
3050 CORE_ADDR b_start
= obj_section_addr (b
);
3051 CORE_ADDR b_end
= obj_section_endaddr (b
);
3053 return (a_start
< b_end
&& b_start
< a_end
);
3056 /* Function: overlay_unmapped_address (PC, SECTION)
3057 Returns the address corresponding to PC in the unmapped (load) range.
3058 May be the same as PC. */
3061 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3063 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3065 bfd
*abfd
= section
->objfile
->obfd
;
3066 asection
*bfd_section
= section
->the_bfd_section
;
3068 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3069 - bfd_section_vma (abfd
, bfd_section
);
3075 /* Function: overlay_mapped_address (PC, SECTION)
3076 Returns the address corresponding to PC in the mapped (runtime) range.
3077 May be the same as PC. */
3080 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3082 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3084 bfd
*abfd
= section
->objfile
->obfd
;
3085 asection
*bfd_section
= section
->the_bfd_section
;
3087 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3088 - bfd_section_lma (abfd
, bfd_section
);
3095 /* Function: symbol_overlayed_address
3096 Return one of two addresses (relative to the VMA or to the LMA),
3097 depending on whether the section is mapped or not. */
3100 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3102 if (overlay_debugging
)
3104 /* If the symbol has no section, just return its regular address. */
3107 /* If the symbol's section is not an overlay, just return its address */
3108 if (!section_is_overlay (section
))
3110 /* If the symbol's section is mapped, just return its address */
3111 if (section_is_mapped (section
))
3114 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3115 * then return its LOADED address rather than its vma address!!
3117 return overlay_unmapped_address (address
, section
);
3122 /* Function: find_pc_overlay (PC)
3123 Return the best-match overlay section for PC:
3124 If PC matches a mapped overlay section's VMA, return that section.
3125 Else if PC matches an unmapped section's VMA, return that section.
3126 Else if PC matches an unmapped section's LMA, return that section. */
3128 struct obj_section
*
3129 find_pc_overlay (CORE_ADDR pc
)
3131 struct objfile
*objfile
;
3132 struct obj_section
*osect
, *best_match
= NULL
;
3134 if (overlay_debugging
)
3135 ALL_OBJSECTIONS (objfile
, osect
)
3136 if (section_is_overlay (osect
))
3138 if (pc_in_mapped_range (pc
, osect
))
3140 if (section_is_mapped (osect
))
3145 else if (pc_in_unmapped_range (pc
, osect
))
3151 /* Function: find_pc_mapped_section (PC)
3152 If PC falls into the VMA address range of an overlay section that is
3153 currently marked as MAPPED, return that section. Else return NULL. */
3155 struct obj_section
*
3156 find_pc_mapped_section (CORE_ADDR pc
)
3158 struct objfile
*objfile
;
3159 struct obj_section
*osect
;
3161 if (overlay_debugging
)
3162 ALL_OBJSECTIONS (objfile
, osect
)
3163 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3169 /* Function: list_overlays_command
3170 Print a list of mapped sections and their PC ranges */
3173 list_overlays_command (char *args
, int from_tty
)
3176 struct objfile
*objfile
;
3177 struct obj_section
*osect
;
3179 if (overlay_debugging
)
3180 ALL_OBJSECTIONS (objfile
, osect
)
3181 if (section_is_mapped (osect
))
3183 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3188 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3189 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3190 size
= bfd_get_section_size (osect
->the_bfd_section
);
3191 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3193 printf_filtered ("Section %s, loaded at ", name
);
3194 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3195 puts_filtered (" - ");
3196 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3197 printf_filtered (", mapped at ");
3198 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3199 puts_filtered (" - ");
3200 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3201 puts_filtered ("\n");
3206 printf_filtered (_("No sections are mapped.\n"));
3209 /* Function: map_overlay_command
3210 Mark the named section as mapped (ie. residing at its VMA address). */
3213 map_overlay_command (char *args
, int from_tty
)
3215 struct objfile
*objfile
, *objfile2
;
3216 struct obj_section
*sec
, *sec2
;
3218 if (!overlay_debugging
)
3220 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3221 the 'overlay manual' command."));
3223 if (args
== 0 || *args
== 0)
3224 error (_("Argument required: name of an overlay section"));
3226 /* First, find a section matching the user supplied argument */
3227 ALL_OBJSECTIONS (objfile
, sec
)
3228 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3230 /* Now, check to see if the section is an overlay. */
3231 if (!section_is_overlay (sec
))
3232 continue; /* not an overlay section */
3234 /* Mark the overlay as "mapped" */
3235 sec
->ovly_mapped
= 1;
3237 /* Next, make a pass and unmap any sections that are
3238 overlapped by this new section: */
3239 ALL_OBJSECTIONS (objfile2
, sec2
)
3240 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3243 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3244 bfd_section_name (objfile
->obfd
,
3245 sec2
->the_bfd_section
));
3246 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3250 error (_("No overlay section called %s"), args
);
3253 /* Function: unmap_overlay_command
3254 Mark the overlay section as unmapped
3255 (ie. resident in its LMA address range, rather than the VMA range). */
3258 unmap_overlay_command (char *args
, int from_tty
)
3260 struct objfile
*objfile
;
3261 struct obj_section
*sec
;
3263 if (!overlay_debugging
)
3265 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3266 the 'overlay manual' command."));
3268 if (args
== 0 || *args
== 0)
3269 error (_("Argument required: name of an overlay section"));
3271 /* First, find a section matching the user supplied argument */
3272 ALL_OBJSECTIONS (objfile
, sec
)
3273 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3275 if (!sec
->ovly_mapped
)
3276 error (_("Section %s is not mapped"), args
);
3277 sec
->ovly_mapped
= 0;
3280 error (_("No overlay section called %s"), args
);
3283 /* Function: overlay_auto_command
3284 A utility command to turn on overlay debugging.
3285 Possibly this should be done via a set/show command. */
3288 overlay_auto_command (char *args
, int from_tty
)
3290 overlay_debugging
= ovly_auto
;
3291 enable_overlay_breakpoints ();
3293 printf_unfiltered (_("Automatic overlay debugging enabled."));
3296 /* Function: overlay_manual_command
3297 A utility command to turn on overlay debugging.
3298 Possibly this should be done via a set/show command. */
3301 overlay_manual_command (char *args
, int from_tty
)
3303 overlay_debugging
= ovly_on
;
3304 disable_overlay_breakpoints ();
3306 printf_unfiltered (_("Overlay debugging enabled."));
3309 /* Function: overlay_off_command
3310 A utility command to turn on overlay debugging.
3311 Possibly this should be done via a set/show command. */
3314 overlay_off_command (char *args
, int from_tty
)
3316 overlay_debugging
= ovly_off
;
3317 disable_overlay_breakpoints ();
3319 printf_unfiltered (_("Overlay debugging disabled."));
3323 overlay_load_command (char *args
, int from_tty
)
3325 struct gdbarch
*gdbarch
= get_current_arch ();
3327 if (gdbarch_overlay_update_p (gdbarch
))
3328 gdbarch_overlay_update (gdbarch
, NULL
);
3330 error (_("This target does not know how to read its overlay state."));
3333 /* Function: overlay_command
3334 A place-holder for a mis-typed command */
3336 /* Command list chain containing all defined "overlay" subcommands. */
3337 struct cmd_list_element
*overlaylist
;
3340 overlay_command (char *args
, int from_tty
)
3343 ("\"overlay\" must be followed by the name of an overlay command.\n");
3344 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3348 /* Target Overlays for the "Simplest" overlay manager:
3350 This is GDB's default target overlay layer. It works with the
3351 minimal overlay manager supplied as an example by Cygnus. The
3352 entry point is via a function pointer "gdbarch_overlay_update",
3353 so targets that use a different runtime overlay manager can
3354 substitute their own overlay_update function and take over the
3357 The overlay_update function pokes around in the target's data structures
3358 to see what overlays are mapped, and updates GDB's overlay mapping with
3361 In this simple implementation, the target data structures are as follows:
3362 unsigned _novlys; /# number of overlay sections #/
3363 unsigned _ovly_table[_novlys][4] = {
3364 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3365 {..., ..., ..., ...},
3367 unsigned _novly_regions; /# number of overlay regions #/
3368 unsigned _ovly_region_table[_novly_regions][3] = {
3369 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3372 These functions will attempt to update GDB's mappedness state in the
3373 symbol section table, based on the target's mappedness state.
3375 To do this, we keep a cached copy of the target's _ovly_table, and
3376 attempt to detect when the cached copy is invalidated. The main
3377 entry point is "simple_overlay_update(SECT), which looks up SECT in
3378 the cached table and re-reads only the entry for that section from
3379 the target (whenever possible).
3382 /* Cached, dynamically allocated copies of the target data structures: */
3383 static unsigned (*cache_ovly_table
)[4] = 0;
3385 static unsigned (*cache_ovly_region_table
)[3] = 0;
3387 static unsigned cache_novlys
= 0;
3389 static unsigned cache_novly_regions
= 0;
3391 static CORE_ADDR cache_ovly_table_base
= 0;
3393 static CORE_ADDR cache_ovly_region_table_base
= 0;
3397 VMA
, SIZE
, LMA
, MAPPED
3400 /* Throw away the cached copy of _ovly_table */
3402 simple_free_overlay_table (void)
3404 if (cache_ovly_table
)
3405 xfree (cache_ovly_table
);
3407 cache_ovly_table
= NULL
;
3408 cache_ovly_table_base
= 0;
3412 /* Throw away the cached copy of _ovly_region_table */
3414 simple_free_overlay_region_table (void)
3416 if (cache_ovly_region_table
)
3417 xfree (cache_ovly_region_table
);
3418 cache_novly_regions
= 0;
3419 cache_ovly_region_table
= NULL
;
3420 cache_ovly_region_table_base
= 0;
3424 /* Read an array of ints of size SIZE from the target into a local buffer.
3425 Convert to host order. int LEN is number of ints */
3427 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3428 int len
, int size
, enum bfd_endian byte_order
)
3430 /* FIXME (alloca): Not safe if array is very large. */
3431 gdb_byte
*buf
= alloca (len
* size
);
3434 read_memory (memaddr
, buf
, len
* size
);
3435 for (i
= 0; i
< len
; i
++)
3436 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3439 /* Find and grab a copy of the target _ovly_table
3440 (and _novlys, which is needed for the table's size) */
3442 simple_read_overlay_table (void)
3444 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3445 struct gdbarch
*gdbarch
;
3447 enum bfd_endian byte_order
;
3449 simple_free_overlay_table ();
3450 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3453 error (_("Error reading inferior's overlay table: "
3454 "couldn't find `_novlys' variable\n"
3455 "in inferior. Use `overlay manual' mode."));
3459 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3460 if (! ovly_table_msym
)
3462 error (_("Error reading inferior's overlay table: couldn't find "
3463 "`_ovly_table' array\n"
3464 "in inferior. Use `overlay manual' mode."));
3468 gdbarch
= get_objfile_arch (msymbol_objfile (ovly_table_msym
));
3469 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3470 byte_order
= gdbarch_byte_order (gdbarch
);
3472 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
),
3475 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3476 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3477 read_target_long_array (cache_ovly_table_base
,
3478 (unsigned int *) cache_ovly_table
,
3479 cache_novlys
* 4, word_size
, byte_order
);
3481 return 1; /* SUCCESS */
3485 /* Find and grab a copy of the target _ovly_region_table
3486 (and _novly_regions, which is needed for the table's size) */
3488 simple_read_overlay_region_table (void)
3490 struct minimal_symbol
*msym
;
3491 struct gdbarch
*gdbarch
;
3493 enum bfd_endian byte_order
;
3495 simple_free_overlay_region_table ();
3496 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3498 return 0; /* failure */
3500 gdbarch
= get_objfile_arch (msymbol_objfile (msym
));
3501 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3502 byte_order
= gdbarch_byte_order (gdbarch
);
3504 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
),
3507 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3508 if (cache_ovly_region_table
!= NULL
)
3510 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3513 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3514 read_target_long_array (cache_ovly_region_table_base
,
3515 (unsigned int *) cache_ovly_region_table
,
3516 cache_novly_regions
* 3,
3517 word_size
, byte_order
);
3520 return 0; /* failure */
3523 return 0; /* failure */
3524 return 1; /* SUCCESS */
3528 /* Function: simple_overlay_update_1
3529 A helper function for simple_overlay_update. Assuming a cached copy
3530 of _ovly_table exists, look through it to find an entry whose vma,
3531 lma and size match those of OSECT. Re-read the entry and make sure
3532 it still matches OSECT (else the table may no longer be valid).
3533 Set OSECT's mapped state to match the entry. Return: 1 for
3534 success, 0 for failure. */
3537 simple_overlay_update_1 (struct obj_section
*osect
)
3540 bfd
*obfd
= osect
->objfile
->obfd
;
3541 asection
*bsect
= osect
->the_bfd_section
;
3542 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3543 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3544 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3546 size
= bfd_get_section_size (osect
->the_bfd_section
);
3547 for (i
= 0; i
< cache_novlys
; i
++)
3548 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3549 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3550 /* && cache_ovly_table[i][SIZE] == size */ )
3552 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3553 (unsigned int *) cache_ovly_table
[i
],
3554 4, word_size
, byte_order
);
3555 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3556 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3557 /* && cache_ovly_table[i][SIZE] == size */ )
3559 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3562 else /* Warning! Warning! Target's ovly table has changed! */
3568 /* Function: simple_overlay_update
3569 If OSECT is NULL, then update all sections' mapped state
3570 (after re-reading the entire target _ovly_table).
3571 If OSECT is non-NULL, then try to find a matching entry in the
3572 cached ovly_table and update only OSECT's mapped state.
3573 If a cached entry can't be found or the cache isn't valid, then
3574 re-read the entire cache, and go ahead and update all sections. */
3577 simple_overlay_update (struct obj_section
*osect
)
3579 struct objfile
*objfile
;
3581 /* Were we given an osect to look up? NULL means do all of them. */
3583 /* Have we got a cached copy of the target's overlay table? */
3584 if (cache_ovly_table
!= NULL
)
3585 /* Does its cached location match what's currently in the symtab? */
3586 if (cache_ovly_table_base
==
3587 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3588 /* Then go ahead and try to look up this single section in the cache */
3589 if (simple_overlay_update_1 (osect
))
3590 /* Found it! We're done. */
3593 /* Cached table no good: need to read the entire table anew.
3594 Or else we want all the sections, in which case it's actually
3595 more efficient to read the whole table in one block anyway. */
3597 if (! simple_read_overlay_table ())
3600 /* Now may as well update all sections, even if only one was requested. */
3601 ALL_OBJSECTIONS (objfile
, osect
)
3602 if (section_is_overlay (osect
))
3605 bfd
*obfd
= osect
->objfile
->obfd
;
3606 asection
*bsect
= osect
->the_bfd_section
;
3608 size
= bfd_get_section_size (bsect
);
3609 for (i
= 0; i
< cache_novlys
; i
++)
3610 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3611 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3612 /* && cache_ovly_table[i][SIZE] == size */ )
3613 { /* obj_section matches i'th entry in ovly_table */
3614 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3615 break; /* finished with inner for loop: break out */
3620 /* Set the output sections and output offsets for section SECTP in
3621 ABFD. The relocation code in BFD will read these offsets, so we
3622 need to be sure they're initialized. We map each section to itself,
3623 with no offset; this means that SECTP->vma will be honored. */
3626 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3628 sectp
->output_section
= sectp
;
3629 sectp
->output_offset
= 0;
3632 /* Default implementation for sym_relocate. */
3636 default_symfile_relocate (struct objfile
*objfile
, asection
*sectp
,
3639 bfd
*abfd
= objfile
->obfd
;
3641 /* We're only interested in sections with relocation
3643 if ((sectp
->flags
& SEC_RELOC
) == 0)
3646 /* We will handle section offsets properly elsewhere, so relocate as if
3647 all sections begin at 0. */
3648 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3650 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3653 /* Relocate the contents of a debug section SECTP in ABFD. The
3654 contents are stored in BUF if it is non-NULL, or returned in a
3655 malloc'd buffer otherwise.
3657 For some platforms and debug info formats, shared libraries contain
3658 relocations against the debug sections (particularly for DWARF-2;
3659 one affected platform is PowerPC GNU/Linux, although it depends on
3660 the version of the linker in use). Also, ELF object files naturally
3661 have unresolved relocations for their debug sections. We need to apply
3662 the relocations in order to get the locations of symbols correct.
3663 Another example that may require relocation processing, is the
3664 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3668 symfile_relocate_debug_section (struct objfile
*objfile
,
3669 asection
*sectp
, bfd_byte
*buf
)
3671 gdb_assert (objfile
->sf
->sym_relocate
);
3673 return (*objfile
->sf
->sym_relocate
) (objfile
, sectp
, buf
);
3676 struct symfile_segment_data
*
3677 get_symfile_segment_data (bfd
*abfd
)
3679 struct sym_fns
*sf
= find_sym_fns (abfd
);
3684 return sf
->sym_segments (abfd
);
3688 free_symfile_segment_data (struct symfile_segment_data
*data
)
3690 xfree (data
->segment_bases
);
3691 xfree (data
->segment_sizes
);
3692 xfree (data
->segment_info
);
3698 - DATA, containing segment addresses from the object file ABFD, and
3699 the mapping from ABFD's sections onto the segments that own them,
3701 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3702 segment addresses reported by the target,
3703 store the appropriate offsets for each section in OFFSETS.
3705 If there are fewer entries in SEGMENT_BASES than there are segments
3706 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3708 If there are more entries, then ignore the extra. The target may
3709 not be able to distinguish between an empty data segment and a
3710 missing data segment; a missing text segment is less plausible. */
3712 symfile_map_offsets_to_segments (bfd
*abfd
, struct symfile_segment_data
*data
,
3713 struct section_offsets
*offsets
,
3714 int num_segment_bases
,
3715 const CORE_ADDR
*segment_bases
)
3720 /* It doesn't make sense to call this function unless you have some
3721 segment base addresses. */
3722 gdb_assert (num_segment_bases
> 0);
3724 /* If we do not have segment mappings for the object file, we
3725 can not relocate it by segments. */
3726 gdb_assert (data
!= NULL
);
3727 gdb_assert (data
->num_segments
> 0);
3729 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3731 int which
= data
->segment_info
[i
];
3733 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3735 /* Don't bother computing offsets for sections that aren't
3736 loaded as part of any segment. */
3740 /* Use the last SEGMENT_BASES entry as the address of any extra
3741 segments mentioned in DATA->segment_info. */
3742 if (which
> num_segment_bases
)
3743 which
= num_segment_bases
;
3745 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3746 - data
->segment_bases
[which
- 1]);
3753 symfile_find_segment_sections (struct objfile
*objfile
)
3755 bfd
*abfd
= objfile
->obfd
;
3758 struct symfile_segment_data
*data
;
3760 data
= get_symfile_segment_data (objfile
->obfd
);
3764 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3766 free_symfile_segment_data (data
);
3770 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3773 int which
= data
->segment_info
[i
];
3777 if (objfile
->sect_index_text
== -1)
3778 objfile
->sect_index_text
= sect
->index
;
3780 if (objfile
->sect_index_rodata
== -1)
3781 objfile
->sect_index_rodata
= sect
->index
;
3783 else if (which
== 2)
3785 if (objfile
->sect_index_data
== -1)
3786 objfile
->sect_index_data
= sect
->index
;
3788 if (objfile
->sect_index_bss
== -1)
3789 objfile
->sect_index_bss
= sect
->index
;
3793 free_symfile_segment_data (data
);
3797 _initialize_symfile (void)
3799 struct cmd_list_element
*c
;
3801 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3802 Load symbol table from executable file FILE.\n\
3803 The `file' command can also load symbol tables, as well as setting the file\n\
3804 to execute."), &cmdlist
);
3805 set_cmd_completer (c
, filename_completer
);
3807 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3808 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3809 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3810 ADDR is the starting address of the file's text.\n\
3811 The optional arguments are section-name section-address pairs and\n\
3812 should be specified if the data and bss segments are not contiguous\n\
3813 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3815 set_cmd_completer (c
, filename_completer
);
3817 c
= add_cmd ("load", class_files
, load_command
, _("\
3818 Dynamically load FILE into the running program, and record its symbols\n\
3819 for access from GDB.\n\
3820 A load OFFSET may also be given."), &cmdlist
);
3821 set_cmd_completer (c
, filename_completer
);
3823 add_setshow_boolean_cmd ("symbol-reloading", class_support
,
3824 &symbol_reloading
, _("\
3825 Set dynamic symbol table reloading multiple times in one run."), _("\
3826 Show dynamic symbol table reloading multiple times in one run."), NULL
,
3828 show_symbol_reloading
,
3829 &setlist
, &showlist
);
3831 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3832 _("Commands for debugging overlays."), &overlaylist
,
3833 "overlay ", 0, &cmdlist
);
3835 add_com_alias ("ovly", "overlay", class_alias
, 1);
3836 add_com_alias ("ov", "overlay", class_alias
, 1);
3838 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3839 _("Assert that an overlay section is mapped."), &overlaylist
);
3841 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3842 _("Assert that an overlay section is unmapped."), &overlaylist
);
3844 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3845 _("List mappings of overlay sections."), &overlaylist
);
3847 add_cmd ("manual", class_support
, overlay_manual_command
,
3848 _("Enable overlay debugging."), &overlaylist
);
3849 add_cmd ("off", class_support
, overlay_off_command
,
3850 _("Disable overlay debugging."), &overlaylist
);
3851 add_cmd ("auto", class_support
, overlay_auto_command
,
3852 _("Enable automatic overlay debugging."), &overlaylist
);
3853 add_cmd ("load-target", class_support
, overlay_load_command
,
3854 _("Read the overlay mapping state from the target."), &overlaylist
);
3856 /* Filename extension to source language lookup table: */
3857 init_filename_language_table ();
3858 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3860 Set mapping between filename extension and source language."), _("\
3861 Show mapping between filename extension and source language."), _("\
3862 Usage: set extension-language .foo bar"),
3863 set_ext_lang_command
,
3865 &setlist
, &showlist
);
3867 add_info ("extensions", info_ext_lang_command
,
3868 _("All filename extensions associated with a source language."));
3870 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3871 &debug_file_directory
, _("\
3872 Set the directories where separate debug symbols are searched for."), _("\
3873 Show the directories where separate debug symbols are searched for."), _("\
3874 Separate debug symbols are first searched for in the same\n\
3875 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3876 and lastly at the path of the directory of the binary with\n\
3877 each global debug-file-directory component prepended."),
3879 show_debug_file_directory
,
3880 &setlist
, &showlist
);