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
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/>. */
36 #include "breakpoint.h"
38 #include "complaints.h"
40 #include "inferior.h" /* for write_pc */
41 #include "filenames.h" /* for DOSish file names */
42 #include "gdb-stabs.h"
43 #include "gdb_obstack.h"
44 #include "completer.h"
47 #include "readline/readline.h"
48 #include "gdb_assert.h"
52 #include "parser-defs.h"
55 #include <sys/types.h>
57 #include "gdb_string.h"
64 int (*deprecated_ui_load_progress_hook
) (const char *section
, unsigned long num
);
65 void (*deprecated_show_load_progress
) (const char *section
,
66 unsigned long section_sent
,
67 unsigned long section_size
,
68 unsigned long total_sent
,
69 unsigned long total_size
);
70 void (*deprecated_pre_add_symbol_hook
) (const char *);
71 void (*deprecated_post_add_symbol_hook
) (void);
73 static void clear_symtab_users_cleanup (void *ignore
);
75 /* Global variables owned by this file */
76 int readnow_symbol_files
; /* Read full symbols immediately */
78 /* External variables and functions referenced. */
80 extern void report_transfer_performance (unsigned long, time_t, time_t);
82 /* Functions this file defines */
85 static int simple_read_overlay_region_table (void);
86 static void simple_free_overlay_region_table (void);
89 static void set_initial_language (void);
91 static void load_command (char *, int);
93 static void symbol_file_add_main_1 (char *args
, int from_tty
, int flags
);
95 static void add_symbol_file_command (char *, int);
97 static void add_shared_symbol_files_command (char *, int);
99 static void reread_separate_symbols (struct objfile
*objfile
);
101 static void cashier_psymtab (struct partial_symtab
*);
103 bfd
*symfile_bfd_open (char *);
105 int get_section_index (struct objfile
*, char *);
107 static struct sym_fns
*find_sym_fns (bfd
*);
109 static void decrement_reading_symtab (void *);
111 static void overlay_invalidate_all (void);
113 static int overlay_is_mapped (struct obj_section
*);
115 void list_overlays_command (char *, int);
117 void map_overlay_command (char *, int);
119 void unmap_overlay_command (char *, int);
121 static void overlay_auto_command (char *, int);
123 static void overlay_manual_command (char *, int);
125 static void overlay_off_command (char *, int);
127 static void overlay_load_command (char *, int);
129 static void overlay_command (char *, int);
131 static void simple_free_overlay_table (void);
133 static void read_target_long_array (CORE_ADDR
, unsigned int *, int);
135 static int simple_read_overlay_table (void);
137 static int simple_overlay_update_1 (struct obj_section
*);
139 static void add_filename_language (char *ext
, enum language lang
);
141 static void info_ext_lang_command (char *args
, int from_tty
);
143 static char *find_separate_debug_file (struct objfile
*objfile
);
145 static void init_filename_language_table (void);
147 static void symfile_find_segment_sections (struct objfile
*objfile
);
149 void _initialize_symfile (void);
151 /* List of all available sym_fns. On gdb startup, each object file reader
152 calls add_symtab_fns() to register information on each format it is
155 static struct sym_fns
*symtab_fns
= NULL
;
157 /* Flag for whether user will be reloading symbols multiple times.
158 Defaults to ON for VxWorks, otherwise OFF. */
160 #ifdef SYMBOL_RELOADING_DEFAULT
161 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
163 int symbol_reloading
= 0;
166 show_symbol_reloading (struct ui_file
*file
, int from_tty
,
167 struct cmd_list_element
*c
, const char *value
)
169 fprintf_filtered (file
, _("\
170 Dynamic symbol table reloading multiple times in one run is %s.\n"),
175 /* If non-zero, shared library symbols will be added automatically
176 when the inferior is created, new libraries are loaded, or when
177 attaching to the inferior. This is almost always what users will
178 want to have happen; but for very large programs, the startup time
179 will be excessive, and so if this is a problem, the user can clear
180 this flag and then add the shared library symbols as needed. Note
181 that there is a potential for confusion, since if the shared
182 library symbols are not loaded, commands like "info fun" will *not*
183 report all the functions that are actually present. */
185 int auto_solib_add
= 1;
187 /* For systems that support it, a threshold size in megabytes. If
188 automatically adding a new library's symbol table to those already
189 known to the debugger would cause the total shared library symbol
190 size to exceed this threshhold, then the shlib's symbols are not
191 added. The threshold is ignored if the user explicitly asks for a
192 shlib to be added, such as when using the "sharedlibrary"
195 int auto_solib_limit
;
198 /* This compares two partial symbols by names, using strcmp_iw_ordered
199 for the comparison. */
202 compare_psymbols (const void *s1p
, const void *s2p
)
204 struct partial_symbol
*const *s1
= s1p
;
205 struct partial_symbol
*const *s2
= s2p
;
207 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1
),
208 SYMBOL_SEARCH_NAME (*s2
));
212 sort_pst_symbols (struct partial_symtab
*pst
)
214 /* Sort the global list; don't sort the static list */
216 qsort (pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
,
217 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
221 /* Make a null terminated copy of the string at PTR with SIZE characters in
222 the obstack pointed to by OBSTACKP . Returns the address of the copy.
223 Note that the string at PTR does not have to be null terminated, I.E. it
224 may be part of a larger string and we are only saving a substring. */
227 obsavestring (const char *ptr
, int size
, struct obstack
*obstackp
)
229 char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
230 /* Open-coded memcpy--saves function call time. These strings are usually
231 short. FIXME: Is this really still true with a compiler that can
234 const char *p1
= ptr
;
236 const char *end
= ptr
+ size
;
244 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
245 in the obstack pointed to by OBSTACKP. */
248 obconcat (struct obstack
*obstackp
, const char *s1
, const char *s2
,
251 int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
252 char *val
= (char *) obstack_alloc (obstackp
, len
);
259 /* True if we are nested inside psymtab_to_symtab. */
261 int currently_reading_symtab
= 0;
264 decrement_reading_symtab (void *dummy
)
266 currently_reading_symtab
--;
269 /* Get the symbol table that corresponds to a partial_symtab.
270 This is fast after the first time you do it. In fact, there
271 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
275 psymtab_to_symtab (struct partial_symtab
*pst
)
277 /* If it's been looked up before, return it. */
281 /* If it has not yet been read in, read it. */
284 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
285 currently_reading_symtab
++;
286 (*pst
->read_symtab
) (pst
);
287 do_cleanups (back_to
);
293 /* Remember the lowest-addressed loadable section we've seen.
294 This function is called via bfd_map_over_sections.
296 In case of equal vmas, the section with the largest size becomes the
297 lowest-addressed loadable section.
299 If the vmas and sizes are equal, the last section is considered the
300 lowest-addressed loadable section. */
303 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
305 asection
**lowest
= (asection
**) obj
;
307 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
310 *lowest
= sect
; /* First loadable section */
311 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
312 *lowest
= sect
; /* A lower loadable section */
313 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
314 && (bfd_section_size (abfd
, (*lowest
))
315 <= bfd_section_size (abfd
, sect
)))
319 /* Create a new section_addr_info, with room for NUM_SECTIONS. */
321 struct section_addr_info
*
322 alloc_section_addr_info (size_t num_sections
)
324 struct section_addr_info
*sap
;
327 size
= (sizeof (struct section_addr_info
)
328 + sizeof (struct other_sections
) * (num_sections
- 1));
329 sap
= (struct section_addr_info
*) xmalloc (size
);
330 memset (sap
, 0, size
);
331 sap
->num_sections
= num_sections
;
337 /* Return a freshly allocated copy of ADDRS. The section names, if
338 any, are also freshly allocated copies of those in ADDRS. */
339 struct section_addr_info
*
340 copy_section_addr_info (struct section_addr_info
*addrs
)
342 struct section_addr_info
*copy
343 = alloc_section_addr_info (addrs
->num_sections
);
346 copy
->num_sections
= addrs
->num_sections
;
347 for (i
= 0; i
< addrs
->num_sections
; i
++)
349 copy
->other
[i
].addr
= addrs
->other
[i
].addr
;
350 if (addrs
->other
[i
].name
)
351 copy
->other
[i
].name
= xstrdup (addrs
->other
[i
].name
);
353 copy
->other
[i
].name
= NULL
;
354 copy
->other
[i
].sectindex
= addrs
->other
[i
].sectindex
;
362 /* Build (allocate and populate) a section_addr_info struct from
363 an existing section table. */
365 extern struct section_addr_info
*
366 build_section_addr_info_from_section_table (const struct section_table
*start
,
367 const struct section_table
*end
)
369 struct section_addr_info
*sap
;
370 const struct section_table
*stp
;
373 sap
= alloc_section_addr_info (end
- start
);
375 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
377 if (bfd_get_section_flags (stp
->bfd
,
378 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
379 && oidx
< end
- start
)
381 sap
->other
[oidx
].addr
= stp
->addr
;
382 sap
->other
[oidx
].name
383 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
384 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
393 /* Free all memory allocated by build_section_addr_info_from_section_table. */
396 free_section_addr_info (struct section_addr_info
*sap
)
400 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
401 if (sap
->other
[idx
].name
)
402 xfree (sap
->other
[idx
].name
);
407 /* Initialize OBJFILE's sect_index_* members. */
409 init_objfile_sect_indices (struct objfile
*objfile
)
414 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
416 objfile
->sect_index_text
= sect
->index
;
418 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
420 objfile
->sect_index_data
= sect
->index
;
422 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
424 objfile
->sect_index_bss
= sect
->index
;
426 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
428 objfile
->sect_index_rodata
= sect
->index
;
430 /* This is where things get really weird... We MUST have valid
431 indices for the various sect_index_* members or gdb will abort.
432 So if for example, there is no ".text" section, we have to
433 accomodate that. First, check for a file with the standard
434 one or two segments. */
436 symfile_find_segment_sections (objfile
);
438 /* Except when explicitly adding symbol files at some address,
439 section_offsets contains nothing but zeros, so it doesn't matter
440 which slot in section_offsets the individual sect_index_* members
441 index into. So if they are all zero, it is safe to just point
442 all the currently uninitialized indices to the first slot. But
443 beware: if this is the main executable, it may be relocated
444 later, e.g. by the remote qOffsets packet, and then this will
445 be wrong! That's why we try segments first. */
447 for (i
= 0; i
< objfile
->num_sections
; i
++)
449 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
454 if (i
== objfile
->num_sections
)
456 if (objfile
->sect_index_text
== -1)
457 objfile
->sect_index_text
= 0;
458 if (objfile
->sect_index_data
== -1)
459 objfile
->sect_index_data
= 0;
460 if (objfile
->sect_index_bss
== -1)
461 objfile
->sect_index_bss
= 0;
462 if (objfile
->sect_index_rodata
== -1)
463 objfile
->sect_index_rodata
= 0;
467 /* The arguments to place_section. */
469 struct place_section_arg
471 struct section_offsets
*offsets
;
475 /* Find a unique offset to use for loadable section SECT if
476 the user did not provide an offset. */
479 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
481 struct place_section_arg
*arg
= obj
;
482 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
484 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
486 /* We are only interested in allocated sections. */
487 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
490 /* If the user specified an offset, honor it. */
491 if (offsets
[sect
->index
] != 0)
494 /* Otherwise, let's try to find a place for the section. */
495 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
502 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
504 int indx
= cur_sec
->index
;
505 CORE_ADDR cur_offset
;
507 /* We don't need to compare against ourself. */
511 /* We can only conflict with allocated sections. */
512 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
515 /* If the section offset is 0, either the section has not been placed
516 yet, or it was the lowest section placed (in which case LOWEST
517 will be past its end). */
518 if (offsets
[indx
] == 0)
521 /* If this section would overlap us, then we must move up. */
522 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
523 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
525 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
526 start_addr
= (start_addr
+ align
- 1) & -align
;
531 /* Otherwise, we appear to be OK. So far. */
536 offsets
[sect
->index
] = start_addr
;
537 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
539 exec_set_section_address (bfd_get_filename (abfd
), sect
->index
, start_addr
);
542 /* Parse the user's idea of an offset for dynamic linking, into our idea
543 of how to represent it for fast symbol reading. This is the default
544 version of the sym_fns.sym_offsets function for symbol readers that
545 don't need to do anything special. It allocates a section_offsets table
546 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
549 default_symfile_offsets (struct objfile
*objfile
,
550 struct section_addr_info
*addrs
)
554 objfile
->num_sections
= bfd_count_sections (objfile
->obfd
);
555 objfile
->section_offsets
= (struct section_offsets
*)
556 obstack_alloc (&objfile
->objfile_obstack
,
557 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
558 memset (objfile
->section_offsets
, 0,
559 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
561 /* Now calculate offsets for section that were specified by the
563 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
565 struct other_sections
*osp
;
567 osp
= &addrs
->other
[i
] ;
571 /* Record all sections in offsets */
572 /* The section_offsets in the objfile are here filled in using
574 (objfile
->section_offsets
)->offsets
[osp
->sectindex
] = osp
->addr
;
577 /* For relocatable files, all loadable sections will start at zero.
578 The zero is meaningless, so try to pick arbitrary addresses such
579 that no loadable sections overlap. This algorithm is quadratic,
580 but the number of sections in a single object file is generally
582 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
584 struct place_section_arg arg
;
585 bfd
*abfd
= objfile
->obfd
;
587 CORE_ADDR lowest
= 0;
589 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
590 /* We do not expect this to happen; just skip this step if the
591 relocatable file has a section with an assigned VMA. */
592 if (bfd_section_vma (abfd
, cur_sec
) != 0)
597 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
599 /* Pick non-overlapping offsets for sections the user did not
601 arg
.offsets
= objfile
->section_offsets
;
603 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
605 /* Correctly filling in the section offsets is not quite
606 enough. Relocatable files have two properties that
607 (most) shared objects do not:
609 - Their debug information will contain relocations. Some
610 shared libraries do also, but many do not, so this can not
613 - If there are multiple code sections they will be loaded
614 at different relative addresses in memory than they are
615 in the objfile, since all sections in the file will start
618 Because GDB has very limited ability to map from an
619 address in debug info to the correct code section,
620 it relies on adding SECT_OFF_TEXT to things which might be
621 code. If we clear all the section offsets, and set the
622 section VMAs instead, then symfile_relocate_debug_section
623 will return meaningful debug information pointing at the
626 GDB has too many different data structures for section
627 addresses - a bfd, objfile, and so_list all have section
628 tables, as does exec_ops. Some of these could probably
631 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
632 cur_sec
= cur_sec
->next
)
634 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
637 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
638 offsets
[cur_sec
->index
] = 0;
643 /* Remember the bfd indexes for the .text, .data, .bss and
645 init_objfile_sect_indices (objfile
);
649 /* Divide the file into segments, which are individual relocatable units.
650 This is the default version of the sym_fns.sym_segments function for
651 symbol readers that do not have an explicit representation of segments.
652 It assumes that object files do not have segments, and fully linked
653 files have a single segment. */
655 struct symfile_segment_data
*
656 default_symfile_segments (bfd
*abfd
)
660 struct symfile_segment_data
*data
;
663 /* Relocatable files contain enough information to position each
664 loadable section independently; they should not be relocated
666 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
669 /* Make sure there is at least one loadable section in the file. */
670 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
672 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
680 low
= bfd_get_section_vma (abfd
, sect
);
681 high
= low
+ bfd_get_section_size (sect
);
683 data
= XZALLOC (struct symfile_segment_data
);
684 data
->num_segments
= 1;
685 data
->segment_bases
= XCALLOC (1, CORE_ADDR
);
686 data
->segment_sizes
= XCALLOC (1, CORE_ADDR
);
688 num_sections
= bfd_count_sections (abfd
);
689 data
->segment_info
= XCALLOC (num_sections
, int);
691 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
695 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
698 vma
= bfd_get_section_vma (abfd
, sect
);
701 if (vma
+ bfd_get_section_size (sect
) > high
)
702 high
= vma
+ bfd_get_section_size (sect
);
704 data
->segment_info
[i
] = 1;
707 data
->segment_bases
[0] = low
;
708 data
->segment_sizes
[0] = high
- low
;
713 /* Process a symbol file, as either the main file or as a dynamically
716 OBJFILE is where the symbols are to be read from.
718 ADDRS is the list of section load addresses. If the user has given
719 an 'add-symbol-file' command, then this is the list of offsets and
720 addresses he or she provided as arguments to the command; or, if
721 we're handling a shared library, these are the actual addresses the
722 sections are loaded at, according to the inferior's dynamic linker
723 (as gleaned by GDB's shared library code). We convert each address
724 into an offset from the section VMA's as it appears in the object
725 file, and then call the file's sym_offsets function to convert this
726 into a format-specific offset table --- a `struct section_offsets'.
727 If ADDRS is non-zero, OFFSETS must be zero.
729 OFFSETS is a table of section offsets already in the right
730 format-specific representation. NUM_OFFSETS is the number of
731 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
732 assume this is the proper table the call to sym_offsets described
733 above would produce. Instead of calling sym_offsets, we just dump
734 it right into objfile->section_offsets. (When we're re-reading
735 symbols from an objfile, we don't have the original load address
736 list any more; all we have is the section offset table.) If
737 OFFSETS is non-zero, ADDRS must be zero.
739 MAINLINE is nonzero if this is the main symbol file, or zero if
740 it's an extra symbol file such as dynamically loaded code.
742 VERBO is nonzero if the caller has printed a verbose message about
743 the symbol reading (and complaints can be more terse about it). */
746 syms_from_objfile (struct objfile
*objfile
,
747 struct section_addr_info
*addrs
,
748 struct section_offsets
*offsets
,
753 struct section_addr_info
*local_addr
= NULL
;
754 struct cleanup
*old_chain
;
756 gdb_assert (! (addrs
&& offsets
));
758 init_entry_point_info (objfile
);
759 objfile
->sf
= find_sym_fns (objfile
->obfd
);
761 if (objfile
->sf
== NULL
)
762 return; /* No symbols. */
764 /* Make sure that partially constructed symbol tables will be cleaned up
765 if an error occurs during symbol reading. */
766 old_chain
= make_cleanup_free_objfile (objfile
);
768 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
769 list. We now establish the convention that an addr of zero means
770 no load address was specified. */
771 if (! addrs
&& ! offsets
)
774 = alloc_section_addr_info (bfd_count_sections (objfile
->obfd
));
775 make_cleanup (xfree
, local_addr
);
779 /* Now either addrs or offsets is non-zero. */
783 /* We will modify the main symbol table, make sure that all its users
784 will be cleaned up if an error occurs during symbol reading. */
785 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
787 /* Since no error yet, throw away the old symbol table. */
789 if (symfile_objfile
!= NULL
)
791 free_objfile (symfile_objfile
);
792 symfile_objfile
= NULL
;
795 /* Currently we keep symbols from the add-symbol-file command.
796 If the user wants to get rid of them, they should do "symbol-file"
797 without arguments first. Not sure this is the best behavior
800 (*objfile
->sf
->sym_new_init
) (objfile
);
803 /* Convert addr into an offset rather than an absolute address.
804 We find the lowest address of a loaded segment in the objfile,
805 and assume that <addr> is where that got loaded.
807 We no longer warn if the lowest section is not a text segment (as
808 happens for the PA64 port. */
809 if (!mainline
&& addrs
&& addrs
->other
[0].name
)
811 asection
*lower_sect
;
813 CORE_ADDR lower_offset
;
816 /* Find lowest loadable section to be used as starting point for
817 continguous sections. FIXME!! won't work without call to find
818 .text first, but this assumes text is lowest section. */
819 lower_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
820 if (lower_sect
== NULL
)
821 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
823 if (lower_sect
== NULL
)
824 warning (_("no loadable sections found in added symbol-file %s"),
827 if ((bfd_get_section_flags (objfile
->obfd
, lower_sect
) & SEC_CODE
) == 0)
828 warning (_("Lowest section in %s is %s at %s"),
830 bfd_section_name (objfile
->obfd
, lower_sect
),
831 paddr (bfd_section_vma (objfile
->obfd
, lower_sect
)));
832 if (lower_sect
!= NULL
)
833 lower_offset
= bfd_section_vma (objfile
->obfd
, lower_sect
);
837 /* Calculate offsets for the loadable sections.
838 FIXME! Sections must be in order of increasing loadable section
839 so that contiguous sections can use the lower-offset!!!
841 Adjust offsets if the segments are not contiguous.
842 If the section is contiguous, its offset should be set to
843 the offset of the highest loadable section lower than it
844 (the loadable section directly below it in memory).
845 this_offset = lower_offset = lower_addr - lower_orig_addr */
847 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
849 if (addrs
->other
[i
].addr
!= 0)
851 sect
= bfd_get_section_by_name (objfile
->obfd
,
852 addrs
->other
[i
].name
);
856 -= bfd_section_vma (objfile
->obfd
, sect
);
857 lower_offset
= addrs
->other
[i
].addr
;
858 /* This is the index used by BFD. */
859 addrs
->other
[i
].sectindex
= sect
->index
;
863 warning (_("section %s not found in %s"),
864 addrs
->other
[i
].name
,
866 addrs
->other
[i
].addr
= 0;
870 addrs
->other
[i
].addr
= lower_offset
;
874 /* Initialize symbol reading routines for this objfile, allow complaints to
875 appear for this new file, and record how verbose to be, then do the
876 initial symbol reading for this file. */
878 (*objfile
->sf
->sym_init
) (objfile
);
879 clear_complaints (&symfile_complaints
, 1, verbo
);
882 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
885 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
887 /* Just copy in the offset table directly as given to us. */
888 objfile
->num_sections
= num_offsets
;
889 objfile
->section_offsets
890 = ((struct section_offsets
*)
891 obstack_alloc (&objfile
->objfile_obstack
, size
));
892 memcpy (objfile
->section_offsets
, offsets
, size
);
894 init_objfile_sect_indices (objfile
);
897 #ifndef DEPRECATED_IBM6000_TARGET
898 /* This is a SVR4/SunOS specific hack, I think. In any event, it
899 screws RS/6000. sym_offsets should be doing this sort of thing,
900 because it knows the mapping between bfd sections and
902 /* This is a hack. As far as I can tell, section offsets are not
903 target dependent. They are all set to addr with a couple of
904 exceptions. The exceptions are sysvr4 shared libraries, whose
905 offsets are kept in solib structures anyway and rs6000 xcoff
906 which handles shared libraries in a completely unique way.
908 Section offsets are built similarly, except that they are built
909 by adding addr in all cases because there is no clear mapping
910 from section_offsets into actual sections. Note that solib.c
911 has a different algorithm for finding section offsets.
913 These should probably all be collapsed into some target
914 independent form of shared library support. FIXME. */
918 struct obj_section
*s
;
920 /* Map section offsets in "addr" back to the object's
921 sections by comparing the section names with bfd's
922 section names. Then adjust the section address by
923 the offset. */ /* for gdb/13815 */
925 ALL_OBJFILE_OSECTIONS (objfile
, s
)
927 CORE_ADDR s_addr
= 0;
931 !s_addr
&& i
< addrs
->num_sections
&& addrs
->other
[i
].name
;
933 if (strcmp (bfd_section_name (s
->objfile
->obfd
,
935 addrs
->other
[i
].name
) == 0)
936 s_addr
= addrs
->other
[i
].addr
; /* end added for gdb/13815 */
938 s
->addr
-= s
->offset
;
940 s
->endaddr
-= s
->offset
;
941 s
->endaddr
+= s_addr
;
945 #endif /* not DEPRECATED_IBM6000_TARGET */
947 (*objfile
->sf
->sym_read
) (objfile
, mainline
);
949 /* Don't allow char * to have a typename (else would get caddr_t).
950 Ditto void *. FIXME: Check whether this is now done by all the
951 symbol readers themselves (many of them now do), and if so remove
954 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
955 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
957 /* Mark the objfile has having had initial symbol read attempted. Note
958 that this does not mean we found any symbols... */
960 objfile
->flags
|= OBJF_SYMS
;
962 /* Discard cleanups as symbol reading was successful. */
964 discard_cleanups (old_chain
);
967 /* Perform required actions after either reading in the initial
968 symbols for a new objfile, or mapping in the symbols from a reusable
972 new_symfile_objfile (struct objfile
*objfile
, int mainline
, int verbo
)
975 /* If this is the main symbol file we have to clean up all users of the
976 old main symbol file. Otherwise it is sufficient to fixup all the
977 breakpoints that may have been redefined by this symbol file. */
980 /* OK, make it the "real" symbol file. */
981 symfile_objfile
= objfile
;
983 clear_symtab_users ();
987 breakpoint_re_set ();
990 /* We're done reading the symbol file; finish off complaints. */
991 clear_complaints (&symfile_complaints
, 0, verbo
);
994 /* Process a symbol file, as either the main file or as a dynamically
997 ABFD is a BFD already open on the file, as from symfile_bfd_open.
998 This BFD will be closed on error, and is always consumed by this function.
1000 FROM_TTY says how verbose to be.
1002 MAINLINE specifies whether this is the main symbol file, or whether
1003 it's an extra symbol file such as dynamically loaded code.
1005 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
1006 syms_from_objfile, above. ADDRS is ignored when MAINLINE is
1009 Upon success, returns a pointer to the objfile that was added.
1010 Upon failure, jumps back to command level (never returns). */
1011 static struct objfile
*
1012 symbol_file_add_with_addrs_or_offsets (bfd
*abfd
, int from_tty
,
1013 struct section_addr_info
*addrs
,
1014 struct section_offsets
*offsets
,
1016 int mainline
, int flags
)
1018 struct objfile
*objfile
;
1019 struct partial_symtab
*psymtab
;
1021 struct section_addr_info
*orig_addrs
= NULL
;
1022 struct cleanup
*my_cleanups
;
1023 const char *name
= bfd_get_filename (abfd
);
1025 my_cleanups
= make_cleanup_bfd_close (abfd
);
1027 /* Give user a chance to burp if we'd be
1028 interactively wiping out any existing symbols. */
1030 if ((have_full_symbols () || have_partial_symbols ())
1033 && !query ("Load new symbol table from \"%s\"? ", name
))
1034 error (_("Not confirmed."));
1036 objfile
= allocate_objfile (abfd
, flags
);
1037 discard_cleanups (my_cleanups
);
1041 orig_addrs
= copy_section_addr_info (addrs
);
1042 make_cleanup_free_section_addr_info (orig_addrs
);
1045 /* We either created a new mapped symbol table, mapped an existing
1046 symbol table file which has not had initial symbol reading
1047 performed, or need to read an unmapped symbol table. */
1048 if (from_tty
|| info_verbose
)
1050 if (deprecated_pre_add_symbol_hook
)
1051 deprecated_pre_add_symbol_hook (name
);
1054 printf_unfiltered (_("Reading symbols from %s..."), name
);
1056 gdb_flush (gdb_stdout
);
1059 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
1060 mainline
, from_tty
);
1062 /* We now have at least a partial symbol table. Check to see if the
1063 user requested that all symbols be read on initial access via either
1064 the gdb startup command line or on a per symbol file basis. Expand
1065 all partial symbol tables for this objfile if so. */
1067 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
1069 if (from_tty
|| info_verbose
)
1071 printf_unfiltered (_("expanding to full symbols..."));
1073 gdb_flush (gdb_stdout
);
1076 for (psymtab
= objfile
->psymtabs
;
1078 psymtab
= psymtab
->next
)
1080 psymtab_to_symtab (psymtab
);
1084 debugfile
= find_separate_debug_file (objfile
);
1089 objfile
->separate_debug_objfile
1090 = symbol_file_add (debugfile
, from_tty
, orig_addrs
, 0, flags
);
1094 objfile
->separate_debug_objfile
1095 = symbol_file_add (debugfile
, from_tty
, NULL
, 0, flags
);
1097 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
1100 /* Put the separate debug object before the normal one, this is so that
1101 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
1102 put_objfile_before (objfile
->separate_debug_objfile
, objfile
);
1107 if (!have_partial_symbols () && !have_full_symbols ())
1110 printf_filtered (_("(no debugging symbols found)"));
1111 if (from_tty
|| info_verbose
)
1112 printf_filtered ("...");
1114 printf_filtered ("\n");
1118 if (from_tty
|| info_verbose
)
1120 if (deprecated_post_add_symbol_hook
)
1121 deprecated_post_add_symbol_hook ();
1124 printf_unfiltered (_("done.\n"));
1128 /* We print some messages regardless of whether 'from_tty ||
1129 info_verbose' is true, so make sure they go out at the right
1131 gdb_flush (gdb_stdout
);
1133 do_cleanups (my_cleanups
);
1135 if (objfile
->sf
== NULL
)
1136 return objfile
; /* No symbols. */
1138 new_symfile_objfile (objfile
, mainline
, from_tty
);
1140 observer_notify_new_objfile (objfile
);
1142 bfd_cache_close_all ();
1147 /* Process the symbol file ABFD, as either the main file or as a
1148 dynamically loaded file.
1150 See symbol_file_add_with_addrs_or_offsets's comments for
1153 symbol_file_add_from_bfd (bfd
*abfd
, int from_tty
,
1154 struct section_addr_info
*addrs
,
1155 int mainline
, int flags
)
1157 return symbol_file_add_with_addrs_or_offsets (abfd
,
1158 from_tty
, addrs
, 0, 0,
1163 /* Process a symbol file, as either the main file or as a dynamically
1164 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1167 symbol_file_add (char *name
, int from_tty
, struct section_addr_info
*addrs
,
1168 int mainline
, int flags
)
1170 return symbol_file_add_from_bfd (symfile_bfd_open (name
), from_tty
,
1171 addrs
, mainline
, flags
);
1175 /* Call symbol_file_add() with default values and update whatever is
1176 affected by the loading of a new main().
1177 Used when the file is supplied in the gdb command line
1178 and by some targets with special loading requirements.
1179 The auxiliary function, symbol_file_add_main_1(), has the flags
1180 argument for the switches that can only be specified in the symbol_file
1184 symbol_file_add_main (char *args
, int from_tty
)
1186 symbol_file_add_main_1 (args
, from_tty
, 0);
1190 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1192 symbol_file_add (args
, from_tty
, NULL
, 1, flags
);
1194 /* Getting new symbols may change our opinion about
1195 what is frameless. */
1196 reinit_frame_cache ();
1198 set_initial_language ();
1202 symbol_file_clear (int from_tty
)
1204 if ((have_full_symbols () || have_partial_symbols ())
1207 ? !query (_("Discard symbol table from `%s'? "),
1208 symfile_objfile
->name
)
1209 : !query (_("Discard symbol table? "))))
1210 error (_("Not confirmed."));
1211 free_all_objfiles ();
1213 /* solib descriptors may have handles to objfiles. Since their
1214 storage has just been released, we'd better wipe the solib
1215 descriptors as well.
1217 #if defined(SOLIB_RESTART)
1221 symfile_objfile
= NULL
;
1223 printf_unfiltered (_("No symbol file now.\n"));
1227 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1230 bfd_size_type debuglink_size
;
1231 unsigned long crc32
;
1236 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1241 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1243 contents
= xmalloc (debuglink_size
);
1244 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1245 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1247 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1248 crc_offset
= strlen (contents
) + 1;
1249 crc_offset
= (crc_offset
+ 3) & ~3;
1251 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1258 separate_debug_file_exists (const char *name
, unsigned long crc
)
1260 unsigned long file_crc
= 0;
1262 gdb_byte buffer
[8*1024];
1265 fd
= open (name
, O_RDONLY
| O_BINARY
);
1269 while ((count
= read (fd
, buffer
, sizeof (buffer
))) > 0)
1270 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1274 return crc
== file_crc
;
1277 char *debug_file_directory
= NULL
;
1279 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1280 struct cmd_list_element
*c
, const char *value
)
1282 fprintf_filtered (file
, _("\
1283 The directory where separate debug symbols are searched for is \"%s\".\n"),
1287 #if ! defined (DEBUG_SUBDIRECTORY)
1288 #define DEBUG_SUBDIRECTORY ".debug"
1292 find_separate_debug_file (struct objfile
*objfile
)
1300 bfd_size_type debuglink_size
;
1301 unsigned long crc32
;
1304 basename
= get_debug_link_info (objfile
, &crc32
);
1306 if (basename
== NULL
)
1309 dir
= xstrdup (objfile
->name
);
1311 /* Strip off the final filename part, leaving the directory name,
1312 followed by a slash. Objfile names should always be absolute and
1313 tilde-expanded, so there should always be a slash in there
1315 for (i
= strlen(dir
) - 1; i
>= 0; i
--)
1317 if (IS_DIR_SEPARATOR (dir
[i
]))
1320 gdb_assert (i
>= 0 && IS_DIR_SEPARATOR (dir
[i
]));
1323 debugfile
= alloca (strlen (debug_file_directory
) + 1
1325 + strlen (DEBUG_SUBDIRECTORY
)
1330 /* First try in the same directory as the original file. */
1331 strcpy (debugfile
, dir
);
1332 strcat (debugfile
, basename
);
1334 if (separate_debug_file_exists (debugfile
, crc32
))
1338 return xstrdup (debugfile
);
1341 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1342 strcpy (debugfile
, dir
);
1343 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1344 strcat (debugfile
, "/");
1345 strcat (debugfile
, basename
);
1347 if (separate_debug_file_exists (debugfile
, crc32
))
1351 return xstrdup (debugfile
);
1354 /* Then try in the global debugfile directory. */
1355 strcpy (debugfile
, debug_file_directory
);
1356 strcat (debugfile
, "/");
1357 strcat (debugfile
, dir
);
1358 strcat (debugfile
, basename
);
1360 if (separate_debug_file_exists (debugfile
, crc32
))
1364 return xstrdup (debugfile
);
1367 /* If the file is in the sysroot, try using its base path in the
1368 global debugfile directory. */
1369 canon_name
= lrealpath (dir
);
1371 && strncmp (canon_name
, gdb_sysroot
, strlen (gdb_sysroot
)) == 0
1372 && IS_DIR_SEPARATOR (canon_name
[strlen (gdb_sysroot
)]))
1374 strcpy (debugfile
, debug_file_directory
);
1375 strcat (debugfile
, canon_name
+ strlen (gdb_sysroot
));
1376 strcat (debugfile
, "/");
1377 strcat (debugfile
, basename
);
1379 if (separate_debug_file_exists (debugfile
, crc32
))
1384 return xstrdup (debugfile
);
1397 /* This is the symbol-file command. Read the file, analyze its
1398 symbols, and add a struct symtab to a symtab list. The syntax of
1399 the command is rather bizarre:
1401 1. The function buildargv implements various quoting conventions
1402 which are undocumented and have little or nothing in common with
1403 the way things are quoted (or not quoted) elsewhere in GDB.
1405 2. Options are used, which are not generally used in GDB (perhaps
1406 "set mapped on", "set readnow on" would be better)
1408 3. The order of options matters, which is contrary to GNU
1409 conventions (because it is confusing and inconvenient). */
1412 symbol_file_command (char *args
, int from_tty
)
1418 symbol_file_clear (from_tty
);
1422 char **argv
= buildargv (args
);
1423 int flags
= OBJF_USERLOADED
;
1424 struct cleanup
*cleanups
;
1430 cleanups
= make_cleanup_freeargv (argv
);
1431 while (*argv
!= NULL
)
1433 if (strcmp (*argv
, "-readnow") == 0)
1434 flags
|= OBJF_READNOW
;
1435 else if (**argv
== '-')
1436 error (_("unknown option `%s'"), *argv
);
1439 symbol_file_add_main_1 (*argv
, from_tty
, flags
);
1447 error (_("no symbol file name was specified"));
1449 do_cleanups (cleanups
);
1453 /* Set the initial language.
1455 FIXME: A better solution would be to record the language in the
1456 psymtab when reading partial symbols, and then use it (if known) to
1457 set the language. This would be a win for formats that encode the
1458 language in an easily discoverable place, such as DWARF. For
1459 stabs, we can jump through hoops looking for specially named
1460 symbols or try to intuit the language from the specific type of
1461 stabs we find, but we can't do that until later when we read in
1465 set_initial_language (void)
1467 struct partial_symtab
*pst
;
1468 enum language lang
= language_unknown
;
1470 pst
= find_main_psymtab ();
1473 if (pst
->filename
!= NULL
)
1474 lang
= deduce_language_from_filename (pst
->filename
);
1476 if (lang
== language_unknown
)
1478 /* Make C the default language */
1482 set_language (lang
);
1483 expected_language
= current_language
; /* Don't warn the user. */
1487 /* Open the file specified by NAME and hand it off to BFD for
1488 preliminary analysis. Return a newly initialized bfd *, which
1489 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1490 absolute). In case of trouble, error() is called. */
1493 symfile_bfd_open (char *name
)
1497 char *absolute_name
;
1499 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy. */
1501 /* Look down path for it, allocate 2nd new malloc'd copy. */
1502 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, name
,
1503 O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1504 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1507 char *exename
= alloca (strlen (name
) + 5);
1508 strcat (strcpy (exename
, name
), ".exe");
1509 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
1510 O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1515 make_cleanup (xfree
, name
);
1516 perror_with_name (name
);
1519 /* Free 1st new malloc'd copy, but keep the 2nd malloc'd copy in
1520 bfd. It'll be freed in free_objfile(). */
1522 name
= absolute_name
;
1524 sym_bfd
= bfd_fopen (name
, gnutarget
, FOPEN_RB
, desc
);
1528 make_cleanup (xfree
, name
);
1529 error (_("\"%s\": can't open to read symbols: %s."), name
,
1530 bfd_errmsg (bfd_get_error ()));
1532 bfd_set_cacheable (sym_bfd
, 1);
1534 if (!bfd_check_format (sym_bfd
, bfd_object
))
1536 /* FIXME: should be checking for errors from bfd_close (for one
1537 thing, on error it does not free all the storage associated
1539 bfd_close (sym_bfd
); /* This also closes desc. */
1540 make_cleanup (xfree
, name
);
1541 error (_("\"%s\": can't read symbols: %s."), name
,
1542 bfd_errmsg (bfd_get_error ()));
1548 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1549 the section was not found. */
1552 get_section_index (struct objfile
*objfile
, char *section_name
)
1554 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1562 /* Link SF into the global symtab_fns list. Called on startup by the
1563 _initialize routine in each object file format reader, to register
1564 information about each format the the reader is prepared to
1568 add_symtab_fns (struct sym_fns
*sf
)
1570 sf
->next
= symtab_fns
;
1574 /* Initialize OBJFILE to read symbols from its associated BFD. It
1575 either returns or calls error(). The result is an initialized
1576 struct sym_fns in the objfile structure, that contains cached
1577 information about the symbol file. */
1579 static struct sym_fns
*
1580 find_sym_fns (bfd
*abfd
)
1583 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1585 if (our_flavour
== bfd_target_srec_flavour
1586 || our_flavour
== bfd_target_ihex_flavour
1587 || our_flavour
== bfd_target_tekhex_flavour
)
1588 return NULL
; /* No symbols. */
1590 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1591 if (our_flavour
== sf
->sym_flavour
)
1594 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1595 bfd_get_target (abfd
));
1599 /* This function runs the load command of our current target. */
1602 load_command (char *arg
, int from_tty
)
1609 parg
= arg
= get_exec_file (1);
1611 /* Count how many \ " ' tab space there are in the name. */
1612 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1620 /* We need to quote this string so buildargv can pull it apart. */
1621 char *temp
= xmalloc (strlen (arg
) + count
+ 1 );
1625 make_cleanup (xfree
, temp
);
1628 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1630 strncpy (ptemp
, prev
, parg
- prev
);
1631 ptemp
+= parg
- prev
;
1635 strcpy (ptemp
, prev
);
1641 /* The user might be reloading because the binary has changed. Take
1642 this opportunity to check. */
1643 reopen_exec_file ();
1646 target_load (arg
, from_tty
);
1648 /* After re-loading the executable, we don't really know which
1649 overlays are mapped any more. */
1650 overlay_cache_invalid
= 1;
1653 /* This version of "load" should be usable for any target. Currently
1654 it is just used for remote targets, not inftarg.c or core files,
1655 on the theory that only in that case is it useful.
1657 Avoiding xmodem and the like seems like a win (a) because we don't have
1658 to worry about finding it, and (b) On VMS, fork() is very slow and so
1659 we don't want to run a subprocess. On the other hand, I'm not sure how
1660 performance compares. */
1662 static int validate_download
= 0;
1664 /* Callback service function for generic_load (bfd_map_over_sections). */
1667 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1669 bfd_size_type
*sum
= data
;
1671 *sum
+= bfd_get_section_size (asec
);
1674 /* Opaque data for load_section_callback. */
1675 struct load_section_data
{
1676 unsigned long load_offset
;
1677 struct load_progress_data
*progress_data
;
1678 VEC(memory_write_request_s
) *requests
;
1681 /* Opaque data for load_progress. */
1682 struct load_progress_data
{
1683 /* Cumulative data. */
1684 unsigned long write_count
;
1685 unsigned long data_count
;
1686 bfd_size_type total_size
;
1689 /* Opaque data for load_progress for a single section. */
1690 struct load_progress_section_data
{
1691 struct load_progress_data
*cumulative
;
1693 /* Per-section data. */
1694 const char *section_name
;
1695 ULONGEST section_sent
;
1696 ULONGEST section_size
;
1701 /* Target write callback routine for progress reporting. */
1704 load_progress (ULONGEST bytes
, void *untyped_arg
)
1706 struct load_progress_section_data
*args
= untyped_arg
;
1707 struct load_progress_data
*totals
;
1710 /* Writing padding data. No easy way to get at the cumulative
1711 stats, so just ignore this. */
1714 totals
= args
->cumulative
;
1716 if (bytes
== 0 && args
->section_sent
== 0)
1718 /* The write is just starting. Let the user know we've started
1720 ui_out_message (uiout
, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1721 args
->section_name
, paddr_nz (args
->section_size
),
1722 paddr_nz (args
->lma
));
1726 if (validate_download
)
1728 /* Broken memories and broken monitors manifest themselves here
1729 when bring new computers to life. This doubles already slow
1731 /* NOTE: cagney/1999-10-18: A more efficient implementation
1732 might add a verify_memory() method to the target vector and
1733 then use that. remote.c could implement that method using
1734 the ``qCRC'' packet. */
1735 gdb_byte
*check
= xmalloc (bytes
);
1736 struct cleanup
*verify_cleanups
= make_cleanup (xfree
, check
);
1738 if (target_read_memory (args
->lma
, check
, bytes
) != 0)
1739 error (_("Download verify read failed at 0x%s"),
1741 if (memcmp (args
->buffer
, check
, bytes
) != 0)
1742 error (_("Download verify compare failed at 0x%s"),
1744 do_cleanups (verify_cleanups
);
1746 totals
->data_count
+= bytes
;
1748 args
->buffer
+= bytes
;
1749 totals
->write_count
+= 1;
1750 args
->section_sent
+= bytes
;
1752 || (deprecated_ui_load_progress_hook
!= NULL
1753 && deprecated_ui_load_progress_hook (args
->section_name
,
1754 args
->section_sent
)))
1755 error (_("Canceled the download"));
1757 if (deprecated_show_load_progress
!= NULL
)
1758 deprecated_show_load_progress (args
->section_name
,
1762 totals
->total_size
);
1765 /* Callback service function for generic_load (bfd_map_over_sections). */
1768 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1770 struct memory_write_request
*new_request
;
1771 struct load_section_data
*args
= data
;
1772 struct load_progress_section_data
*section_data
;
1773 bfd_size_type size
= bfd_get_section_size (asec
);
1775 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1777 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1783 new_request
= VEC_safe_push (memory_write_request_s
,
1784 args
->requests
, NULL
);
1785 memset (new_request
, 0, sizeof (struct memory_write_request
));
1786 section_data
= xcalloc (1, sizeof (struct load_progress_section_data
));
1787 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1788 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size be in instead? */
1789 new_request
->data
= xmalloc (size
);
1790 new_request
->baton
= section_data
;
1792 buffer
= new_request
->data
;
1794 section_data
->cumulative
= args
->progress_data
;
1795 section_data
->section_name
= sect_name
;
1796 section_data
->section_size
= size
;
1797 section_data
->lma
= new_request
->begin
;
1798 section_data
->buffer
= buffer
;
1800 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1803 /* Clean up an entire memory request vector, including load
1804 data and progress records. */
1807 clear_memory_write_data (void *arg
)
1809 VEC(memory_write_request_s
) **vec_p
= arg
;
1810 VEC(memory_write_request_s
) *vec
= *vec_p
;
1812 struct memory_write_request
*mr
;
1814 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
1819 VEC_free (memory_write_request_s
, vec
);
1823 generic_load (char *args
, int from_tty
)
1826 struct timeval start_time
, end_time
;
1828 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, 0);
1829 struct load_section_data cbdata
;
1830 struct load_progress_data total_progress
;
1835 memset (&cbdata
, 0, sizeof (cbdata
));
1836 memset (&total_progress
, 0, sizeof (total_progress
));
1837 cbdata
.progress_data
= &total_progress
;
1839 make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
1841 argv
= buildargv (args
);
1846 make_cleanup_freeargv (argv
);
1848 filename
= tilde_expand (argv
[0]);
1849 make_cleanup (xfree
, filename
);
1851 if (argv
[1] != NULL
)
1855 cbdata
.load_offset
= strtoul (argv
[1], &endptr
, 0);
1857 /* If the last word was not a valid number then
1858 treat it as a file name with spaces in. */
1859 if (argv
[1] == endptr
)
1860 error (_("Invalid download offset:%s."), argv
[1]);
1862 if (argv
[2] != NULL
)
1863 error (_("Too many parameters."));
1866 /* Open the file for loading. */
1867 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1868 if (loadfile_bfd
== NULL
)
1870 perror_with_name (filename
);
1874 /* FIXME: should be checking for errors from bfd_close (for one thing,
1875 on error it does not free all the storage associated with the
1877 make_cleanup_bfd_close (loadfile_bfd
);
1879 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1881 error (_("\"%s\" is not an object file: %s"), filename
,
1882 bfd_errmsg (bfd_get_error ()));
1885 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1886 (void *) &total_progress
.total_size
);
1888 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1890 gettimeofday (&start_time
, NULL
);
1892 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
1893 load_progress
) != 0)
1894 error (_("Load failed"));
1896 gettimeofday (&end_time
, NULL
);
1898 entry
= bfd_get_start_address (loadfile_bfd
);
1899 ui_out_text (uiout
, "Start address ");
1900 ui_out_field_fmt (uiout
, "address", "0x%s", paddr_nz (entry
));
1901 ui_out_text (uiout
, ", load size ");
1902 ui_out_field_fmt (uiout
, "load-size", "%lu", total_progress
.data_count
);
1903 ui_out_text (uiout
, "\n");
1904 /* We were doing this in remote-mips.c, I suspect it is right
1905 for other targets too. */
1908 /* FIXME: are we supposed to call symbol_file_add or not? According
1909 to a comment from remote-mips.c (where a call to symbol_file_add
1910 was commented out), making the call confuses GDB if more than one
1911 file is loaded in. Some targets do (e.g., remote-vx.c) but
1912 others don't (or didn't - perhaps they have all been deleted). */
1914 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
1915 total_progress
.write_count
,
1916 &start_time
, &end_time
);
1918 do_cleanups (old_cleanups
);
1921 /* Report how fast the transfer went. */
1923 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1924 replaced by print_transfer_performance (with a very different
1925 function signature). */
1928 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1931 struct timeval start
, end
;
1933 start
.tv_sec
= start_time
;
1935 end
.tv_sec
= end_time
;
1938 print_transfer_performance (gdb_stdout
, data_count
, 0, &start
, &end
);
1942 print_transfer_performance (struct ui_file
*stream
,
1943 unsigned long data_count
,
1944 unsigned long write_count
,
1945 const struct timeval
*start_time
,
1946 const struct timeval
*end_time
)
1948 ULONGEST time_count
;
1950 /* Compute the elapsed time in milliseconds, as a tradeoff between
1951 accuracy and overflow. */
1952 time_count
= (end_time
->tv_sec
- start_time
->tv_sec
) * 1000;
1953 time_count
+= (end_time
->tv_usec
- start_time
->tv_usec
) / 1000;
1955 ui_out_text (uiout
, "Transfer rate: ");
1958 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / time_count
;
1960 if (ui_out_is_mi_like_p (uiout
))
1962 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
* 8);
1963 ui_out_text (uiout
, " bits/sec");
1965 else if (rate
< 1024)
1967 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
);
1968 ui_out_text (uiout
, " bytes/sec");
1972 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
/ 1024);
1973 ui_out_text (uiout
, " KB/sec");
1978 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
1979 ui_out_text (uiout
, " bits in <1 sec");
1981 if (write_count
> 0)
1983 ui_out_text (uiout
, ", ");
1984 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
1985 ui_out_text (uiout
, " bytes/write");
1987 ui_out_text (uiout
, ".\n");
1990 /* This function allows the addition of incrementally linked object files.
1991 It does not modify any state in the target, only in the debugger. */
1992 /* Note: ezannoni 2000-04-13 This function/command used to have a
1993 special case syntax for the rombug target (Rombug is the boot
1994 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1995 rombug case, the user doesn't need to supply a text address,
1996 instead a call to target_link() (in target.c) would supply the
1997 value to use. We are now discontinuing this type of ad hoc syntax. */
2000 add_symbol_file_command (char *args
, int from_tty
)
2002 char *filename
= NULL
;
2003 int flags
= OBJF_USERLOADED
;
2005 int expecting_option
= 0;
2006 int section_index
= 0;
2010 int expecting_sec_name
= 0;
2011 int expecting_sec_addr
= 0;
2020 struct section_addr_info
*section_addrs
;
2021 struct sect_opt
*sect_opts
= NULL
;
2022 size_t num_sect_opts
= 0;
2023 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2026 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
2027 * sizeof (struct sect_opt
));
2032 error (_("add-symbol-file takes a file name and an address"));
2034 argv
= buildargv (args
);
2035 make_cleanup_freeargv (argv
);
2040 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2042 /* Process the argument. */
2045 /* The first argument is the file name. */
2046 filename
= tilde_expand (arg
);
2047 make_cleanup (xfree
, filename
);
2052 /* The second argument is always the text address at which
2053 to load the program. */
2054 sect_opts
[section_index
].name
= ".text";
2055 sect_opts
[section_index
].value
= arg
;
2056 if (++section_index
>= num_sect_opts
)
2059 sect_opts
= ((struct sect_opt
*)
2060 xrealloc (sect_opts
,
2062 * sizeof (struct sect_opt
)));
2067 /* It's an option (starting with '-') or it's an argument
2072 if (strcmp (arg
, "-readnow") == 0)
2073 flags
|= OBJF_READNOW
;
2074 else if (strcmp (arg
, "-s") == 0)
2076 expecting_sec_name
= 1;
2077 expecting_sec_addr
= 1;
2082 if (expecting_sec_name
)
2084 sect_opts
[section_index
].name
= arg
;
2085 expecting_sec_name
= 0;
2088 if (expecting_sec_addr
)
2090 sect_opts
[section_index
].value
= arg
;
2091 expecting_sec_addr
= 0;
2092 if (++section_index
>= num_sect_opts
)
2095 sect_opts
= ((struct sect_opt
*)
2096 xrealloc (sect_opts
,
2098 * sizeof (struct sect_opt
)));
2102 error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
2107 /* This command takes at least two arguments. The first one is a
2108 filename, and the second is the address where this file has been
2109 loaded. Abort now if this address hasn't been provided by the
2111 if (section_index
< 1)
2112 error (_("The address where %s has been loaded is missing"), filename
);
2114 /* Print the prompt for the query below. And save the arguments into
2115 a sect_addr_info structure to be passed around to other
2116 functions. We have to split this up into separate print
2117 statements because hex_string returns a local static
2120 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
2121 section_addrs
= alloc_section_addr_info (section_index
);
2122 make_cleanup (xfree
, section_addrs
);
2123 for (i
= 0; i
< section_index
; i
++)
2126 char *val
= sect_opts
[i
].value
;
2127 char *sec
= sect_opts
[i
].name
;
2129 addr
= parse_and_eval_address (val
);
2131 /* Here we store the section offsets in the order they were
2132 entered on the command line. */
2133 section_addrs
->other
[sec_num
].name
= sec
;
2134 section_addrs
->other
[sec_num
].addr
= addr
;
2135 printf_unfiltered ("\t%s_addr = %s\n",
2136 sec
, hex_string ((unsigned long)addr
));
2139 /* The object's sections are initialized when a
2140 call is made to build_objfile_section_table (objfile).
2141 This happens in reread_symbols.
2142 At this point, we don't know what file type this is,
2143 so we can't determine what section names are valid. */
2146 if (from_tty
&& (!query ("%s", "")))
2147 error (_("Not confirmed."));
2149 symbol_file_add (filename
, from_tty
, section_addrs
, 0, flags
);
2151 /* Getting new symbols may change our opinion about what is
2153 reinit_frame_cache ();
2154 do_cleanups (my_cleanups
);
2158 add_shared_symbol_files_command (char *args
, int from_tty
)
2160 #ifdef ADD_SHARED_SYMBOL_FILES
2161 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
2163 error (_("This command is not available in this configuration of GDB."));
2167 /* Re-read symbols if a symbol-file has changed. */
2169 reread_symbols (void)
2171 struct objfile
*objfile
;
2174 struct stat new_statbuf
;
2177 /* With the addition of shared libraries, this should be modified,
2178 the load time should be saved in the partial symbol tables, since
2179 different tables may come from different source files. FIXME.
2180 This routine should then walk down each partial symbol table
2181 and see if the symbol table that it originates from has been changed */
2183 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2187 #ifdef DEPRECATED_IBM6000_TARGET
2188 /* If this object is from a shared library, then you should
2189 stat on the library name, not member name. */
2191 if (objfile
->obfd
->my_archive
)
2192 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2195 res
= stat (objfile
->name
, &new_statbuf
);
2198 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2199 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2203 new_modtime
= new_statbuf
.st_mtime
;
2204 if (new_modtime
!= objfile
->mtime
)
2206 struct cleanup
*old_cleanups
;
2207 struct section_offsets
*offsets
;
2209 char *obfd_filename
;
2211 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2214 /* There are various functions like symbol_file_add,
2215 symfile_bfd_open, syms_from_objfile, etc., which might
2216 appear to do what we want. But they have various other
2217 effects which we *don't* want. So we just do stuff
2218 ourselves. We don't worry about mapped files (for one thing,
2219 any mapped file will be out of date). */
2221 /* If we get an error, blow away this objfile (not sure if
2222 that is the correct response for things like shared
2224 old_cleanups
= make_cleanup_free_objfile (objfile
);
2225 /* We need to do this whenever any symbols go away. */
2226 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2228 /* Clean up any state BFD has sitting around. We don't need
2229 to close the descriptor but BFD lacks a way of closing the
2230 BFD without closing the descriptor. */
2231 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2232 if (!bfd_close (objfile
->obfd
))
2233 error (_("Can't close BFD for %s: %s"), objfile
->name
,
2234 bfd_errmsg (bfd_get_error ()));
2235 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
2236 if (objfile
->obfd
== NULL
)
2237 error (_("Can't open %s to read symbols."), objfile
->name
);
2238 /* bfd_openr sets cacheable to true, which is what we want. */
2239 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2240 error (_("Can't read symbols from %s: %s."), objfile
->name
,
2241 bfd_errmsg (bfd_get_error ()));
2243 /* Save the offsets, we will nuke them with the rest of the
2245 num_offsets
= objfile
->num_sections
;
2246 offsets
= ((struct section_offsets
*)
2247 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2248 memcpy (offsets
, objfile
->section_offsets
,
2249 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2251 /* Remove any references to this objfile in the global
2253 preserve_values (objfile
);
2255 /* Nuke all the state that we will re-read. Much of the following
2256 code which sets things to NULL really is necessary to tell
2257 other parts of GDB that there is nothing currently there. */
2259 /* FIXME: Do we have to free a whole linked list, or is this
2261 if (objfile
->global_psymbols
.list
)
2262 xfree (objfile
->global_psymbols
.list
);
2263 memset (&objfile
->global_psymbols
, 0,
2264 sizeof (objfile
->global_psymbols
));
2265 if (objfile
->static_psymbols
.list
)
2266 xfree (objfile
->static_psymbols
.list
);
2267 memset (&objfile
->static_psymbols
, 0,
2268 sizeof (objfile
->static_psymbols
));
2270 /* Free the obstacks for non-reusable objfiles */
2271 bcache_xfree (objfile
->psymbol_cache
);
2272 objfile
->psymbol_cache
= bcache_xmalloc ();
2273 bcache_xfree (objfile
->macro_cache
);
2274 objfile
->macro_cache
= bcache_xmalloc ();
2275 if (objfile
->demangled_names_hash
!= NULL
)
2277 htab_delete (objfile
->demangled_names_hash
);
2278 objfile
->demangled_names_hash
= NULL
;
2280 obstack_free (&objfile
->objfile_obstack
, 0);
2281 objfile
->sections
= NULL
;
2282 objfile
->symtabs
= NULL
;
2283 objfile
->psymtabs
= NULL
;
2284 objfile
->free_psymtabs
= NULL
;
2285 objfile
->cp_namespace_symtab
= NULL
;
2286 objfile
->msymbols
= NULL
;
2287 objfile
->deprecated_sym_private
= NULL
;
2288 objfile
->minimal_symbol_count
= 0;
2289 memset (&objfile
->msymbol_hash
, 0,
2290 sizeof (objfile
->msymbol_hash
));
2291 memset (&objfile
->msymbol_demangled_hash
, 0,
2292 sizeof (objfile
->msymbol_demangled_hash
));
2293 objfile
->fundamental_types
= NULL
;
2294 clear_objfile_data (objfile
);
2295 if (objfile
->sf
!= NULL
)
2297 (*objfile
->sf
->sym_finish
) (objfile
);
2300 /* We never make this a mapped file. */
2302 objfile
->psymbol_cache
= bcache_xmalloc ();
2303 objfile
->macro_cache
= bcache_xmalloc ();
2304 /* obstack_init also initializes the obstack so it is
2305 empty. We could use obstack_specify_allocation but
2306 gdb_obstack.h specifies the alloc/dealloc
2308 obstack_init (&objfile
->objfile_obstack
);
2309 if (build_objfile_section_table (objfile
))
2311 error (_("Can't find the file sections in `%s': %s"),
2312 objfile
->name
, bfd_errmsg (bfd_get_error ()));
2314 terminate_minimal_symbol_table (objfile
);
2316 /* We use the same section offsets as from last time. I'm not
2317 sure whether that is always correct for shared libraries. */
2318 objfile
->section_offsets
= (struct section_offsets
*)
2319 obstack_alloc (&objfile
->objfile_obstack
,
2320 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2321 memcpy (objfile
->section_offsets
, offsets
,
2322 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2323 objfile
->num_sections
= num_offsets
;
2325 /* What the hell is sym_new_init for, anyway? The concept of
2326 distinguishing between the main file and additional files
2327 in this way seems rather dubious. */
2328 if (objfile
== symfile_objfile
)
2330 (*objfile
->sf
->sym_new_init
) (objfile
);
2333 (*objfile
->sf
->sym_init
) (objfile
);
2334 clear_complaints (&symfile_complaints
, 1, 1);
2335 /* The "mainline" parameter is a hideous hack; I think leaving it
2336 zero is OK since dbxread.c also does what it needs to do if
2337 objfile->global_psymbols.size is 0. */
2338 (*objfile
->sf
->sym_read
) (objfile
, 0);
2339 if (!have_partial_symbols () && !have_full_symbols ())
2342 printf_unfiltered (_("(no debugging symbols found)\n"));
2345 objfile
->flags
|= OBJF_SYMS
;
2347 /* We're done reading the symbol file; finish off complaints. */
2348 clear_complaints (&symfile_complaints
, 0, 1);
2350 /* Getting new symbols may change our opinion about what is
2353 reinit_frame_cache ();
2355 /* Discard cleanups as symbol reading was successful. */
2356 discard_cleanups (old_cleanups
);
2358 /* If the mtime has changed between the time we set new_modtime
2359 and now, we *want* this to be out of date, so don't call stat
2361 objfile
->mtime
= new_modtime
;
2363 reread_separate_symbols (objfile
);
2370 clear_symtab_users ();
2371 /* At least one objfile has changed, so we can consider that
2372 the executable we're debugging has changed too. */
2373 observer_notify_executable_changed (NULL
);
2379 /* Handle separate debug info for OBJFILE, which has just been
2381 - If we had separate debug info before, but now we don't, get rid
2382 of the separated objfile.
2383 - If we didn't have separated debug info before, but now we do,
2384 read in the new separated debug info file.
2385 - If the debug link points to a different file, toss the old one
2386 and read the new one.
2387 This function does *not* handle the case where objfile is still
2388 using the same separate debug info file, but that file's timestamp
2389 has changed. That case should be handled by the loop in
2390 reread_symbols already. */
2392 reread_separate_symbols (struct objfile
*objfile
)
2395 unsigned long crc32
;
2397 /* Does the updated objfile's debug info live in a
2399 debug_file
= find_separate_debug_file (objfile
);
2401 if (objfile
->separate_debug_objfile
)
2403 /* There are two cases where we need to get rid of
2404 the old separated debug info objfile:
2405 - if the new primary objfile doesn't have
2406 separated debug info, or
2407 - if the new primary objfile has separate debug
2408 info, but it's under a different filename.
2410 If the old and new objfiles both have separate
2411 debug info, under the same filename, then we're
2412 okay --- if the separated file's contents have
2413 changed, we will have caught that when we
2414 visited it in this function's outermost
2417 || strcmp (debug_file
, objfile
->separate_debug_objfile
->name
) != 0)
2418 free_objfile (objfile
->separate_debug_objfile
);
2421 /* If the new objfile has separate debug info, and we
2422 haven't loaded it already, do so now. */
2424 && ! objfile
->separate_debug_objfile
)
2426 /* Use the same section offset table as objfile itself.
2427 Preserve the flags from objfile that make sense. */
2428 objfile
->separate_debug_objfile
2429 = (symbol_file_add_with_addrs_or_offsets
2430 (symfile_bfd_open (debug_file
),
2431 info_verbose
, /* from_tty: Don't override the default. */
2432 0, /* No addr table. */
2433 objfile
->section_offsets
, objfile
->num_sections
,
2434 0, /* Not mainline. See comments about this above. */
2435 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
2436 | OBJF_USERLOADED
)));
2437 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
2455 static filename_language
*filename_language_table
;
2456 static int fl_table_size
, fl_table_next
;
2459 add_filename_language (char *ext
, enum language lang
)
2461 if (fl_table_next
>= fl_table_size
)
2463 fl_table_size
+= 10;
2464 filename_language_table
=
2465 xrealloc (filename_language_table
,
2466 fl_table_size
* sizeof (*filename_language_table
));
2469 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2470 filename_language_table
[fl_table_next
].lang
= lang
;
2474 static char *ext_args
;
2476 show_ext_args (struct ui_file
*file
, int from_tty
,
2477 struct cmd_list_element
*c
, const char *value
)
2479 fprintf_filtered (file
, _("\
2480 Mapping between filename extension and source language is \"%s\".\n"),
2485 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2488 char *cp
= ext_args
;
2491 /* First arg is filename extension, starting with '.' */
2493 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2495 /* Find end of first arg. */
2496 while (*cp
&& !isspace (*cp
))
2500 error (_("'%s': two arguments required -- filename extension and language"),
2503 /* Null-terminate first arg */
2506 /* Find beginning of second arg, which should be a source language. */
2507 while (*cp
&& isspace (*cp
))
2511 error (_("'%s': two arguments required -- filename extension and language"),
2514 /* Lookup the language from among those we know. */
2515 lang
= language_enum (cp
);
2517 /* Now lookup the filename extension: do we already know it? */
2518 for (i
= 0; i
< fl_table_next
; i
++)
2519 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2522 if (i
>= fl_table_next
)
2524 /* new file extension */
2525 add_filename_language (ext_args
, lang
);
2529 /* redefining a previously known filename extension */
2532 /* query ("Really make files of type %s '%s'?", */
2533 /* ext_args, language_str (lang)); */
2535 xfree (filename_language_table
[i
].ext
);
2536 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2537 filename_language_table
[i
].lang
= lang
;
2542 info_ext_lang_command (char *args
, int from_tty
)
2546 printf_filtered (_("Filename extensions and the languages they represent:"));
2547 printf_filtered ("\n\n");
2548 for (i
= 0; i
< fl_table_next
; i
++)
2549 printf_filtered ("\t%s\t- %s\n",
2550 filename_language_table
[i
].ext
,
2551 language_str (filename_language_table
[i
].lang
));
2555 init_filename_language_table (void)
2557 if (fl_table_size
== 0) /* protect against repetition */
2561 filename_language_table
=
2562 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2563 add_filename_language (".c", language_c
);
2564 add_filename_language (".C", language_cplus
);
2565 add_filename_language (".cc", language_cplus
);
2566 add_filename_language (".cp", language_cplus
);
2567 add_filename_language (".cpp", language_cplus
);
2568 add_filename_language (".cxx", language_cplus
);
2569 add_filename_language (".c++", language_cplus
);
2570 add_filename_language (".java", language_java
);
2571 add_filename_language (".class", language_java
);
2572 add_filename_language (".m", language_objc
);
2573 add_filename_language (".f", language_fortran
);
2574 add_filename_language (".F", language_fortran
);
2575 add_filename_language (".s", language_asm
);
2576 add_filename_language (".S", language_asm
);
2577 add_filename_language (".pas", language_pascal
);
2578 add_filename_language (".p", language_pascal
);
2579 add_filename_language (".pp", language_pascal
);
2580 add_filename_language (".adb", language_ada
);
2581 add_filename_language (".ads", language_ada
);
2582 add_filename_language (".a", language_ada
);
2583 add_filename_language (".ada", language_ada
);
2588 deduce_language_from_filename (char *filename
)
2593 if (filename
!= NULL
)
2594 if ((cp
= strrchr (filename
, '.')) != NULL
)
2595 for (i
= 0; i
< fl_table_next
; i
++)
2596 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2597 return filename_language_table
[i
].lang
;
2599 return language_unknown
;
2604 Allocate and partly initialize a new symbol table. Return a pointer
2605 to it. error() if no space.
2607 Caller must set these fields:
2613 possibly free_named_symtabs (symtab->filename);
2617 allocate_symtab (char *filename
, struct objfile
*objfile
)
2619 struct symtab
*symtab
;
2621 symtab
= (struct symtab
*)
2622 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2623 memset (symtab
, 0, sizeof (*symtab
));
2624 symtab
->filename
= obsavestring (filename
, strlen (filename
),
2625 &objfile
->objfile_obstack
);
2626 symtab
->fullname
= NULL
;
2627 symtab
->language
= deduce_language_from_filename (filename
);
2628 symtab
->debugformat
= obsavestring ("unknown", 7,
2629 &objfile
->objfile_obstack
);
2631 /* Hook it to the objfile it comes from */
2633 symtab
->objfile
= objfile
;
2634 symtab
->next
= objfile
->symtabs
;
2635 objfile
->symtabs
= symtab
;
2640 struct partial_symtab
*
2641 allocate_psymtab (char *filename
, struct objfile
*objfile
)
2643 struct partial_symtab
*psymtab
;
2645 if (objfile
->free_psymtabs
)
2647 psymtab
= objfile
->free_psymtabs
;
2648 objfile
->free_psymtabs
= psymtab
->next
;
2651 psymtab
= (struct partial_symtab
*)
2652 obstack_alloc (&objfile
->objfile_obstack
,
2653 sizeof (struct partial_symtab
));
2655 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2656 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
2657 &objfile
->objfile_obstack
);
2658 psymtab
->symtab
= NULL
;
2660 /* Prepend it to the psymtab list for the objfile it belongs to.
2661 Psymtabs are searched in most recent inserted -> least recent
2664 psymtab
->objfile
= objfile
;
2665 psymtab
->next
= objfile
->psymtabs
;
2666 objfile
->psymtabs
= psymtab
;
2669 struct partial_symtab
**prev_pst
;
2670 psymtab
->objfile
= objfile
;
2671 psymtab
->next
= NULL
;
2672 prev_pst
= &(objfile
->psymtabs
);
2673 while ((*prev_pst
) != NULL
)
2674 prev_pst
= &((*prev_pst
)->next
);
2675 (*prev_pst
) = psymtab
;
2683 discard_psymtab (struct partial_symtab
*pst
)
2685 struct partial_symtab
**prev_pst
;
2688 Empty psymtabs happen as a result of header files which don't
2689 have any symbols in them. There can be a lot of them. But this
2690 check is wrong, in that a psymtab with N_SLINE entries but
2691 nothing else is not empty, but we don't realize that. Fixing
2692 that without slowing things down might be tricky. */
2694 /* First, snip it out of the psymtab chain */
2696 prev_pst
= &(pst
->objfile
->psymtabs
);
2697 while ((*prev_pst
) != pst
)
2698 prev_pst
= &((*prev_pst
)->next
);
2699 (*prev_pst
) = pst
->next
;
2701 /* Next, put it on a free list for recycling */
2703 pst
->next
= pst
->objfile
->free_psymtabs
;
2704 pst
->objfile
->free_psymtabs
= pst
;
2708 /* Reset all data structures in gdb which may contain references to symbol
2712 clear_symtab_users (void)
2714 /* Someday, we should do better than this, by only blowing away
2715 the things that really need to be blown. */
2717 /* Clear the "current" symtab first, because it is no longer valid.
2718 breakpoint_re_set may try to access the current symtab. */
2719 clear_current_source_symtab_and_line ();
2722 breakpoint_re_set ();
2723 set_default_breakpoint (0, 0, 0, 0);
2724 clear_pc_function_cache ();
2725 observer_notify_new_objfile (NULL
);
2727 /* Clear globals which might have pointed into a removed objfile.
2728 FIXME: It's not clear which of these are supposed to persist
2729 between expressions and which ought to be reset each time. */
2730 expression_context_block
= NULL
;
2731 innermost_block
= NULL
;
2733 /* Varobj may refer to old symbols, perform a cleanup. */
2734 varobj_invalidate ();
2739 clear_symtab_users_cleanup (void *ignore
)
2741 clear_symtab_users ();
2744 /* clear_symtab_users_once:
2746 This function is run after symbol reading, or from a cleanup.
2747 If an old symbol table was obsoleted, the old symbol table
2748 has been blown away, but the other GDB data structures that may
2749 reference it have not yet been cleared or re-directed. (The old
2750 symtab was zapped, and the cleanup queued, in free_named_symtab()
2753 This function can be queued N times as a cleanup, or called
2754 directly; it will do all the work the first time, and then will be a
2755 no-op until the next time it is queued. This works by bumping a
2756 counter at queueing time. Much later when the cleanup is run, or at
2757 the end of symbol processing (in case the cleanup is discarded), if
2758 the queued count is greater than the "done-count", we do the work
2759 and set the done-count to the queued count. If the queued count is
2760 less than or equal to the done-count, we just ignore the call. This
2761 is needed because reading a single .o file will often replace many
2762 symtabs (one per .h file, for example), and we don't want to reset
2763 the breakpoints N times in the user's face.
2765 The reason we both queue a cleanup, and call it directly after symbol
2766 reading, is because the cleanup protects us in case of errors, but is
2767 discarded if symbol reading is successful. */
2770 /* FIXME: As free_named_symtabs is currently a big noop this function
2771 is no longer needed. */
2772 static void clear_symtab_users_once (void);
2774 static int clear_symtab_users_queued
;
2775 static int clear_symtab_users_done
;
2778 clear_symtab_users_once (void)
2780 /* Enforce once-per-`do_cleanups'-semantics */
2781 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2783 clear_symtab_users_done
= clear_symtab_users_queued
;
2785 clear_symtab_users ();
2789 /* Delete the specified psymtab, and any others that reference it. */
2792 cashier_psymtab (struct partial_symtab
*pst
)
2794 struct partial_symtab
*ps
, *pprev
= NULL
;
2797 /* Find its previous psymtab in the chain */
2798 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2807 /* Unhook it from the chain. */
2808 if (ps
== pst
->objfile
->psymtabs
)
2809 pst
->objfile
->psymtabs
= ps
->next
;
2811 pprev
->next
= ps
->next
;
2813 /* FIXME, we can't conveniently deallocate the entries in the
2814 partial_symbol lists (global_psymbols/static_psymbols) that
2815 this psymtab points to. These just take up space until all
2816 the psymtabs are reclaimed. Ditto the dependencies list and
2817 filename, which are all in the objfile_obstack. */
2819 /* We need to cashier any psymtab that has this one as a dependency... */
2821 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2823 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2825 if (ps
->dependencies
[i
] == pst
)
2827 cashier_psymtab (ps
);
2828 goto again
; /* Must restart, chain has been munged. */
2835 /* If a symtab or psymtab for filename NAME is found, free it along
2836 with any dependent breakpoints, displays, etc.
2837 Used when loading new versions of object modules with the "add-file"
2838 command. This is only called on the top-level symtab or psymtab's name;
2839 it is not called for subsidiary files such as .h files.
2841 Return value is 1 if we blew away the environment, 0 if not.
2842 FIXME. The return value appears to never be used.
2844 FIXME. I think this is not the best way to do this. We should
2845 work on being gentler to the environment while still cleaning up
2846 all stray pointers into the freed symtab. */
2849 free_named_symtabs (char *name
)
2852 /* FIXME: With the new method of each objfile having it's own
2853 psymtab list, this function needs serious rethinking. In particular,
2854 why was it ever necessary to toss psymtabs with specific compilation
2855 unit filenames, as opposed to all psymtabs from a particular symbol
2857 Well, the answer is that some systems permit reloading of particular
2858 compilation units. We want to blow away any old info about these
2859 compilation units, regardless of which objfiles they arrived in. --gnu. */
2862 struct symtab
*prev
;
2863 struct partial_symtab
*ps
;
2864 struct blockvector
*bv
;
2867 /* We only wack things if the symbol-reload switch is set. */
2868 if (!symbol_reloading
)
2871 /* Some symbol formats have trouble providing file names... */
2872 if (name
== 0 || *name
== '\0')
2875 /* Look for a psymtab with the specified name. */
2878 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2880 if (strcmp (name
, ps
->filename
) == 0)
2882 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2883 goto again2
; /* Must restart, chain has been munged */
2887 /* Look for a symtab with the specified name. */
2889 for (s
= symtab_list
; s
; s
= s
->next
)
2891 if (strcmp (name
, s
->filename
) == 0)
2898 if (s
== symtab_list
)
2899 symtab_list
= s
->next
;
2901 prev
->next
= s
->next
;
2903 /* For now, queue a delete for all breakpoints, displays, etc., whether
2904 or not they depend on the symtab being freed. This should be
2905 changed so that only those data structures affected are deleted. */
2907 /* But don't delete anything if the symtab is empty.
2908 This test is necessary due to a bug in "dbxread.c" that
2909 causes empty symtabs to be created for N_SO symbols that
2910 contain the pathname of the object file. (This problem
2911 has been fixed in GDB 3.9x). */
2913 bv
= BLOCKVECTOR (s
);
2914 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2915 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2916 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2918 complaint (&symfile_complaints
, _("Replacing old symbols for `%s'"),
2920 clear_symtab_users_queued
++;
2921 make_cleanup (clear_symtab_users_once
, 0);
2925 complaint (&symfile_complaints
, _("Empty symbol table found for `%s'"),
2932 /* It is still possible that some breakpoints will be affected
2933 even though no symtab was found, since the file might have
2934 been compiled without debugging, and hence not be associated
2935 with a symtab. In order to handle this correctly, we would need
2936 to keep a list of text address ranges for undebuggable files.
2937 For now, we do nothing, since this is a fairly obscure case. */
2941 /* FIXME, what about the minimal symbol table? */
2948 /* Allocate and partially fill a partial symtab. It will be
2949 completely filled at the end of the symbol list.
2951 FILENAME is the name of the symbol-file we are reading from. */
2953 struct partial_symtab
*
2954 start_psymtab_common (struct objfile
*objfile
,
2955 struct section_offsets
*section_offsets
, char *filename
,
2956 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2957 struct partial_symbol
**static_syms
)
2959 struct partial_symtab
*psymtab
;
2961 psymtab
= allocate_psymtab (filename
, objfile
);
2962 psymtab
->section_offsets
= section_offsets
;
2963 psymtab
->textlow
= textlow
;
2964 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2965 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2966 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2970 /* Add a symbol with a long value to a psymtab.
2971 Since one arg is a struct, we pass in a ptr and deref it (sigh).
2972 Return the partial symbol that has been added. */
2974 /* NOTE: carlton/2003-09-11: The reason why we return the partial
2975 symbol is so that callers can get access to the symbol's demangled
2976 name, which they don't have any cheap way to determine otherwise.
2977 (Currenly, dwarf2read.c is the only file who uses that information,
2978 though it's possible that other readers might in the future.)
2979 Elena wasn't thrilled about that, and I don't blame her, but we
2980 couldn't come up with a better way to get that information. If
2981 it's needed in other situations, we could consider breaking up
2982 SYMBOL_SET_NAMES to provide access to the demangled name lookup
2985 const struct partial_symbol
*
2986 add_psymbol_to_list (char *name
, int namelength
, domain_enum domain
,
2987 enum address_class
class,
2988 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2989 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2990 enum language language
, struct objfile
*objfile
)
2992 struct partial_symbol
*psym
;
2993 char *buf
= alloca (namelength
+ 1);
2994 /* psymbol is static so that there will be no uninitialized gaps in the
2995 structure which might contain random data, causing cache misses in
2997 static struct partial_symbol psymbol
;
2999 /* Create local copy of the partial symbol */
3000 memcpy (buf
, name
, namelength
);
3001 buf
[namelength
] = '\0';
3002 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
3005 SYMBOL_VALUE (&psymbol
) = val
;
3009 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
3011 SYMBOL_SECTION (&psymbol
) = 0;
3012 SYMBOL_LANGUAGE (&psymbol
) = language
;
3013 PSYMBOL_DOMAIN (&psymbol
) = domain
;
3014 PSYMBOL_CLASS (&psymbol
) = class;
3016 SYMBOL_SET_NAMES (&psymbol
, buf
, namelength
, objfile
);
3018 /* Stash the partial symbol away in the cache */
3019 psym
= deprecated_bcache (&psymbol
, sizeof (struct partial_symbol
),
3020 objfile
->psymbol_cache
);
3022 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
3023 if (list
->next
>= list
->list
+ list
->size
)
3025 extend_psymbol_list (list
, objfile
);
3027 *list
->next
++ = psym
;
3028 OBJSTAT (objfile
, n_psyms
++);
3033 /* Initialize storage for partial symbols. */
3036 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
3038 /* Free any previously allocated psymbol lists. */
3040 if (objfile
->global_psymbols
.list
)
3042 xfree (objfile
->global_psymbols
.list
);
3044 if (objfile
->static_psymbols
.list
)
3046 xfree (objfile
->static_psymbols
.list
);
3049 /* Current best guess is that approximately a twentieth
3050 of the total symbols (in a debugging file) are global or static
3053 objfile
->global_psymbols
.size
= total_symbols
/ 10;
3054 objfile
->static_psymbols
.size
= total_symbols
/ 10;
3056 if (objfile
->global_psymbols
.size
> 0)
3058 objfile
->global_psymbols
.next
=
3059 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
3060 xmalloc ((objfile
->global_psymbols
.size
3061 * sizeof (struct partial_symbol
*)));
3063 if (objfile
->static_psymbols
.size
> 0)
3065 objfile
->static_psymbols
.next
=
3066 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
3067 xmalloc ((objfile
->static_psymbols
.size
3068 * sizeof (struct partial_symbol
*)));
3073 The following code implements an abstraction for debugging overlay sections.
3075 The target model is as follows:
3076 1) The gnu linker will permit multiple sections to be mapped into the
3077 same VMA, each with its own unique LMA (or load address).
3078 2) It is assumed that some runtime mechanism exists for mapping the
3079 sections, one by one, from the load address into the VMA address.
3080 3) This code provides a mechanism for gdb to keep track of which
3081 sections should be considered to be mapped from the VMA to the LMA.
3082 This information is used for symbol lookup, and memory read/write.
3083 For instance, if a section has been mapped then its contents
3084 should be read from the VMA, otherwise from the LMA.
3086 Two levels of debugger support for overlays are available. One is
3087 "manual", in which the debugger relies on the user to tell it which
3088 overlays are currently mapped. This level of support is
3089 implemented entirely in the core debugger, and the information about
3090 whether a section is mapped is kept in the objfile->obj_section table.
3092 The second level of support is "automatic", and is only available if
3093 the target-specific code provides functionality to read the target's
3094 overlay mapping table, and translate its contents for the debugger
3095 (by updating the mapped state information in the obj_section tables).
3097 The interface is as follows:
3099 overlay map <name> -- tell gdb to consider this section mapped
3100 overlay unmap <name> -- tell gdb to consider this section unmapped
3101 overlay list -- list the sections that GDB thinks are mapped
3102 overlay read-target -- get the target's state of what's mapped
3103 overlay off/manual/auto -- set overlay debugging state
3104 Functional interface:
3105 find_pc_mapped_section(pc): if the pc is in the range of a mapped
3106 section, return that section.
3107 find_pc_overlay(pc): find any overlay section that contains
3108 the pc, either in its VMA or its LMA
3109 overlay_is_mapped(sect): true if overlay is marked as mapped
3110 section_is_overlay(sect): true if section's VMA != LMA
3111 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
3112 pc_in_unmapped_range(...): true if pc belongs to section's LMA
3113 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
3114 overlay_mapped_address(...): map an address from section's LMA to VMA
3115 overlay_unmapped_address(...): map an address from section's VMA to LMA
3116 symbol_overlayed_address(...): Return a "current" address for symbol:
3117 either in VMA or LMA depending on whether
3118 the symbol's section is currently mapped
3121 /* Overlay debugging state: */
3123 enum overlay_debugging_state overlay_debugging
= ovly_off
;
3124 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
3126 /* Function: section_is_overlay (SECTION)
3127 Returns true if SECTION has VMA not equal to LMA, ie.
3128 SECTION is loaded at an address different from where it will "run". */
3131 section_is_overlay (asection
*section
)
3133 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
3135 if (overlay_debugging
)
3136 if (section
&& section
->lma
!= 0 &&
3137 section
->vma
!= section
->lma
)
3143 /* Function: overlay_invalidate_all (void)
3144 Invalidate the mapped state of all overlay sections (mark it as stale). */
3147 overlay_invalidate_all (void)
3149 struct objfile
*objfile
;
3150 struct obj_section
*sect
;
3152 ALL_OBJSECTIONS (objfile
, sect
)
3153 if (section_is_overlay (sect
->the_bfd_section
))
3154 sect
->ovly_mapped
= -1;
3157 /* Function: overlay_is_mapped (SECTION)
3158 Returns true if section is an overlay, and is currently mapped.
3159 Private: public access is thru function section_is_mapped.
3161 Access to the ovly_mapped flag is restricted to this function, so
3162 that we can do automatic update. If the global flag
3163 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3164 overlay_invalidate_all. If the mapped state of the particular
3165 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3168 overlay_is_mapped (struct obj_section
*osect
)
3170 if (osect
== 0 || !section_is_overlay (osect
->the_bfd_section
))
3173 switch (overlay_debugging
)
3177 return 0; /* overlay debugging off */
3178 case ovly_auto
: /* overlay debugging automatic */
3179 /* Unles there is a gdbarch_overlay_update function,
3180 there's really nothing useful to do here (can't really go auto) */
3181 if (gdbarch_overlay_update_p (current_gdbarch
))
3183 if (overlay_cache_invalid
)
3185 overlay_invalidate_all ();
3186 overlay_cache_invalid
= 0;
3188 if (osect
->ovly_mapped
== -1)
3189 gdbarch_overlay_update (current_gdbarch
, osect
);
3191 /* fall thru to manual case */
3192 case ovly_on
: /* overlay debugging manual */
3193 return osect
->ovly_mapped
== 1;
3197 /* Function: section_is_mapped
3198 Returns true if section is an overlay, and is currently mapped. */
3201 section_is_mapped (asection
*section
)
3203 struct objfile
*objfile
;
3204 struct obj_section
*osect
;
3206 if (overlay_debugging
)
3207 if (section
&& section_is_overlay (section
))
3208 ALL_OBJSECTIONS (objfile
, osect
)
3209 if (osect
->the_bfd_section
== section
)
3210 return overlay_is_mapped (osect
);
3215 /* Function: pc_in_unmapped_range
3216 If PC falls into the lma range of SECTION, return true, else false. */
3219 pc_in_unmapped_range (CORE_ADDR pc
, asection
*section
)
3221 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
3225 if (overlay_debugging
)
3226 if (section
&& section_is_overlay (section
))
3228 size
= bfd_get_section_size (section
);
3229 if (section
->lma
<= pc
&& pc
< section
->lma
+ size
)
3235 /* Function: pc_in_mapped_range
3236 If PC falls into the vma range of SECTION, return true, else false. */
3239 pc_in_mapped_range (CORE_ADDR pc
, asection
*section
)
3241 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3245 if (overlay_debugging
)
3246 if (section
&& section_is_overlay (section
))
3248 size
= bfd_get_section_size (section
);
3249 if (section
->vma
<= pc
&& pc
< section
->vma
+ size
)
3256 /* Return true if the mapped ranges of sections A and B overlap, false
3259 sections_overlap (asection
*a
, asection
*b
)
3261 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3263 CORE_ADDR a_start
= a
->vma
;
3264 CORE_ADDR a_end
= a
->vma
+ bfd_get_section_size (a
);
3265 CORE_ADDR b_start
= b
->vma
;
3266 CORE_ADDR b_end
= b
->vma
+ bfd_get_section_size (b
);
3268 return (a_start
< b_end
&& b_start
< a_end
);
3271 /* Function: overlay_unmapped_address (PC, SECTION)
3272 Returns the address corresponding to PC in the unmapped (load) range.
3273 May be the same as PC. */
3276 overlay_unmapped_address (CORE_ADDR pc
, asection
*section
)
3278 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
3280 if (overlay_debugging
)
3281 if (section
&& section_is_overlay (section
) &&
3282 pc_in_mapped_range (pc
, section
))
3283 return pc
+ section
->lma
- section
->vma
;
3288 /* Function: overlay_mapped_address (PC, SECTION)
3289 Returns the address corresponding to PC in the mapped (runtime) range.
3290 May be the same as PC. */
3293 overlay_mapped_address (CORE_ADDR pc
, asection
*section
)
3295 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3297 if (overlay_debugging
)
3298 if (section
&& section_is_overlay (section
) &&
3299 pc_in_unmapped_range (pc
, section
))
3300 return pc
+ section
->vma
- section
->lma
;
3306 /* Function: symbol_overlayed_address
3307 Return one of two addresses (relative to the VMA or to the LMA),
3308 depending on whether the section is mapped or not. */
3311 symbol_overlayed_address (CORE_ADDR address
, asection
*section
)
3313 if (overlay_debugging
)
3315 /* If the symbol has no section, just return its regular address. */
3318 /* If the symbol's section is not an overlay, just return its address */
3319 if (!section_is_overlay (section
))
3321 /* If the symbol's section is mapped, just return its address */
3322 if (section_is_mapped (section
))
3325 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3326 * then return its LOADED address rather than its vma address!!
3328 return overlay_unmapped_address (address
, section
);
3333 /* Function: find_pc_overlay (PC)
3334 Return the best-match overlay section for PC:
3335 If PC matches a mapped overlay section's VMA, return that section.
3336 Else if PC matches an unmapped section's VMA, return that section.
3337 Else if PC matches an unmapped section's LMA, return that section. */
3340 find_pc_overlay (CORE_ADDR pc
)
3342 struct objfile
*objfile
;
3343 struct obj_section
*osect
, *best_match
= NULL
;
3345 if (overlay_debugging
)
3346 ALL_OBJSECTIONS (objfile
, osect
)
3347 if (section_is_overlay (osect
->the_bfd_section
))
3349 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
))
3351 if (overlay_is_mapped (osect
))
3352 return osect
->the_bfd_section
;
3356 else if (pc_in_unmapped_range (pc
, osect
->the_bfd_section
))
3359 return best_match
? best_match
->the_bfd_section
: NULL
;
3362 /* Function: find_pc_mapped_section (PC)
3363 If PC falls into the VMA address range of an overlay section that is
3364 currently marked as MAPPED, return that section. Else return NULL. */
3367 find_pc_mapped_section (CORE_ADDR pc
)
3369 struct objfile
*objfile
;
3370 struct obj_section
*osect
;
3372 if (overlay_debugging
)
3373 ALL_OBJSECTIONS (objfile
, osect
)
3374 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
) &&
3375 overlay_is_mapped (osect
))
3376 return osect
->the_bfd_section
;
3381 /* Function: list_overlays_command
3382 Print a list of mapped sections and their PC ranges */
3385 list_overlays_command (char *args
, int from_tty
)
3388 struct objfile
*objfile
;
3389 struct obj_section
*osect
;
3391 if (overlay_debugging
)
3392 ALL_OBJSECTIONS (objfile
, osect
)
3393 if (overlay_is_mapped (osect
))
3399 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3400 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3401 size
= bfd_get_section_size (osect
->the_bfd_section
);
3402 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3404 printf_filtered ("Section %s, loaded at ", name
);
3405 deprecated_print_address_numeric (lma
, 1, gdb_stdout
);
3406 puts_filtered (" - ");
3407 deprecated_print_address_numeric (lma
+ size
, 1, gdb_stdout
);
3408 printf_filtered (", mapped at ");
3409 deprecated_print_address_numeric (vma
, 1, gdb_stdout
);
3410 puts_filtered (" - ");
3411 deprecated_print_address_numeric (vma
+ size
, 1, gdb_stdout
);
3412 puts_filtered ("\n");
3417 printf_filtered (_("No sections are mapped.\n"));
3420 /* Function: map_overlay_command
3421 Mark the named section as mapped (ie. residing at its VMA address). */
3424 map_overlay_command (char *args
, int from_tty
)
3426 struct objfile
*objfile
, *objfile2
;
3427 struct obj_section
*sec
, *sec2
;
3430 if (!overlay_debugging
)
3432 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3433 the 'overlay manual' command."));
3435 if (args
== 0 || *args
== 0)
3436 error (_("Argument required: name of an overlay section"));
3438 /* First, find a section matching the user supplied argument */
3439 ALL_OBJSECTIONS (objfile
, sec
)
3440 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3442 /* Now, check to see if the section is an overlay. */
3443 bfdsec
= sec
->the_bfd_section
;
3444 if (!section_is_overlay (bfdsec
))
3445 continue; /* not an overlay section */
3447 /* Mark the overlay as "mapped" */
3448 sec
->ovly_mapped
= 1;
3450 /* Next, make a pass and unmap any sections that are
3451 overlapped by this new section: */
3452 ALL_OBJSECTIONS (objfile2
, sec2
)
3453 if (sec2
->ovly_mapped
3455 && sec
->the_bfd_section
!= sec2
->the_bfd_section
3456 && sections_overlap (sec
->the_bfd_section
,
3457 sec2
->the_bfd_section
))
3460 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3461 bfd_section_name (objfile
->obfd
,
3462 sec2
->the_bfd_section
));
3463 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3467 error (_("No overlay section called %s"), args
);
3470 /* Function: unmap_overlay_command
3471 Mark the overlay section as unmapped
3472 (ie. resident in its LMA address range, rather than the VMA range). */
3475 unmap_overlay_command (char *args
, int from_tty
)
3477 struct objfile
*objfile
;
3478 struct obj_section
*sec
;
3480 if (!overlay_debugging
)
3482 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3483 the 'overlay manual' command."));
3485 if (args
== 0 || *args
== 0)
3486 error (_("Argument required: name of an overlay section"));
3488 /* First, find a section matching the user supplied argument */
3489 ALL_OBJSECTIONS (objfile
, sec
)
3490 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3492 if (!sec
->ovly_mapped
)
3493 error (_("Section %s is not mapped"), args
);
3494 sec
->ovly_mapped
= 0;
3497 error (_("No overlay section called %s"), args
);
3500 /* Function: overlay_auto_command
3501 A utility command to turn on overlay debugging.
3502 Possibly this should be done via a set/show command. */
3505 overlay_auto_command (char *args
, int from_tty
)
3507 overlay_debugging
= ovly_auto
;
3508 enable_overlay_breakpoints ();
3510 printf_unfiltered (_("Automatic overlay debugging enabled."));
3513 /* Function: overlay_manual_command
3514 A utility command to turn on overlay debugging.
3515 Possibly this should be done via a set/show command. */
3518 overlay_manual_command (char *args
, int from_tty
)
3520 overlay_debugging
= ovly_on
;
3521 disable_overlay_breakpoints ();
3523 printf_unfiltered (_("Overlay debugging enabled."));
3526 /* Function: overlay_off_command
3527 A utility command to turn on overlay debugging.
3528 Possibly this should be done via a set/show command. */
3531 overlay_off_command (char *args
, int from_tty
)
3533 overlay_debugging
= ovly_off
;
3534 disable_overlay_breakpoints ();
3536 printf_unfiltered (_("Overlay debugging disabled."));
3540 overlay_load_command (char *args
, int from_tty
)
3542 if (gdbarch_overlay_update_p (current_gdbarch
))
3543 gdbarch_overlay_update (current_gdbarch
, NULL
);
3545 error (_("This target does not know how to read its overlay state."));
3548 /* Function: overlay_command
3549 A place-holder for a mis-typed command */
3551 /* Command list chain containing all defined "overlay" subcommands. */
3552 struct cmd_list_element
*overlaylist
;
3555 overlay_command (char *args
, int from_tty
)
3558 ("\"overlay\" must be followed by the name of an overlay command.\n");
3559 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3563 /* Target Overlays for the "Simplest" overlay manager:
3565 This is GDB's default target overlay layer. It works with the
3566 minimal overlay manager supplied as an example by Cygnus. The
3567 entry point is via a function pointer "gdbarch_overlay_update",
3568 so targets that use a different runtime overlay manager can
3569 substitute their own overlay_update function and take over the
3572 The overlay_update function pokes around in the target's data structures
3573 to see what overlays are mapped, and updates GDB's overlay mapping with
3576 In this simple implementation, the target data structures are as follows:
3577 unsigned _novlys; /# number of overlay sections #/
3578 unsigned _ovly_table[_novlys][4] = {
3579 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3580 {..., ..., ..., ...},
3582 unsigned _novly_regions; /# number of overlay regions #/
3583 unsigned _ovly_region_table[_novly_regions][3] = {
3584 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3587 These functions will attempt to update GDB's mappedness state in the
3588 symbol section table, based on the target's mappedness state.
3590 To do this, we keep a cached copy of the target's _ovly_table, and
3591 attempt to detect when the cached copy is invalidated. The main
3592 entry point is "simple_overlay_update(SECT), which looks up SECT in
3593 the cached table and re-reads only the entry for that section from
3594 the target (whenever possible).
3597 /* Cached, dynamically allocated copies of the target data structures: */
3598 static unsigned (*cache_ovly_table
)[4] = 0;
3600 static unsigned (*cache_ovly_region_table
)[3] = 0;
3602 static unsigned cache_novlys
= 0;
3604 static unsigned cache_novly_regions
= 0;
3606 static CORE_ADDR cache_ovly_table_base
= 0;
3608 static CORE_ADDR cache_ovly_region_table_base
= 0;
3612 VMA
, SIZE
, LMA
, MAPPED
3614 #define TARGET_LONG_BYTES (gdbarch_long_bit (current_gdbarch) \
3617 /* Throw away the cached copy of _ovly_table */
3619 simple_free_overlay_table (void)
3621 if (cache_ovly_table
)
3622 xfree (cache_ovly_table
);
3624 cache_ovly_table
= NULL
;
3625 cache_ovly_table_base
= 0;
3629 /* Throw away the cached copy of _ovly_region_table */
3631 simple_free_overlay_region_table (void)
3633 if (cache_ovly_region_table
)
3634 xfree (cache_ovly_region_table
);
3635 cache_novly_regions
= 0;
3636 cache_ovly_region_table
= NULL
;
3637 cache_ovly_region_table_base
= 0;
3641 /* Read an array of ints from the target into a local buffer.
3642 Convert to host order. int LEN is number of ints */
3644 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
, int len
)
3646 /* FIXME (alloca): Not safe if array is very large. */
3647 gdb_byte
*buf
= alloca (len
* TARGET_LONG_BYTES
);
3650 read_memory (memaddr
, buf
, len
* TARGET_LONG_BYTES
);
3651 for (i
= 0; i
< len
; i
++)
3652 myaddr
[i
] = extract_unsigned_integer (TARGET_LONG_BYTES
* i
+ buf
,
3656 /* Find and grab a copy of the target _ovly_table
3657 (and _novlys, which is needed for the table's size) */
3659 simple_read_overlay_table (void)
3661 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3663 simple_free_overlay_table ();
3664 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3667 error (_("Error reading inferior's overlay table: "
3668 "couldn't find `_novlys' variable\n"
3669 "in inferior. Use `overlay manual' mode."));
3673 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3674 if (! ovly_table_msym
)
3676 error (_("Error reading inferior's overlay table: couldn't find "
3677 "`_ovly_table' array\n"
3678 "in inferior. Use `overlay manual' mode."));
3682 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
), 4);
3684 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3685 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3686 read_target_long_array (cache_ovly_table_base
,
3687 (unsigned int *) cache_ovly_table
,
3690 return 1; /* SUCCESS */
3694 /* Find and grab a copy of the target _ovly_region_table
3695 (and _novly_regions, which is needed for the table's size) */
3697 simple_read_overlay_region_table (void)
3699 struct minimal_symbol
*msym
;
3701 simple_free_overlay_region_table ();
3702 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3704 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
3706 return 0; /* failure */
3707 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3708 if (cache_ovly_region_table
!= NULL
)
3710 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3713 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3714 read_target_long_array (cache_ovly_region_table_base
,
3715 (unsigned int *) cache_ovly_region_table
,
3716 cache_novly_regions
* 3);
3719 return 0; /* failure */
3722 return 0; /* failure */
3723 return 1; /* SUCCESS */
3727 /* Function: simple_overlay_update_1
3728 A helper function for simple_overlay_update. Assuming a cached copy
3729 of _ovly_table exists, look through it to find an entry whose vma,
3730 lma and size match those of OSECT. Re-read the entry and make sure
3731 it still matches OSECT (else the table may no longer be valid).
3732 Set OSECT's mapped state to match the entry. Return: 1 for
3733 success, 0 for failure. */
3736 simple_overlay_update_1 (struct obj_section
*osect
)
3739 bfd
*obfd
= osect
->objfile
->obfd
;
3740 asection
*bsect
= osect
->the_bfd_section
;
3742 size
= bfd_get_section_size (osect
->the_bfd_section
);
3743 for (i
= 0; i
< cache_novlys
; i
++)
3744 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3745 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3746 /* && cache_ovly_table[i][SIZE] == size */ )
3748 read_target_long_array (cache_ovly_table_base
+ i
* TARGET_LONG_BYTES
,
3749 (unsigned int *) cache_ovly_table
[i
], 4);
3750 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3751 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3752 /* && cache_ovly_table[i][SIZE] == size */ )
3754 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3757 else /* Warning! Warning! Target's ovly table has changed! */
3763 /* Function: simple_overlay_update
3764 If OSECT is NULL, then update all sections' mapped state
3765 (after re-reading the entire target _ovly_table).
3766 If OSECT is non-NULL, then try to find a matching entry in the
3767 cached ovly_table and update only OSECT's mapped state.
3768 If a cached entry can't be found or the cache isn't valid, then
3769 re-read the entire cache, and go ahead and update all sections. */
3772 simple_overlay_update (struct obj_section
*osect
)
3774 struct objfile
*objfile
;
3776 /* Were we given an osect to look up? NULL means do all of them. */
3778 /* Have we got a cached copy of the target's overlay table? */
3779 if (cache_ovly_table
!= NULL
)
3780 /* Does its cached location match what's currently in the symtab? */
3781 if (cache_ovly_table_base
==
3782 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3783 /* Then go ahead and try to look up this single section in the cache */
3784 if (simple_overlay_update_1 (osect
))
3785 /* Found it! We're done. */
3788 /* Cached table no good: need to read the entire table anew.
3789 Or else we want all the sections, in which case it's actually
3790 more efficient to read the whole table in one block anyway. */
3792 if (! simple_read_overlay_table ())
3795 /* Now may as well update all sections, even if only one was requested. */
3796 ALL_OBJSECTIONS (objfile
, osect
)
3797 if (section_is_overlay (osect
->the_bfd_section
))
3800 bfd
*obfd
= osect
->objfile
->obfd
;
3801 asection
*bsect
= osect
->the_bfd_section
;
3803 size
= bfd_get_section_size (bsect
);
3804 for (i
= 0; i
< cache_novlys
; i
++)
3805 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3806 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3807 /* && cache_ovly_table[i][SIZE] == size */ )
3808 { /* obj_section matches i'th entry in ovly_table */
3809 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3810 break; /* finished with inner for loop: break out */
3815 /* Set the output sections and output offsets for section SECTP in
3816 ABFD. The relocation code in BFD will read these offsets, so we
3817 need to be sure they're initialized. We map each section to itself,
3818 with no offset; this means that SECTP->vma will be honored. */
3821 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3823 sectp
->output_section
= sectp
;
3824 sectp
->output_offset
= 0;
3827 /* Relocate the contents of a debug section SECTP in ABFD. The
3828 contents are stored in BUF if it is non-NULL, or returned in a
3829 malloc'd buffer otherwise.
3831 For some platforms and debug info formats, shared libraries contain
3832 relocations against the debug sections (particularly for DWARF-2;
3833 one affected platform is PowerPC GNU/Linux, although it depends on
3834 the version of the linker in use). Also, ELF object files naturally
3835 have unresolved relocations for their debug sections. We need to apply
3836 the relocations in order to get the locations of symbols correct. */
3839 symfile_relocate_debug_section (bfd
*abfd
, asection
*sectp
, bfd_byte
*buf
)
3841 /* We're only interested in debugging sections with relocation
3843 if ((sectp
->flags
& SEC_RELOC
) == 0)
3845 if ((sectp
->flags
& SEC_DEBUGGING
) == 0)
3848 /* We will handle section offsets properly elsewhere, so relocate as if
3849 all sections begin at 0. */
3850 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3852 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3855 struct symfile_segment_data
*
3856 get_symfile_segment_data (bfd
*abfd
)
3858 struct sym_fns
*sf
= find_sym_fns (abfd
);
3863 return sf
->sym_segments (abfd
);
3867 free_symfile_segment_data (struct symfile_segment_data
*data
)
3869 xfree (data
->segment_bases
);
3870 xfree (data
->segment_sizes
);
3871 xfree (data
->segment_info
);
3876 symfile_map_offsets_to_segments (bfd
*abfd
, struct symfile_segment_data
*data
,
3877 struct section_offsets
*offsets
,
3878 int num_segment_bases
,
3879 const CORE_ADDR
*segment_bases
)
3884 /* If we do not have segment mappings for the object file, we
3885 can not relocate it by segments. */
3886 gdb_assert (data
!= NULL
);
3887 gdb_assert (data
->num_segments
> 0);
3889 /* If more offsets are provided than we have segments, make sure the
3890 excess offsets are all the same as the last segment's offset.
3891 This allows "Text=X;Data=X" for files which have only a single
3893 if (num_segment_bases
> data
->num_segments
)
3894 for (i
= data
->num_segments
; i
< num_segment_bases
; i
++)
3895 if (segment_bases
[i
] != segment_bases
[data
->num_segments
- 1])
3898 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3901 int which
= data
->segment_info
[i
];
3903 if (which
> num_segment_bases
)
3904 offsets
->offsets
[i
] = segment_bases
[num_segment_bases
- 1];
3906 offsets
->offsets
[i
] = segment_bases
[which
- 1];
3910 offsets
->offsets
[i
] -= data
->segment_bases
[which
- 1];
3917 symfile_find_segment_sections (struct objfile
*objfile
)
3919 bfd
*abfd
= objfile
->obfd
;
3922 struct symfile_segment_data
*data
;
3924 data
= get_symfile_segment_data (objfile
->obfd
);
3928 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3930 free_symfile_segment_data (data
);
3934 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3937 int which
= data
->segment_info
[i
];
3941 if (objfile
->sect_index_text
== -1)
3942 objfile
->sect_index_text
= sect
->index
;
3944 if (objfile
->sect_index_rodata
== -1)
3945 objfile
->sect_index_rodata
= sect
->index
;
3947 else if (which
== 2)
3949 if (objfile
->sect_index_data
== -1)
3950 objfile
->sect_index_data
= sect
->index
;
3952 if (objfile
->sect_index_bss
== -1)
3953 objfile
->sect_index_bss
= sect
->index
;
3957 free_symfile_segment_data (data
);
3961 _initialize_symfile (void)
3963 struct cmd_list_element
*c
;
3965 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3966 Load symbol table from executable file FILE.\n\
3967 The `file' command can also load symbol tables, as well as setting the file\n\
3968 to execute."), &cmdlist
);
3969 set_cmd_completer (c
, filename_completer
);
3971 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3972 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3973 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3974 ADDR is the starting address of the file's text.\n\
3975 The optional arguments are section-name section-address pairs and\n\
3976 should be specified if the data and bss segments are not contiguous\n\
3977 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3979 set_cmd_completer (c
, filename_completer
);
3981 c
= add_cmd ("add-shared-symbol-files", class_files
,
3982 add_shared_symbol_files_command
, _("\
3983 Load the symbols from shared objects in the dynamic linker's link map."),
3985 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
3988 c
= add_cmd ("load", class_files
, load_command
, _("\
3989 Dynamically load FILE into the running program, and record its symbols\n\
3990 for access from GDB.\n\
3991 A load OFFSET may also be given."), &cmdlist
);
3992 set_cmd_completer (c
, filename_completer
);
3994 add_setshow_boolean_cmd ("symbol-reloading", class_support
,
3995 &symbol_reloading
, _("\
3996 Set dynamic symbol table reloading multiple times in one run."), _("\
3997 Show dynamic symbol table reloading multiple times in one run."), NULL
,
3999 show_symbol_reloading
,
4000 &setlist
, &showlist
);
4002 add_prefix_cmd ("overlay", class_support
, overlay_command
,
4003 _("Commands for debugging overlays."), &overlaylist
,
4004 "overlay ", 0, &cmdlist
);
4006 add_com_alias ("ovly", "overlay", class_alias
, 1);
4007 add_com_alias ("ov", "overlay", class_alias
, 1);
4009 add_cmd ("map-overlay", class_support
, map_overlay_command
,
4010 _("Assert that an overlay section is mapped."), &overlaylist
);
4012 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
4013 _("Assert that an overlay section is unmapped."), &overlaylist
);
4015 add_cmd ("list-overlays", class_support
, list_overlays_command
,
4016 _("List mappings of overlay sections."), &overlaylist
);
4018 add_cmd ("manual", class_support
, overlay_manual_command
,
4019 _("Enable overlay debugging."), &overlaylist
);
4020 add_cmd ("off", class_support
, overlay_off_command
,
4021 _("Disable overlay debugging."), &overlaylist
);
4022 add_cmd ("auto", class_support
, overlay_auto_command
,
4023 _("Enable automatic overlay debugging."), &overlaylist
);
4024 add_cmd ("load-target", class_support
, overlay_load_command
,
4025 _("Read the overlay mapping state from the target."), &overlaylist
);
4027 /* Filename extension to source language lookup table: */
4028 init_filename_language_table ();
4029 add_setshow_string_noescape_cmd ("extension-language", class_files
,
4031 Set mapping between filename extension and source language."), _("\
4032 Show mapping between filename extension and source language."), _("\
4033 Usage: set extension-language .foo bar"),
4034 set_ext_lang_command
,
4036 &setlist
, &showlist
);
4038 add_info ("extensions", info_ext_lang_command
,
4039 _("All filename extensions associated with a source language."));
4041 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
4042 &debug_file_directory
, _("\
4043 Set the directory where separate debug symbols are searched for."), _("\
4044 Show the directory where separate debug symbols are searched for."), _("\
4045 Separate debug symbols are first searched for in the same\n\
4046 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
4047 and lastly at the path of the directory of the binary with\n\
4048 the global debug-file directory prepended."),
4050 show_debug_file_directory
,
4051 &setlist
, &showlist
);