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
2457 static filename_language
*filename_language_table
;
2458 static int fl_table_size
, fl_table_next
;
2461 add_filename_language (char *ext
, enum language lang
)
2463 if (fl_table_next
>= fl_table_size
)
2465 fl_table_size
+= 10;
2466 filename_language_table
=
2467 xrealloc (filename_language_table
,
2468 fl_table_size
* sizeof (*filename_language_table
));
2471 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2472 filename_language_table
[fl_table_next
].lang
= lang
;
2476 static char *ext_args
;
2478 show_ext_args (struct ui_file
*file
, int from_tty
,
2479 struct cmd_list_element
*c
, const char *value
)
2481 fprintf_filtered (file
, _("\
2482 Mapping between filename extension and source language is \"%s\".\n"),
2487 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2490 char *cp
= ext_args
;
2493 /* First arg is filename extension, starting with '.' */
2495 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2497 /* Find end of first arg. */
2498 while (*cp
&& !isspace (*cp
))
2502 error (_("'%s': two arguments required -- filename extension and language"),
2505 /* Null-terminate first arg */
2508 /* Find beginning of second arg, which should be a source language. */
2509 while (*cp
&& isspace (*cp
))
2513 error (_("'%s': two arguments required -- filename extension and language"),
2516 /* Lookup the language from among those we know. */
2517 lang
= language_enum (cp
);
2519 /* Now lookup the filename extension: do we already know it? */
2520 for (i
= 0; i
< fl_table_next
; i
++)
2521 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2524 if (i
>= fl_table_next
)
2526 /* new file extension */
2527 add_filename_language (ext_args
, lang
);
2531 /* redefining a previously known filename extension */
2534 /* query ("Really make files of type %s '%s'?", */
2535 /* ext_args, language_str (lang)); */
2537 xfree (filename_language_table
[i
].ext
);
2538 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2539 filename_language_table
[i
].lang
= lang
;
2544 info_ext_lang_command (char *args
, int from_tty
)
2548 printf_filtered (_("Filename extensions and the languages they represent:"));
2549 printf_filtered ("\n\n");
2550 for (i
= 0; i
< fl_table_next
; i
++)
2551 printf_filtered ("\t%s\t- %s\n",
2552 filename_language_table
[i
].ext
,
2553 language_str (filename_language_table
[i
].lang
));
2557 init_filename_language_table (void)
2559 if (fl_table_size
== 0) /* protect against repetition */
2563 filename_language_table
=
2564 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2565 add_filename_language (".c", language_c
);
2566 add_filename_language (".C", language_cplus
);
2567 add_filename_language (".cc", language_cplus
);
2568 add_filename_language (".cp", language_cplus
);
2569 add_filename_language (".cpp", language_cplus
);
2570 add_filename_language (".cxx", language_cplus
);
2571 add_filename_language (".c++", language_cplus
);
2572 add_filename_language (".java", language_java
);
2573 add_filename_language (".class", language_java
);
2574 add_filename_language (".m", language_objc
);
2575 add_filename_language (".f", language_fortran
);
2576 add_filename_language (".F", language_fortran
);
2577 add_filename_language (".s", language_asm
);
2578 add_filename_language (".S", language_asm
);
2579 add_filename_language (".pas", language_pascal
);
2580 add_filename_language (".p", language_pascal
);
2581 add_filename_language (".pp", language_pascal
);
2582 add_filename_language (".adb", language_ada
);
2583 add_filename_language (".ads", language_ada
);
2584 add_filename_language (".a", language_ada
);
2585 add_filename_language (".ada", language_ada
);
2590 deduce_language_from_filename (char *filename
)
2595 if (filename
!= NULL
)
2596 if ((cp
= strrchr (filename
, '.')) != NULL
)
2597 for (i
= 0; i
< fl_table_next
; i
++)
2598 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2599 return filename_language_table
[i
].lang
;
2601 return language_unknown
;
2606 Allocate and partly initialize a new symbol table. Return a pointer
2607 to it. error() if no space.
2609 Caller must set these fields:
2615 possibly free_named_symtabs (symtab->filename);
2619 allocate_symtab (char *filename
, struct objfile
*objfile
)
2621 struct symtab
*symtab
;
2623 symtab
= (struct symtab
*)
2624 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2625 memset (symtab
, 0, sizeof (*symtab
));
2626 symtab
->filename
= obsavestring (filename
, strlen (filename
),
2627 &objfile
->objfile_obstack
);
2628 symtab
->fullname
= NULL
;
2629 symtab
->language
= deduce_language_from_filename (filename
);
2630 symtab
->debugformat
= obsavestring ("unknown", 7,
2631 &objfile
->objfile_obstack
);
2633 /* Hook it to the objfile it comes from */
2635 symtab
->objfile
= objfile
;
2636 symtab
->next
= objfile
->symtabs
;
2637 objfile
->symtabs
= symtab
;
2642 struct partial_symtab
*
2643 allocate_psymtab (char *filename
, struct objfile
*objfile
)
2645 struct partial_symtab
*psymtab
;
2647 if (objfile
->free_psymtabs
)
2649 psymtab
= objfile
->free_psymtabs
;
2650 objfile
->free_psymtabs
= psymtab
->next
;
2653 psymtab
= (struct partial_symtab
*)
2654 obstack_alloc (&objfile
->objfile_obstack
,
2655 sizeof (struct partial_symtab
));
2657 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2658 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
2659 &objfile
->objfile_obstack
);
2660 psymtab
->symtab
= NULL
;
2662 /* Prepend it to the psymtab list for the objfile it belongs to.
2663 Psymtabs are searched in most recent inserted -> least recent
2666 psymtab
->objfile
= objfile
;
2667 psymtab
->next
= objfile
->psymtabs
;
2668 objfile
->psymtabs
= psymtab
;
2671 struct partial_symtab
**prev_pst
;
2672 psymtab
->objfile
= objfile
;
2673 psymtab
->next
= NULL
;
2674 prev_pst
= &(objfile
->psymtabs
);
2675 while ((*prev_pst
) != NULL
)
2676 prev_pst
= &((*prev_pst
)->next
);
2677 (*prev_pst
) = psymtab
;
2685 discard_psymtab (struct partial_symtab
*pst
)
2687 struct partial_symtab
**prev_pst
;
2690 Empty psymtabs happen as a result of header files which don't
2691 have any symbols in them. There can be a lot of them. But this
2692 check is wrong, in that a psymtab with N_SLINE entries but
2693 nothing else is not empty, but we don't realize that. Fixing
2694 that without slowing things down might be tricky. */
2696 /* First, snip it out of the psymtab chain */
2698 prev_pst
= &(pst
->objfile
->psymtabs
);
2699 while ((*prev_pst
) != pst
)
2700 prev_pst
= &((*prev_pst
)->next
);
2701 (*prev_pst
) = pst
->next
;
2703 /* Next, put it on a free list for recycling */
2705 pst
->next
= pst
->objfile
->free_psymtabs
;
2706 pst
->objfile
->free_psymtabs
= pst
;
2710 /* Reset all data structures in gdb which may contain references to symbol
2714 clear_symtab_users (void)
2716 /* Someday, we should do better than this, by only blowing away
2717 the things that really need to be blown. */
2719 /* Clear the "current" symtab first, because it is no longer valid.
2720 breakpoint_re_set may try to access the current symtab. */
2721 clear_current_source_symtab_and_line ();
2724 breakpoint_re_set ();
2725 set_default_breakpoint (0, 0, 0, 0);
2726 clear_pc_function_cache ();
2727 observer_notify_new_objfile (NULL
);
2729 /* Clear globals which might have pointed into a removed objfile.
2730 FIXME: It's not clear which of these are supposed to persist
2731 between expressions and which ought to be reset each time. */
2732 expression_context_block
= NULL
;
2733 innermost_block
= NULL
;
2735 /* Varobj may refer to old symbols, perform a cleanup. */
2736 varobj_invalidate ();
2741 clear_symtab_users_cleanup (void *ignore
)
2743 clear_symtab_users ();
2746 /* clear_symtab_users_once:
2748 This function is run after symbol reading, or from a cleanup.
2749 If an old symbol table was obsoleted, the old symbol table
2750 has been blown away, but the other GDB data structures that may
2751 reference it have not yet been cleared or re-directed. (The old
2752 symtab was zapped, and the cleanup queued, in free_named_symtab()
2755 This function can be queued N times as a cleanup, or called
2756 directly; it will do all the work the first time, and then will be a
2757 no-op until the next time it is queued. This works by bumping a
2758 counter at queueing time. Much later when the cleanup is run, or at
2759 the end of symbol processing (in case the cleanup is discarded), if
2760 the queued count is greater than the "done-count", we do the work
2761 and set the done-count to the queued count. If the queued count is
2762 less than or equal to the done-count, we just ignore the call. This
2763 is needed because reading a single .o file will often replace many
2764 symtabs (one per .h file, for example), and we don't want to reset
2765 the breakpoints N times in the user's face.
2767 The reason we both queue a cleanup, and call it directly after symbol
2768 reading, is because the cleanup protects us in case of errors, but is
2769 discarded if symbol reading is successful. */
2772 /* FIXME: As free_named_symtabs is currently a big noop this function
2773 is no longer needed. */
2774 static void clear_symtab_users_once (void);
2776 static int clear_symtab_users_queued
;
2777 static int clear_symtab_users_done
;
2780 clear_symtab_users_once (void)
2782 /* Enforce once-per-`do_cleanups'-semantics */
2783 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2785 clear_symtab_users_done
= clear_symtab_users_queued
;
2787 clear_symtab_users ();
2791 /* Delete the specified psymtab, and any others that reference it. */
2794 cashier_psymtab (struct partial_symtab
*pst
)
2796 struct partial_symtab
*ps
, *pprev
= NULL
;
2799 /* Find its previous psymtab in the chain */
2800 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2809 /* Unhook it from the chain. */
2810 if (ps
== pst
->objfile
->psymtabs
)
2811 pst
->objfile
->psymtabs
= ps
->next
;
2813 pprev
->next
= ps
->next
;
2815 /* FIXME, we can't conveniently deallocate the entries in the
2816 partial_symbol lists (global_psymbols/static_psymbols) that
2817 this psymtab points to. These just take up space until all
2818 the psymtabs are reclaimed. Ditto the dependencies list and
2819 filename, which are all in the objfile_obstack. */
2821 /* We need to cashier any psymtab that has this one as a dependency... */
2823 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2825 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2827 if (ps
->dependencies
[i
] == pst
)
2829 cashier_psymtab (ps
);
2830 goto again
; /* Must restart, chain has been munged. */
2837 /* If a symtab or psymtab for filename NAME is found, free it along
2838 with any dependent breakpoints, displays, etc.
2839 Used when loading new versions of object modules with the "add-file"
2840 command. This is only called on the top-level symtab or psymtab's name;
2841 it is not called for subsidiary files such as .h files.
2843 Return value is 1 if we blew away the environment, 0 if not.
2844 FIXME. The return value appears to never be used.
2846 FIXME. I think this is not the best way to do this. We should
2847 work on being gentler to the environment while still cleaning up
2848 all stray pointers into the freed symtab. */
2851 free_named_symtabs (char *name
)
2854 /* FIXME: With the new method of each objfile having it's own
2855 psymtab list, this function needs serious rethinking. In particular,
2856 why was it ever necessary to toss psymtabs with specific compilation
2857 unit filenames, as opposed to all psymtabs from a particular symbol
2859 Well, the answer is that some systems permit reloading of particular
2860 compilation units. We want to blow away any old info about these
2861 compilation units, regardless of which objfiles they arrived in. --gnu. */
2864 struct symtab
*prev
;
2865 struct partial_symtab
*ps
;
2866 struct blockvector
*bv
;
2869 /* We only wack things if the symbol-reload switch is set. */
2870 if (!symbol_reloading
)
2873 /* Some symbol formats have trouble providing file names... */
2874 if (name
== 0 || *name
== '\0')
2877 /* Look for a psymtab with the specified name. */
2880 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2882 if (strcmp (name
, ps
->filename
) == 0)
2884 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2885 goto again2
; /* Must restart, chain has been munged */
2889 /* Look for a symtab with the specified name. */
2891 for (s
= symtab_list
; s
; s
= s
->next
)
2893 if (strcmp (name
, s
->filename
) == 0)
2900 if (s
== symtab_list
)
2901 symtab_list
= s
->next
;
2903 prev
->next
= s
->next
;
2905 /* For now, queue a delete for all breakpoints, displays, etc., whether
2906 or not they depend on the symtab being freed. This should be
2907 changed so that only those data structures affected are deleted. */
2909 /* But don't delete anything if the symtab is empty.
2910 This test is necessary due to a bug in "dbxread.c" that
2911 causes empty symtabs to be created for N_SO symbols that
2912 contain the pathname of the object file. (This problem
2913 has been fixed in GDB 3.9x). */
2915 bv
= BLOCKVECTOR (s
);
2916 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2917 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2918 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2920 complaint (&symfile_complaints
, _("Replacing old symbols for `%s'"),
2922 clear_symtab_users_queued
++;
2923 make_cleanup (clear_symtab_users_once
, 0);
2927 complaint (&symfile_complaints
, _("Empty symbol table found for `%s'"),
2934 /* It is still possible that some breakpoints will be affected
2935 even though no symtab was found, since the file might have
2936 been compiled without debugging, and hence not be associated
2937 with a symtab. In order to handle this correctly, we would need
2938 to keep a list of text address ranges for undebuggable files.
2939 For now, we do nothing, since this is a fairly obscure case. */
2943 /* FIXME, what about the minimal symbol table? */
2950 /* Allocate and partially fill a partial symtab. It will be
2951 completely filled at the end of the symbol list.
2953 FILENAME is the name of the symbol-file we are reading from. */
2955 struct partial_symtab
*
2956 start_psymtab_common (struct objfile
*objfile
,
2957 struct section_offsets
*section_offsets
, char *filename
,
2958 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2959 struct partial_symbol
**static_syms
)
2961 struct partial_symtab
*psymtab
;
2963 psymtab
= allocate_psymtab (filename
, objfile
);
2964 psymtab
->section_offsets
= section_offsets
;
2965 psymtab
->textlow
= textlow
;
2966 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2967 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2968 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2972 /* Add a symbol with a long value to a psymtab.
2973 Since one arg is a struct, we pass in a ptr and deref it (sigh).
2974 Return the partial symbol that has been added. */
2976 /* NOTE: carlton/2003-09-11: The reason why we return the partial
2977 symbol is so that callers can get access to the symbol's demangled
2978 name, which they don't have any cheap way to determine otherwise.
2979 (Currenly, dwarf2read.c is the only file who uses that information,
2980 though it's possible that other readers might in the future.)
2981 Elena wasn't thrilled about that, and I don't blame her, but we
2982 couldn't come up with a better way to get that information. If
2983 it's needed in other situations, we could consider breaking up
2984 SYMBOL_SET_NAMES to provide access to the demangled name lookup
2987 const struct partial_symbol
*
2988 add_psymbol_to_list (char *name
, int namelength
, domain_enum domain
,
2989 enum address_class
class,
2990 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2991 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2992 enum language language
, struct objfile
*objfile
)
2994 struct partial_symbol
*psym
;
2995 char *buf
= alloca (namelength
+ 1);
2996 /* psymbol is static so that there will be no uninitialized gaps in the
2997 structure which might contain random data, causing cache misses in
2999 static struct partial_symbol psymbol
;
3001 /* Create local copy of the partial symbol */
3002 memcpy (buf
, name
, namelength
);
3003 buf
[namelength
] = '\0';
3004 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
3007 SYMBOL_VALUE (&psymbol
) = val
;
3011 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
3013 SYMBOL_SECTION (&psymbol
) = 0;
3014 SYMBOL_LANGUAGE (&psymbol
) = language
;
3015 PSYMBOL_DOMAIN (&psymbol
) = domain
;
3016 PSYMBOL_CLASS (&psymbol
) = class;
3018 SYMBOL_SET_NAMES (&psymbol
, buf
, namelength
, objfile
);
3020 /* Stash the partial symbol away in the cache */
3021 psym
= deprecated_bcache (&psymbol
, sizeof (struct partial_symbol
),
3022 objfile
->psymbol_cache
);
3024 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
3025 if (list
->next
>= list
->list
+ list
->size
)
3027 extend_psymbol_list (list
, objfile
);
3029 *list
->next
++ = psym
;
3030 OBJSTAT (objfile
, n_psyms
++);
3035 /* Initialize storage for partial symbols. */
3038 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
3040 /* Free any previously allocated psymbol lists. */
3042 if (objfile
->global_psymbols
.list
)
3044 xfree (objfile
->global_psymbols
.list
);
3046 if (objfile
->static_psymbols
.list
)
3048 xfree (objfile
->static_psymbols
.list
);
3051 /* Current best guess is that approximately a twentieth
3052 of the total symbols (in a debugging file) are global or static
3055 objfile
->global_psymbols
.size
= total_symbols
/ 10;
3056 objfile
->static_psymbols
.size
= total_symbols
/ 10;
3058 if (objfile
->global_psymbols
.size
> 0)
3060 objfile
->global_psymbols
.next
=
3061 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
3062 xmalloc ((objfile
->global_psymbols
.size
3063 * sizeof (struct partial_symbol
*)));
3065 if (objfile
->static_psymbols
.size
> 0)
3067 objfile
->static_psymbols
.next
=
3068 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
3069 xmalloc ((objfile
->static_psymbols
.size
3070 * sizeof (struct partial_symbol
*)));
3075 The following code implements an abstraction for debugging overlay sections.
3077 The target model is as follows:
3078 1) The gnu linker will permit multiple sections to be mapped into the
3079 same VMA, each with its own unique LMA (or load address).
3080 2) It is assumed that some runtime mechanism exists for mapping the
3081 sections, one by one, from the load address into the VMA address.
3082 3) This code provides a mechanism for gdb to keep track of which
3083 sections should be considered to be mapped from the VMA to the LMA.
3084 This information is used for symbol lookup, and memory read/write.
3085 For instance, if a section has been mapped then its contents
3086 should be read from the VMA, otherwise from the LMA.
3088 Two levels of debugger support for overlays are available. One is
3089 "manual", in which the debugger relies on the user to tell it which
3090 overlays are currently mapped. This level of support is
3091 implemented entirely in the core debugger, and the information about
3092 whether a section is mapped is kept in the objfile->obj_section table.
3094 The second level of support is "automatic", and is only available if
3095 the target-specific code provides functionality to read the target's
3096 overlay mapping table, and translate its contents for the debugger
3097 (by updating the mapped state information in the obj_section tables).
3099 The interface is as follows:
3101 overlay map <name> -- tell gdb to consider this section mapped
3102 overlay unmap <name> -- tell gdb to consider this section unmapped
3103 overlay list -- list the sections that GDB thinks are mapped
3104 overlay read-target -- get the target's state of what's mapped
3105 overlay off/manual/auto -- set overlay debugging state
3106 Functional interface:
3107 find_pc_mapped_section(pc): if the pc is in the range of a mapped
3108 section, return that section.
3109 find_pc_overlay(pc): find any overlay section that contains
3110 the pc, either in its VMA or its LMA
3111 overlay_is_mapped(sect): true if overlay is marked as mapped
3112 section_is_overlay(sect): true if section's VMA != LMA
3113 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
3114 pc_in_unmapped_range(...): true if pc belongs to section's LMA
3115 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
3116 overlay_mapped_address(...): map an address from section's LMA to VMA
3117 overlay_unmapped_address(...): map an address from section's VMA to LMA
3118 symbol_overlayed_address(...): Return a "current" address for symbol:
3119 either in VMA or LMA depending on whether
3120 the symbol's section is currently mapped
3123 /* Overlay debugging state: */
3125 enum overlay_debugging_state overlay_debugging
= ovly_off
;
3126 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
3128 /* Function: section_is_overlay (SECTION)
3129 Returns true if SECTION has VMA not equal to LMA, ie.
3130 SECTION is loaded at an address different from where it will "run". */
3133 section_is_overlay (asection
*section
)
3135 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
3137 if (overlay_debugging
)
3138 if (section
&& section
->lma
!= 0 &&
3139 section
->vma
!= section
->lma
)
3145 /* Function: overlay_invalidate_all (void)
3146 Invalidate the mapped state of all overlay sections (mark it as stale). */
3149 overlay_invalidate_all (void)
3151 struct objfile
*objfile
;
3152 struct obj_section
*sect
;
3154 ALL_OBJSECTIONS (objfile
, sect
)
3155 if (section_is_overlay (sect
->the_bfd_section
))
3156 sect
->ovly_mapped
= -1;
3159 /* Function: overlay_is_mapped (SECTION)
3160 Returns true if section is an overlay, and is currently mapped.
3161 Private: public access is thru function section_is_mapped.
3163 Access to the ovly_mapped flag is restricted to this function, so
3164 that we can do automatic update. If the global flag
3165 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3166 overlay_invalidate_all. If the mapped state of the particular
3167 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3170 overlay_is_mapped (struct obj_section
*osect
)
3172 if (osect
== 0 || !section_is_overlay (osect
->the_bfd_section
))
3175 switch (overlay_debugging
)
3179 return 0; /* overlay debugging off */
3180 case ovly_auto
: /* overlay debugging automatic */
3181 /* Unles there is a gdbarch_overlay_update function,
3182 there's really nothing useful to do here (can't really go auto) */
3183 if (gdbarch_overlay_update_p (current_gdbarch
))
3185 if (overlay_cache_invalid
)
3187 overlay_invalidate_all ();
3188 overlay_cache_invalid
= 0;
3190 if (osect
->ovly_mapped
== -1)
3191 gdbarch_overlay_update (current_gdbarch
, osect
);
3193 /* fall thru to manual case */
3194 case ovly_on
: /* overlay debugging manual */
3195 return osect
->ovly_mapped
== 1;
3199 /* Function: section_is_mapped
3200 Returns true if section is an overlay, and is currently mapped. */
3203 section_is_mapped (asection
*section
)
3205 struct objfile
*objfile
;
3206 struct obj_section
*osect
;
3208 if (overlay_debugging
)
3209 if (section
&& section_is_overlay (section
))
3210 ALL_OBJSECTIONS (objfile
, osect
)
3211 if (osect
->the_bfd_section
== section
)
3212 return overlay_is_mapped (osect
);
3217 /* Function: pc_in_unmapped_range
3218 If PC falls into the lma range of SECTION, return true, else false. */
3221 pc_in_unmapped_range (CORE_ADDR pc
, asection
*section
)
3223 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
3227 if (overlay_debugging
)
3228 if (section
&& section_is_overlay (section
))
3230 size
= bfd_get_section_size (section
);
3231 if (section
->lma
<= pc
&& pc
< section
->lma
+ size
)
3237 /* Function: pc_in_mapped_range
3238 If PC falls into the vma range of SECTION, return true, else false. */
3241 pc_in_mapped_range (CORE_ADDR pc
, asection
*section
)
3243 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3247 if (overlay_debugging
)
3248 if (section
&& section_is_overlay (section
))
3250 size
= bfd_get_section_size (section
);
3251 if (section
->vma
<= pc
&& pc
< section
->vma
+ size
)
3258 /* Return true if the mapped ranges of sections A and B overlap, false
3261 sections_overlap (asection
*a
, asection
*b
)
3263 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3265 CORE_ADDR a_start
= a
->vma
;
3266 CORE_ADDR a_end
= a
->vma
+ bfd_get_section_size (a
);
3267 CORE_ADDR b_start
= b
->vma
;
3268 CORE_ADDR b_end
= b
->vma
+ bfd_get_section_size (b
);
3270 return (a_start
< b_end
&& b_start
< a_end
);
3273 /* Function: overlay_unmapped_address (PC, SECTION)
3274 Returns the address corresponding to PC in the unmapped (load) range.
3275 May be the same as PC. */
3278 overlay_unmapped_address (CORE_ADDR pc
, asection
*section
)
3280 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
3282 if (overlay_debugging
)
3283 if (section
&& section_is_overlay (section
) &&
3284 pc_in_mapped_range (pc
, section
))
3285 return pc
+ section
->lma
- section
->vma
;
3290 /* Function: overlay_mapped_address (PC, SECTION)
3291 Returns the address corresponding to PC in the mapped (runtime) range.
3292 May be the same as PC. */
3295 overlay_mapped_address (CORE_ADDR pc
, asection
*section
)
3297 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3299 if (overlay_debugging
)
3300 if (section
&& section_is_overlay (section
) &&
3301 pc_in_unmapped_range (pc
, section
))
3302 return pc
+ section
->vma
- section
->lma
;
3308 /* Function: symbol_overlayed_address
3309 Return one of two addresses (relative to the VMA or to the LMA),
3310 depending on whether the section is mapped or not. */
3313 symbol_overlayed_address (CORE_ADDR address
, asection
*section
)
3315 if (overlay_debugging
)
3317 /* If the symbol has no section, just return its regular address. */
3320 /* If the symbol's section is not an overlay, just return its address */
3321 if (!section_is_overlay (section
))
3323 /* If the symbol's section is mapped, just return its address */
3324 if (section_is_mapped (section
))
3327 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3328 * then return its LOADED address rather than its vma address!!
3330 return overlay_unmapped_address (address
, section
);
3335 /* Function: find_pc_overlay (PC)
3336 Return the best-match overlay section for PC:
3337 If PC matches a mapped overlay section's VMA, return that section.
3338 Else if PC matches an unmapped section's VMA, return that section.
3339 Else if PC matches an unmapped section's LMA, return that section. */
3342 find_pc_overlay (CORE_ADDR pc
)
3344 struct objfile
*objfile
;
3345 struct obj_section
*osect
, *best_match
= NULL
;
3347 if (overlay_debugging
)
3348 ALL_OBJSECTIONS (objfile
, osect
)
3349 if (section_is_overlay (osect
->the_bfd_section
))
3351 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
))
3353 if (overlay_is_mapped (osect
))
3354 return osect
->the_bfd_section
;
3358 else if (pc_in_unmapped_range (pc
, osect
->the_bfd_section
))
3361 return best_match
? best_match
->the_bfd_section
: NULL
;
3364 /* Function: find_pc_mapped_section (PC)
3365 If PC falls into the VMA address range of an overlay section that is
3366 currently marked as MAPPED, return that section. Else return NULL. */
3369 find_pc_mapped_section (CORE_ADDR pc
)
3371 struct objfile
*objfile
;
3372 struct obj_section
*osect
;
3374 if (overlay_debugging
)
3375 ALL_OBJSECTIONS (objfile
, osect
)
3376 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
) &&
3377 overlay_is_mapped (osect
))
3378 return osect
->the_bfd_section
;
3383 /* Function: list_overlays_command
3384 Print a list of mapped sections and their PC ranges */
3387 list_overlays_command (char *args
, int from_tty
)
3390 struct objfile
*objfile
;
3391 struct obj_section
*osect
;
3393 if (overlay_debugging
)
3394 ALL_OBJSECTIONS (objfile
, osect
)
3395 if (overlay_is_mapped (osect
))
3401 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3402 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3403 size
= bfd_get_section_size (osect
->the_bfd_section
);
3404 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3406 printf_filtered ("Section %s, loaded at ", name
);
3407 deprecated_print_address_numeric (lma
, 1, gdb_stdout
);
3408 puts_filtered (" - ");
3409 deprecated_print_address_numeric (lma
+ size
, 1, gdb_stdout
);
3410 printf_filtered (", mapped at ");
3411 deprecated_print_address_numeric (vma
, 1, gdb_stdout
);
3412 puts_filtered (" - ");
3413 deprecated_print_address_numeric (vma
+ size
, 1, gdb_stdout
);
3414 puts_filtered ("\n");
3419 printf_filtered (_("No sections are mapped.\n"));
3422 /* Function: map_overlay_command
3423 Mark the named section as mapped (ie. residing at its VMA address). */
3426 map_overlay_command (char *args
, int from_tty
)
3428 struct objfile
*objfile
, *objfile2
;
3429 struct obj_section
*sec
, *sec2
;
3432 if (!overlay_debugging
)
3434 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3435 the 'overlay manual' command."));
3437 if (args
== 0 || *args
== 0)
3438 error (_("Argument required: name of an overlay section"));
3440 /* First, find a section matching the user supplied argument */
3441 ALL_OBJSECTIONS (objfile
, sec
)
3442 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3444 /* Now, check to see if the section is an overlay. */
3445 bfdsec
= sec
->the_bfd_section
;
3446 if (!section_is_overlay (bfdsec
))
3447 continue; /* not an overlay section */
3449 /* Mark the overlay as "mapped" */
3450 sec
->ovly_mapped
= 1;
3452 /* Next, make a pass and unmap any sections that are
3453 overlapped by this new section: */
3454 ALL_OBJSECTIONS (objfile2
, sec2
)
3455 if (sec2
->ovly_mapped
3457 && sec
->the_bfd_section
!= sec2
->the_bfd_section
3458 && sections_overlap (sec
->the_bfd_section
,
3459 sec2
->the_bfd_section
))
3462 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3463 bfd_section_name (objfile
->obfd
,
3464 sec2
->the_bfd_section
));
3465 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3469 error (_("No overlay section called %s"), args
);
3472 /* Function: unmap_overlay_command
3473 Mark the overlay section as unmapped
3474 (ie. resident in its LMA address range, rather than the VMA range). */
3477 unmap_overlay_command (char *args
, int from_tty
)
3479 struct objfile
*objfile
;
3480 struct obj_section
*sec
;
3482 if (!overlay_debugging
)
3484 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3485 the 'overlay manual' command."));
3487 if (args
== 0 || *args
== 0)
3488 error (_("Argument required: name of an overlay section"));
3490 /* First, find a section matching the user supplied argument */
3491 ALL_OBJSECTIONS (objfile
, sec
)
3492 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3494 if (!sec
->ovly_mapped
)
3495 error (_("Section %s is not mapped"), args
);
3496 sec
->ovly_mapped
= 0;
3499 error (_("No overlay section called %s"), args
);
3502 /* Function: overlay_auto_command
3503 A utility command to turn on overlay debugging.
3504 Possibly this should be done via a set/show command. */
3507 overlay_auto_command (char *args
, int from_tty
)
3509 overlay_debugging
= ovly_auto
;
3510 enable_overlay_breakpoints ();
3512 printf_unfiltered (_("Automatic overlay debugging enabled."));
3515 /* Function: overlay_manual_command
3516 A utility command to turn on overlay debugging.
3517 Possibly this should be done via a set/show command. */
3520 overlay_manual_command (char *args
, int from_tty
)
3522 overlay_debugging
= ovly_on
;
3523 disable_overlay_breakpoints ();
3525 printf_unfiltered (_("Overlay debugging enabled."));
3528 /* Function: overlay_off_command
3529 A utility command to turn on overlay debugging.
3530 Possibly this should be done via a set/show command. */
3533 overlay_off_command (char *args
, int from_tty
)
3535 overlay_debugging
= ovly_off
;
3536 disable_overlay_breakpoints ();
3538 printf_unfiltered (_("Overlay debugging disabled."));
3542 overlay_load_command (char *args
, int from_tty
)
3544 if (gdbarch_overlay_update_p (current_gdbarch
))
3545 gdbarch_overlay_update (current_gdbarch
, NULL
);
3547 error (_("This target does not know how to read its overlay state."));
3550 /* Function: overlay_command
3551 A place-holder for a mis-typed command */
3553 /* Command list chain containing all defined "overlay" subcommands. */
3554 struct cmd_list_element
*overlaylist
;
3557 overlay_command (char *args
, int from_tty
)
3560 ("\"overlay\" must be followed by the name of an overlay command.\n");
3561 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3565 /* Target Overlays for the "Simplest" overlay manager:
3567 This is GDB's default target overlay layer. It works with the
3568 minimal overlay manager supplied as an example by Cygnus. The
3569 entry point is via a function pointer "gdbarch_overlay_update",
3570 so targets that use a different runtime overlay manager can
3571 substitute their own overlay_update function and take over the
3574 The overlay_update function pokes around in the target's data structures
3575 to see what overlays are mapped, and updates GDB's overlay mapping with
3578 In this simple implementation, the target data structures are as follows:
3579 unsigned _novlys; /# number of overlay sections #/
3580 unsigned _ovly_table[_novlys][4] = {
3581 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3582 {..., ..., ..., ...},
3584 unsigned _novly_regions; /# number of overlay regions #/
3585 unsigned _ovly_region_table[_novly_regions][3] = {
3586 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3589 These functions will attempt to update GDB's mappedness state in the
3590 symbol section table, based on the target's mappedness state.
3592 To do this, we keep a cached copy of the target's _ovly_table, and
3593 attempt to detect when the cached copy is invalidated. The main
3594 entry point is "simple_overlay_update(SECT), which looks up SECT in
3595 the cached table and re-reads only the entry for that section from
3596 the target (whenever possible).
3599 /* Cached, dynamically allocated copies of the target data structures: */
3600 static unsigned (*cache_ovly_table
)[4] = 0;
3602 static unsigned (*cache_ovly_region_table
)[3] = 0;
3604 static unsigned cache_novlys
= 0;
3606 static unsigned cache_novly_regions
= 0;
3608 static CORE_ADDR cache_ovly_table_base
= 0;
3610 static CORE_ADDR cache_ovly_region_table_base
= 0;
3614 VMA
, SIZE
, LMA
, MAPPED
3616 #define TARGET_LONG_BYTES (gdbarch_long_bit (current_gdbarch) \
3619 /* Throw away the cached copy of _ovly_table */
3621 simple_free_overlay_table (void)
3623 if (cache_ovly_table
)
3624 xfree (cache_ovly_table
);
3626 cache_ovly_table
= NULL
;
3627 cache_ovly_table_base
= 0;
3631 /* Throw away the cached copy of _ovly_region_table */
3633 simple_free_overlay_region_table (void)
3635 if (cache_ovly_region_table
)
3636 xfree (cache_ovly_region_table
);
3637 cache_novly_regions
= 0;
3638 cache_ovly_region_table
= NULL
;
3639 cache_ovly_region_table_base
= 0;
3643 /* Read an array of ints from the target into a local buffer.
3644 Convert to host order. int LEN is number of ints */
3646 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
, int len
)
3648 /* FIXME (alloca): Not safe if array is very large. */
3649 gdb_byte
*buf
= alloca (len
* TARGET_LONG_BYTES
);
3652 read_memory (memaddr
, buf
, len
* TARGET_LONG_BYTES
);
3653 for (i
= 0; i
< len
; i
++)
3654 myaddr
[i
] = extract_unsigned_integer (TARGET_LONG_BYTES
* i
+ buf
,
3658 /* Find and grab a copy of the target _ovly_table
3659 (and _novlys, which is needed for the table's size) */
3661 simple_read_overlay_table (void)
3663 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3665 simple_free_overlay_table ();
3666 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3669 error (_("Error reading inferior's overlay table: "
3670 "couldn't find `_novlys' variable\n"
3671 "in inferior. Use `overlay manual' mode."));
3675 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3676 if (! ovly_table_msym
)
3678 error (_("Error reading inferior's overlay table: couldn't find "
3679 "`_ovly_table' array\n"
3680 "in inferior. Use `overlay manual' mode."));
3684 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
), 4);
3686 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3687 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3688 read_target_long_array (cache_ovly_table_base
,
3689 (unsigned int *) cache_ovly_table
,
3692 return 1; /* SUCCESS */
3696 /* Find and grab a copy of the target _ovly_region_table
3697 (and _novly_regions, which is needed for the table's size) */
3699 simple_read_overlay_region_table (void)
3701 struct minimal_symbol
*msym
;
3703 simple_free_overlay_region_table ();
3704 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3706 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
3708 return 0; /* failure */
3709 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3710 if (cache_ovly_region_table
!= NULL
)
3712 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3715 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3716 read_target_long_array (cache_ovly_region_table_base
,
3717 (unsigned int *) cache_ovly_region_table
,
3718 cache_novly_regions
* 3);
3721 return 0; /* failure */
3724 return 0; /* failure */
3725 return 1; /* SUCCESS */
3729 /* Function: simple_overlay_update_1
3730 A helper function for simple_overlay_update. Assuming a cached copy
3731 of _ovly_table exists, look through it to find an entry whose vma,
3732 lma and size match those of OSECT. Re-read the entry and make sure
3733 it still matches OSECT (else the table may no longer be valid).
3734 Set OSECT's mapped state to match the entry. Return: 1 for
3735 success, 0 for failure. */
3738 simple_overlay_update_1 (struct obj_section
*osect
)
3741 bfd
*obfd
= osect
->objfile
->obfd
;
3742 asection
*bsect
= osect
->the_bfd_section
;
3744 size
= bfd_get_section_size (osect
->the_bfd_section
);
3745 for (i
= 0; i
< cache_novlys
; i
++)
3746 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3747 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3748 /* && cache_ovly_table[i][SIZE] == size */ )
3750 read_target_long_array (cache_ovly_table_base
+ i
* TARGET_LONG_BYTES
,
3751 (unsigned int *) cache_ovly_table
[i
], 4);
3752 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3753 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3754 /* && cache_ovly_table[i][SIZE] == size */ )
3756 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3759 else /* Warning! Warning! Target's ovly table has changed! */
3765 /* Function: simple_overlay_update
3766 If OSECT is NULL, then update all sections' mapped state
3767 (after re-reading the entire target _ovly_table).
3768 If OSECT is non-NULL, then try to find a matching entry in the
3769 cached ovly_table and update only OSECT's mapped state.
3770 If a cached entry can't be found or the cache isn't valid, then
3771 re-read the entire cache, and go ahead and update all sections. */
3774 simple_overlay_update (struct obj_section
*osect
)
3776 struct objfile
*objfile
;
3778 /* Were we given an osect to look up? NULL means do all of them. */
3780 /* Have we got a cached copy of the target's overlay table? */
3781 if (cache_ovly_table
!= NULL
)
3782 /* Does its cached location match what's currently in the symtab? */
3783 if (cache_ovly_table_base
==
3784 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3785 /* Then go ahead and try to look up this single section in the cache */
3786 if (simple_overlay_update_1 (osect
))
3787 /* Found it! We're done. */
3790 /* Cached table no good: need to read the entire table anew.
3791 Or else we want all the sections, in which case it's actually
3792 more efficient to read the whole table in one block anyway. */
3794 if (! simple_read_overlay_table ())
3797 /* Now may as well update all sections, even if only one was requested. */
3798 ALL_OBJSECTIONS (objfile
, osect
)
3799 if (section_is_overlay (osect
->the_bfd_section
))
3802 bfd
*obfd
= osect
->objfile
->obfd
;
3803 asection
*bsect
= osect
->the_bfd_section
;
3805 size
= bfd_get_section_size (bsect
);
3806 for (i
= 0; i
< cache_novlys
; i
++)
3807 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3808 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3809 /* && cache_ovly_table[i][SIZE] == size */ )
3810 { /* obj_section matches i'th entry in ovly_table */
3811 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3812 break; /* finished with inner for loop: break out */
3817 /* Set the output sections and output offsets for section SECTP in
3818 ABFD. The relocation code in BFD will read these offsets, so we
3819 need to be sure they're initialized. We map each section to itself,
3820 with no offset; this means that SECTP->vma will be honored. */
3823 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3825 sectp
->output_section
= sectp
;
3826 sectp
->output_offset
= 0;
3829 /* Relocate the contents of a debug section SECTP in ABFD. The
3830 contents are stored in BUF if it is non-NULL, or returned in a
3831 malloc'd buffer otherwise.
3833 For some platforms and debug info formats, shared libraries contain
3834 relocations against the debug sections (particularly for DWARF-2;
3835 one affected platform is PowerPC GNU/Linux, although it depends on
3836 the version of the linker in use). Also, ELF object files naturally
3837 have unresolved relocations for their debug sections. We need to apply
3838 the relocations in order to get the locations of symbols correct. */
3841 symfile_relocate_debug_section (bfd
*abfd
, asection
*sectp
, bfd_byte
*buf
)
3843 /* We're only interested in debugging sections with relocation
3845 if ((sectp
->flags
& SEC_RELOC
) == 0)
3847 if ((sectp
->flags
& SEC_DEBUGGING
) == 0)
3850 /* We will handle section offsets properly elsewhere, so relocate as if
3851 all sections begin at 0. */
3852 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3854 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3857 struct symfile_segment_data
*
3858 get_symfile_segment_data (bfd
*abfd
)
3860 struct sym_fns
*sf
= find_sym_fns (abfd
);
3865 return sf
->sym_segments (abfd
);
3869 free_symfile_segment_data (struct symfile_segment_data
*data
)
3871 xfree (data
->segment_bases
);
3872 xfree (data
->segment_sizes
);
3873 xfree (data
->segment_info
);
3878 symfile_map_offsets_to_segments (bfd
*abfd
, struct symfile_segment_data
*data
,
3879 struct section_offsets
*offsets
,
3880 int num_segment_bases
,
3881 const CORE_ADDR
*segment_bases
)
3886 /* If we do not have segment mappings for the object file, we
3887 can not relocate it by segments. */
3888 gdb_assert (data
!= NULL
);
3889 gdb_assert (data
->num_segments
> 0);
3891 /* If more offsets are provided than we have segments, make sure the
3892 excess offsets are all the same as the last segment's offset.
3893 This allows "Text=X;Data=X" for files which have only a single
3895 if (num_segment_bases
> data
->num_segments
)
3896 for (i
= data
->num_segments
; i
< num_segment_bases
; i
++)
3897 if (segment_bases
[i
] != segment_bases
[data
->num_segments
- 1])
3900 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3903 int which
= data
->segment_info
[i
];
3905 if (which
> num_segment_bases
)
3906 offsets
->offsets
[i
] = segment_bases
[num_segment_bases
- 1];
3908 offsets
->offsets
[i
] = segment_bases
[which
- 1];
3912 offsets
->offsets
[i
] -= data
->segment_bases
[which
- 1];
3919 symfile_find_segment_sections (struct objfile
*objfile
)
3921 bfd
*abfd
= objfile
->obfd
;
3924 struct symfile_segment_data
*data
;
3926 data
= get_symfile_segment_data (objfile
->obfd
);
3930 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3932 free_symfile_segment_data (data
);
3936 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3939 int which
= data
->segment_info
[i
];
3943 if (objfile
->sect_index_text
== -1)
3944 objfile
->sect_index_text
= sect
->index
;
3946 if (objfile
->sect_index_rodata
== -1)
3947 objfile
->sect_index_rodata
= sect
->index
;
3949 else if (which
== 2)
3951 if (objfile
->sect_index_data
== -1)
3952 objfile
->sect_index_data
= sect
->index
;
3954 if (objfile
->sect_index_bss
== -1)
3955 objfile
->sect_index_bss
= sect
->index
;
3959 free_symfile_segment_data (data
);
3963 _initialize_symfile (void)
3965 struct cmd_list_element
*c
;
3967 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3968 Load symbol table from executable file FILE.\n\
3969 The `file' command can also load symbol tables, as well as setting the file\n\
3970 to execute."), &cmdlist
);
3971 set_cmd_completer (c
, filename_completer
);
3973 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3974 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3975 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3976 ADDR is the starting address of the file's text.\n\
3977 The optional arguments are section-name section-address pairs and\n\
3978 should be specified if the data and bss segments are not contiguous\n\
3979 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3981 set_cmd_completer (c
, filename_completer
);
3983 c
= add_cmd ("add-shared-symbol-files", class_files
,
3984 add_shared_symbol_files_command
, _("\
3985 Load the symbols from shared objects in the dynamic linker's link map."),
3987 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
3990 c
= add_cmd ("load", class_files
, load_command
, _("\
3991 Dynamically load FILE into the running program, and record its symbols\n\
3992 for access from GDB.\n\
3993 A load OFFSET may also be given."), &cmdlist
);
3994 set_cmd_completer (c
, filename_completer
);
3996 add_setshow_boolean_cmd ("symbol-reloading", class_support
,
3997 &symbol_reloading
, _("\
3998 Set dynamic symbol table reloading multiple times in one run."), _("\
3999 Show dynamic symbol table reloading multiple times in one run."), NULL
,
4001 show_symbol_reloading
,
4002 &setlist
, &showlist
);
4004 add_prefix_cmd ("overlay", class_support
, overlay_command
,
4005 _("Commands for debugging overlays."), &overlaylist
,
4006 "overlay ", 0, &cmdlist
);
4008 add_com_alias ("ovly", "overlay", class_alias
, 1);
4009 add_com_alias ("ov", "overlay", class_alias
, 1);
4011 add_cmd ("map-overlay", class_support
, map_overlay_command
,
4012 _("Assert that an overlay section is mapped."), &overlaylist
);
4014 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
4015 _("Assert that an overlay section is unmapped."), &overlaylist
);
4017 add_cmd ("list-overlays", class_support
, list_overlays_command
,
4018 _("List mappings of overlay sections."), &overlaylist
);
4020 add_cmd ("manual", class_support
, overlay_manual_command
,
4021 _("Enable overlay debugging."), &overlaylist
);
4022 add_cmd ("off", class_support
, overlay_off_command
,
4023 _("Disable overlay debugging."), &overlaylist
);
4024 add_cmd ("auto", class_support
, overlay_auto_command
,
4025 _("Enable automatic overlay debugging."), &overlaylist
);
4026 add_cmd ("load-target", class_support
, overlay_load_command
,
4027 _("Read the overlay mapping state from the target."), &overlaylist
);
4029 /* Filename extension to source language lookup table: */
4030 init_filename_language_table ();
4031 add_setshow_string_noescape_cmd ("extension-language", class_files
,
4033 Set mapping between filename extension and source language."), _("\
4034 Show mapping between filename extension and source language."), _("\
4035 Usage: set extension-language .foo bar"),
4036 set_ext_lang_command
,
4038 &setlist
, &showlist
);
4040 add_info ("extensions", info_ext_lang_command
,
4041 _("All filename extensions associated with a source language."));
4043 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
4044 &debug_file_directory
, _("\
4045 Set the directory where separate debug symbols are searched for."), _("\
4046 Show the directory where separate debug symbols are searched for."), _("\
4047 Separate debug symbols are first searched for in the same\n\
4048 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
4049 and lastly at the path of the directory of the binary with\n\
4050 the global debug-file directory prepended."),
4052 show_debug_file_directory
,
4053 &setlist
, &showlist
);