1 /* Generic symbol file reading for the GNU debugger, GDB.
2 Copyright 1990-1996, 1998, 2000 Free Software Foundation, Inc.
3 Contributed by Cygnus Support, using pieces from other GDB modules.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
32 #include "breakpoint.h"
34 #include "complaints.h"
36 #include "inferior.h" /* for write_pc */
37 #include "gdb-stabs.h"
39 #include "completer.h"
42 #include <sys/types.h>
44 #include "gdb_string.h"
55 /* Some HP-UX related globals to clear when a new "main"
56 symbol file is loaded. HP-specific. */
58 extern int hp_som_som_object_present
;
59 extern int hp_cxx_exception_support_initialized
;
60 #define RESET_HP_UX_GLOBALS() do {\
61 hp_som_som_object_present = 0; /* indicates HP-compiled code */ \
62 hp_cxx_exception_support_initialized = 0; /* must reinitialize exception stuff */ \
66 int (*ui_load_progress_hook
) (const char *section
, unsigned long num
);
67 void (*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 (*pre_add_symbol_hook
) (char *);
73 void (*post_add_symbol_hook
) (void);
74 void (*target_new_objfile_hook
) (struct objfile
*);
76 static void clear_symtab_users_cleanup (void *ignore
);
78 /* Global variables owned by this file */
79 int readnow_symbol_files
; /* Read full symbols immediately */
81 struct complaint oldsyms_complaint
=
83 "Replacing old symbols for `%s'", 0, 0
86 struct complaint empty_symtab_complaint
=
88 "Empty symbol table found for `%s'", 0, 0
91 struct complaint unknown_option_complaint
=
93 "Unknown option `%s' ignored", 0, 0
96 /* External variables and functions referenced. */
98 extern int info_verbose
;
100 extern void report_transfer_performance (unsigned long, time_t, time_t);
102 /* Functions this file defines */
105 static int simple_read_overlay_region_table (void);
106 static void simple_free_overlay_region_table (void);
109 static void set_initial_language (void);
111 static void load_command (char *, int);
113 static void add_symbol_file_command (char *, int);
115 static void add_shared_symbol_files_command (char *, int);
117 static void cashier_psymtab (struct partial_symtab
*);
119 static int compare_psymbols (const void *, const void *);
121 static int compare_symbols (const void *, const void *);
123 bfd
*symfile_bfd_open (char *);
125 static void find_sym_fns (struct objfile
*);
127 static void decrement_reading_symtab (void *);
129 static void overlay_invalidate_all (void);
131 static int overlay_is_mapped (struct obj_section
*);
133 void list_overlays_command (char *, int);
135 void map_overlay_command (char *, int);
137 void unmap_overlay_command (char *, int);
139 static void overlay_auto_command (char *, int);
141 static void overlay_manual_command (char *, int);
143 static void overlay_off_command (char *, int);
145 static void overlay_load_command (char *, int);
147 static void overlay_command (char *, int);
149 static void simple_free_overlay_table (void);
151 static void read_target_long_array (CORE_ADDR
, unsigned int *, int);
153 static int simple_read_overlay_table (void);
155 static int simple_overlay_update_1 (struct obj_section
*);
157 static void add_filename_language (char *ext
, enum language lang
);
159 static void set_ext_lang_command (char *args
, int from_tty
);
161 static void info_ext_lang_command (char *args
, int from_tty
);
163 static void init_filename_language_table (void);
165 void _initialize_symfile (void);
167 /* List of all available sym_fns. On gdb startup, each object file reader
168 calls add_symtab_fns() to register information on each format it is
171 static struct sym_fns
*symtab_fns
= NULL
;
173 /* Flag for whether user will be reloading symbols multiple times.
174 Defaults to ON for VxWorks, otherwise OFF. */
176 #ifdef SYMBOL_RELOADING_DEFAULT
177 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
179 int symbol_reloading
= 0;
182 /* If non-zero, then on HP-UX (i.e., platforms that use somsolib.c),
183 this variable is interpreted as a threshhold. If adding a new
184 library's symbol table to those already known to the debugger would
185 exceed this threshhold, then the shlib's symbols are not added.
187 If non-zero on other platforms, shared library symbols will be added
188 automatically when the inferior is created, new libraries are loaded,
189 or when attaching to the inferior. This is almost always what users
190 will want to have happen; but for very large programs, the startup
191 time will be excessive, and so if this is a problem, the user can
192 clear this flag and then add the shared library symbols as needed.
193 Note that there is a potential for confusion, since if the shared
194 library symbols are not loaded, commands like "info fun" will *not*
195 report all the functions that are actually present.
197 Note that HP-UX interprets this variable to mean, "threshhold size
198 in megabytes, where zero means never add". Other platforms interpret
199 this variable to mean, "always add if non-zero, never add if zero."
202 int auto_solib_add
= 1;
205 /* Since this function is called from within qsort, in an ANSI environment
206 it must conform to the prototype for qsort, which specifies that the
207 comparison function takes two "void *" pointers. */
210 compare_symbols (const PTR s1p
, const PTR s2p
)
212 register struct symbol
**s1
, **s2
;
214 s1
= (struct symbol
**) s1p
;
215 s2
= (struct symbol
**) s2p
;
216 return (strcmp (SYMBOL_SOURCE_NAME (*s1
), SYMBOL_SOURCE_NAME (*s2
)));
223 compare_psymbols -- compare two partial symbols by name
227 Given pointers to pointers to two partial symbol table entries,
228 compare them by name and return -N, 0, or +N (ala strcmp).
229 Typically used by sorting routines like qsort().
233 Does direct compare of first two characters before punting
234 and passing to strcmp for longer compares. Note that the
235 original version had a bug whereby two null strings or two
236 identically named one character strings would return the
237 comparison of memory following the null byte.
242 compare_psymbols (const PTR s1p
, const PTR s2p
)
244 register struct partial_symbol
**s1
, **s2
;
245 register char *st1
, *st2
;
247 s1
= (struct partial_symbol
**) s1p
;
248 s2
= (struct partial_symbol
**) s2p
;
249 st1
= SYMBOL_SOURCE_NAME (*s1
);
250 st2
= SYMBOL_SOURCE_NAME (*s2
);
253 if ((st1
[0] - st2
[0]) || !st1
[0])
255 return (st1
[0] - st2
[0]);
257 else if ((st1
[1] - st2
[1]) || !st1
[1])
259 return (st1
[1] - st2
[1]);
263 return (strcmp (st1
, st2
));
268 sort_pst_symbols (struct partial_symtab
*pst
)
270 /* Sort the global list; don't sort the static list */
272 qsort (pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
,
273 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
277 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
280 sort_block_syms (register struct block
*b
)
282 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
283 sizeof (struct symbol
*), compare_symbols
);
286 /* Call sort_symtab_syms to sort alphabetically
287 the symbols of each block of one symtab. */
290 sort_symtab_syms (register struct symtab
*s
)
292 register struct blockvector
*bv
;
295 register struct block
*b
;
299 bv
= BLOCKVECTOR (s
);
300 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
301 for (i
= 0; i
< nbl
; i
++)
303 b
= BLOCKVECTOR_BLOCK (bv
, i
);
304 if (BLOCK_SHOULD_SORT (b
))
309 /* Make a null terminated copy of the string at PTR with SIZE characters in
310 the obstack pointed to by OBSTACKP . Returns the address of the copy.
311 Note that the string at PTR does not have to be null terminated, I.E. it
312 may be part of a larger string and we are only saving a substring. */
315 obsavestring (char *ptr
, int size
, struct obstack
*obstackp
)
317 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
318 /* Open-coded memcpy--saves function call time. These strings are usually
319 short. FIXME: Is this really still true with a compiler that can
322 register char *p1
= ptr
;
323 register char *p2
= p
;
324 char *end
= ptr
+ size
;
332 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
333 in the obstack pointed to by OBSTACKP. */
336 obconcat (struct obstack
*obstackp
, const char *s1
, const char *s2
,
339 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
340 register char *val
= (char *) obstack_alloc (obstackp
, len
);
347 /* True if we are nested inside psymtab_to_symtab. */
349 int currently_reading_symtab
= 0;
352 decrement_reading_symtab (void *dummy
)
354 currently_reading_symtab
--;
357 /* Get the symbol table that corresponds to a partial_symtab.
358 This is fast after the first time you do it. In fact, there
359 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
363 psymtab_to_symtab (register struct partial_symtab
*pst
)
365 /* If it's been looked up before, return it. */
369 /* If it has not yet been read in, read it. */
372 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
373 currently_reading_symtab
++;
374 (*pst
->read_symtab
) (pst
);
375 do_cleanups (back_to
);
381 /* Initialize entry point information for this objfile. */
384 init_entry_point_info (struct objfile
*objfile
)
386 /* Save startup file's range of PC addresses to help blockframe.c
387 decide where the bottom of the stack is. */
389 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
391 /* Executable file -- record its entry point so we'll recognize
392 the startup file because it contains the entry point. */
393 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
397 /* Examination of non-executable.o files. Short-circuit this stuff. */
398 objfile
->ei
.entry_point
= INVALID_ENTRY_POINT
;
400 objfile
->ei
.entry_file_lowpc
= INVALID_ENTRY_LOWPC
;
401 objfile
->ei
.entry_file_highpc
= INVALID_ENTRY_HIGHPC
;
402 objfile
->ei
.entry_func_lowpc
= INVALID_ENTRY_LOWPC
;
403 objfile
->ei
.entry_func_highpc
= INVALID_ENTRY_HIGHPC
;
404 objfile
->ei
.main_func_lowpc
= INVALID_ENTRY_LOWPC
;
405 objfile
->ei
.main_func_highpc
= INVALID_ENTRY_HIGHPC
;
408 /* Get current entry point address. */
411 entry_point_address (void)
413 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
416 /* Remember the lowest-addressed loadable section we've seen.
417 This function is called via bfd_map_over_sections.
419 In case of equal vmas, the section with the largest size becomes the
420 lowest-addressed loadable section.
422 If the vmas and sizes are equal, the last section is considered the
423 lowest-addressed loadable section. */
426 find_lowest_section (bfd
*abfd
, asection
*sect
, PTR obj
)
428 asection
**lowest
= (asection
**) obj
;
430 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
433 *lowest
= sect
; /* First loadable section */
434 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
435 *lowest
= sect
; /* A lower loadable section */
436 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
437 && (bfd_section_size (abfd
, (*lowest
))
438 <= bfd_section_size (abfd
, sect
)))
443 /* Build (allocate and populate) a section_addr_info struct from
444 an existing section table. */
446 extern struct section_addr_info
*
447 build_section_addr_info_from_section_table (const struct section_table
*start
,
448 const struct section_table
*end
)
450 struct section_addr_info
*sap
;
451 const struct section_table
*stp
;
454 sap
= xmalloc (sizeof (struct section_addr_info
));
455 memset (sap
, 0, sizeof (struct section_addr_info
));
457 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
459 if (stp
->the_bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)
460 && oidx
< MAX_SECTIONS
)
462 sap
->other
[oidx
].addr
= stp
->addr
;
463 sap
->other
[oidx
].name
= xstrdup (stp
->the_bfd_section
->name
);
464 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
473 /* Free all memory allocated by build_section_addr_info_from_section_table. */
476 free_section_addr_info (struct section_addr_info
*sap
)
480 for (idx
= 0; idx
< MAX_SECTIONS
; idx
++)
481 if (sap
->other
[idx
].name
)
482 xfree (sap
->other
[idx
].name
);
487 /* Parse the user's idea of an offset for dynamic linking, into our idea
488 of how to represent it for fast symbol reading. This is the default
489 version of the sym_fns.sym_offsets function for symbol readers that
490 don't need to do anything special. It allocates a section_offsets table
491 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
494 default_symfile_offsets (struct objfile
*objfile
,
495 struct section_addr_info
*addrs
)
498 asection
*sect
= NULL
;
500 objfile
->num_sections
= SECT_OFF_MAX
;
501 objfile
->section_offsets
= (struct section_offsets
*)
502 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
503 memset (objfile
->section_offsets
, 0, SIZEOF_SECTION_OFFSETS
);
505 /* Now calculate offsets for section that were specified by the
507 for (i
= 0; i
< MAX_SECTIONS
&& addrs
->other
[i
].name
; i
++)
509 struct other_sections
*osp
;
511 osp
= &addrs
->other
[i
] ;
515 /* Record all sections in offsets */
516 /* The section_offsets in the objfile are here filled in using
518 (objfile
->section_offsets
)->offsets
[osp
->sectindex
] = osp
->addr
;
521 /* Remember the bfd indexes for the .text, .data, .bss and
524 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
526 objfile
->sect_index_text
= sect
->index
;
528 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
530 objfile
->sect_index_data
= sect
->index
;
532 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
534 objfile
->sect_index_bss
= sect
->index
;
536 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
538 objfile
->sect_index_rodata
= sect
->index
;
542 /* Process a symbol file, as either the main file or as a dynamically
545 OBJFILE is where the symbols are to be read from.
547 ADDR is the address where the text segment was loaded, unless the
548 objfile is the main symbol file, in which case it is zero.
550 MAINLINE is nonzero if this is the main symbol file, or zero if
551 it's an extra symbol file such as dynamically loaded code.
553 VERBO is nonzero if the caller has printed a verbose message about
554 the symbol reading (and complaints can be more terse about it). */
557 syms_from_objfile (struct objfile
*objfile
, struct section_addr_info
*addrs
,
558 int mainline
, int verbo
)
560 asection
*lower_sect
;
562 CORE_ADDR lower_offset
;
563 struct section_addr_info local_addr
;
564 struct cleanup
*old_chain
;
567 /* If ADDRS is NULL, initialize the local section_addr_info struct and
568 point ADDRS to it. We now establish the convention that an addr of
569 zero means no load address was specified. */
573 memset (&local_addr
, 0, sizeof (local_addr
));
577 init_entry_point_info (objfile
);
578 find_sym_fns (objfile
);
580 /* Make sure that partially constructed symbol tables will be cleaned up
581 if an error occurs during symbol reading. */
582 old_chain
= make_cleanup_free_objfile (objfile
);
586 /* We will modify the main symbol table, make sure that all its users
587 will be cleaned up if an error occurs during symbol reading. */
588 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
590 /* Since no error yet, throw away the old symbol table. */
592 if (symfile_objfile
!= NULL
)
594 free_objfile (symfile_objfile
);
595 symfile_objfile
= NULL
;
598 /* Currently we keep symbols from the add-symbol-file command.
599 If the user wants to get rid of them, they should do "symbol-file"
600 without arguments first. Not sure this is the best behavior
603 (*objfile
->sf
->sym_new_init
) (objfile
);
606 /* Convert addr into an offset rather than an absolute address.
607 We find the lowest address of a loaded segment in the objfile,
608 and assume that <addr> is where that got loaded.
610 We no longer warn if the lowest section is not a text segment (as
611 happens for the PA64 port. */
614 /* Find lowest loadable section to be used as starting point for
615 continguous sections. FIXME!! won't work without call to find
616 .text first, but this assumes text is lowest section. */
617 lower_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
618 if (lower_sect
== NULL
)
619 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
621 if (lower_sect
== NULL
)
622 warning ("no loadable sections found in added symbol-file %s",
625 if ((bfd_get_section_flags (objfile
->obfd
, lower_sect
) & SEC_CODE
) == 0)
626 warning ("Lowest section in %s is %s at %s",
628 bfd_section_name (objfile
->obfd
, lower_sect
),
629 paddr (bfd_section_vma (objfile
->obfd
, lower_sect
)));
630 if (lower_sect
!= NULL
)
631 lower_offset
= bfd_section_vma (objfile
->obfd
, lower_sect
);
635 /* Calculate offsets for the loadable sections.
636 FIXME! Sections must be in order of increasing loadable section
637 so that contiguous sections can use the lower-offset!!!
639 Adjust offsets if the segments are not contiguous.
640 If the section is contiguous, its offset should be set to
641 the offset of the highest loadable section lower than it
642 (the loadable section directly below it in memory).
643 this_offset = lower_offset = lower_addr - lower_orig_addr */
645 /* Calculate offsets for sections. */
646 for (i
=0 ; i
< MAX_SECTIONS
&& addrs
->other
[i
].name
; i
++)
648 if (addrs
->other
[i
].addr
!= 0)
650 sect
= bfd_get_section_by_name (objfile
->obfd
, addrs
->other
[i
].name
);
653 addrs
->other
[i
].addr
-= bfd_section_vma (objfile
->obfd
, sect
);
654 lower_offset
= addrs
->other
[i
].addr
;
655 /* This is the index used by BFD. */
656 addrs
->other
[i
].sectindex
= sect
->index
;
660 warning ("section %s not found in %s", addrs
->other
[i
].name
,
662 addrs
->other
[i
].addr
= 0;
666 addrs
->other
[i
].addr
= lower_offset
;
670 /* Initialize symbol reading routines for this objfile, allow complaints to
671 appear for this new file, and record how verbose to be, then do the
672 initial symbol reading for this file. */
674 (*objfile
->sf
->sym_init
) (objfile
);
675 clear_complaints (1, verbo
);
677 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
679 #ifndef IBM6000_TARGET
680 /* This is a SVR4/SunOS specific hack, I think. In any event, it
681 screws RS/6000. sym_offsets should be doing this sort of thing,
682 because it knows the mapping between bfd sections and
684 /* This is a hack. As far as I can tell, section offsets are not
685 target dependent. They are all set to addr with a couple of
686 exceptions. The exceptions are sysvr4 shared libraries, whose
687 offsets are kept in solib structures anyway and rs6000 xcoff
688 which handles shared libraries in a completely unique way.
690 Section offsets are built similarly, except that they are built
691 by adding addr in all cases because there is no clear mapping
692 from section_offsets into actual sections. Note that solib.c
693 has a different algorithm for finding section offsets.
695 These should probably all be collapsed into some target
696 independent form of shared library support. FIXME. */
700 struct obj_section
*s
;
702 /* Map section offsets in "addr" back to the object's
703 sections by comparing the section names with bfd's
704 section names. Then adjust the section address by
705 the offset. */ /* for gdb/13815 */
707 ALL_OBJFILE_OSECTIONS (objfile
, s
)
709 CORE_ADDR s_addr
= 0;
713 !s_addr
&& i
< MAX_SECTIONS
&& addrs
->other
[i
].name
;
715 if (strcmp (s
->the_bfd_section
->name
, addrs
->other
[i
].name
) == 0)
716 s_addr
= addrs
->other
[i
].addr
; /* end added for gdb/13815 */
718 s
->addr
-= s
->offset
;
720 s
->endaddr
-= s
->offset
;
721 s
->endaddr
+= s_addr
;
725 #endif /* not IBM6000_TARGET */
727 (*objfile
->sf
->sym_read
) (objfile
, mainline
);
729 if (!have_partial_symbols () && !have_full_symbols ())
732 printf_filtered ("(no debugging symbols found)...");
736 /* Don't allow char * to have a typename (else would get caddr_t).
737 Ditto void *. FIXME: Check whether this is now done by all the
738 symbol readers themselves (many of them now do), and if so remove
741 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
742 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
744 /* Mark the objfile has having had initial symbol read attempted. Note
745 that this does not mean we found any symbols... */
747 objfile
->flags
|= OBJF_SYMS
;
749 /* Discard cleanups as symbol reading was successful. */
751 discard_cleanups (old_chain
);
753 /* Call this after reading in a new symbol table to give target
754 dependent code a crack at the new symbols. For instance, this
755 could be used to update the values of target-specific symbols GDB
756 needs to keep track of (such as _sigtramp, or whatever). */
758 TARGET_SYMFILE_POSTREAD (objfile
);
761 /* Perform required actions after either reading in the initial
762 symbols for a new objfile, or mapping in the symbols from a reusable
766 new_symfile_objfile (struct objfile
*objfile
, int mainline
, int verbo
)
769 /* If this is the main symbol file we have to clean up all users of the
770 old main symbol file. Otherwise it is sufficient to fixup all the
771 breakpoints that may have been redefined by this symbol file. */
774 /* OK, make it the "real" symbol file. */
775 symfile_objfile
= objfile
;
777 clear_symtab_users ();
781 breakpoint_re_set ();
784 /* We're done reading the symbol file; finish off complaints. */
785 clear_complaints (0, verbo
);
788 /* Process a symbol file, as either the main file or as a dynamically
791 NAME is the file name (which will be tilde-expanded and made
792 absolute herein) (but we don't free or modify NAME itself).
793 FROM_TTY says how verbose to be. MAINLINE specifies whether this
794 is the main symbol file, or whether it's an extra symbol file such
795 as dynamically loaded code. If !mainline, ADDR is the address
796 where the text segment was loaded.
798 Upon success, returns a pointer to the objfile that was added.
799 Upon failure, jumps back to command level (never returns). */
802 symbol_file_add (char *name
, int from_tty
, struct section_addr_info
*addrs
,
803 int mainline
, int flags
)
805 struct objfile
*objfile
;
806 struct partial_symtab
*psymtab
;
809 /* Open a bfd for the file, and give user a chance to burp if we'd be
810 interactively wiping out any existing symbols. */
812 abfd
= symfile_bfd_open (name
);
814 if ((have_full_symbols () || have_partial_symbols ())
817 && !query ("Load new symbol table from \"%s\"? ", name
))
818 error ("Not confirmed.");
820 objfile
= allocate_objfile (abfd
, flags
);
822 /* If the objfile uses a mapped symbol file, and we have a psymtab for
823 it, then skip reading any symbols at this time. */
825 if ((objfile
->flags
& OBJF_MAPPED
) && (objfile
->flags
& OBJF_SYMS
))
827 /* We mapped in an existing symbol table file that already has had
828 initial symbol reading performed, so we can skip that part. Notify
829 the user that instead of reading the symbols, they have been mapped.
831 if (from_tty
|| info_verbose
)
833 printf_filtered ("Mapped symbols for %s...", name
);
835 gdb_flush (gdb_stdout
);
837 init_entry_point_info (objfile
);
838 find_sym_fns (objfile
);
842 /* We either created a new mapped symbol table, mapped an existing
843 symbol table file which has not had initial symbol reading
844 performed, or need to read an unmapped symbol table. */
845 if (from_tty
|| info_verbose
)
847 if (pre_add_symbol_hook
)
848 pre_add_symbol_hook (name
);
851 printf_filtered ("Reading symbols from %s...", name
);
853 gdb_flush (gdb_stdout
);
856 syms_from_objfile (objfile
, addrs
, mainline
, from_tty
);
859 /* We now have at least a partial symbol table. Check to see if the
860 user requested that all symbols be read on initial access via either
861 the gdb startup command line or on a per symbol file basis. Expand
862 all partial symbol tables for this objfile if so. */
864 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
866 if (from_tty
|| info_verbose
)
868 printf_filtered ("expanding to full symbols...");
870 gdb_flush (gdb_stdout
);
873 for (psymtab
= objfile
->psymtabs
;
875 psymtab
= psymtab
->next
)
877 psymtab_to_symtab (psymtab
);
881 if (from_tty
|| info_verbose
)
883 if (post_add_symbol_hook
)
884 post_add_symbol_hook ();
887 printf_filtered ("done.\n");
888 gdb_flush (gdb_stdout
);
892 new_symfile_objfile (objfile
, mainline
, from_tty
);
894 if (target_new_objfile_hook
)
895 target_new_objfile_hook (objfile
);
900 /* Just call the above with default values.
901 Used when the file is supplied in the gdb command line. */
904 symbol_file_add_main (char *args
, int from_tty
)
906 symbol_file_add (args
, from_tty
, NULL
, 1, 0);
910 symbol_file_clear (int from_tty
)
912 if ((have_full_symbols () || have_partial_symbols ())
914 && !query ("Discard symbol table from `%s'? ",
915 symfile_objfile
->name
))
916 error ("Not confirmed.");
917 free_all_objfiles ();
919 /* solib descriptors may have handles to objfiles. Since their
920 storage has just been released, we'd better wipe the solib
923 #if defined(SOLIB_RESTART)
927 symfile_objfile
= NULL
;
929 printf_unfiltered ("No symbol file now.\n");
931 RESET_HP_UX_GLOBALS ();
935 /* This is the symbol-file command. Read the file, analyze its
936 symbols, and add a struct symtab to a symtab list. The syntax of
937 the command is rather bizarre--(1) buildargv implements various
938 quoting conventions which are undocumented and have little or
939 nothing in common with the way things are quoted (or not quoted)
940 elsewhere in GDB, (2) options are used, which are not generally
941 used in GDB (perhaps "set mapped on", "set readnow on" would be
942 better), (3) the order of options matters, which is contrary to GNU
943 conventions (because it is confusing and inconvenient). */
944 /* Note: ezannoni 2000-04-17. This function used to have support for
945 rombug (see remote-os9k.c). It consisted of a call to target_link()
946 (target.c) to get the address of the text segment from the target,
947 and pass that to symbol_file_add(). This is no longer supported. */
950 symbol_file_command (char *args
, int from_tty
)
954 struct cleanup
*cleanups
;
955 int flags
= OBJF_USERLOADED
;
961 symbol_file_clear (from_tty
);
965 if ((argv
= buildargv (args
)) == NULL
)
969 cleanups
= make_cleanup_freeargv (argv
);
970 while (*argv
!= NULL
)
972 if (STREQ (*argv
, "-mapped"))
973 flags
|= OBJF_MAPPED
;
975 if (STREQ (*argv
, "-readnow"))
976 flags
|= OBJF_READNOW
;
979 error ("unknown option `%s'", *argv
);
983 symbol_file_add (name
, from_tty
, NULL
, 1, flags
);
985 RESET_HP_UX_GLOBALS ();
987 /* Getting new symbols may change our opinion about
988 what is frameless. */
989 reinit_frame_cache ();
991 set_initial_language ();
998 error ("no symbol file name was specified");
1000 TUIDO (((TuiOpaqueFuncPtr
) tuiDisplayMainFunction
));
1001 do_cleanups (cleanups
);
1005 /* Set the initial language.
1007 A better solution would be to record the language in the psymtab when reading
1008 partial symbols, and then use it (if known) to set the language. This would
1009 be a win for formats that encode the language in an easily discoverable place,
1010 such as DWARF. For stabs, we can jump through hoops looking for specially
1011 named symbols or try to intuit the language from the specific type of stabs
1012 we find, but we can't do that until later when we read in full symbols.
1016 set_initial_language (void)
1018 struct partial_symtab
*pst
;
1019 enum language lang
= language_unknown
;
1021 pst
= find_main_psymtab ();
1024 if (pst
->filename
!= NULL
)
1026 lang
= deduce_language_from_filename (pst
->filename
);
1028 if (lang
== language_unknown
)
1030 /* Make C the default language */
1033 set_language (lang
);
1034 expected_language
= current_language
; /* Don't warn the user */
1038 /* Open file specified by NAME and hand it off to BFD for preliminary
1039 analysis. Result is a newly initialized bfd *, which includes a newly
1040 malloc'd` copy of NAME (tilde-expanded and made absolute).
1041 In case of trouble, error() is called. */
1044 symfile_bfd_open (char *name
)
1048 char *absolute_name
;
1052 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
1054 /* Look down path for it, allocate 2nd new malloc'd copy. */
1055 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1056 #if defined(__GO32__) || defined(_WIN32)
1059 char *exename
= alloca (strlen (name
) + 5);
1060 strcat (strcpy (exename
, name
), ".exe");
1061 desc
= openp (getenv ("PATH"), 1, exename
, O_RDONLY
| O_BINARY
,
1067 make_cleanup (xfree
, name
);
1068 perror_with_name (name
);
1070 xfree (name
); /* Free 1st new malloc'd copy */
1071 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
1072 /* It'll be freed in free_objfile(). */
1074 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
1078 make_cleanup (xfree
, name
);
1079 error ("\"%s\": can't open to read symbols: %s.", name
,
1080 bfd_errmsg (bfd_get_error ()));
1082 sym_bfd
->cacheable
= true;
1084 if (!bfd_check_format (sym_bfd
, bfd_object
))
1086 /* FIXME: should be checking for errors from bfd_close (for one thing,
1087 on error it does not free all the storage associated with the
1089 bfd_close (sym_bfd
); /* This also closes desc */
1090 make_cleanup (xfree
, name
);
1091 error ("\"%s\": can't read symbols: %s.", name
,
1092 bfd_errmsg (bfd_get_error ()));
1097 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
1098 startup by the _initialize routine in each object file format reader,
1099 to register information about each format the the reader is prepared
1103 add_symtab_fns (struct sym_fns
*sf
)
1105 sf
->next
= symtab_fns
;
1110 /* Initialize to read symbols from the symbol file sym_bfd. It either
1111 returns or calls error(). The result is an initialized struct sym_fns
1112 in the objfile structure, that contains cached information about the
1116 find_sym_fns (struct objfile
*objfile
)
1119 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
->obfd
);
1120 char *our_target
= bfd_get_target (objfile
->obfd
);
1122 /* Special kludge for apollo. See dstread.c. */
1123 if (STREQN (our_target
, "apollo", 6))
1124 our_flavour
= (enum bfd_flavour
) -2;
1126 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1128 if (our_flavour
== sf
->sym_flavour
)
1134 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
1135 bfd_get_target (objfile
->obfd
));
1138 /* This function runs the load command of our current target. */
1141 load_command (char *arg
, int from_tty
)
1144 arg
= get_exec_file (1);
1145 target_load (arg
, from_tty
);
1148 /* This version of "load" should be usable for any target. Currently
1149 it is just used for remote targets, not inftarg.c or core files,
1150 on the theory that only in that case is it useful.
1152 Avoiding xmodem and the like seems like a win (a) because we don't have
1153 to worry about finding it, and (b) On VMS, fork() is very slow and so
1154 we don't want to run a subprocess. On the other hand, I'm not sure how
1155 performance compares. */
1157 static int download_write_size
= 512;
1158 static int validate_download
= 0;
1161 generic_load (char *args
, int from_tty
)
1165 time_t start_time
, end_time
; /* Start and end times of download */
1166 unsigned long data_count
= 0; /* Number of bytes transferred to memory */
1167 unsigned long write_count
= 0; /* Number of writes needed. */
1168 unsigned long load_offset
; /* offset to add to vma for each section */
1170 struct cleanup
*old_cleanups
;
1172 CORE_ADDR total_size
= 0;
1173 CORE_ADDR total_sent
= 0;
1175 /* Parse the input argument - the user can specify a load offset as
1176 a second argument. */
1177 filename
= xmalloc (strlen (args
) + 1);
1178 old_cleanups
= make_cleanup (xfree
, filename
);
1179 strcpy (filename
, args
);
1180 offptr
= strchr (filename
, ' ');
1184 load_offset
= strtoul (offptr
, &endptr
, 0);
1185 if (offptr
== endptr
)
1186 error ("Invalid download offset:%s\n", offptr
);
1192 /* Open the file for loading. */
1193 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1194 if (loadfile_bfd
== NULL
)
1196 perror_with_name (filename
);
1200 /* FIXME: should be checking for errors from bfd_close (for one thing,
1201 on error it does not free all the storage associated with the
1203 make_cleanup_bfd_close (loadfile_bfd
);
1205 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1207 error ("\"%s\" is not an object file: %s", filename
,
1208 bfd_errmsg (bfd_get_error ()));
1211 for (s
= loadfile_bfd
->sections
; s
; s
= s
->next
)
1212 if (s
->flags
& SEC_LOAD
)
1213 total_size
+= bfd_get_section_size_before_reloc (s
);
1215 start_time
= time (NULL
);
1217 for (s
= loadfile_bfd
->sections
; s
; s
= s
->next
)
1219 if (s
->flags
& SEC_LOAD
)
1221 CORE_ADDR size
= bfd_get_section_size_before_reloc (s
);
1225 struct cleanup
*old_chain
;
1226 CORE_ADDR lma
= s
->lma
+ load_offset
;
1227 CORE_ADDR block_size
;
1229 const char *sect_name
= bfd_get_section_name (loadfile_bfd
, s
);
1232 if (download_write_size
> 0 && size
> download_write_size
)
1233 block_size
= download_write_size
;
1237 buffer
= xmalloc (size
);
1238 old_chain
= make_cleanup (xfree
, buffer
);
1240 /* Is this really necessary? I guess it gives the user something
1241 to look at during a long download. */
1243 ui_out_message (uiout
, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1244 sect_name
, paddr_nz (size
), paddr_nz (lma
));
1246 fprintf_unfiltered (gdb_stdout
,
1247 "Loading section %s, size 0x%s lma 0x%s\n",
1248 sect_name
, paddr_nz (size
), paddr_nz (lma
));
1251 bfd_get_section_contents (loadfile_bfd
, s
, buffer
, 0, size
);
1257 CORE_ADDR this_transfer
= size
- sent
;
1258 if (this_transfer
>= block_size
)
1259 this_transfer
= block_size
;
1260 len
= target_write_memory_partial (lma
, buffer
,
1261 this_transfer
, &err
);
1264 if (validate_download
)
1266 /* Broken memories and broken monitors manifest
1267 themselves here when bring new computers to
1268 life. This doubles already slow downloads. */
1269 /* NOTE: cagney/1999-10-18: A more efficient
1270 implementation might add a verify_memory()
1271 method to the target vector and then use
1272 that. remote.c could implement that method
1273 using the ``qCRC'' packet. */
1274 char *check
= xmalloc (len
);
1275 struct cleanup
*verify_cleanups
= make_cleanup (xfree
, check
);
1276 if (target_read_memory (lma
, check
, len
) != 0)
1277 error ("Download verify read failed at 0x%s",
1279 if (memcmp (buffer
, check
, len
) != 0)
1280 error ("Download verify compare failed at 0x%s",
1282 do_cleanups (verify_cleanups
);
1291 || (ui_load_progress_hook
!= NULL
1292 && ui_load_progress_hook (sect_name
, sent
)))
1293 error ("Canceled the download");
1295 if (show_load_progress
!= NULL
)
1296 show_load_progress (sect_name
, sent
, size
, total_sent
, total_size
);
1298 while (sent
< size
);
1301 error ("Memory access error while loading section %s.", sect_name
);
1303 do_cleanups (old_chain
);
1308 end_time
= time (NULL
);
1311 entry
= bfd_get_start_address (loadfile_bfd
);
1313 ui_out_text (uiout
, "Start address ");
1314 ui_out_field_fmt (uiout
, "address", "0x%s" , paddr_nz (entry
));
1315 ui_out_text (uiout
, ", load size ");
1316 ui_out_field_fmt (uiout
, "load-size", "%ld" , data_count
);
1317 ui_out_text (uiout
, "\n");
1320 fprintf_unfiltered (gdb_stdout
,
1321 "Start address 0x%s , load size %ld\n",
1322 paddr_nz (entry
), data_count
);
1324 /* We were doing this in remote-mips.c, I suspect it is right
1325 for other targets too. */
1329 /* FIXME: are we supposed to call symbol_file_add or not? According to
1330 a comment from remote-mips.c (where a call to symbol_file_add was
1331 commented out), making the call confuses GDB if more than one file is
1332 loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
1335 print_transfer_performance (gdb_stdout
, data_count
, write_count
,
1336 end_time
- start_time
);
1338 do_cleanups (old_cleanups
);
1341 /* Report how fast the transfer went. */
1343 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1344 replaced by print_transfer_performance (with a very different
1345 function signature). */
1348 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1351 print_transfer_performance (gdb_stdout
, data_count
, end_time
- start_time
, 0);
1355 print_transfer_performance (struct ui_file
*stream
,
1356 unsigned long data_count
,
1357 unsigned long write_count
,
1358 unsigned long time_count
)
1361 ui_out_text (uiout
, "Transfer rate: ");
1364 ui_out_field_fmt (uiout
, "transfer-rate", "%ld",
1365 (data_count
* 8) / time_count
);
1366 ui_out_text (uiout
, " bits/sec");
1370 ui_out_field_fmt (uiout
, "transferred-bits", "%ld", (data_count
* 8));
1371 ui_out_text (uiout
, " bits in <1 sec");
1373 if (write_count
> 0)
1375 ui_out_text (uiout
, ", ");
1376 ui_out_field_fmt (uiout
, "write-rate", "%ld", data_count
/ write_count
);
1377 ui_out_text (uiout
, " bytes/write");
1379 ui_out_text (uiout
, ".\n");
1381 fprintf_unfiltered (stream
, "Transfer rate: ");
1383 fprintf_unfiltered (stream
, "%ld bits/sec", (data_count
* 8) / time_count
);
1385 fprintf_unfiltered (stream
, "%ld bits in <1 sec", (data_count
* 8));
1386 if (write_count
> 0)
1387 fprintf_unfiltered (stream
, ", %ld bytes/write", data_count
/ write_count
);
1388 fprintf_unfiltered (stream
, ".\n");
1392 /* This function allows the addition of incrementally linked object files.
1393 It does not modify any state in the target, only in the debugger. */
1394 /* Note: ezannoni 2000-04-13 This function/command used to have a
1395 special case syntax for the rombug target (Rombug is the boot
1396 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1397 rombug case, the user doesn't need to supply a text address,
1398 instead a call to target_link() (in target.c) would supply the
1399 value to use. We are now discontinuing this type of ad hoc syntax. */
1403 add_symbol_file_command (char *args
, int from_tty
)
1405 char *filename
= NULL
;
1406 int flags
= OBJF_USERLOADED
;
1408 int expecting_option
= 0;
1409 int section_index
= 0;
1413 int expecting_sec_name
= 0;
1414 int expecting_sec_addr
= 0;
1420 } sect_opts
[SECT_OFF_MAX
];
1422 struct section_addr_info section_addrs
;
1423 struct cleanup
*my_cleanups
;
1428 error ("add-symbol-file takes a file name and an address");
1430 /* Make a copy of the string that we can safely write into. */
1431 args
= xstrdup (args
);
1433 /* Ensure section_addrs is initialized */
1434 memset (§ion_addrs
, 0, sizeof (section_addrs
));
1436 while (*args
!= '\000')
1438 /* Any leading spaces? */
1439 while (isspace (*args
))
1442 /* Point arg to the beginning of the argument. */
1445 /* Move args pointer over the argument. */
1446 while ((*args
!= '\000') && !isspace (*args
))
1449 /* If there are more arguments, terminate arg and
1451 if (*args
!= '\000')
1454 /* Now process the argument. */
1457 /* The first argument is the file name. */
1458 filename
= tilde_expand (arg
);
1459 my_cleanups
= make_cleanup (xfree
, filename
);
1464 /* The second argument is always the text address at which
1465 to load the program. */
1466 sect_opts
[section_index
].name
= ".text";
1467 sect_opts
[section_index
].value
= arg
;
1472 /* It's an option (starting with '-') or it's an argument
1477 if (strcmp (arg
, "-mapped") == 0)
1478 flags
|= OBJF_MAPPED
;
1480 if (strcmp (arg
, "-readnow") == 0)
1481 flags
|= OBJF_READNOW
;
1483 if (strcmp (arg
, "-s") == 0)
1485 if (section_index
>= SECT_OFF_MAX
)
1486 error ("Too many sections specified.");
1487 expecting_sec_name
= 1;
1488 expecting_sec_addr
= 1;
1493 if (expecting_sec_name
)
1495 sect_opts
[section_index
].name
= arg
;
1496 expecting_sec_name
= 0;
1499 if (expecting_sec_addr
)
1501 sect_opts
[section_index
].value
= arg
;
1502 expecting_sec_addr
= 0;
1506 error ("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*");
1512 /* Print the prompt for the query below. And save the arguments into
1513 a sect_addr_info structure to be passed around to other
1514 functions. We have to split this up into separate print
1515 statements because local_hex_string returns a local static
1518 printf_filtered ("add symbol table from file \"%s\" at\n", filename
);
1519 for (i
= 0; i
< section_index
; i
++)
1522 char *val
= sect_opts
[i
].value
;
1523 char *sec
= sect_opts
[i
].name
;
1525 val
= sect_opts
[i
].value
;
1526 if (val
[0] == '0' && val
[1] == 'x')
1527 addr
= strtoul (val
+2, NULL
, 16);
1529 addr
= strtoul (val
, NULL
, 10);
1531 /* Here we store the section offsets in the order they were
1532 entered on the command line. */
1533 section_addrs
.other
[sec_num
].name
= sec
;
1534 section_addrs
.other
[sec_num
].addr
= addr
;
1535 printf_filtered ("\t%s_addr = %s\n",
1537 local_hex_string ((unsigned long)addr
));
1540 /* The object's sections are initialized when a
1541 call is made to build_objfile_section_table (objfile).
1542 This happens in reread_symbols.
1543 At this point, we don't know what file type this is,
1544 so we can't determine what section names are valid. */
1547 if (from_tty
&& (!query ("%s", "")))
1548 error ("Not confirmed.");
1550 symbol_file_add (filename
, from_tty
, §ion_addrs
, 0, flags
);
1552 /* Getting new symbols may change our opinion about what is
1554 reinit_frame_cache ();
1555 do_cleanups (my_cleanups
);
1559 add_shared_symbol_files_command (char *args
, int from_tty
)
1561 #ifdef ADD_SHARED_SYMBOL_FILES
1562 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1564 error ("This command is not available in this configuration of GDB.");
1568 /* Re-read symbols if a symbol-file has changed. */
1570 reread_symbols (void)
1572 struct objfile
*objfile
;
1575 struct stat new_statbuf
;
1578 /* With the addition of shared libraries, this should be modified,
1579 the load time should be saved in the partial symbol tables, since
1580 different tables may come from different source files. FIXME.
1581 This routine should then walk down each partial symbol table
1582 and see if the symbol table that it originates from has been changed */
1584 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
1588 #ifdef IBM6000_TARGET
1589 /* If this object is from a shared library, then you should
1590 stat on the library name, not member name. */
1592 if (objfile
->obfd
->my_archive
)
1593 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1596 res
= stat (objfile
->name
, &new_statbuf
);
1599 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1600 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1604 new_modtime
= new_statbuf
.st_mtime
;
1605 if (new_modtime
!= objfile
->mtime
)
1607 struct cleanup
*old_cleanups
;
1608 struct section_offsets
*offsets
;
1610 char *obfd_filename
;
1612 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1615 /* There are various functions like symbol_file_add,
1616 symfile_bfd_open, syms_from_objfile, etc., which might
1617 appear to do what we want. But they have various other
1618 effects which we *don't* want. So we just do stuff
1619 ourselves. We don't worry about mapped files (for one thing,
1620 any mapped file will be out of date). */
1622 /* If we get an error, blow away this objfile (not sure if
1623 that is the correct response for things like shared
1625 old_cleanups
= make_cleanup_free_objfile (objfile
);
1626 /* We need to do this whenever any symbols go away. */
1627 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1629 /* Clean up any state BFD has sitting around. We don't need
1630 to close the descriptor but BFD lacks a way of closing the
1631 BFD without closing the descriptor. */
1632 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1633 if (!bfd_close (objfile
->obfd
))
1634 error ("Can't close BFD for %s: %s", objfile
->name
,
1635 bfd_errmsg (bfd_get_error ()));
1636 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1637 if (objfile
->obfd
== NULL
)
1638 error ("Can't open %s to read symbols.", objfile
->name
);
1639 /* bfd_openr sets cacheable to true, which is what we want. */
1640 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1641 error ("Can't read symbols from %s: %s.", objfile
->name
,
1642 bfd_errmsg (bfd_get_error ()));
1644 /* Save the offsets, we will nuke them with the rest of the
1646 num_offsets
= objfile
->num_sections
;
1647 offsets
= (struct section_offsets
*) alloca (SIZEOF_SECTION_OFFSETS
);
1648 memcpy (offsets
, objfile
->section_offsets
, SIZEOF_SECTION_OFFSETS
);
1650 /* Nuke all the state that we will re-read. Much of the following
1651 code which sets things to NULL really is necessary to tell
1652 other parts of GDB that there is nothing currently there. */
1654 /* FIXME: Do we have to free a whole linked list, or is this
1656 if (objfile
->global_psymbols
.list
)
1657 mfree (objfile
->md
, objfile
->global_psymbols
.list
);
1658 memset (&objfile
->global_psymbols
, 0,
1659 sizeof (objfile
->global_psymbols
));
1660 if (objfile
->static_psymbols
.list
)
1661 mfree (objfile
->md
, objfile
->static_psymbols
.list
);
1662 memset (&objfile
->static_psymbols
, 0,
1663 sizeof (objfile
->static_psymbols
));
1665 /* Free the obstacks for non-reusable objfiles */
1666 free_bcache (&objfile
->psymbol_cache
);
1667 obstack_free (&objfile
->psymbol_obstack
, 0);
1668 obstack_free (&objfile
->symbol_obstack
, 0);
1669 obstack_free (&objfile
->type_obstack
, 0);
1670 objfile
->sections
= NULL
;
1671 objfile
->symtabs
= NULL
;
1672 objfile
->psymtabs
= NULL
;
1673 objfile
->free_psymtabs
= NULL
;
1674 objfile
->msymbols
= NULL
;
1675 objfile
->minimal_symbol_count
= 0;
1676 memset (&objfile
->msymbol_hash
, 0,
1677 sizeof (objfile
->msymbol_hash
));
1678 memset (&objfile
->msymbol_demangled_hash
, 0,
1679 sizeof (objfile
->msymbol_demangled_hash
));
1680 objfile
->fundamental_types
= NULL
;
1681 if (objfile
->sf
!= NULL
)
1683 (*objfile
->sf
->sym_finish
) (objfile
);
1686 /* We never make this a mapped file. */
1688 /* obstack_specify_allocation also initializes the obstack so
1690 obstack_specify_allocation (&objfile
->psymbol_cache
.cache
, 0, 0,
1692 obstack_specify_allocation (&objfile
->psymbol_obstack
, 0, 0,
1694 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0,
1696 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0,
1698 if (build_objfile_section_table (objfile
))
1700 error ("Can't find the file sections in `%s': %s",
1701 objfile
->name
, bfd_errmsg (bfd_get_error ()));
1704 /* We use the same section offsets as from last time. I'm not
1705 sure whether that is always correct for shared libraries. */
1706 objfile
->section_offsets
= (struct section_offsets
*)
1707 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
1708 memcpy (objfile
->section_offsets
, offsets
, SIZEOF_SECTION_OFFSETS
);
1709 objfile
->num_sections
= num_offsets
;
1711 /* What the hell is sym_new_init for, anyway? The concept of
1712 distinguishing between the main file and additional files
1713 in this way seems rather dubious. */
1714 if (objfile
== symfile_objfile
)
1716 (*objfile
->sf
->sym_new_init
) (objfile
);
1718 RESET_HP_UX_GLOBALS ();
1722 (*objfile
->sf
->sym_init
) (objfile
);
1723 clear_complaints (1, 1);
1724 /* The "mainline" parameter is a hideous hack; I think leaving it
1725 zero is OK since dbxread.c also does what it needs to do if
1726 objfile->global_psymbols.size is 0. */
1727 (*objfile
->sf
->sym_read
) (objfile
, 0);
1728 if (!have_partial_symbols () && !have_full_symbols ())
1731 printf_filtered ("(no debugging symbols found)\n");
1734 objfile
->flags
|= OBJF_SYMS
;
1736 /* We're done reading the symbol file; finish off complaints. */
1737 clear_complaints (0, 1);
1739 /* Getting new symbols may change our opinion about what is
1742 reinit_frame_cache ();
1744 /* Discard cleanups as symbol reading was successful. */
1745 discard_cleanups (old_cleanups
);
1747 /* If the mtime has changed between the time we set new_modtime
1748 and now, we *want* this to be out of date, so don't call stat
1750 objfile
->mtime
= new_modtime
;
1753 /* Call this after reading in a new symbol table to give target
1754 dependent code a crack at the new symbols. For instance, this
1755 could be used to update the values of target-specific symbols GDB
1756 needs to keep track of (such as _sigtramp, or whatever). */
1758 TARGET_SYMFILE_POSTREAD (objfile
);
1764 clear_symtab_users ();
1776 static filename_language
*filename_language_table
;
1777 static int fl_table_size
, fl_table_next
;
1780 add_filename_language (char *ext
, enum language lang
)
1782 if (fl_table_next
>= fl_table_size
)
1784 fl_table_size
+= 10;
1785 filename_language_table
= realloc (filename_language_table
,
1789 filename_language_table
[fl_table_next
].ext
= strsave (ext
);
1790 filename_language_table
[fl_table_next
].lang
= lang
;
1794 static char *ext_args
;
1797 set_ext_lang_command (char *args
, int from_tty
)
1800 char *cp
= ext_args
;
1803 /* First arg is filename extension, starting with '.' */
1805 error ("'%s': Filename extension must begin with '.'", ext_args
);
1807 /* Find end of first arg. */
1808 while (*cp
&& !isspace (*cp
))
1812 error ("'%s': two arguments required -- filename extension and language",
1815 /* Null-terminate first arg */
1818 /* Find beginning of second arg, which should be a source language. */
1819 while (*cp
&& isspace (*cp
))
1823 error ("'%s': two arguments required -- filename extension and language",
1826 /* Lookup the language from among those we know. */
1827 lang
= language_enum (cp
);
1829 /* Now lookup the filename extension: do we already know it? */
1830 for (i
= 0; i
< fl_table_next
; i
++)
1831 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
1834 if (i
>= fl_table_next
)
1836 /* new file extension */
1837 add_filename_language (ext_args
, lang
);
1841 /* redefining a previously known filename extension */
1844 /* query ("Really make files of type %s '%s'?", */
1845 /* ext_args, language_str (lang)); */
1847 xfree (filename_language_table
[i
].ext
);
1848 filename_language_table
[i
].ext
= strsave (ext_args
);
1849 filename_language_table
[i
].lang
= lang
;
1854 info_ext_lang_command (char *args
, int from_tty
)
1858 printf_filtered ("Filename extensions and the languages they represent:");
1859 printf_filtered ("\n\n");
1860 for (i
= 0; i
< fl_table_next
; i
++)
1861 printf_filtered ("\t%s\t- %s\n",
1862 filename_language_table
[i
].ext
,
1863 language_str (filename_language_table
[i
].lang
));
1867 init_filename_language_table (void)
1869 if (fl_table_size
== 0) /* protect against repetition */
1873 filename_language_table
=
1874 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
1875 add_filename_language (".c", language_c
);
1876 add_filename_language (".C", language_cplus
);
1877 add_filename_language (".cc", language_cplus
);
1878 add_filename_language (".cp", language_cplus
);
1879 add_filename_language (".cpp", language_cplus
);
1880 add_filename_language (".cxx", language_cplus
);
1881 add_filename_language (".c++", language_cplus
);
1882 add_filename_language (".java", language_java
);
1883 add_filename_language (".class", language_java
);
1884 add_filename_language (".ch", language_chill
);
1885 add_filename_language (".c186", language_chill
);
1886 add_filename_language (".c286", language_chill
);
1887 add_filename_language (".f", language_fortran
);
1888 add_filename_language (".F", language_fortran
);
1889 add_filename_language (".s", language_asm
);
1890 add_filename_language (".S", language_asm
);
1891 add_filename_language (".pas", language_pascal
);
1892 add_filename_language (".p", language_pascal
);
1893 add_filename_language (".pp", language_pascal
);
1898 deduce_language_from_filename (char *filename
)
1903 if (filename
!= NULL
)
1904 if ((cp
= strrchr (filename
, '.')) != NULL
)
1905 for (i
= 0; i
< fl_table_next
; i
++)
1906 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
1907 return filename_language_table
[i
].lang
;
1909 return language_unknown
;
1914 Allocate and partly initialize a new symbol table. Return a pointer
1915 to it. error() if no space.
1917 Caller must set these fields:
1923 possibly free_named_symtabs (symtab->filename);
1927 allocate_symtab (char *filename
, struct objfile
*objfile
)
1929 register struct symtab
*symtab
;
1931 symtab
= (struct symtab
*)
1932 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct symtab
));
1933 memset (symtab
, 0, sizeof (*symtab
));
1934 symtab
->filename
= obsavestring (filename
, strlen (filename
),
1935 &objfile
->symbol_obstack
);
1936 symtab
->fullname
= NULL
;
1937 symtab
->language
= deduce_language_from_filename (filename
);
1938 symtab
->debugformat
= obsavestring ("unknown", 7,
1939 &objfile
->symbol_obstack
);
1941 /* Hook it to the objfile it comes from */
1943 symtab
->objfile
= objfile
;
1944 symtab
->next
= objfile
->symtabs
;
1945 objfile
->symtabs
= symtab
;
1947 /* FIXME: This should go away. It is only defined for the Z8000,
1948 and the Z8000 definition of this macro doesn't have anything to
1949 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
1950 here for convenience. */
1951 #ifdef INIT_EXTRA_SYMTAB_INFO
1952 INIT_EXTRA_SYMTAB_INFO (symtab
);
1958 struct partial_symtab
*
1959 allocate_psymtab (char *filename
, struct objfile
*objfile
)
1961 struct partial_symtab
*psymtab
;
1963 if (objfile
->free_psymtabs
)
1965 psymtab
= objfile
->free_psymtabs
;
1966 objfile
->free_psymtabs
= psymtab
->next
;
1969 psymtab
= (struct partial_symtab
*)
1970 obstack_alloc (&objfile
->psymbol_obstack
,
1971 sizeof (struct partial_symtab
));
1973 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1974 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
1975 &objfile
->psymbol_obstack
);
1976 psymtab
->symtab
= NULL
;
1978 /* Prepend it to the psymtab list for the objfile it belongs to.
1979 Psymtabs are searched in most recent inserted -> least recent
1982 psymtab
->objfile
= objfile
;
1983 psymtab
->next
= objfile
->psymtabs
;
1984 objfile
->psymtabs
= psymtab
;
1987 struct partial_symtab
**prev_pst
;
1988 psymtab
->objfile
= objfile
;
1989 psymtab
->next
= NULL
;
1990 prev_pst
= &(objfile
->psymtabs
);
1991 while ((*prev_pst
) != NULL
)
1992 prev_pst
= &((*prev_pst
)->next
);
1993 (*prev_pst
) = psymtab
;
2001 discard_psymtab (struct partial_symtab
*pst
)
2003 struct partial_symtab
**prev_pst
;
2006 Empty psymtabs happen as a result of header files which don't
2007 have any symbols in them. There can be a lot of them. But this
2008 check is wrong, in that a psymtab with N_SLINE entries but
2009 nothing else is not empty, but we don't realize that. Fixing
2010 that without slowing things down might be tricky. */
2012 /* First, snip it out of the psymtab chain */
2014 prev_pst
= &(pst
->objfile
->psymtabs
);
2015 while ((*prev_pst
) != pst
)
2016 prev_pst
= &((*prev_pst
)->next
);
2017 (*prev_pst
) = pst
->next
;
2019 /* Next, put it on a free list for recycling */
2021 pst
->next
= pst
->objfile
->free_psymtabs
;
2022 pst
->objfile
->free_psymtabs
= pst
;
2026 /* Reset all data structures in gdb which may contain references to symbol
2030 clear_symtab_users (void)
2032 /* Someday, we should do better than this, by only blowing away
2033 the things that really need to be blown. */
2034 clear_value_history ();
2036 clear_internalvars ();
2037 breakpoint_re_set ();
2038 set_default_breakpoint (0, 0, 0, 0);
2039 current_source_symtab
= 0;
2040 current_source_line
= 0;
2041 clear_pc_function_cache ();
2042 if (target_new_objfile_hook
)
2043 target_new_objfile_hook (NULL
);
2047 clear_symtab_users_cleanup (void *ignore
)
2049 clear_symtab_users ();
2052 /* clear_symtab_users_once:
2054 This function is run after symbol reading, or from a cleanup.
2055 If an old symbol table was obsoleted, the old symbol table
2056 has been blown away, but the other GDB data structures that may
2057 reference it have not yet been cleared or re-directed. (The old
2058 symtab was zapped, and the cleanup queued, in free_named_symtab()
2061 This function can be queued N times as a cleanup, or called
2062 directly; it will do all the work the first time, and then will be a
2063 no-op until the next time it is queued. This works by bumping a
2064 counter at queueing time. Much later when the cleanup is run, or at
2065 the end of symbol processing (in case the cleanup is discarded), if
2066 the queued count is greater than the "done-count", we do the work
2067 and set the done-count to the queued count. If the queued count is
2068 less than or equal to the done-count, we just ignore the call. This
2069 is needed because reading a single .o file will often replace many
2070 symtabs (one per .h file, for example), and we don't want to reset
2071 the breakpoints N times in the user's face.
2073 The reason we both queue a cleanup, and call it directly after symbol
2074 reading, is because the cleanup protects us in case of errors, but is
2075 discarded if symbol reading is successful. */
2078 /* FIXME: As free_named_symtabs is currently a big noop this function
2079 is no longer needed. */
2080 static void clear_symtab_users_once (void);
2082 static int clear_symtab_users_queued
;
2083 static int clear_symtab_users_done
;
2086 clear_symtab_users_once (void)
2088 /* Enforce once-per-`do_cleanups'-semantics */
2089 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2091 clear_symtab_users_done
= clear_symtab_users_queued
;
2093 clear_symtab_users ();
2097 /* Delete the specified psymtab, and any others that reference it. */
2100 cashier_psymtab (struct partial_symtab
*pst
)
2102 struct partial_symtab
*ps
, *pprev
= NULL
;
2105 /* Find its previous psymtab in the chain */
2106 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2115 /* Unhook it from the chain. */
2116 if (ps
== pst
->objfile
->psymtabs
)
2117 pst
->objfile
->psymtabs
= ps
->next
;
2119 pprev
->next
= ps
->next
;
2121 /* FIXME, we can't conveniently deallocate the entries in the
2122 partial_symbol lists (global_psymbols/static_psymbols) that
2123 this psymtab points to. These just take up space until all
2124 the psymtabs are reclaimed. Ditto the dependencies list and
2125 filename, which are all in the psymbol_obstack. */
2127 /* We need to cashier any psymtab that has this one as a dependency... */
2129 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2131 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2133 if (ps
->dependencies
[i
] == pst
)
2135 cashier_psymtab (ps
);
2136 goto again
; /* Must restart, chain has been munged. */
2143 /* If a symtab or psymtab for filename NAME is found, free it along
2144 with any dependent breakpoints, displays, etc.
2145 Used when loading new versions of object modules with the "add-file"
2146 command. This is only called on the top-level symtab or psymtab's name;
2147 it is not called for subsidiary files such as .h files.
2149 Return value is 1 if we blew away the environment, 0 if not.
2150 FIXME. The return value appears to never be used.
2152 FIXME. I think this is not the best way to do this. We should
2153 work on being gentler to the environment while still cleaning up
2154 all stray pointers into the freed symtab. */
2157 free_named_symtabs (char *name
)
2160 /* FIXME: With the new method of each objfile having it's own
2161 psymtab list, this function needs serious rethinking. In particular,
2162 why was it ever necessary to toss psymtabs with specific compilation
2163 unit filenames, as opposed to all psymtabs from a particular symbol
2165 Well, the answer is that some systems permit reloading of particular
2166 compilation units. We want to blow away any old info about these
2167 compilation units, regardless of which objfiles they arrived in. --gnu. */
2169 register struct symtab
*s
;
2170 register struct symtab
*prev
;
2171 register struct partial_symtab
*ps
;
2172 struct blockvector
*bv
;
2175 /* We only wack things if the symbol-reload switch is set. */
2176 if (!symbol_reloading
)
2179 /* Some symbol formats have trouble providing file names... */
2180 if (name
== 0 || *name
== '\0')
2183 /* Look for a psymtab with the specified name. */
2186 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2188 if (STREQ (name
, ps
->filename
))
2190 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2191 goto again2
; /* Must restart, chain has been munged */
2195 /* Look for a symtab with the specified name. */
2197 for (s
= symtab_list
; s
; s
= s
->next
)
2199 if (STREQ (name
, s
->filename
))
2206 if (s
== symtab_list
)
2207 symtab_list
= s
->next
;
2209 prev
->next
= s
->next
;
2211 /* For now, queue a delete for all breakpoints, displays, etc., whether
2212 or not they depend on the symtab being freed. This should be
2213 changed so that only those data structures affected are deleted. */
2215 /* But don't delete anything if the symtab is empty.
2216 This test is necessary due to a bug in "dbxread.c" that
2217 causes empty symtabs to be created for N_SO symbols that
2218 contain the pathname of the object file. (This problem
2219 has been fixed in GDB 3.9x). */
2221 bv
= BLOCKVECTOR (s
);
2222 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2223 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2224 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2226 complain (&oldsyms_complaint
, name
);
2228 clear_symtab_users_queued
++;
2229 make_cleanup (clear_symtab_users_once
, 0);
2234 complain (&empty_symtab_complaint
, name
);
2241 /* It is still possible that some breakpoints will be affected
2242 even though no symtab was found, since the file might have
2243 been compiled without debugging, and hence not be associated
2244 with a symtab. In order to handle this correctly, we would need
2245 to keep a list of text address ranges for undebuggable files.
2246 For now, we do nothing, since this is a fairly obscure case. */
2250 /* FIXME, what about the minimal symbol table? */
2257 /* Allocate and partially fill a partial symtab. It will be
2258 completely filled at the end of the symbol list.
2260 FILENAME is the name of the symbol-file we are reading from. */
2262 struct partial_symtab
*
2263 start_psymtab_common (struct objfile
*objfile
,
2264 struct section_offsets
*section_offsets
, char *filename
,
2265 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2266 struct partial_symbol
**static_syms
)
2268 struct partial_symtab
*psymtab
;
2270 psymtab
= allocate_psymtab (filename
, objfile
);
2271 psymtab
->section_offsets
= section_offsets
;
2272 psymtab
->textlow
= textlow
;
2273 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2274 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2275 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2279 /* Add a symbol with a long value to a psymtab.
2280 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
2283 add_psymbol_to_list (char *name
, int namelength
, namespace_enum
namespace,
2284 enum address_class
class,
2285 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2286 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2287 enum language language
, struct objfile
*objfile
)
2289 register struct partial_symbol
*psym
;
2290 char *buf
= alloca (namelength
+ 1);
2291 /* psymbol is static so that there will be no uninitialized gaps in the
2292 structure which might contain random data, causing cache misses in
2294 static struct partial_symbol psymbol
;
2296 /* Create local copy of the partial symbol */
2297 memcpy (buf
, name
, namelength
);
2298 buf
[namelength
] = '\0';
2299 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, &objfile
->psymbol_cache
);
2300 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2303 SYMBOL_VALUE (&psymbol
) = val
;
2307 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2309 SYMBOL_SECTION (&psymbol
) = 0;
2310 SYMBOL_LANGUAGE (&psymbol
) = language
;
2311 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2312 PSYMBOL_CLASS (&psymbol
) = class;
2313 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2315 /* Stash the partial symbol away in the cache */
2316 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), &objfile
->psymbol_cache
);
2318 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2319 if (list
->next
>= list
->list
+ list
->size
)
2321 extend_psymbol_list (list
, objfile
);
2323 *list
->next
++ = psym
;
2324 OBJSTAT (objfile
, n_psyms
++);
2327 /* Add a symbol with a long value to a psymtab. This differs from
2328 * add_psymbol_to_list above in taking both a mangled and a demangled
2332 add_psymbol_with_dem_name_to_list (char *name
, int namelength
, char *dem_name
,
2333 int dem_namelength
, namespace_enum
namespace,
2334 enum address_class
class,
2335 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2336 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2337 enum language language
,
2338 struct objfile
*objfile
)
2340 register struct partial_symbol
*psym
;
2341 char *buf
= alloca (namelength
+ 1);
2342 /* psymbol is static so that there will be no uninitialized gaps in the
2343 structure which might contain random data, causing cache misses in
2345 static struct partial_symbol psymbol
;
2347 /* Create local copy of the partial symbol */
2349 memcpy (buf
, name
, namelength
);
2350 buf
[namelength
] = '\0';
2351 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, &objfile
->psymbol_cache
);
2353 buf
= alloca (dem_namelength
+ 1);
2354 memcpy (buf
, dem_name
, dem_namelength
);
2355 buf
[dem_namelength
] = '\0';
2360 case language_cplus
:
2361 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol
) =
2362 bcache (buf
, dem_namelength
+ 1, &objfile
->psymbol_cache
);
2364 case language_chill
:
2365 SYMBOL_CHILL_DEMANGLED_NAME (&psymbol
) =
2366 bcache (buf
, dem_namelength
+ 1, &objfile
->psymbol_cache
);
2368 /* FIXME What should be done for the default case? Ignoring for now. */
2371 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2374 SYMBOL_VALUE (&psymbol
) = val
;
2378 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2380 SYMBOL_SECTION (&psymbol
) = 0;
2381 SYMBOL_LANGUAGE (&psymbol
) = language
;
2382 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2383 PSYMBOL_CLASS (&psymbol
) = class;
2384 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2386 /* Stash the partial symbol away in the cache */
2387 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), &objfile
->psymbol_cache
);
2389 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2390 if (list
->next
>= list
->list
+ list
->size
)
2392 extend_psymbol_list (list
, objfile
);
2394 *list
->next
++ = psym
;
2395 OBJSTAT (objfile
, n_psyms
++);
2398 /* Initialize storage for partial symbols. */
2401 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
2403 /* Free any previously allocated psymbol lists. */
2405 if (objfile
->global_psymbols
.list
)
2407 mfree (objfile
->md
, (PTR
) objfile
->global_psymbols
.list
);
2409 if (objfile
->static_psymbols
.list
)
2411 mfree (objfile
->md
, (PTR
) objfile
->static_psymbols
.list
);
2414 /* Current best guess is that approximately a twentieth
2415 of the total symbols (in a debugging file) are global or static
2418 objfile
->global_psymbols
.size
= total_symbols
/ 10;
2419 objfile
->static_psymbols
.size
= total_symbols
/ 10;
2421 if (objfile
->global_psymbols
.size
> 0)
2423 objfile
->global_psymbols
.next
=
2424 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
2425 xmmalloc (objfile
->md
, (objfile
->global_psymbols
.size
2426 * sizeof (struct partial_symbol
*)));
2428 if (objfile
->static_psymbols
.size
> 0)
2430 objfile
->static_psymbols
.next
=
2431 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
2432 xmmalloc (objfile
->md
, (objfile
->static_psymbols
.size
2433 * sizeof (struct partial_symbol
*)));
2438 The following code implements an abstraction for debugging overlay sections.
2440 The target model is as follows:
2441 1) The gnu linker will permit multiple sections to be mapped into the
2442 same VMA, each with its own unique LMA (or load address).
2443 2) It is assumed that some runtime mechanism exists for mapping the
2444 sections, one by one, from the load address into the VMA address.
2445 3) This code provides a mechanism for gdb to keep track of which
2446 sections should be considered to be mapped from the VMA to the LMA.
2447 This information is used for symbol lookup, and memory read/write.
2448 For instance, if a section has been mapped then its contents
2449 should be read from the VMA, otherwise from the LMA.
2451 Two levels of debugger support for overlays are available. One is
2452 "manual", in which the debugger relies on the user to tell it which
2453 overlays are currently mapped. This level of support is
2454 implemented entirely in the core debugger, and the information about
2455 whether a section is mapped is kept in the objfile->obj_section table.
2457 The second level of support is "automatic", and is only available if
2458 the target-specific code provides functionality to read the target's
2459 overlay mapping table, and translate its contents for the debugger
2460 (by updating the mapped state information in the obj_section tables).
2462 The interface is as follows:
2464 overlay map <name> -- tell gdb to consider this section mapped
2465 overlay unmap <name> -- tell gdb to consider this section unmapped
2466 overlay list -- list the sections that GDB thinks are mapped
2467 overlay read-target -- get the target's state of what's mapped
2468 overlay off/manual/auto -- set overlay debugging state
2469 Functional interface:
2470 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2471 section, return that section.
2472 find_pc_overlay(pc): find any overlay section that contains
2473 the pc, either in its VMA or its LMA
2474 overlay_is_mapped(sect): true if overlay is marked as mapped
2475 section_is_overlay(sect): true if section's VMA != LMA
2476 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2477 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2478 overlay_mapped_address(...): map an address from section's LMA to VMA
2479 overlay_unmapped_address(...): map an address from section's VMA to LMA
2480 symbol_overlayed_address(...): Return a "current" address for symbol:
2481 either in VMA or LMA depending on whether
2482 the symbol's section is currently mapped
2485 /* Overlay debugging state: */
2487 int overlay_debugging
= 0; /* 0 == off, 1 == manual, -1 == auto */
2488 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
2490 /* Target vector for refreshing overlay mapped state */
2491 static void simple_overlay_update (struct obj_section
*);
2492 void (*target_overlay_update
) (struct obj_section
*) = simple_overlay_update
;
2494 /* Function: section_is_overlay (SECTION)
2495 Returns true if SECTION has VMA not equal to LMA, ie.
2496 SECTION is loaded at an address different from where it will "run". */
2499 section_is_overlay (asection
*section
)
2501 if (overlay_debugging
)
2502 if (section
&& section
->lma
!= 0 &&
2503 section
->vma
!= section
->lma
)
2509 /* Function: overlay_invalidate_all (void)
2510 Invalidate the mapped state of all overlay sections (mark it as stale). */
2513 overlay_invalidate_all (void)
2515 struct objfile
*objfile
;
2516 struct obj_section
*sect
;
2518 ALL_OBJSECTIONS (objfile
, sect
)
2519 if (section_is_overlay (sect
->the_bfd_section
))
2520 sect
->ovly_mapped
= -1;
2523 /* Function: overlay_is_mapped (SECTION)
2524 Returns true if section is an overlay, and is currently mapped.
2525 Private: public access is thru function section_is_mapped.
2527 Access to the ovly_mapped flag is restricted to this function, so
2528 that we can do automatic update. If the global flag
2529 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2530 overlay_invalidate_all. If the mapped state of the particular
2531 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2534 overlay_is_mapped (struct obj_section
*osect
)
2536 if (osect
== 0 || !section_is_overlay (osect
->the_bfd_section
))
2539 switch (overlay_debugging
)
2543 return 0; /* overlay debugging off */
2544 case -1: /* overlay debugging automatic */
2545 /* Unles there is a target_overlay_update function,
2546 there's really nothing useful to do here (can't really go auto) */
2547 if (target_overlay_update
)
2549 if (overlay_cache_invalid
)
2551 overlay_invalidate_all ();
2552 overlay_cache_invalid
= 0;
2554 if (osect
->ovly_mapped
== -1)
2555 (*target_overlay_update
) (osect
);
2557 /* fall thru to manual case */
2558 case 1: /* overlay debugging manual */
2559 return osect
->ovly_mapped
== 1;
2563 /* Function: section_is_mapped
2564 Returns true if section is an overlay, and is currently mapped. */
2567 section_is_mapped (asection
*section
)
2569 struct objfile
*objfile
;
2570 struct obj_section
*osect
;
2572 if (overlay_debugging
)
2573 if (section
&& section_is_overlay (section
))
2574 ALL_OBJSECTIONS (objfile
, osect
)
2575 if (osect
->the_bfd_section
== section
)
2576 return overlay_is_mapped (osect
);
2581 /* Function: pc_in_unmapped_range
2582 If PC falls into the lma range of SECTION, return true, else false. */
2585 pc_in_unmapped_range (CORE_ADDR pc
, asection
*section
)
2589 if (overlay_debugging
)
2590 if (section
&& section_is_overlay (section
))
2592 size
= bfd_get_section_size_before_reloc (section
);
2593 if (section
->lma
<= pc
&& pc
< section
->lma
+ size
)
2599 /* Function: pc_in_mapped_range
2600 If PC falls into the vma range of SECTION, return true, else false. */
2603 pc_in_mapped_range (CORE_ADDR pc
, asection
*section
)
2607 if (overlay_debugging
)
2608 if (section
&& section_is_overlay (section
))
2610 size
= bfd_get_section_size_before_reloc (section
);
2611 if (section
->vma
<= pc
&& pc
< section
->vma
+ size
)
2617 /* Function: overlay_unmapped_address (PC, SECTION)
2618 Returns the address corresponding to PC in the unmapped (load) range.
2619 May be the same as PC. */
2622 overlay_unmapped_address (CORE_ADDR pc
, asection
*section
)
2624 if (overlay_debugging
)
2625 if (section
&& section_is_overlay (section
) &&
2626 pc_in_mapped_range (pc
, section
))
2627 return pc
+ section
->lma
- section
->vma
;
2632 /* Function: overlay_mapped_address (PC, SECTION)
2633 Returns the address corresponding to PC in the mapped (runtime) range.
2634 May be the same as PC. */
2637 overlay_mapped_address (CORE_ADDR pc
, asection
*section
)
2639 if (overlay_debugging
)
2640 if (section
&& section_is_overlay (section
) &&
2641 pc_in_unmapped_range (pc
, section
))
2642 return pc
+ section
->vma
- section
->lma
;
2648 /* Function: symbol_overlayed_address
2649 Return one of two addresses (relative to the VMA or to the LMA),
2650 depending on whether the section is mapped or not. */
2653 symbol_overlayed_address (CORE_ADDR address
, asection
*section
)
2655 if (overlay_debugging
)
2657 /* If the symbol has no section, just return its regular address. */
2660 /* If the symbol's section is not an overlay, just return its address */
2661 if (!section_is_overlay (section
))
2663 /* If the symbol's section is mapped, just return its address */
2664 if (section_is_mapped (section
))
2667 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
2668 * then return its LOADED address rather than its vma address!!
2670 return overlay_unmapped_address (address
, section
);
2675 /* Function: find_pc_overlay (PC)
2676 Return the best-match overlay section for PC:
2677 If PC matches a mapped overlay section's VMA, return that section.
2678 Else if PC matches an unmapped section's VMA, return that section.
2679 Else if PC matches an unmapped section's LMA, return that section. */
2682 find_pc_overlay (CORE_ADDR pc
)
2684 struct objfile
*objfile
;
2685 struct obj_section
*osect
, *best_match
= NULL
;
2687 if (overlay_debugging
)
2688 ALL_OBJSECTIONS (objfile
, osect
)
2689 if (section_is_overlay (osect
->the_bfd_section
))
2691 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
))
2693 if (overlay_is_mapped (osect
))
2694 return osect
->the_bfd_section
;
2698 else if (pc_in_unmapped_range (pc
, osect
->the_bfd_section
))
2701 return best_match
? best_match
->the_bfd_section
: NULL
;
2704 /* Function: find_pc_mapped_section (PC)
2705 If PC falls into the VMA address range of an overlay section that is
2706 currently marked as MAPPED, return that section. Else return NULL. */
2709 find_pc_mapped_section (CORE_ADDR pc
)
2711 struct objfile
*objfile
;
2712 struct obj_section
*osect
;
2714 if (overlay_debugging
)
2715 ALL_OBJSECTIONS (objfile
, osect
)
2716 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
) &&
2717 overlay_is_mapped (osect
))
2718 return osect
->the_bfd_section
;
2723 /* Function: list_overlays_command
2724 Print a list of mapped sections and their PC ranges */
2727 list_overlays_command (char *args
, int from_tty
)
2730 struct objfile
*objfile
;
2731 struct obj_section
*osect
;
2733 if (overlay_debugging
)
2734 ALL_OBJSECTIONS (objfile
, osect
)
2735 if (overlay_is_mapped (osect
))
2741 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
2742 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
2743 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
2744 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
2746 printf_filtered ("Section %s, loaded at ", name
);
2747 print_address_numeric (lma
, 1, gdb_stdout
);
2748 puts_filtered (" - ");
2749 print_address_numeric (lma
+ size
, 1, gdb_stdout
);
2750 printf_filtered (", mapped at ");
2751 print_address_numeric (vma
, 1, gdb_stdout
);
2752 puts_filtered (" - ");
2753 print_address_numeric (vma
+ size
, 1, gdb_stdout
);
2754 puts_filtered ("\n");
2759 printf_filtered ("No sections are mapped.\n");
2762 /* Function: map_overlay_command
2763 Mark the named section as mapped (ie. residing at its VMA address). */
2766 map_overlay_command (char *args
, int from_tty
)
2768 struct objfile
*objfile
, *objfile2
;
2769 struct obj_section
*sec
, *sec2
;
2772 if (!overlay_debugging
)
2774 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
2775 the 'overlay manual' command.");
2777 if (args
== 0 || *args
== 0)
2778 error ("Argument required: name of an overlay section");
2780 /* First, find a section matching the user supplied argument */
2781 ALL_OBJSECTIONS (objfile
, sec
)
2782 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
2784 /* Now, check to see if the section is an overlay. */
2785 bfdsec
= sec
->the_bfd_section
;
2786 if (!section_is_overlay (bfdsec
))
2787 continue; /* not an overlay section */
2789 /* Mark the overlay as "mapped" */
2790 sec
->ovly_mapped
= 1;
2792 /* Next, make a pass and unmap any sections that are
2793 overlapped by this new section: */
2794 ALL_OBJSECTIONS (objfile2
, sec2
)
2795 if (sec2
->ovly_mapped
&&
2797 sec
->the_bfd_section
!= sec2
->the_bfd_section
&&
2798 (pc_in_mapped_range (sec2
->addr
, sec
->the_bfd_section
) ||
2799 pc_in_mapped_range (sec2
->endaddr
, sec
->the_bfd_section
)))
2802 printf_filtered ("Note: section %s unmapped by overlap\n",
2803 bfd_section_name (objfile
->obfd
,
2804 sec2
->the_bfd_section
));
2805 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
2809 error ("No overlay section called %s", args
);
2812 /* Function: unmap_overlay_command
2813 Mark the overlay section as unmapped
2814 (ie. resident in its LMA address range, rather than the VMA range). */
2817 unmap_overlay_command (char *args
, int from_tty
)
2819 struct objfile
*objfile
;
2820 struct obj_section
*sec
;
2822 if (!overlay_debugging
)
2824 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
2825 the 'overlay manual' command.");
2827 if (args
== 0 || *args
== 0)
2828 error ("Argument required: name of an overlay section");
2830 /* First, find a section matching the user supplied argument */
2831 ALL_OBJSECTIONS (objfile
, sec
)
2832 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
2834 if (!sec
->ovly_mapped
)
2835 error ("Section %s is not mapped", args
);
2836 sec
->ovly_mapped
= 0;
2839 error ("No overlay section called %s", args
);
2842 /* Function: overlay_auto_command
2843 A utility command to turn on overlay debugging.
2844 Possibly this should be done via a set/show command. */
2847 overlay_auto_command (char *args
, int from_tty
)
2849 overlay_debugging
= -1;
2851 printf_filtered ("Automatic overlay debugging enabled.");
2854 /* Function: overlay_manual_command
2855 A utility command to turn on overlay debugging.
2856 Possibly this should be done via a set/show command. */
2859 overlay_manual_command (char *args
, int from_tty
)
2861 overlay_debugging
= 1;
2863 printf_filtered ("Overlay debugging enabled.");
2866 /* Function: overlay_off_command
2867 A utility command to turn on overlay debugging.
2868 Possibly this should be done via a set/show command. */
2871 overlay_off_command (char *args
, int from_tty
)
2873 overlay_debugging
= 0;
2875 printf_filtered ("Overlay debugging disabled.");
2879 overlay_load_command (char *args
, int from_tty
)
2881 if (target_overlay_update
)
2882 (*target_overlay_update
) (NULL
);
2884 error ("This target does not know how to read its overlay state.");
2887 /* Function: overlay_command
2888 A place-holder for a mis-typed command */
2890 /* Command list chain containing all defined "overlay" subcommands. */
2891 struct cmd_list_element
*overlaylist
;
2894 overlay_command (char *args
, int from_tty
)
2897 ("\"overlay\" must be followed by the name of an overlay command.\n");
2898 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
2902 /* Target Overlays for the "Simplest" overlay manager:
2904 This is GDB's default target overlay layer. It works with the
2905 minimal overlay manager supplied as an example by Cygnus. The
2906 entry point is via a function pointer "target_overlay_update",
2907 so targets that use a different runtime overlay manager can
2908 substitute their own overlay_update function and take over the
2911 The overlay_update function pokes around in the target's data structures
2912 to see what overlays are mapped, and updates GDB's overlay mapping with
2915 In this simple implementation, the target data structures are as follows:
2916 unsigned _novlys; /# number of overlay sections #/
2917 unsigned _ovly_table[_novlys][4] = {
2918 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
2919 {..., ..., ..., ...},
2921 unsigned _novly_regions; /# number of overlay regions #/
2922 unsigned _ovly_region_table[_novly_regions][3] = {
2923 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
2926 These functions will attempt to update GDB's mappedness state in the
2927 symbol section table, based on the target's mappedness state.
2929 To do this, we keep a cached copy of the target's _ovly_table, and
2930 attempt to detect when the cached copy is invalidated. The main
2931 entry point is "simple_overlay_update(SECT), which looks up SECT in
2932 the cached table and re-reads only the entry for that section from
2933 the target (whenever possible).
2936 /* Cached, dynamically allocated copies of the target data structures: */
2937 static unsigned (*cache_ovly_table
)[4] = 0;
2939 static unsigned (*cache_ovly_region_table
)[3] = 0;
2941 static unsigned cache_novlys
= 0;
2943 static unsigned cache_novly_regions
= 0;
2945 static CORE_ADDR cache_ovly_table_base
= 0;
2947 static CORE_ADDR cache_ovly_region_table_base
= 0;
2951 VMA
, SIZE
, LMA
, MAPPED
2953 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
2955 /* Throw away the cached copy of _ovly_table */
2957 simple_free_overlay_table (void)
2959 if (cache_ovly_table
)
2960 xfree (cache_ovly_table
);
2962 cache_ovly_table
= NULL
;
2963 cache_ovly_table_base
= 0;
2967 /* Throw away the cached copy of _ovly_region_table */
2969 simple_free_overlay_region_table (void)
2971 if (cache_ovly_region_table
)
2972 xfree (cache_ovly_region_table
);
2973 cache_novly_regions
= 0;
2974 cache_ovly_region_table
= NULL
;
2975 cache_ovly_region_table_base
= 0;
2979 /* Read an array of ints from the target into a local buffer.
2980 Convert to host order. int LEN is number of ints */
2982 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
, int len
)
2984 char *buf
= alloca (len
* TARGET_LONG_BYTES
);
2987 read_memory (memaddr
, buf
, len
* TARGET_LONG_BYTES
);
2988 for (i
= 0; i
< len
; i
++)
2989 myaddr
[i
] = extract_unsigned_integer (TARGET_LONG_BYTES
* i
+ buf
,
2993 /* Find and grab a copy of the target _ovly_table
2994 (and _novlys, which is needed for the table's size) */
2996 simple_read_overlay_table (void)
2998 struct minimal_symbol
*msym
;
3000 simple_free_overlay_table ();
3001 msym
= lookup_minimal_symbol ("_novlys", 0, 0);
3003 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
3005 return 0; /* failure */
3006 cache_ovly_table
= (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3007 if (cache_ovly_table
!= NULL
)
3009 msym
= lookup_minimal_symbol ("_ovly_table", 0, 0);
3012 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3013 read_target_long_array (cache_ovly_table_base
,
3014 (int *) cache_ovly_table
,
3018 return 0; /* failure */
3021 return 0; /* failure */
3022 return 1; /* SUCCESS */
3026 /* Find and grab a copy of the target _ovly_region_table
3027 (and _novly_regions, which is needed for the table's size) */
3029 simple_read_overlay_region_table (void)
3031 struct minimal_symbol
*msym
;
3033 simple_free_overlay_region_table ();
3034 msym
= lookup_minimal_symbol ("_novly_regions", 0, 0);
3036 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
3038 return 0; /* failure */
3039 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3040 if (cache_ovly_region_table
!= NULL
)
3042 msym
= lookup_minimal_symbol ("_ovly_region_table", 0, 0);
3045 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3046 read_target_long_array (cache_ovly_region_table_base
,
3047 (int *) cache_ovly_region_table
,
3048 cache_novly_regions
* 3);
3051 return 0; /* failure */
3054 return 0; /* failure */
3055 return 1; /* SUCCESS */
3059 /* Function: simple_overlay_update_1
3060 A helper function for simple_overlay_update. Assuming a cached copy
3061 of _ovly_table exists, look through it to find an entry whose vma,
3062 lma and size match those of OSECT. Re-read the entry and make sure
3063 it still matches OSECT (else the table may no longer be valid).
3064 Set OSECT's mapped state to match the entry. Return: 1 for
3065 success, 0 for failure. */
3068 simple_overlay_update_1 (struct obj_section
*osect
)
3072 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3073 for (i
= 0; i
< cache_novlys
; i
++)
3074 if (cache_ovly_table
[i
][VMA
] == osect
->the_bfd_section
->vma
&&
3075 cache_ovly_table
[i
][LMA
] == osect
->the_bfd_section
->lma
/* &&
3076 cache_ovly_table[i][SIZE] == size */ )
3078 read_target_long_array (cache_ovly_table_base
+ i
* TARGET_LONG_BYTES
,
3079 (int *) cache_ovly_table
[i
], 4);
3080 if (cache_ovly_table
[i
][VMA
] == osect
->the_bfd_section
->vma
&&
3081 cache_ovly_table
[i
][LMA
] == osect
->the_bfd_section
->lma
/* &&
3082 cache_ovly_table[i][SIZE] == size */ )
3084 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3087 else /* Warning! Warning! Target's ovly table has changed! */
3093 /* Function: simple_overlay_update
3094 If OSECT is NULL, then update all sections' mapped state
3095 (after re-reading the entire target _ovly_table).
3096 If OSECT is non-NULL, then try to find a matching entry in the
3097 cached ovly_table and update only OSECT's mapped state.
3098 If a cached entry can't be found or the cache isn't valid, then
3099 re-read the entire cache, and go ahead and update all sections. */
3102 simple_overlay_update (struct obj_section
*osect
)
3104 struct objfile
*objfile
;
3106 /* Were we given an osect to look up? NULL means do all of them. */
3108 /* Have we got a cached copy of the target's overlay table? */
3109 if (cache_ovly_table
!= NULL
)
3110 /* Does its cached location match what's currently in the symtab? */
3111 if (cache_ovly_table_base
==
3112 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", 0, 0)))
3113 /* Then go ahead and try to look up this single section in the cache */
3114 if (simple_overlay_update_1 (osect
))
3115 /* Found it! We're done. */
3118 /* Cached table no good: need to read the entire table anew.
3119 Or else we want all the sections, in which case it's actually
3120 more efficient to read the whole table in one block anyway. */
3122 if (simple_read_overlay_table () == 0) /* read failed? No table? */
3124 warning ("Failed to read the target overlay mapping table.");
3127 /* Now may as well update all sections, even if only one was requested. */
3128 ALL_OBJSECTIONS (objfile
, osect
)
3129 if (section_is_overlay (osect
->the_bfd_section
))
3133 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3134 for (i
= 0; i
< cache_novlys
; i
++)
3135 if (cache_ovly_table
[i
][VMA
] == osect
->the_bfd_section
->vma
&&
3136 cache_ovly_table
[i
][LMA
] == osect
->the_bfd_section
->lma
/* &&
3137 cache_ovly_table[i][SIZE] == size */ )
3138 { /* obj_section matches i'th entry in ovly_table */
3139 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3140 break; /* finished with inner for loop: break out */
3147 _initialize_symfile (void)
3149 struct cmd_list_element
*c
;
3151 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
3152 "Load symbol table from executable file FILE.\n\
3153 The `file' command can also load symbol tables, as well as setting the file\n\
3154 to execute.", &cmdlist
);
3155 c
->completer
= filename_completer
;
3157 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
3158 "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3159 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
3160 ADDR is the starting address of the file's text.\n\
3161 The optional arguments are section-name section-address pairs and\n\
3162 should be specified if the data and bss segments are not contiguous\n\
3163 with the text. SECT is a section name to be loaded at SECT_ADDR.",
3165 c
->completer
= filename_completer
;
3167 c
= add_cmd ("add-shared-symbol-files", class_files
,
3168 add_shared_symbol_files_command
,
3169 "Load the symbols from shared objects in the dynamic linker's link map.",
3171 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
3174 c
= add_cmd ("load", class_files
, load_command
,
3175 "Dynamically load FILE into the running program, and record its symbols\n\
3176 for access from GDB.", &cmdlist
);
3177 c
->completer
= filename_completer
;
3180 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
3181 (char *) &symbol_reloading
,
3182 "Set dynamic symbol table reloading multiple times in one run.",
3186 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3187 "Commands for debugging overlays.", &overlaylist
,
3188 "overlay ", 0, &cmdlist
);
3190 add_com_alias ("ovly", "overlay", class_alias
, 1);
3191 add_com_alias ("ov", "overlay", class_alias
, 1);
3193 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3194 "Assert that an overlay section is mapped.", &overlaylist
);
3196 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3197 "Assert that an overlay section is unmapped.", &overlaylist
);
3199 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3200 "List mappings of overlay sections.", &overlaylist
);
3202 add_cmd ("manual", class_support
, overlay_manual_command
,
3203 "Enable overlay debugging.", &overlaylist
);
3204 add_cmd ("off", class_support
, overlay_off_command
,
3205 "Disable overlay debugging.", &overlaylist
);
3206 add_cmd ("auto", class_support
, overlay_auto_command
,
3207 "Enable automatic overlay debugging.", &overlaylist
);
3208 add_cmd ("load-target", class_support
, overlay_load_command
,
3209 "Read the overlay mapping state from the target.", &overlaylist
);
3211 /* Filename extension to source language lookup table: */
3212 init_filename_language_table ();
3213 c
= add_set_cmd ("extension-language", class_files
, var_string_noescape
,
3215 "Set mapping between filename extension and source language.\n\
3216 Usage: set extension-language .foo bar",
3218 c
->function
.cfunc
= set_ext_lang_command
;
3220 add_info ("extensions", info_ext_lang_command
,
3221 "All filename extensions associated with a source language.");
3224 (add_set_cmd ("download-write-size", class_obscure
,
3225 var_integer
, (char *) &download_write_size
,
3226 "Set the write size used when downloading a program.\n"
3227 "Only used when downloading a program onto a remote\n"
3228 "target. Specify zero, or a negative value, to disable\n"
3229 "blocked writes. The actual size of each transfer is also\n"
3230 "limited by the size of the target packet and the memory\n"