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 2 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, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
38 #include "breakpoint.h"
40 #include "complaints.h"
42 #include "inferior.h" /* for write_pc */
43 #include "filenames.h" /* for DOSish file names */
44 #include "gdb-stabs.h"
45 #include "gdb_obstack.h"
46 #include "completer.h"
49 #include "readline/readline.h"
50 #include "gdb_assert.h"
54 #include "parser-defs.h"
57 #include <sys/types.h>
59 #include "gdb_string.h"
66 int (*deprecated_ui_load_progress_hook
) (const char *section
, unsigned long num
);
67 void (*deprecated_show_load_progress
) (const char *section
,
68 unsigned long section_sent
,
69 unsigned long section_size
,
70 unsigned long total_sent
,
71 unsigned long total_size
);
72 void (*deprecated_pre_add_symbol_hook
) (const char *);
73 void (*deprecated_post_add_symbol_hook
) (void);
75 static void clear_symtab_users_cleanup (void *ignore
);
77 /* Global variables owned by this file */
78 int readnow_symbol_files
; /* Read full symbols immediately */
80 /* External variables and functions referenced. */
82 extern void report_transfer_performance (unsigned long, time_t, time_t);
84 /* Functions this file defines */
87 static int simple_read_overlay_region_table (void);
88 static void simple_free_overlay_region_table (void);
91 static void set_initial_language (void);
93 static void load_command (char *, int);
95 static void symbol_file_add_main_1 (char *args
, int from_tty
, int flags
);
97 static void add_symbol_file_command (char *, int);
99 static void add_shared_symbol_files_command (char *, int);
101 static void reread_separate_symbols (struct objfile
*objfile
);
103 static void cashier_psymtab (struct partial_symtab
*);
105 bfd
*symfile_bfd_open (char *);
107 int get_section_index (struct objfile
*, char *);
109 static struct sym_fns
*find_sym_fns (bfd
*);
111 static void decrement_reading_symtab (void *);
113 static void overlay_invalidate_all (void);
115 static int overlay_is_mapped (struct obj_section
*);
117 void list_overlays_command (char *, int);
119 void map_overlay_command (char *, int);
121 void unmap_overlay_command (char *, int);
123 static void overlay_auto_command (char *, int);
125 static void overlay_manual_command (char *, int);
127 static void overlay_off_command (char *, int);
129 static void overlay_load_command (char *, int);
131 static void overlay_command (char *, int);
133 static void simple_free_overlay_table (void);
135 static void read_target_long_array (CORE_ADDR
, unsigned int *, int);
137 static int simple_read_overlay_table (void);
139 static int simple_overlay_update_1 (struct obj_section
*);
141 static void add_filename_language (char *ext
, enum language lang
);
143 static void info_ext_lang_command (char *args
, int from_tty
);
145 static char *find_separate_debug_file (struct objfile
*objfile
);
147 static void init_filename_language_table (void);
149 static void symfile_find_segment_sections (struct objfile
*objfile
);
151 void _initialize_symfile (void);
153 /* List of all available sym_fns. On gdb startup, each object file reader
154 calls add_symtab_fns() to register information on each format it is
157 static struct sym_fns
*symtab_fns
= NULL
;
159 /* Flag for whether user will be reloading symbols multiple times.
160 Defaults to ON for VxWorks, otherwise OFF. */
162 #ifdef SYMBOL_RELOADING_DEFAULT
163 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
165 int symbol_reloading
= 0;
168 show_symbol_reloading (struct ui_file
*file
, int from_tty
,
169 struct cmd_list_element
*c
, const char *value
)
171 fprintf_filtered (file
, _("\
172 Dynamic symbol table reloading multiple times in one run is %s.\n"),
177 /* If non-zero, shared library symbols will be added automatically
178 when the inferior is created, new libraries are loaded, or when
179 attaching to the inferior. This is almost always what users will
180 want to have happen; but for very large programs, the startup time
181 will be excessive, and so if this is a problem, the user can clear
182 this flag and then add the shared library symbols as needed. Note
183 that there is a potential for confusion, since if the shared
184 library symbols are not loaded, commands like "info fun" will *not*
185 report all the functions that are actually present. */
187 int auto_solib_add
= 1;
189 /* For systems that support it, a threshold size in megabytes. If
190 automatically adding a new library's symbol table to those already
191 known to the debugger would cause the total shared library symbol
192 size to exceed this threshhold, then the shlib's symbols are not
193 added. The threshold is ignored if the user explicitly asks for a
194 shlib to be added, such as when using the "sharedlibrary"
197 int auto_solib_limit
;
200 /* This compares two partial symbols by names, using strcmp_iw_ordered
201 for the comparison. */
204 compare_psymbols (const void *s1p
, const void *s2p
)
206 struct partial_symbol
*const *s1
= s1p
;
207 struct partial_symbol
*const *s2
= s2p
;
209 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1
),
210 SYMBOL_SEARCH_NAME (*s2
));
214 sort_pst_symbols (struct partial_symtab
*pst
)
216 /* Sort the global list; don't sort the static list */
218 qsort (pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
,
219 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
223 /* Make a null terminated copy of the string at PTR with SIZE characters in
224 the obstack pointed to by OBSTACKP . Returns the address of the copy.
225 Note that the string at PTR does not have to be null terminated, I.E. it
226 may be part of a larger string and we are only saving a substring. */
229 obsavestring (const char *ptr
, int size
, struct obstack
*obstackp
)
231 char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
232 /* Open-coded memcpy--saves function call time. These strings are usually
233 short. FIXME: Is this really still true with a compiler that can
236 const char *p1
= ptr
;
238 const char *end
= ptr
+ size
;
246 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
247 in the obstack pointed to by OBSTACKP. */
250 obconcat (struct obstack
*obstackp
, const char *s1
, const char *s2
,
253 int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
254 char *val
= (char *) obstack_alloc (obstackp
, len
);
261 /* True if we are nested inside psymtab_to_symtab. */
263 int currently_reading_symtab
= 0;
266 decrement_reading_symtab (void *dummy
)
268 currently_reading_symtab
--;
271 /* Get the symbol table that corresponds to a partial_symtab.
272 This is fast after the first time you do it. In fact, there
273 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
277 psymtab_to_symtab (struct partial_symtab
*pst
)
279 /* If it's been looked up before, return it. */
283 /* If it has not yet been read in, read it. */
286 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
287 currently_reading_symtab
++;
288 (*pst
->read_symtab
) (pst
);
289 do_cleanups (back_to
);
295 /* Remember the lowest-addressed loadable section we've seen.
296 This function is called via bfd_map_over_sections.
298 In case of equal vmas, the section with the largest size becomes the
299 lowest-addressed loadable section.
301 If the vmas and sizes are equal, the last section is considered the
302 lowest-addressed loadable section. */
305 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
307 asection
**lowest
= (asection
**) obj
;
309 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
312 *lowest
= sect
; /* First loadable section */
313 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
314 *lowest
= sect
; /* A lower loadable section */
315 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
316 && (bfd_section_size (abfd
, (*lowest
))
317 <= bfd_section_size (abfd
, sect
)))
321 /* Create a new section_addr_info, with room for NUM_SECTIONS. */
323 struct section_addr_info
*
324 alloc_section_addr_info (size_t num_sections
)
326 struct section_addr_info
*sap
;
329 size
= (sizeof (struct section_addr_info
)
330 + sizeof (struct other_sections
) * (num_sections
- 1));
331 sap
= (struct section_addr_info
*) xmalloc (size
);
332 memset (sap
, 0, size
);
333 sap
->num_sections
= num_sections
;
339 /* Return a freshly allocated copy of ADDRS. The section names, if
340 any, are also freshly allocated copies of those in ADDRS. */
341 struct section_addr_info
*
342 copy_section_addr_info (struct section_addr_info
*addrs
)
344 struct section_addr_info
*copy
345 = alloc_section_addr_info (addrs
->num_sections
);
348 copy
->num_sections
= addrs
->num_sections
;
349 for (i
= 0; i
< addrs
->num_sections
; i
++)
351 copy
->other
[i
].addr
= addrs
->other
[i
].addr
;
352 if (addrs
->other
[i
].name
)
353 copy
->other
[i
].name
= xstrdup (addrs
->other
[i
].name
);
355 copy
->other
[i
].name
= NULL
;
356 copy
->other
[i
].sectindex
= addrs
->other
[i
].sectindex
;
364 /* Build (allocate and populate) a section_addr_info struct from
365 an existing section table. */
367 extern struct section_addr_info
*
368 build_section_addr_info_from_section_table (const struct section_table
*start
,
369 const struct section_table
*end
)
371 struct section_addr_info
*sap
;
372 const struct section_table
*stp
;
375 sap
= alloc_section_addr_info (end
- start
);
377 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
379 if (bfd_get_section_flags (stp
->bfd
,
380 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
381 && oidx
< end
- start
)
383 sap
->other
[oidx
].addr
= stp
->addr
;
384 sap
->other
[oidx
].name
385 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
386 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
395 /* Free all memory allocated by build_section_addr_info_from_section_table. */
398 free_section_addr_info (struct section_addr_info
*sap
)
402 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
403 if (sap
->other
[idx
].name
)
404 xfree (sap
->other
[idx
].name
);
409 /* Initialize OBJFILE's sect_index_* members. */
411 init_objfile_sect_indices (struct objfile
*objfile
)
416 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
418 objfile
->sect_index_text
= sect
->index
;
420 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
422 objfile
->sect_index_data
= sect
->index
;
424 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
426 objfile
->sect_index_bss
= sect
->index
;
428 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
430 objfile
->sect_index_rodata
= sect
->index
;
432 /* This is where things get really weird... We MUST have valid
433 indices for the various sect_index_* members or gdb will abort.
434 So if for example, there is no ".text" section, we have to
435 accomodate that. First, check for a file with the standard
436 one or two segments. */
438 symfile_find_segment_sections (objfile
);
440 /* Except when explicitly adding symbol files at some address,
441 section_offsets contains nothing but zeros, so it doesn't matter
442 which slot in section_offsets the individual sect_index_* members
443 index into. So if they are all zero, it is safe to just point
444 all the currently uninitialized indices to the first slot. But
445 beware: if this is the main executable, it may be relocated
446 later, e.g. by the remote qOffsets packet, and then this will
447 be wrong! That's why we try segments first. */
449 for (i
= 0; i
< objfile
->num_sections
; i
++)
451 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
456 if (i
== objfile
->num_sections
)
458 if (objfile
->sect_index_text
== -1)
459 objfile
->sect_index_text
= 0;
460 if (objfile
->sect_index_data
== -1)
461 objfile
->sect_index_data
= 0;
462 if (objfile
->sect_index_bss
== -1)
463 objfile
->sect_index_bss
= 0;
464 if (objfile
->sect_index_rodata
== -1)
465 objfile
->sect_index_rodata
= 0;
469 /* The arguments to place_section. */
471 struct place_section_arg
473 struct section_offsets
*offsets
;
477 /* Find a unique offset to use for loadable section SECT if
478 the user did not provide an offset. */
481 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
483 struct place_section_arg
*arg
= obj
;
484 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
486 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
488 /* We are only interested in allocated sections. */
489 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
492 /* If the user specified an offset, honor it. */
493 if (offsets
[sect
->index
] != 0)
496 /* Otherwise, let's try to find a place for the section. */
497 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
504 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
506 int indx
= cur_sec
->index
;
507 CORE_ADDR cur_offset
;
509 /* We don't need to compare against ourself. */
513 /* We can only conflict with allocated sections. */
514 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
517 /* If the section offset is 0, either the section has not been placed
518 yet, or it was the lowest section placed (in which case LOWEST
519 will be past its end). */
520 if (offsets
[indx
] == 0)
523 /* If this section would overlap us, then we must move up. */
524 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
525 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
527 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
528 start_addr
= (start_addr
+ align
- 1) & -align
;
533 /* Otherwise, we appear to be OK. So far. */
538 offsets
[sect
->index
] = start_addr
;
539 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
541 exec_set_section_address (bfd_get_filename (abfd
), sect
->index
, start_addr
);
544 /* Parse the user's idea of an offset for dynamic linking, into our idea
545 of how to represent it for fast symbol reading. This is the default
546 version of the sym_fns.sym_offsets function for symbol readers that
547 don't need to do anything special. It allocates a section_offsets table
548 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
551 default_symfile_offsets (struct objfile
*objfile
,
552 struct section_addr_info
*addrs
)
556 objfile
->num_sections
= bfd_count_sections (objfile
->obfd
);
557 objfile
->section_offsets
= (struct section_offsets
*)
558 obstack_alloc (&objfile
->objfile_obstack
,
559 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
560 memset (objfile
->section_offsets
, 0,
561 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
563 /* Now calculate offsets for section that were specified by the
565 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
567 struct other_sections
*osp
;
569 osp
= &addrs
->other
[i
] ;
573 /* Record all sections in offsets */
574 /* The section_offsets in the objfile are here filled in using
576 (objfile
->section_offsets
)->offsets
[osp
->sectindex
] = osp
->addr
;
579 /* For relocatable files, all loadable sections will start at zero.
580 The zero is meaningless, so try to pick arbitrary addresses such
581 that no loadable sections overlap. This algorithm is quadratic,
582 but the number of sections in a single object file is generally
584 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
586 struct place_section_arg arg
;
587 bfd
*abfd
= objfile
->obfd
;
589 CORE_ADDR lowest
= 0;
591 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
592 /* We do not expect this to happen; just skip this step if the
593 relocatable file has a section with an assigned VMA. */
594 if (bfd_section_vma (abfd
, cur_sec
) != 0)
599 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
601 /* Pick non-overlapping offsets for sections the user did not
603 arg
.offsets
= objfile
->section_offsets
;
605 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
607 /* Correctly filling in the section offsets is not quite
608 enough. Relocatable files have two properties that
609 (most) shared objects do not:
611 - Their debug information will contain relocations. Some
612 shared libraries do also, but many do not, so this can not
615 - If there are multiple code sections they will be loaded
616 at different relative addresses in memory than they are
617 in the objfile, since all sections in the file will start
620 Because GDB has very limited ability to map from an
621 address in debug info to the correct code section,
622 it relies on adding SECT_OFF_TEXT to things which might be
623 code. If we clear all the section offsets, and set the
624 section VMAs instead, then symfile_relocate_debug_section
625 will return meaningful debug information pointing at the
628 GDB has too many different data structures for section
629 addresses - a bfd, objfile, and so_list all have section
630 tables, as does exec_ops. Some of these could probably
633 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
634 cur_sec
= cur_sec
->next
)
636 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
639 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
640 offsets
[cur_sec
->index
] = 0;
645 /* Remember the bfd indexes for the .text, .data, .bss and
647 init_objfile_sect_indices (objfile
);
651 /* Divide the file into segments, which are individual relocatable units.
652 This is the default version of the sym_fns.sym_segments function for
653 symbol readers that do not have an explicit representation of segments.
654 It assumes that object files do not have segments, and fully linked
655 files have a single segment. */
657 struct symfile_segment_data
*
658 default_symfile_segments (bfd
*abfd
)
662 struct symfile_segment_data
*data
;
665 /* Relocatable files contain enough information to position each
666 loadable section independently; they should not be relocated
668 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
671 /* Make sure there is at least one loadable section in the file. */
672 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
674 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
682 low
= bfd_get_section_vma (abfd
, sect
);
683 high
= low
+ bfd_get_section_size (sect
);
685 data
= XZALLOC (struct symfile_segment_data
);
686 data
->num_segments
= 1;
687 data
->segment_bases
= XCALLOC (1, CORE_ADDR
);
688 data
->segment_sizes
= XCALLOC (1, CORE_ADDR
);
690 num_sections
= bfd_count_sections (abfd
);
691 data
->segment_info
= XCALLOC (num_sections
, int);
693 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
697 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
700 vma
= bfd_get_section_vma (abfd
, sect
);
703 if (vma
+ bfd_get_section_size (sect
) > high
)
704 high
= vma
+ bfd_get_section_size (sect
);
706 data
->segment_info
[i
] = 1;
709 data
->segment_bases
[0] = low
;
710 data
->segment_sizes
[0] = high
- low
;
715 /* Process a symbol file, as either the main file or as a dynamically
718 OBJFILE is where the symbols are to be read from.
720 ADDRS is the list of section load addresses. If the user has given
721 an 'add-symbol-file' command, then this is the list of offsets and
722 addresses he or she provided as arguments to the command; or, if
723 we're handling a shared library, these are the actual addresses the
724 sections are loaded at, according to the inferior's dynamic linker
725 (as gleaned by GDB's shared library code). We convert each address
726 into an offset from the section VMA's as it appears in the object
727 file, and then call the file's sym_offsets function to convert this
728 into a format-specific offset table --- a `struct section_offsets'.
729 If ADDRS is non-zero, OFFSETS must be zero.
731 OFFSETS is a table of section offsets already in the right
732 format-specific representation. NUM_OFFSETS is the number of
733 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
734 assume this is the proper table the call to sym_offsets described
735 above would produce. Instead of calling sym_offsets, we just dump
736 it right into objfile->section_offsets. (When we're re-reading
737 symbols from an objfile, we don't have the original load address
738 list any more; all we have is the section offset table.) If
739 OFFSETS is non-zero, ADDRS must be zero.
741 MAINLINE is nonzero if this is the main symbol file, or zero if
742 it's an extra symbol file such as dynamically loaded code.
744 VERBO is nonzero if the caller has printed a verbose message about
745 the symbol reading (and complaints can be more terse about it). */
748 syms_from_objfile (struct objfile
*objfile
,
749 struct section_addr_info
*addrs
,
750 struct section_offsets
*offsets
,
755 struct section_addr_info
*local_addr
= NULL
;
756 struct cleanup
*old_chain
;
758 gdb_assert (! (addrs
&& offsets
));
760 init_entry_point_info (objfile
);
761 objfile
->sf
= find_sym_fns (objfile
->obfd
);
763 if (objfile
->sf
== NULL
)
764 return; /* No symbols. */
766 /* Make sure that partially constructed symbol tables will be cleaned up
767 if an error occurs during symbol reading. */
768 old_chain
= make_cleanup_free_objfile (objfile
);
770 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
771 list. We now establish the convention that an addr of zero means
772 no load address was specified. */
773 if (! addrs
&& ! offsets
)
776 = alloc_section_addr_info (bfd_count_sections (objfile
->obfd
));
777 make_cleanup (xfree
, local_addr
);
781 /* Now either addrs or offsets is non-zero. */
785 /* We will modify the main symbol table, make sure that all its users
786 will be cleaned up if an error occurs during symbol reading. */
787 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
789 /* Since no error yet, throw away the old symbol table. */
791 if (symfile_objfile
!= NULL
)
793 free_objfile (symfile_objfile
);
794 symfile_objfile
= NULL
;
797 /* Currently we keep symbols from the add-symbol-file command.
798 If the user wants to get rid of them, they should do "symbol-file"
799 without arguments first. Not sure this is the best behavior
802 (*objfile
->sf
->sym_new_init
) (objfile
);
805 /* Convert addr into an offset rather than an absolute address.
806 We find the lowest address of a loaded segment in the objfile,
807 and assume that <addr> is where that got loaded.
809 We no longer warn if the lowest section is not a text segment (as
810 happens for the PA64 port. */
811 if (!mainline
&& addrs
&& addrs
->other
[0].name
)
813 asection
*lower_sect
;
815 CORE_ADDR lower_offset
;
818 /* Find lowest loadable section to be used as starting point for
819 continguous sections. FIXME!! won't work without call to find
820 .text first, but this assumes text is lowest section. */
821 lower_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
822 if (lower_sect
== NULL
)
823 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
825 if (lower_sect
== NULL
)
826 warning (_("no loadable sections found in added symbol-file %s"),
829 if ((bfd_get_section_flags (objfile
->obfd
, lower_sect
) & SEC_CODE
) == 0)
830 warning (_("Lowest section in %s is %s at %s"),
832 bfd_section_name (objfile
->obfd
, lower_sect
),
833 paddr (bfd_section_vma (objfile
->obfd
, lower_sect
)));
834 if (lower_sect
!= NULL
)
835 lower_offset
= bfd_section_vma (objfile
->obfd
, lower_sect
);
839 /* Calculate offsets for the loadable sections.
840 FIXME! Sections must be in order of increasing loadable section
841 so that contiguous sections can use the lower-offset!!!
843 Adjust offsets if the segments are not contiguous.
844 If the section is contiguous, its offset should be set to
845 the offset of the highest loadable section lower than it
846 (the loadable section directly below it in memory).
847 this_offset = lower_offset = lower_addr - lower_orig_addr */
849 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
851 if (addrs
->other
[i
].addr
!= 0)
853 sect
= bfd_get_section_by_name (objfile
->obfd
,
854 addrs
->other
[i
].name
);
858 -= bfd_section_vma (objfile
->obfd
, sect
);
859 lower_offset
= addrs
->other
[i
].addr
;
860 /* This is the index used by BFD. */
861 addrs
->other
[i
].sectindex
= sect
->index
;
865 warning (_("section %s not found in %s"),
866 addrs
->other
[i
].name
,
868 addrs
->other
[i
].addr
= 0;
872 addrs
->other
[i
].addr
= lower_offset
;
876 /* Initialize symbol reading routines for this objfile, allow complaints to
877 appear for this new file, and record how verbose to be, then do the
878 initial symbol reading for this file. */
880 (*objfile
->sf
->sym_init
) (objfile
);
881 clear_complaints (&symfile_complaints
, 1, verbo
);
884 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
887 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
889 /* Just copy in the offset table directly as given to us. */
890 objfile
->num_sections
= num_offsets
;
891 objfile
->section_offsets
892 = ((struct section_offsets
*)
893 obstack_alloc (&objfile
->objfile_obstack
, size
));
894 memcpy (objfile
->section_offsets
, offsets
, size
);
896 init_objfile_sect_indices (objfile
);
899 #ifndef DEPRECATED_IBM6000_TARGET
900 /* This is a SVR4/SunOS specific hack, I think. In any event, it
901 screws RS/6000. sym_offsets should be doing this sort of thing,
902 because it knows the mapping between bfd sections and
904 /* This is a hack. As far as I can tell, section offsets are not
905 target dependent. They are all set to addr with a couple of
906 exceptions. The exceptions are sysvr4 shared libraries, whose
907 offsets are kept in solib structures anyway and rs6000 xcoff
908 which handles shared libraries in a completely unique way.
910 Section offsets are built similarly, except that they are built
911 by adding addr in all cases because there is no clear mapping
912 from section_offsets into actual sections. Note that solib.c
913 has a different algorithm for finding section offsets.
915 These should probably all be collapsed into some target
916 independent form of shared library support. FIXME. */
920 struct obj_section
*s
;
922 /* Map section offsets in "addr" back to the object's
923 sections by comparing the section names with bfd's
924 section names. Then adjust the section address by
925 the offset. */ /* for gdb/13815 */
927 ALL_OBJFILE_OSECTIONS (objfile
, s
)
929 CORE_ADDR s_addr
= 0;
933 !s_addr
&& i
< addrs
->num_sections
&& addrs
->other
[i
].name
;
935 if (strcmp (bfd_section_name (s
->objfile
->obfd
,
937 addrs
->other
[i
].name
) == 0)
938 s_addr
= addrs
->other
[i
].addr
; /* end added for gdb/13815 */
940 s
->addr
-= s
->offset
;
942 s
->endaddr
-= s
->offset
;
943 s
->endaddr
+= s_addr
;
947 #endif /* not DEPRECATED_IBM6000_TARGET */
949 (*objfile
->sf
->sym_read
) (objfile
, mainline
);
951 /* Don't allow char * to have a typename (else would get caddr_t).
952 Ditto void *. FIXME: Check whether this is now done by all the
953 symbol readers themselves (many of them now do), and if so remove
956 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
957 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
959 /* Mark the objfile has having had initial symbol read attempted. Note
960 that this does not mean we found any symbols... */
962 objfile
->flags
|= OBJF_SYMS
;
964 /* Discard cleanups as symbol reading was successful. */
966 discard_cleanups (old_chain
);
969 /* Perform required actions after either reading in the initial
970 symbols for a new objfile, or mapping in the symbols from a reusable
974 new_symfile_objfile (struct objfile
*objfile
, int mainline
, int verbo
)
977 /* If this is the main symbol file we have to clean up all users of the
978 old main symbol file. Otherwise it is sufficient to fixup all the
979 breakpoints that may have been redefined by this symbol file. */
982 /* OK, make it the "real" symbol file. */
983 symfile_objfile
= objfile
;
985 clear_symtab_users ();
989 breakpoint_re_set ();
992 /* We're done reading the symbol file; finish off complaints. */
993 clear_complaints (&symfile_complaints
, 0, verbo
);
996 /* Process a symbol file, as either the main file or as a dynamically
999 ABFD is a BFD already open on the file, as from symfile_bfd_open.
1000 This BFD will be closed on error, and is always consumed by this function.
1002 FROM_TTY says how verbose to be.
1004 MAINLINE specifies whether this is the main symbol file, or whether
1005 it's an extra symbol file such as dynamically loaded code.
1007 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
1008 syms_from_objfile, above. ADDRS is ignored when MAINLINE is
1011 Upon success, returns a pointer to the objfile that was added.
1012 Upon failure, jumps back to command level (never returns). */
1013 static struct objfile
*
1014 symbol_file_add_with_addrs_or_offsets (bfd
*abfd
, int from_tty
,
1015 struct section_addr_info
*addrs
,
1016 struct section_offsets
*offsets
,
1018 int mainline
, int flags
)
1020 struct objfile
*objfile
;
1021 struct partial_symtab
*psymtab
;
1023 struct section_addr_info
*orig_addrs
= NULL
;
1024 struct cleanup
*my_cleanups
;
1025 const char *name
= bfd_get_filename (abfd
);
1027 my_cleanups
= make_cleanup_bfd_close (abfd
);
1029 /* Give user a chance to burp if we'd be
1030 interactively wiping out any existing symbols. */
1032 if ((have_full_symbols () || have_partial_symbols ())
1035 && !query ("Load new symbol table from \"%s\"? ", name
))
1036 error (_("Not confirmed."));
1038 objfile
= allocate_objfile (abfd
, flags
);
1039 discard_cleanups (my_cleanups
);
1043 orig_addrs
= copy_section_addr_info (addrs
);
1044 make_cleanup_free_section_addr_info (orig_addrs
);
1047 /* We either created a new mapped symbol table, mapped an existing
1048 symbol table file which has not had initial symbol reading
1049 performed, or need to read an unmapped symbol table. */
1050 if (from_tty
|| info_verbose
)
1052 if (deprecated_pre_add_symbol_hook
)
1053 deprecated_pre_add_symbol_hook (name
);
1056 printf_unfiltered (_("Reading symbols from %s..."), name
);
1058 gdb_flush (gdb_stdout
);
1061 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
1062 mainline
, from_tty
);
1064 /* We now have at least a partial symbol table. Check to see if the
1065 user requested that all symbols be read on initial access via either
1066 the gdb startup command line or on a per symbol file basis. Expand
1067 all partial symbol tables for this objfile if so. */
1069 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
1071 if (from_tty
|| info_verbose
)
1073 printf_unfiltered (_("expanding to full symbols..."));
1075 gdb_flush (gdb_stdout
);
1078 for (psymtab
= objfile
->psymtabs
;
1080 psymtab
= psymtab
->next
)
1082 psymtab_to_symtab (psymtab
);
1086 debugfile
= find_separate_debug_file (objfile
);
1091 objfile
->separate_debug_objfile
1092 = symbol_file_add (debugfile
, from_tty
, orig_addrs
, 0, flags
);
1096 objfile
->separate_debug_objfile
1097 = symbol_file_add (debugfile
, from_tty
, NULL
, 0, flags
);
1099 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
1102 /* Put the separate debug object before the normal one, this is so that
1103 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
1104 put_objfile_before (objfile
->separate_debug_objfile
, objfile
);
1109 if (!have_partial_symbols () && !have_full_symbols ())
1112 printf_filtered (_("(no debugging symbols found)"));
1113 if (from_tty
|| info_verbose
)
1114 printf_filtered ("...");
1116 printf_filtered ("\n");
1120 if (from_tty
|| info_verbose
)
1122 if (deprecated_post_add_symbol_hook
)
1123 deprecated_post_add_symbol_hook ();
1126 printf_unfiltered (_("done.\n"));
1130 /* We print some messages regardless of whether 'from_tty ||
1131 info_verbose' is true, so make sure they go out at the right
1133 gdb_flush (gdb_stdout
);
1135 do_cleanups (my_cleanups
);
1137 if (objfile
->sf
== NULL
)
1138 return objfile
; /* No symbols. */
1140 new_symfile_objfile (objfile
, mainline
, from_tty
);
1142 observer_notify_new_objfile (objfile
);
1144 bfd_cache_close_all ();
1149 /* Process the symbol file ABFD, as either the main file or as a
1150 dynamically loaded file.
1152 See symbol_file_add_with_addrs_or_offsets's comments for
1155 symbol_file_add_from_bfd (bfd
*abfd
, int from_tty
,
1156 struct section_addr_info
*addrs
,
1157 int mainline
, int flags
)
1159 return symbol_file_add_with_addrs_or_offsets (abfd
,
1160 from_tty
, addrs
, 0, 0,
1165 /* Process a symbol file, as either the main file or as a dynamically
1166 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1169 symbol_file_add (char *name
, int from_tty
, struct section_addr_info
*addrs
,
1170 int mainline
, int flags
)
1172 return symbol_file_add_from_bfd (symfile_bfd_open (name
), from_tty
,
1173 addrs
, mainline
, flags
);
1177 /* Call symbol_file_add() with default values and update whatever is
1178 affected by the loading of a new main().
1179 Used when the file is supplied in the gdb command line
1180 and by some targets with special loading requirements.
1181 The auxiliary function, symbol_file_add_main_1(), has the flags
1182 argument for the switches that can only be specified in the symbol_file
1186 symbol_file_add_main (char *args
, int from_tty
)
1188 symbol_file_add_main_1 (args
, from_tty
, 0);
1192 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1194 symbol_file_add (args
, from_tty
, NULL
, 1, flags
);
1196 /* Getting new symbols may change our opinion about
1197 what is frameless. */
1198 reinit_frame_cache ();
1200 set_initial_language ();
1204 symbol_file_clear (int from_tty
)
1206 if ((have_full_symbols () || have_partial_symbols ())
1209 ? !query (_("Discard symbol table from `%s'? "),
1210 symfile_objfile
->name
)
1211 : !query (_("Discard symbol table? "))))
1212 error (_("Not confirmed."));
1213 free_all_objfiles ();
1215 /* solib descriptors may have handles to objfiles. Since their
1216 storage has just been released, we'd better wipe the solib
1217 descriptors as well.
1219 #if defined(SOLIB_RESTART)
1223 symfile_objfile
= NULL
;
1225 printf_unfiltered (_("No symbol file now.\n"));
1229 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1232 bfd_size_type debuglink_size
;
1233 unsigned long crc32
;
1238 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1243 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1245 contents
= xmalloc (debuglink_size
);
1246 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1247 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1249 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1250 crc_offset
= strlen (contents
) + 1;
1251 crc_offset
= (crc_offset
+ 3) & ~3;
1253 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1260 separate_debug_file_exists (const char *name
, unsigned long crc
)
1262 unsigned long file_crc
= 0;
1264 gdb_byte buffer
[8*1024];
1267 fd
= open (name
, O_RDONLY
| O_BINARY
);
1271 while ((count
= read (fd
, buffer
, sizeof (buffer
))) > 0)
1272 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1276 return crc
== file_crc
;
1279 char *debug_file_directory
= NULL
;
1281 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1282 struct cmd_list_element
*c
, const char *value
)
1284 fprintf_filtered (file
, _("\
1285 The directory where separate debug symbols are searched for is \"%s\".\n"),
1289 #if ! defined (DEBUG_SUBDIRECTORY)
1290 #define DEBUG_SUBDIRECTORY ".debug"
1294 find_separate_debug_file (struct objfile
*objfile
)
1302 bfd_size_type debuglink_size
;
1303 unsigned long crc32
;
1306 basename
= get_debug_link_info (objfile
, &crc32
);
1308 if (basename
== NULL
)
1311 dir
= xstrdup (objfile
->name
);
1313 /* Strip off the final filename part, leaving the directory name,
1314 followed by a slash. Objfile names should always be absolute and
1315 tilde-expanded, so there should always be a slash in there
1317 for (i
= strlen(dir
) - 1; i
>= 0; i
--)
1319 if (IS_DIR_SEPARATOR (dir
[i
]))
1322 gdb_assert (i
>= 0 && IS_DIR_SEPARATOR (dir
[i
]));
1325 debugfile
= alloca (strlen (debug_file_directory
) + 1
1327 + strlen (DEBUG_SUBDIRECTORY
)
1332 /* First try in the same directory as the original file. */
1333 strcpy (debugfile
, dir
);
1334 strcat (debugfile
, basename
);
1336 if (separate_debug_file_exists (debugfile
, crc32
))
1340 return xstrdup (debugfile
);
1343 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1344 strcpy (debugfile
, dir
);
1345 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1346 strcat (debugfile
, "/");
1347 strcat (debugfile
, basename
);
1349 if (separate_debug_file_exists (debugfile
, crc32
))
1353 return xstrdup (debugfile
);
1356 /* Then try in the global debugfile directory. */
1357 strcpy (debugfile
, debug_file_directory
);
1358 strcat (debugfile
, "/");
1359 strcat (debugfile
, dir
);
1360 strcat (debugfile
, basename
);
1362 if (separate_debug_file_exists (debugfile
, crc32
))
1366 return xstrdup (debugfile
);
1369 /* If the file is in the sysroot, try using its base path in the
1370 global debugfile directory. */
1371 canon_name
= lrealpath (dir
);
1373 && strncmp (canon_name
, gdb_sysroot
, strlen (gdb_sysroot
)) == 0
1374 && IS_DIR_SEPARATOR (canon_name
[strlen (gdb_sysroot
)]))
1376 strcpy (debugfile
, debug_file_directory
);
1377 strcat (debugfile
, canon_name
+ strlen (gdb_sysroot
));
1378 strcat (debugfile
, "/");
1379 strcat (debugfile
, basename
);
1381 if (separate_debug_file_exists (debugfile
, crc32
))
1386 return xstrdup (debugfile
);
1399 /* This is the symbol-file command. Read the file, analyze its
1400 symbols, and add a struct symtab to a symtab list. The syntax of
1401 the command is rather bizarre:
1403 1. The function buildargv implements various quoting conventions
1404 which are undocumented and have little or nothing in common with
1405 the way things are quoted (or not quoted) elsewhere in GDB.
1407 2. Options are used, which are not generally used in GDB (perhaps
1408 "set mapped on", "set readnow on" would be better)
1410 3. The order of options matters, which is contrary to GNU
1411 conventions (because it is confusing and inconvenient). */
1414 symbol_file_command (char *args
, int from_tty
)
1420 symbol_file_clear (from_tty
);
1424 char **argv
= buildargv (args
);
1425 int flags
= OBJF_USERLOADED
;
1426 struct cleanup
*cleanups
;
1432 cleanups
= make_cleanup_freeargv (argv
);
1433 while (*argv
!= NULL
)
1435 if (strcmp (*argv
, "-readnow") == 0)
1436 flags
|= OBJF_READNOW
;
1437 else if (**argv
== '-')
1438 error (_("unknown option `%s'"), *argv
);
1441 symbol_file_add_main_1 (*argv
, from_tty
, flags
);
1449 error (_("no symbol file name was specified"));
1451 do_cleanups (cleanups
);
1455 /* Set the initial language.
1457 FIXME: A better solution would be to record the language in the
1458 psymtab when reading partial symbols, and then use it (if known) to
1459 set the language. This would be a win for formats that encode the
1460 language in an easily discoverable place, such as DWARF. For
1461 stabs, we can jump through hoops looking for specially named
1462 symbols or try to intuit the language from the specific type of
1463 stabs we find, but we can't do that until later when we read in
1467 set_initial_language (void)
1469 struct partial_symtab
*pst
;
1470 enum language lang
= language_unknown
;
1472 pst
= find_main_psymtab ();
1475 if (pst
->filename
!= NULL
)
1476 lang
= deduce_language_from_filename (pst
->filename
);
1478 if (lang
== language_unknown
)
1480 /* Make C the default language */
1484 set_language (lang
);
1485 expected_language
= current_language
; /* Don't warn the user. */
1489 /* Open the file specified by NAME and hand it off to BFD for
1490 preliminary analysis. Return a newly initialized bfd *, which
1491 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1492 absolute). In case of trouble, error() is called. */
1495 symfile_bfd_open (char *name
)
1499 char *absolute_name
;
1501 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy. */
1503 /* Look down path for it, allocate 2nd new malloc'd copy. */
1504 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, name
,
1505 O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1506 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1509 char *exename
= alloca (strlen (name
) + 5);
1510 strcat (strcpy (exename
, name
), ".exe");
1511 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
1512 O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1517 make_cleanup (xfree
, name
);
1518 perror_with_name (name
);
1521 /* Free 1st new malloc'd copy, but keep the 2nd malloc'd copy in
1522 bfd. It'll be freed in free_objfile(). */
1524 name
= absolute_name
;
1526 sym_bfd
= bfd_fopen (name
, gnutarget
, FOPEN_RB
, desc
);
1530 make_cleanup (xfree
, name
);
1531 error (_("\"%s\": can't open to read symbols: %s."), name
,
1532 bfd_errmsg (bfd_get_error ()));
1534 bfd_set_cacheable (sym_bfd
, 1);
1536 if (!bfd_check_format (sym_bfd
, bfd_object
))
1538 /* FIXME: should be checking for errors from bfd_close (for one
1539 thing, on error it does not free all the storage associated
1541 bfd_close (sym_bfd
); /* This also closes desc. */
1542 make_cleanup (xfree
, name
);
1543 error (_("\"%s\": can't read symbols: %s."), name
,
1544 bfd_errmsg (bfd_get_error ()));
1550 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1551 the section was not found. */
1554 get_section_index (struct objfile
*objfile
, char *section_name
)
1556 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1564 /* Link SF into the global symtab_fns list. Called on startup by the
1565 _initialize routine in each object file format reader, to register
1566 information about each format the the reader is prepared to
1570 add_symtab_fns (struct sym_fns
*sf
)
1572 sf
->next
= symtab_fns
;
1576 /* Initialize OBJFILE to read symbols from its associated BFD. It
1577 either returns or calls error(). The result is an initialized
1578 struct sym_fns in the objfile structure, that contains cached
1579 information about the symbol file. */
1581 static struct sym_fns
*
1582 find_sym_fns (bfd
*abfd
)
1585 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1587 if (our_flavour
== bfd_target_srec_flavour
1588 || our_flavour
== bfd_target_ihex_flavour
1589 || our_flavour
== bfd_target_tekhex_flavour
)
1590 return NULL
; /* No symbols. */
1592 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1593 if (our_flavour
== sf
->sym_flavour
)
1596 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1597 bfd_get_target (abfd
));
1601 /* This function runs the load command of our current target. */
1604 load_command (char *arg
, int from_tty
)
1611 parg
= arg
= get_exec_file (1);
1613 /* Count how many \ " ' tab space there are in the name. */
1614 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1622 /* We need to quote this string so buildargv can pull it apart. */
1623 char *temp
= xmalloc (strlen (arg
) + count
+ 1 );
1627 make_cleanup (xfree
, temp
);
1630 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1632 strncpy (ptemp
, prev
, parg
- prev
);
1633 ptemp
+= parg
- prev
;
1637 strcpy (ptemp
, prev
);
1643 /* The user might be reloading because the binary has changed. Take
1644 this opportunity to check. */
1645 reopen_exec_file ();
1648 target_load (arg
, from_tty
);
1650 /* After re-loading the executable, we don't really know which
1651 overlays are mapped any more. */
1652 overlay_cache_invalid
= 1;
1655 /* This version of "load" should be usable for any target. Currently
1656 it is just used for remote targets, not inftarg.c or core files,
1657 on the theory that only in that case is it useful.
1659 Avoiding xmodem and the like seems like a win (a) because we don't have
1660 to worry about finding it, and (b) On VMS, fork() is very slow and so
1661 we don't want to run a subprocess. On the other hand, I'm not sure how
1662 performance compares. */
1664 static int validate_download
= 0;
1666 /* Callback service function for generic_load (bfd_map_over_sections). */
1669 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1671 bfd_size_type
*sum
= data
;
1673 *sum
+= bfd_get_section_size (asec
);
1676 /* Opaque data for load_section_callback. */
1677 struct load_section_data
{
1678 unsigned long load_offset
;
1679 struct load_progress_data
*progress_data
;
1680 VEC(memory_write_request_s
) *requests
;
1683 /* Opaque data for load_progress. */
1684 struct load_progress_data
{
1685 /* Cumulative data. */
1686 unsigned long write_count
;
1687 unsigned long data_count
;
1688 bfd_size_type total_size
;
1691 /* Opaque data for load_progress for a single section. */
1692 struct load_progress_section_data
{
1693 struct load_progress_data
*cumulative
;
1695 /* Per-section data. */
1696 const char *section_name
;
1697 ULONGEST section_sent
;
1698 ULONGEST section_size
;
1703 /* Target write callback routine for progress reporting. */
1706 load_progress (ULONGEST bytes
, void *untyped_arg
)
1708 struct load_progress_section_data
*args
= untyped_arg
;
1709 struct load_progress_data
*totals
;
1712 /* Writing padding data. No easy way to get at the cumulative
1713 stats, so just ignore this. */
1716 totals
= args
->cumulative
;
1718 if (bytes
== 0 && args
->section_sent
== 0)
1720 /* The write is just starting. Let the user know we've started
1722 ui_out_message (uiout
, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1723 args
->section_name
, paddr_nz (args
->section_size
),
1724 paddr_nz (args
->lma
));
1728 if (validate_download
)
1730 /* Broken memories and broken monitors manifest themselves here
1731 when bring new computers to life. This doubles already slow
1733 /* NOTE: cagney/1999-10-18: A more efficient implementation
1734 might add a verify_memory() method to the target vector and
1735 then use that. remote.c could implement that method using
1736 the ``qCRC'' packet. */
1737 gdb_byte
*check
= xmalloc (bytes
);
1738 struct cleanup
*verify_cleanups
= make_cleanup (xfree
, check
);
1740 if (target_read_memory (args
->lma
, check
, bytes
) != 0)
1741 error (_("Download verify read failed at 0x%s"),
1743 if (memcmp (args
->buffer
, check
, bytes
) != 0)
1744 error (_("Download verify compare failed at 0x%s"),
1746 do_cleanups (verify_cleanups
);
1748 totals
->data_count
+= bytes
;
1750 args
->buffer
+= bytes
;
1751 totals
->write_count
+= 1;
1752 args
->section_sent
+= bytes
;
1754 || (deprecated_ui_load_progress_hook
!= NULL
1755 && deprecated_ui_load_progress_hook (args
->section_name
,
1756 args
->section_sent
)))
1757 error (_("Canceled the download"));
1759 if (deprecated_show_load_progress
!= NULL
)
1760 deprecated_show_load_progress (args
->section_name
,
1764 totals
->total_size
);
1767 /* Callback service function for generic_load (bfd_map_over_sections). */
1770 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1772 struct memory_write_request
*new_request
;
1773 struct load_section_data
*args
= data
;
1774 struct load_progress_section_data
*section_data
;
1775 bfd_size_type size
= bfd_get_section_size (asec
);
1777 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1779 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1785 new_request
= VEC_safe_push (memory_write_request_s
,
1786 args
->requests
, NULL
);
1787 memset (new_request
, 0, sizeof (struct memory_write_request
));
1788 section_data
= xcalloc (1, sizeof (struct load_progress_section_data
));
1789 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1790 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size be in instead? */
1791 new_request
->data
= xmalloc (size
);
1792 new_request
->baton
= section_data
;
1794 buffer
= new_request
->data
;
1796 section_data
->cumulative
= args
->progress_data
;
1797 section_data
->section_name
= sect_name
;
1798 section_data
->section_size
= size
;
1799 section_data
->lma
= new_request
->begin
;
1800 section_data
->buffer
= buffer
;
1802 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1805 /* Clean up an entire memory request vector, including load
1806 data and progress records. */
1809 clear_memory_write_data (void *arg
)
1811 VEC(memory_write_request_s
) **vec_p
= arg
;
1812 VEC(memory_write_request_s
) *vec
= *vec_p
;
1814 struct memory_write_request
*mr
;
1816 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
1821 VEC_free (memory_write_request_s
, vec
);
1825 generic_load (char *args
, int from_tty
)
1828 struct timeval start_time
, end_time
;
1830 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, 0);
1831 struct load_section_data cbdata
;
1832 struct load_progress_data total_progress
;
1837 memset (&cbdata
, 0, sizeof (cbdata
));
1838 memset (&total_progress
, 0, sizeof (total_progress
));
1839 cbdata
.progress_data
= &total_progress
;
1841 make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
1843 argv
= buildargv (args
);
1848 make_cleanup_freeargv (argv
);
1850 filename
= tilde_expand (argv
[0]);
1851 make_cleanup (xfree
, filename
);
1853 if (argv
[1] != NULL
)
1857 cbdata
.load_offset
= strtoul (argv
[1], &endptr
, 0);
1859 /* If the last word was not a valid number then
1860 treat it as a file name with spaces in. */
1861 if (argv
[1] == endptr
)
1862 error (_("Invalid download offset:%s."), argv
[1]);
1864 if (argv
[2] != NULL
)
1865 error (_("Too many parameters."));
1868 /* Open the file for loading. */
1869 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1870 if (loadfile_bfd
== NULL
)
1872 perror_with_name (filename
);
1876 /* FIXME: should be checking for errors from bfd_close (for one thing,
1877 on error it does not free all the storage associated with the
1879 make_cleanup_bfd_close (loadfile_bfd
);
1881 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1883 error (_("\"%s\" is not an object file: %s"), filename
,
1884 bfd_errmsg (bfd_get_error ()));
1887 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1888 (void *) &total_progress
.total_size
);
1890 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1892 gettimeofday (&start_time
, NULL
);
1894 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
1895 load_progress
) != 0)
1896 error (_("Load failed"));
1898 gettimeofday (&end_time
, NULL
);
1900 entry
= bfd_get_start_address (loadfile_bfd
);
1901 ui_out_text (uiout
, "Start address ");
1902 ui_out_field_fmt (uiout
, "address", "0x%s", paddr_nz (entry
));
1903 ui_out_text (uiout
, ", load size ");
1904 ui_out_field_fmt (uiout
, "load-size", "%lu", total_progress
.data_count
);
1905 ui_out_text (uiout
, "\n");
1906 /* We were doing this in remote-mips.c, I suspect it is right
1907 for other targets too. */
1910 /* FIXME: are we supposed to call symbol_file_add or not? According
1911 to a comment from remote-mips.c (where a call to symbol_file_add
1912 was commented out), making the call confuses GDB if more than one
1913 file is loaded in. Some targets do (e.g., remote-vx.c) but
1914 others don't (or didn't - perhaps they have all been deleted). */
1916 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
1917 total_progress
.write_count
,
1918 &start_time
, &end_time
);
1920 do_cleanups (old_cleanups
);
1923 /* Report how fast the transfer went. */
1925 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1926 replaced by print_transfer_performance (with a very different
1927 function signature). */
1930 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1933 struct timeval start
, end
;
1935 start
.tv_sec
= start_time
;
1937 end
.tv_sec
= end_time
;
1940 print_transfer_performance (gdb_stdout
, data_count
, 0, &start
, &end
);
1944 print_transfer_performance (struct ui_file
*stream
,
1945 unsigned long data_count
,
1946 unsigned long write_count
,
1947 const struct timeval
*start_time
,
1948 const struct timeval
*end_time
)
1950 ULONGEST time_count
;
1952 /* Compute the elapsed time in milliseconds, as a tradeoff between
1953 accuracy and overflow. */
1954 time_count
= (end_time
->tv_sec
- start_time
->tv_sec
) * 1000;
1955 time_count
+= (end_time
->tv_usec
- start_time
->tv_usec
) / 1000;
1957 ui_out_text (uiout
, "Transfer rate: ");
1960 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / time_count
;
1962 if (ui_out_is_mi_like_p (uiout
))
1964 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
* 8);
1965 ui_out_text (uiout
, " bits/sec");
1967 else if (rate
< 1024)
1969 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
);
1970 ui_out_text (uiout
, " bytes/sec");
1974 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
/ 1024);
1975 ui_out_text (uiout
, " KB/sec");
1980 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
1981 ui_out_text (uiout
, " bits in <1 sec");
1983 if (write_count
> 0)
1985 ui_out_text (uiout
, ", ");
1986 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
1987 ui_out_text (uiout
, " bytes/write");
1989 ui_out_text (uiout
, ".\n");
1992 /* This function allows the addition of incrementally linked object files.
1993 It does not modify any state in the target, only in the debugger. */
1994 /* Note: ezannoni 2000-04-13 This function/command used to have a
1995 special case syntax for the rombug target (Rombug is the boot
1996 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1997 rombug case, the user doesn't need to supply a text address,
1998 instead a call to target_link() (in target.c) would supply the
1999 value to use. We are now discontinuing this type of ad hoc syntax. */
2002 add_symbol_file_command (char *args
, int from_tty
)
2004 char *filename
= NULL
;
2005 int flags
= OBJF_USERLOADED
;
2007 int expecting_option
= 0;
2008 int section_index
= 0;
2012 int expecting_sec_name
= 0;
2013 int expecting_sec_addr
= 0;
2022 struct section_addr_info
*section_addrs
;
2023 struct sect_opt
*sect_opts
= NULL
;
2024 size_t num_sect_opts
= 0;
2025 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2028 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
2029 * sizeof (struct sect_opt
));
2034 error (_("add-symbol-file takes a file name and an address"));
2036 argv
= buildargv (args
);
2037 make_cleanup_freeargv (argv
);
2042 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2044 /* Process the argument. */
2047 /* The first argument is the file name. */
2048 filename
= tilde_expand (arg
);
2049 make_cleanup (xfree
, filename
);
2054 /* The second argument is always the text address at which
2055 to load the program. */
2056 sect_opts
[section_index
].name
= ".text";
2057 sect_opts
[section_index
].value
= arg
;
2058 if (++section_index
>= num_sect_opts
)
2061 sect_opts
= ((struct sect_opt
*)
2062 xrealloc (sect_opts
,
2064 * sizeof (struct sect_opt
)));
2069 /* It's an option (starting with '-') or it's an argument
2074 if (strcmp (arg
, "-readnow") == 0)
2075 flags
|= OBJF_READNOW
;
2076 else if (strcmp (arg
, "-s") == 0)
2078 expecting_sec_name
= 1;
2079 expecting_sec_addr
= 1;
2084 if (expecting_sec_name
)
2086 sect_opts
[section_index
].name
= arg
;
2087 expecting_sec_name
= 0;
2090 if (expecting_sec_addr
)
2092 sect_opts
[section_index
].value
= arg
;
2093 expecting_sec_addr
= 0;
2094 if (++section_index
>= num_sect_opts
)
2097 sect_opts
= ((struct sect_opt
*)
2098 xrealloc (sect_opts
,
2100 * sizeof (struct sect_opt
)));
2104 error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
2109 /* This command takes at least two arguments. The first one is a
2110 filename, and the second is the address where this file has been
2111 loaded. Abort now if this address hasn't been provided by the
2113 if (section_index
< 1)
2114 error (_("The address where %s has been loaded is missing"), filename
);
2116 /* Print the prompt for the query below. And save the arguments into
2117 a sect_addr_info structure to be passed around to other
2118 functions. We have to split this up into separate print
2119 statements because hex_string returns a local static
2122 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
2123 section_addrs
= alloc_section_addr_info (section_index
);
2124 make_cleanup (xfree
, section_addrs
);
2125 for (i
= 0; i
< section_index
; i
++)
2128 char *val
= sect_opts
[i
].value
;
2129 char *sec
= sect_opts
[i
].name
;
2131 addr
= parse_and_eval_address (val
);
2133 /* Here we store the section offsets in the order they were
2134 entered on the command line. */
2135 section_addrs
->other
[sec_num
].name
= sec
;
2136 section_addrs
->other
[sec_num
].addr
= addr
;
2137 printf_unfiltered ("\t%s_addr = %s\n",
2138 sec
, hex_string ((unsigned long)addr
));
2141 /* The object's sections are initialized when a
2142 call is made to build_objfile_section_table (objfile).
2143 This happens in reread_symbols.
2144 At this point, we don't know what file type this is,
2145 so we can't determine what section names are valid. */
2148 if (from_tty
&& (!query ("%s", "")))
2149 error (_("Not confirmed."));
2151 symbol_file_add (filename
, from_tty
, section_addrs
, 0, flags
);
2153 /* Getting new symbols may change our opinion about what is
2155 reinit_frame_cache ();
2156 do_cleanups (my_cleanups
);
2160 add_shared_symbol_files_command (char *args
, int from_tty
)
2162 #ifdef ADD_SHARED_SYMBOL_FILES
2163 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
2165 error (_("This command is not available in this configuration of GDB."));
2169 /* Re-read symbols if a symbol-file has changed. */
2171 reread_symbols (void)
2173 struct objfile
*objfile
;
2176 struct stat new_statbuf
;
2179 /* With the addition of shared libraries, this should be modified,
2180 the load time should be saved in the partial symbol tables, since
2181 different tables may come from different source files. FIXME.
2182 This routine should then walk down each partial symbol table
2183 and see if the symbol table that it originates from has been changed */
2185 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2189 #ifdef DEPRECATED_IBM6000_TARGET
2190 /* If this object is from a shared library, then you should
2191 stat on the library name, not member name. */
2193 if (objfile
->obfd
->my_archive
)
2194 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2197 res
= stat (objfile
->name
, &new_statbuf
);
2200 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2201 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2205 new_modtime
= new_statbuf
.st_mtime
;
2206 if (new_modtime
!= objfile
->mtime
)
2208 struct cleanup
*old_cleanups
;
2209 struct section_offsets
*offsets
;
2211 char *obfd_filename
;
2213 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2216 /* There are various functions like symbol_file_add,
2217 symfile_bfd_open, syms_from_objfile, etc., which might
2218 appear to do what we want. But they have various other
2219 effects which we *don't* want. So we just do stuff
2220 ourselves. We don't worry about mapped files (for one thing,
2221 any mapped file will be out of date). */
2223 /* If we get an error, blow away this objfile (not sure if
2224 that is the correct response for things like shared
2226 old_cleanups
= make_cleanup_free_objfile (objfile
);
2227 /* We need to do this whenever any symbols go away. */
2228 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2230 /* Clean up any state BFD has sitting around. We don't need
2231 to close the descriptor but BFD lacks a way of closing the
2232 BFD without closing the descriptor. */
2233 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2234 if (!bfd_close (objfile
->obfd
))
2235 error (_("Can't close BFD for %s: %s"), objfile
->name
,
2236 bfd_errmsg (bfd_get_error ()));
2237 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
2238 if (objfile
->obfd
== NULL
)
2239 error (_("Can't open %s to read symbols."), objfile
->name
);
2240 /* bfd_openr sets cacheable to true, which is what we want. */
2241 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2242 error (_("Can't read symbols from %s: %s."), objfile
->name
,
2243 bfd_errmsg (bfd_get_error ()));
2245 /* Save the offsets, we will nuke them with the rest of the
2247 num_offsets
= objfile
->num_sections
;
2248 offsets
= ((struct section_offsets
*)
2249 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2250 memcpy (offsets
, objfile
->section_offsets
,
2251 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2253 /* Remove any references to this objfile in the global
2255 preserve_values (objfile
);
2257 /* Nuke all the state that we will re-read. Much of the following
2258 code which sets things to NULL really is necessary to tell
2259 other parts of GDB that there is nothing currently there. */
2261 /* FIXME: Do we have to free a whole linked list, or is this
2263 if (objfile
->global_psymbols
.list
)
2264 xfree (objfile
->global_psymbols
.list
);
2265 memset (&objfile
->global_psymbols
, 0,
2266 sizeof (objfile
->global_psymbols
));
2267 if (objfile
->static_psymbols
.list
)
2268 xfree (objfile
->static_psymbols
.list
);
2269 memset (&objfile
->static_psymbols
, 0,
2270 sizeof (objfile
->static_psymbols
));
2272 /* Free the obstacks for non-reusable objfiles */
2273 bcache_xfree (objfile
->psymbol_cache
);
2274 objfile
->psymbol_cache
= bcache_xmalloc ();
2275 bcache_xfree (objfile
->macro_cache
);
2276 objfile
->macro_cache
= bcache_xmalloc ();
2277 if (objfile
->demangled_names_hash
!= NULL
)
2279 htab_delete (objfile
->demangled_names_hash
);
2280 objfile
->demangled_names_hash
= NULL
;
2282 obstack_free (&objfile
->objfile_obstack
, 0);
2283 objfile
->sections
= NULL
;
2284 objfile
->symtabs
= NULL
;
2285 objfile
->psymtabs
= NULL
;
2286 objfile
->free_psymtabs
= NULL
;
2287 objfile
->cp_namespace_symtab
= NULL
;
2288 objfile
->msymbols
= NULL
;
2289 objfile
->deprecated_sym_private
= NULL
;
2290 objfile
->minimal_symbol_count
= 0;
2291 memset (&objfile
->msymbol_hash
, 0,
2292 sizeof (objfile
->msymbol_hash
));
2293 memset (&objfile
->msymbol_demangled_hash
, 0,
2294 sizeof (objfile
->msymbol_demangled_hash
));
2295 objfile
->fundamental_types
= NULL
;
2296 clear_objfile_data (objfile
);
2297 if (objfile
->sf
!= NULL
)
2299 (*objfile
->sf
->sym_finish
) (objfile
);
2302 /* We never make this a mapped file. */
2304 objfile
->psymbol_cache
= bcache_xmalloc ();
2305 objfile
->macro_cache
= bcache_xmalloc ();
2306 /* obstack_init also initializes the obstack so it is
2307 empty. We could use obstack_specify_allocation but
2308 gdb_obstack.h specifies the alloc/dealloc
2310 obstack_init (&objfile
->objfile_obstack
);
2311 if (build_objfile_section_table (objfile
))
2313 error (_("Can't find the file sections in `%s': %s"),
2314 objfile
->name
, bfd_errmsg (bfd_get_error ()));
2316 terminate_minimal_symbol_table (objfile
);
2318 /* We use the same section offsets as from last time. I'm not
2319 sure whether that is always correct for shared libraries. */
2320 objfile
->section_offsets
= (struct section_offsets
*)
2321 obstack_alloc (&objfile
->objfile_obstack
,
2322 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2323 memcpy (objfile
->section_offsets
, offsets
,
2324 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2325 objfile
->num_sections
= num_offsets
;
2327 /* What the hell is sym_new_init for, anyway? The concept of
2328 distinguishing between the main file and additional files
2329 in this way seems rather dubious. */
2330 if (objfile
== symfile_objfile
)
2332 (*objfile
->sf
->sym_new_init
) (objfile
);
2335 (*objfile
->sf
->sym_init
) (objfile
);
2336 clear_complaints (&symfile_complaints
, 1, 1);
2337 /* The "mainline" parameter is a hideous hack; I think leaving it
2338 zero is OK since dbxread.c also does what it needs to do if
2339 objfile->global_psymbols.size is 0. */
2340 (*objfile
->sf
->sym_read
) (objfile
, 0);
2341 if (!have_partial_symbols () && !have_full_symbols ())
2344 printf_unfiltered (_("(no debugging symbols found)\n"));
2347 objfile
->flags
|= OBJF_SYMS
;
2349 /* We're done reading the symbol file; finish off complaints. */
2350 clear_complaints (&symfile_complaints
, 0, 1);
2352 /* Getting new symbols may change our opinion about what is
2355 reinit_frame_cache ();
2357 /* Discard cleanups as symbol reading was successful. */
2358 discard_cleanups (old_cleanups
);
2360 /* If the mtime has changed between the time we set new_modtime
2361 and now, we *want* this to be out of date, so don't call stat
2363 objfile
->mtime
= new_modtime
;
2365 reread_separate_symbols (objfile
);
2372 clear_symtab_users ();
2373 /* At least one objfile has changed, so we can consider that
2374 the executable we're debugging has changed too. */
2375 observer_notify_executable_changed (NULL
);
2381 /* Handle separate debug info for OBJFILE, which has just been
2383 - If we had separate debug info before, but now we don't, get rid
2384 of the separated objfile.
2385 - If we didn't have separated debug info before, but now we do,
2386 read in the new separated debug info file.
2387 - If the debug link points to a different file, toss the old one
2388 and read the new one.
2389 This function does *not* handle the case where objfile is still
2390 using the same separate debug info file, but that file's timestamp
2391 has changed. That case should be handled by the loop in
2392 reread_symbols already. */
2394 reread_separate_symbols (struct objfile
*objfile
)
2397 unsigned long crc32
;
2399 /* Does the updated objfile's debug info live in a
2401 debug_file
= find_separate_debug_file (objfile
);
2403 if (objfile
->separate_debug_objfile
)
2405 /* There are two cases where we need to get rid of
2406 the old separated debug info objfile:
2407 - if the new primary objfile doesn't have
2408 separated debug info, or
2409 - if the new primary objfile has separate debug
2410 info, but it's under a different filename.
2412 If the old and new objfiles both have separate
2413 debug info, under the same filename, then we're
2414 okay --- if the separated file's contents have
2415 changed, we will have caught that when we
2416 visited it in this function's outermost
2419 || strcmp (debug_file
, objfile
->separate_debug_objfile
->name
) != 0)
2420 free_objfile (objfile
->separate_debug_objfile
);
2423 /* If the new objfile has separate debug info, and we
2424 haven't loaded it already, do so now. */
2426 && ! objfile
->separate_debug_objfile
)
2428 /* Use the same section offset table as objfile itself.
2429 Preserve the flags from objfile that make sense. */
2430 objfile
->separate_debug_objfile
2431 = (symbol_file_add_with_addrs_or_offsets
2432 (symfile_bfd_open (debug_file
),
2433 info_verbose
, /* from_tty: Don't override the default. */
2434 0, /* No addr table. */
2435 objfile
->section_offsets
, objfile
->num_sections
,
2436 0, /* Not mainline. See comments about this above. */
2437 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
2438 | OBJF_USERLOADED
)));
2439 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
);