1 /* Generic symbol file reading for the GNU debugger, GDB.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support, using pieces from other GDB modules.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, 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"
41 #include <sys/types.h>
43 #include "gdb_string.h"
57 /* Some HP-UX related globals to clear when a new "main"
58 symbol file is loaded. HP-specific. */
60 extern int hp_som_som_object_present
;
61 extern int hp_cxx_exception_support_initialized
;
62 #define RESET_HP_UX_GLOBALS() do {\
63 hp_som_som_object_present = 0; /* indicates HP-compiled code */ \
64 hp_cxx_exception_support_initialized = 0; /* must reinitialize exception stuff */ \
68 int (*ui_load_progress_hook
) PARAMS ((char *, unsigned long));
69 void (*pre_add_symbol_hook
) PARAMS ((char *));
70 void (*post_add_symbol_hook
) PARAMS ((void));
72 /* Global variables owned by this file */
73 int readnow_symbol_files
; /* Read full symbols immediately */
75 struct complaint oldsyms_complaint
= {
76 "Replacing old symbols for `%s'", 0, 0
79 struct complaint empty_symtab_complaint
= {
80 "Empty symbol table found for `%s'", 0, 0
83 /* External variables and functions referenced. */
85 extern int info_verbose
;
87 extern void report_transfer_performance
PARAMS ((unsigned long,
90 /* Functions this file defines */
93 static int simple_read_overlay_region_table
PARAMS ((void));
94 static void simple_free_overlay_region_table
PARAMS ((void));
97 static void set_initial_language
PARAMS ((void));
99 static void load_command
PARAMS ((char *, int));
101 static void add_symbol_file_command
PARAMS ((char *, int));
103 static void add_shared_symbol_files_command
PARAMS ((char *, int));
105 static void cashier_psymtab
PARAMS ((struct partial_symtab
*));
107 static int compare_psymbols
PARAMS ((const void *, const void *));
109 static int compare_symbols
PARAMS ((const void *, const void *));
111 bfd
*symfile_bfd_open
PARAMS ((char *));
113 static void find_sym_fns
PARAMS ((struct objfile
*));
115 static void decrement_reading_symtab
PARAMS ((void *));
117 static void overlay_invalidate_all
PARAMS ((void));
119 static int overlay_is_mapped
PARAMS ((struct obj_section
*));
121 void list_overlays_command
PARAMS ((char *, int));
123 void map_overlay_command
PARAMS ((char *, int));
125 void unmap_overlay_command
PARAMS ((char *, int));
127 static void overlay_auto_command
PARAMS ((char *, int));
129 static void overlay_manual_command
PARAMS ((char *, int));
131 static void overlay_off_command
PARAMS ((char *, int));
133 static void overlay_load_command
PARAMS ((char *, int));
135 static void overlay_command
PARAMS ((char *, int));
137 static void simple_free_overlay_table
PARAMS ((void));
139 static void read_target_long_array
PARAMS ((CORE_ADDR
, unsigned int *, int));
141 static int simple_read_overlay_table
PARAMS ((void));
143 static int simple_overlay_update_1
PARAMS ((struct obj_section
*));
145 static void add_filename_language
PARAMS ((char *ext
, enum language lang
));
147 static void set_ext_lang_command
PARAMS ((char *args
, int from_tty
));
149 static void info_ext_lang_command
PARAMS ((char *args
, int from_tty
));
151 static void init_filename_language_table
PARAMS ((void));
153 void _initialize_symfile
PARAMS ((void));
155 /* List of all available sym_fns. On gdb startup, each object file reader
156 calls add_symtab_fns() to register information on each format it is
159 static struct sym_fns
*symtab_fns
= NULL
;
161 /* Flag for whether user will be reloading symbols multiple times.
162 Defaults to ON for VxWorks, otherwise OFF. */
164 #ifdef SYMBOL_RELOADING_DEFAULT
165 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
167 int symbol_reloading
= 0;
170 /* If non-zero, then on HP-UX (i.e., platforms that use somsolib.c),
171 this variable is interpreted as a threshhold. If adding a new
172 library's symbol table to those already known to the debugger would
173 exceed this threshhold, then the shlib's symbols are not added.
175 If non-zero on other platforms, shared library symbols will be added
176 automatically when the inferior is created, new libraries are loaded,
177 or when attaching to the inferior. This is almost always what users
178 will want to have happen; but for very large programs, the startup
179 time will be excessive, and so if this is a problem, the user can
180 clear this flag and then add the shared library symbols as needed.
181 Note that there is a potential for confusion, since if the shared
182 library symbols are not loaded, commands like "info fun" will *not*
183 report all the functions that are actually present.
185 Note that HP-UX interprets this variable to mean, "threshhold size
186 in megabytes, where zero means never add". Other platforms interpret
187 this variable to mean, "always add if non-zero, never add if zero."
190 int auto_solib_add
= 1;
193 /* Since this function is called from within qsort, in an ANSI environment
194 it must conform to the prototype for qsort, which specifies that the
195 comparison function takes two "void *" pointers. */
198 compare_symbols (s1p
, s2p
)
202 register struct symbol
**s1
, **s2
;
204 s1
= (struct symbol
**) s1p
;
205 s2
= (struct symbol
**) s2p
;
207 return (STRCMP (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
)));
214 compare_psymbols -- compare two partial symbols by name
218 Given pointers to pointers to two partial symbol table entries,
219 compare them by name and return -N, 0, or +N (ala strcmp).
220 Typically used by sorting routines like qsort().
224 Does direct compare of first two characters before punting
225 and passing to strcmp for longer compares. Note that the
226 original version had a bug whereby two null strings or two
227 identically named one character strings would return the
228 comparison of memory following the null byte.
233 compare_psymbols (s1p
, s2p
)
237 register char *st1
= SYMBOL_NAME (*(struct partial_symbol
**) s1p
);
238 register char *st2
= SYMBOL_NAME (*(struct partial_symbol
**) s2p
);
240 if ((st1
[0] - st2
[0]) || !st1
[0])
242 return (st1
[0] - st2
[0]);
244 else if ((st1
[1] - st2
[1]) || !st1
[1])
246 return (st1
[1] - st2
[1]);
250 /* Note: I replaced the STRCMP line (commented out below)
251 * with a simpler "strcmp()" which compares the 2 strings
252 * from the beginning. (STRCMP is a macro which first compares
253 * the initial characters, then falls back on strcmp).
254 * The reason is that the STRCMP line was tickling a C compiler
255 * bug on HP-UX 10.30, which is avoided with the simpler
256 * code. The performance gain from the more complicated code
257 * is negligible, given that we have already checked the
258 * initial 2 characters above. I reported the compiler bug,
259 * and once it is fixed the original line can be put back. RT
261 /* return ( STRCMP (st1 + 2, st2 + 2)); */
262 return ( strcmp (st1
, st2
));
267 sort_pst_symbols (pst
)
268 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. */
281 register struct block
*b
;
283 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
284 sizeof (struct symbol
*), compare_symbols
);
287 /* Call sort_symtab_syms to sort alphabetically
288 the symbols of each block of one symtab. */
292 register struct symtab
*s
;
294 register struct blockvector
*bv
;
297 register struct block
*b
;
301 bv
= BLOCKVECTOR (s
);
302 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
303 for (i
= 0; i
< nbl
; i
++)
305 b
= BLOCKVECTOR_BLOCK (bv
, i
);
306 if (BLOCK_SHOULD_SORT (b
))
311 /* Make a null terminated copy of the string at PTR with SIZE characters in
312 the obstack pointed to by OBSTACKP . Returns the address of the copy.
313 Note that the string at PTR does not have to be null terminated, I.E. it
314 may be part of a larger string and we are only saving a substring. */
317 obsavestring (ptr
, size
, obstackp
)
320 struct obstack
*obstackp
;
322 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
323 /* Open-coded memcpy--saves function call time. These strings are usually
324 short. FIXME: Is this really still true with a compiler that can
327 register char *p1
= ptr
;
328 register char *p2
= p
;
329 char *end
= ptr
+ size
;
337 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
338 in the obstack pointed to by OBSTACKP. */
341 obconcat (obstackp
, s1
, s2
, s3
)
342 struct obstack
*obstackp
;
343 const char *s1
, *s2
, *s3
;
345 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
346 register char *val
= (char *) obstack_alloc (obstackp
, len
);
353 /* True if we are nested inside psymtab_to_symtab. */
355 int currently_reading_symtab
= 0;
358 decrement_reading_symtab (dummy
)
361 currently_reading_symtab
--;
364 /* Get the symbol table that corresponds to a partial_symtab.
365 This is fast after the first time you do it. In fact, there
366 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
370 psymtab_to_symtab (pst
)
371 register struct partial_symtab
*pst
;
373 /* If it's been looked up before, return it. */
377 /* If it has not yet been read in, read it. */
380 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
381 currently_reading_symtab
++;
382 (*pst
->read_symtab
) (pst
);
383 do_cleanups (back_to
);
389 /* Initialize entry point information for this objfile. */
392 init_entry_point_info (objfile
)
393 struct objfile
*objfile
;
395 /* Save startup file's range of PC addresses to help blockframe.c
396 decide where the bottom of the stack is. */
398 if (bfd_get_file_flags (objfile
-> obfd
) & EXEC_P
)
400 /* Executable file -- record its entry point so we'll recognize
401 the startup file because it contains the entry point. */
402 objfile
-> ei
.entry_point
= bfd_get_start_address (objfile
-> obfd
);
406 /* Examination of non-executable.o files. Short-circuit this stuff. */
407 objfile
-> ei
.entry_point
= INVALID_ENTRY_POINT
;
409 objfile
-> ei
.entry_file_lowpc
= INVALID_ENTRY_LOWPC
;
410 objfile
-> ei
.entry_file_highpc
= INVALID_ENTRY_HIGHPC
;
411 objfile
-> ei
.entry_func_lowpc
= INVALID_ENTRY_LOWPC
;
412 objfile
-> ei
.entry_func_highpc
= INVALID_ENTRY_HIGHPC
;
413 objfile
-> ei
.main_func_lowpc
= INVALID_ENTRY_LOWPC
;
414 objfile
-> ei
.main_func_highpc
= INVALID_ENTRY_HIGHPC
;
417 /* Get current entry point address. */
420 entry_point_address()
422 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
425 /* Remember the lowest-addressed loadable section we've seen.
426 This function is called via bfd_map_over_sections.
428 In case of equal vmas, the section with the largest size becomes the
429 lowest-addressed loadable section.
431 If the vmas and sizes are equal, the last section is considered the
432 lowest-addressed loadable section. */
435 find_lowest_section (abfd
, sect
, obj
)
440 asection
**lowest
= (asection
**)obj
;
442 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
445 *lowest
= sect
; /* First loadable section */
446 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
447 *lowest
= sect
; /* A lower loadable section */
448 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
449 && (bfd_section_size (abfd
, (*lowest
))
450 <= bfd_section_size (abfd
, sect
)))
454 /* Parse the user's idea of an offset for dynamic linking, into our idea
455 of how to represent it for fast symbol reading. This is the default
456 version of the sym_fns.sym_offsets function for symbol readers that
457 don't need to do anything special. It allocates a section_offsets table
458 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
460 struct section_offsets
*
461 default_symfile_offsets (objfile
, addr
)
462 struct objfile
*objfile
;
465 struct section_offsets
*section_offsets
;
468 objfile
->num_sections
= SECT_OFF_MAX
;
469 section_offsets
= (struct section_offsets
*)
470 obstack_alloc (&objfile
-> psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
472 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
473 ANOFFSET (section_offsets
, i
) = addr
;
475 return section_offsets
;
479 /* Process a symbol file, as either the main file or as a dynamically
482 NAME is the file name (which will be tilde-expanded and made
483 absolute herein) (but we don't free or modify NAME itself).
484 FROM_TTY says how verbose to be. MAINLINE specifies whether this
485 is the main symbol file, or whether it's an extra symbol file such
486 as dynamically loaded code. If !mainline, ADDR is the address
487 where the text segment was loaded. If VERBO, the caller has printed
488 a verbose message about the symbol reading (and complaints can be
489 more terse about it). */
492 syms_from_objfile (objfile
, addr
, mainline
, verbo
)
493 struct objfile
*objfile
;
498 struct section_offsets
*section_offsets
;
499 asection
*lowest_sect
;
500 struct cleanup
*old_chain
;
502 init_entry_point_info (objfile
);
503 find_sym_fns (objfile
);
505 /* Make sure that partially constructed symbol tables will be cleaned up
506 if an error occurs during symbol reading. */
507 old_chain
= make_cleanup ((make_cleanup_func
) free_objfile
, objfile
);
511 /* We will modify the main symbol table, make sure that all its users
512 will be cleaned up if an error occurs during symbol reading. */
513 make_cleanup ((make_cleanup_func
) clear_symtab_users
, 0);
515 /* Since no error yet, throw away the old symbol table. */
517 if (symfile_objfile
!= NULL
)
519 free_objfile (symfile_objfile
);
520 symfile_objfile
= NULL
;
523 /* Currently we keep symbols from the add-symbol-file command.
524 If the user wants to get rid of them, they should do "symbol-file"
525 without arguments first. Not sure this is the best behavior
528 (*objfile
-> sf
-> sym_new_init
) (objfile
);
531 /* Convert addr into an offset rather than an absolute address.
532 We find the lowest address of a loaded segment in the objfile,
533 and assume that <addr> is where that got loaded. Due to historical
534 precedent, we warn if that doesn't happen to be a text segment. */
538 addr
= 0; /* No offset from objfile addresses. */
542 lowest_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
543 if (lowest_sect
== NULL
)
544 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
547 if (lowest_sect
== NULL
)
548 warning ("no loadable sections found in added symbol-file %s",
550 else if ((bfd_get_section_flags (objfile
->obfd
, lowest_sect
) & SEC_CODE
)
552 /* FIXME-32x64--assumes bfd_vma fits in long. */
553 warning ("Lowest section in %s is %s at 0x%lx",
555 bfd_section_name (objfile
->obfd
, lowest_sect
),
556 (unsigned long) bfd_section_vma (objfile
->obfd
, lowest_sect
));
559 addr
-= bfd_section_vma (objfile
->obfd
, lowest_sect
);
562 /* Initialize symbol reading routines for this objfile, allow complaints to
563 appear for this new file, and record how verbose to be, then do the
564 initial symbol reading for this file. */
566 (*objfile
-> sf
-> sym_init
) (objfile
);
567 clear_complaints (1, verbo
);
569 section_offsets
= (*objfile
-> sf
-> sym_offsets
) (objfile
, addr
);
570 objfile
->section_offsets
= section_offsets
;
572 #ifndef IBM6000_TARGET
573 /* This is a SVR4/SunOS specific hack, I think. In any event, it
574 screws RS/6000. sym_offsets should be doing this sort of thing,
575 because it knows the mapping between bfd sections and
577 /* This is a hack. As far as I can tell, section offsets are not
578 target dependent. They are all set to addr with a couple of
579 exceptions. The exceptions are sysvr4 shared libraries, whose
580 offsets are kept in solib structures anyway and rs6000 xcoff
581 which handles shared libraries in a completely unique way.
583 Section offsets are built similarly, except that they are built
584 by adding addr in all cases because there is no clear mapping
585 from section_offsets into actual sections. Note that solib.c
586 has a different algorythm for finding section offsets.
588 These should probably all be collapsed into some target
589 independent form of shared library support. FIXME. */
593 struct obj_section
*s
;
595 for (s
= objfile
->sections
; s
< objfile
->sections_end
; ++s
)
597 s
->addr
-= s
->offset
;
599 s
->endaddr
-= s
->offset
;
604 #endif /* not IBM6000_TARGET */
606 (*objfile
-> sf
-> sym_read
) (objfile
, section_offsets
, mainline
);
608 if (!have_partial_symbols () && !have_full_symbols ())
611 printf_filtered ("(no debugging symbols found)...");
615 /* Don't allow char * to have a typename (else would get caddr_t).
616 Ditto void *. FIXME: Check whether this is now done by all the
617 symbol readers themselves (many of them now do), and if so remove
620 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
621 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
623 /* Mark the objfile has having had initial symbol read attempted. Note
624 that this does not mean we found any symbols... */
626 objfile
-> flags
|= OBJF_SYMS
;
628 /* Discard cleanups as symbol reading was successful. */
630 discard_cleanups (old_chain
);
632 /* Call this after reading in a new symbol table to give target dependant code
633 a crack at the new symbols. For instance, this could be used to update the
634 values of target-specific symbols GDB needs to keep track of (such as
635 _sigtramp, or whatever). */
637 TARGET_SYMFILE_POSTREAD (objfile
);
640 /* Perform required actions after either reading in the initial
641 symbols for a new objfile, or mapping in the symbols from a reusable
645 new_symfile_objfile (objfile
, mainline
, verbo
)
646 struct objfile
*objfile
;
651 /* If this is the main symbol file we have to clean up all users of the
652 old main symbol file. Otherwise it is sufficient to fixup all the
653 breakpoints that may have been redefined by this symbol file. */
656 /* OK, make it the "real" symbol file. */
657 symfile_objfile
= objfile
;
659 clear_symtab_users ();
663 breakpoint_re_set ();
666 /* We're done reading the symbol file; finish off complaints. */
667 clear_complaints (0, verbo
);
670 /* Process a symbol file, as either the main file or as a dynamically
673 NAME is the file name (which will be tilde-expanded and made
674 absolute herein) (but we don't free or modify NAME itself).
675 FROM_TTY says how verbose to be. MAINLINE specifies whether this
676 is the main symbol file, or whether it's an extra symbol file such
677 as dynamically loaded code. If !mainline, ADDR is the address
678 where the text segment was loaded.
680 USER_LOADED is TRUE if the add-symbol-file command was how this
681 symbol file came to be processed.
683 IS_SOLIB is TRUE if this symbol file represents a solib, as discovered
684 by the target's implementation of the solib package.
686 Upon success, returns a pointer to the objfile that was added.
687 Upon failure, jumps back to command level (never returns). */
690 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
, user_loaded
, is_solib
)
700 struct objfile
*objfile
;
701 struct partial_symtab
*psymtab
;
704 /* Open a bfd for the file, and give user a chance to burp if we'd be
705 interactively wiping out any existing symbols. */
707 abfd
= symfile_bfd_open (name
);
709 if ((have_full_symbols () || have_partial_symbols ())
712 && !query ("Load new symbol table from \"%s\"? ", name
))
713 error ("Not confirmed.");
715 objfile
= allocate_objfile (abfd
, mapped
, user_loaded
, is_solib
);
717 /* If the objfile uses a mapped symbol file, and we have a psymtab for
718 it, then skip reading any symbols at this time. */
720 if ((objfile
-> flags
& OBJF_MAPPED
) && (objfile
-> flags
& OBJF_SYMS
))
722 /* We mapped in an existing symbol table file that already has had
723 initial symbol reading performed, so we can skip that part. Notify
724 the user that instead of reading the symbols, they have been mapped.
726 if (from_tty
|| info_verbose
)
728 printf_filtered ("Mapped symbols for %s...", name
);
730 gdb_flush (gdb_stdout
);
732 init_entry_point_info (objfile
);
733 find_sym_fns (objfile
);
737 /* We either created a new mapped symbol table, mapped an existing
738 symbol table file which has not had initial symbol reading
739 performed, or need to read an unmapped symbol table. */
740 if (from_tty
|| info_verbose
)
742 if (pre_add_symbol_hook
)
743 pre_add_symbol_hook (name
);
746 printf_filtered ("Reading symbols from %s...", name
);
748 gdb_flush (gdb_stdout
);
751 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
754 /* We now have at least a partial symbol table. Check to see if the
755 user requested that all symbols be read on initial access via either
756 the gdb startup command line or on a per symbol file basis. Expand
757 all partial symbol tables for this objfile if so. */
759 if (readnow
|| readnow_symbol_files
)
761 if (from_tty
|| info_verbose
)
763 printf_filtered ("expanding to full symbols...");
765 gdb_flush (gdb_stdout
);
768 for (psymtab
= objfile
-> psymtabs
;
770 psymtab
= psymtab
-> next
)
772 psymtab_to_symtab (psymtab
);
776 if (from_tty
|| info_verbose
)
778 if (post_add_symbol_hook
)
779 post_add_symbol_hook ();
782 printf_filtered ("done.\n");
783 gdb_flush (gdb_stdout
);
787 new_symfile_objfile (objfile
, mainline
, from_tty
);
789 target_new_objfile (objfile
);
794 /* This is the symbol-file command. Read the file, analyze its
795 symbols, and add a struct symtab to a symtab list. The syntax of
796 the command is rather bizarre--(1) buildargv implements various
797 quoting conventions which are undocumented and have little or
798 nothing in common with the way things are quoted (or not quoted)
799 elsewhere in GDB, (2) options are used, which are not generally
800 used in GDB (perhaps "set mapped on", "set readnow on" would be
801 better), (3) the order of options matters, which is contrary to GNU
802 conventions (because it is confusing and inconvenient). */
805 symbol_file_command (args
, from_tty
)
811 CORE_ADDR text_relocation
= 0; /* text_relocation */
812 struct cleanup
*cleanups
;
820 if ((have_full_symbols () || have_partial_symbols ())
822 && !query ("Discard symbol table from `%s'? ",
823 symfile_objfile
-> name
))
824 error ("Not confirmed.");
825 free_all_objfiles ();
827 /* solib descriptors may have handles to objfiles. Since their
828 storage has just been released, we'd better wipe the solib
831 #if defined(SOLIB_RESTART)
835 symfile_objfile
= NULL
;
838 printf_unfiltered ("No symbol file now.\n");
841 RESET_HP_UX_GLOBALS ();
846 if ((argv
= buildargv (args
)) == NULL
)
850 cleanups
= make_cleanup_freeargv (argv
);
851 while (*argv
!= NULL
)
853 if (STREQ (*argv
, "-mapped"))
857 else if (STREQ (*argv
, "-readnow"))
861 else if (**argv
== '-')
863 error ("unknown option `%s'", *argv
);
871 /* this is for rombug remote only, to get the text relocation by
872 using link command */
873 p
= strrchr(name
, '/');
877 target_link(p
, &text_relocation
);
879 if (text_relocation
== (CORE_ADDR
)0)
881 else if (text_relocation
== (CORE_ADDR
)-1)
883 symbol_file_add (name
, from_tty
, (CORE_ADDR
)0,
884 1, mapped
, readnow
, 1, 0);
886 RESET_HP_UX_GLOBALS ();
890 symbol_file_add (name
, from_tty
, (CORE_ADDR
)text_relocation
,
891 0, mapped
, readnow
, 1, 0);
893 /* Getting new symbols may change our opinion about what is
895 reinit_frame_cache ();
897 set_initial_language ();
904 error ("no symbol file name was specified");
906 TUIDO(((TuiOpaqueFuncPtr
)tuiDisplayMainFunction
));
907 do_cleanups (cleanups
);
911 /* Set the initial language.
913 A better solution would be to record the language in the psymtab when reading
914 partial symbols, and then use it (if known) to set the language. This would
915 be a win for formats that encode the language in an easily discoverable place,
916 such as DWARF. For stabs, we can jump through hoops looking for specially
917 named symbols or try to intuit the language from the specific type of stabs
918 we find, but we can't do that until later when we read in full symbols.
922 set_initial_language ()
924 struct partial_symtab
*pst
;
925 enum language lang
= language_unknown
;
927 pst
= find_main_psymtab ();
930 if (pst
-> filename
!= NULL
)
932 lang
= deduce_language_from_filename (pst
-> filename
);
934 if (lang
== language_unknown
)
936 /* Make C the default language */
940 expected_language
= current_language
; /* Don't warn the user */
944 /* Open file specified by NAME and hand it off to BFD for preliminary
945 analysis. Result is a newly initialized bfd *, which includes a newly
946 malloc'd` copy of NAME (tilde-expanded and made absolute).
947 In case of trouble, error() is called. */
950 symfile_bfd_open (name
)
959 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
961 /* Look down path for it, allocate 2nd new malloc'd copy. */
962 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
963 #if defined(__GO32__) || defined(_WIN32)
966 char *exename
= alloca (strlen (name
) + 5);
967 strcat (strcpy (exename
, name
), ".exe");
968 desc
= openp (getenv ("PATH"), 1, exename
, O_RDONLY
| O_BINARY
,
974 make_cleanup (free
, name
);
975 perror_with_name (name
);
977 free (name
); /* Free 1st new malloc'd copy */
978 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
979 /* It'll be freed in free_objfile(). */
981 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
985 make_cleanup (free
, name
);
986 error ("\"%s\": can't open to read symbols: %s.", name
,
987 bfd_errmsg (bfd_get_error ()));
989 sym_bfd
->cacheable
= true;
991 if (!bfd_check_format (sym_bfd
, bfd_object
))
993 /* FIXME: should be checking for errors from bfd_close (for one thing,
994 on error it does not free all the storage associated with the
996 bfd_close (sym_bfd
); /* This also closes desc */
997 make_cleanup (free
, name
);
998 error ("\"%s\": can't read symbols: %s.", name
,
999 bfd_errmsg (bfd_get_error ()));
1004 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
1005 startup by the _initialize routine in each object file format reader,
1006 to register information about each format the the reader is prepared
1013 sf
->next
= symtab_fns
;
1018 /* Initialize to read symbols from the symbol file sym_bfd. It either
1019 returns or calls error(). The result is an initialized struct sym_fns
1020 in the objfile structure, that contains cached information about the
1024 find_sym_fns (objfile
)
1025 struct objfile
*objfile
;
1028 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
-> obfd
);
1029 char *our_target
= bfd_get_target (objfile
-> obfd
);
1031 /* Special kludge for RS/6000 and PowerMac. See xcoffread.c. */
1032 if (STREQ (our_target
, "aixcoff-rs6000") ||
1033 STREQ (our_target
, "xcoff-powermac"))
1034 our_flavour
= (enum bfd_flavour
)-1;
1036 /* Special kludge for apollo. See dstread.c. */
1037 if (STREQN (our_target
, "apollo", 6))
1038 our_flavour
= (enum bfd_flavour
)-2;
1040 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
-> next
)
1042 if (our_flavour
== sf
-> sym_flavour
)
1048 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
1049 bfd_get_target (objfile
-> obfd
));
1052 /* This function runs the load command of our current target. */
1055 load_command (arg
, from_tty
)
1060 arg
= get_exec_file (1);
1061 target_load (arg
, from_tty
);
1064 /* This version of "load" should be usable for any target. Currently
1065 it is just used for remote targets, not inftarg.c or core files,
1066 on the theory that only in that case is it useful.
1068 Avoiding xmodem and the like seems like a win (a) because we don't have
1069 to worry about finding it, and (b) On VMS, fork() is very slow and so
1070 we don't want to run a subprocess. On the other hand, I'm not sure how
1071 performance compares. */
1072 #define GENERIC_LOAD_CHUNK 256
1073 #define VALIDATE_DOWNLOAD 0
1075 generic_load (filename
, from_tty
)
1079 struct cleanup
*old_cleanups
;
1082 time_t start_time
, end_time
; /* Start and end times of download */
1083 unsigned long data_count
= 0; /* Number of bytes transferred to memory */
1085 unsigned long load_offset
= 0; /* offset to add to vma for each section */
1086 char buf
[GENERIC_LOAD_CHUNK
+8];
1087 #if VALIDATE_DOWNLOAD
1088 char verify_buffer
[GENERIC_LOAD_CHUNK
+8] ;
1091 /* enable user to specify address for downloading as 2nd arg to load */
1092 n
= sscanf(filename
, "%s 0x%lx", buf
, &load_offset
);
1098 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1099 if (loadfile_bfd
== NULL
)
1101 perror_with_name (filename
);
1104 /* FIXME: should be checking for errors from bfd_close (for one thing,
1105 on error it does not free all the storage associated with the
1107 old_cleanups
= make_cleanup ((make_cleanup_func
) bfd_close
, loadfile_bfd
);
1109 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1111 error ("\"%s\" is not an object file: %s", filename
,
1112 bfd_errmsg (bfd_get_error ()));
1115 start_time
= time (NULL
);
1117 for (s
= loadfile_bfd
->sections
; s
; s
= s
->next
)
1119 if (s
->flags
& SEC_LOAD
)
1123 size
= bfd_get_section_size_before_reloc (s
);
1127 struct cleanup
*old_chain
;
1129 unsigned long l
= size
;
1135 l
= l
> GENERIC_LOAD_CHUNK
? GENERIC_LOAD_CHUNK
: l
;
1137 buffer
= xmalloc (size
);
1138 old_chain
= make_cleanup (free
, buffer
);
1143 /* Is this really necessary? I guess it gives the user something
1144 to look at during a long download. */
1145 printf_filtered ("Loading section %s, size 0x%lx lma ",
1146 bfd_get_section_name (loadfile_bfd
, s
),
1147 (unsigned long) size
);
1148 print_address_numeric (lma
, 1, gdb_stdout
);
1149 printf_filtered ("\n");
1151 bfd_get_section_contents (loadfile_bfd
, s
, buffer
, 0, size
);
1153 sect
= (char *) bfd_get_section_name (loadfile_bfd
, s
);
1157 len
= (size
- sent
) < l
? (size
- sent
) : l
;
1159 err
= target_write_memory (lma
, buffer
, len
);
1160 if (ui_load_progress_hook
)
1161 if (ui_load_progress_hook (sect
, sent
))
1162 error ("Canceled the download");
1163 #if VALIDATE_DOWNLOAD
1164 /* Broken memories and broken monitors manifest themselves
1165 here when bring new computers to life.
1166 This doubles already slow downloads.
1170 target_read_memory(lma
,verify_buffer
,len
) ;
1171 if (0 != bcmp(buffer
,verify_buffer
,len
))
1172 error("Download verify failed at %08x",
1173 (unsigned long)lma
) ;
1181 while (err
== 0 && sent
< size
);
1184 error ("Memory access error while loading section %s.",
1185 bfd_get_section_name (loadfile_bfd
, s
));
1187 do_cleanups (old_chain
);
1192 end_time
= time (NULL
);
1194 unsigned long entry
;
1195 entry
= bfd_get_start_address(loadfile_bfd
) ;
1196 printf_filtered ("Start address 0x%lx , load size %d\n", entry
,data_count
);
1197 /* We were doing this in remote-mips.c, I suspect it is right
1198 for other targets too. */
1202 /* FIXME: are we supposed to call symbol_file_add or not? According to
1203 a comment from remote-mips.c (where a call to symbol_file_add was
1204 commented out), making the call confuses GDB if more than one file is
1205 loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
1208 report_transfer_performance (data_count
, start_time
, end_time
);
1210 do_cleanups (old_cleanups
);
1213 /* Report how fast the transfer went. */
1216 report_transfer_performance (data_count
, start_time
, end_time
)
1217 unsigned long data_count
;
1218 time_t start_time
, end_time
;
1220 printf_filtered ("Transfer rate: ");
1221 if (end_time
!= start_time
)
1222 printf_filtered ("%d bits/sec",
1223 (data_count
* 8) / (end_time
- start_time
));
1225 printf_filtered ("%d bits in <1 sec", (data_count
* 8));
1226 printf_filtered (".\n");
1229 /* This function allows the addition of incrementally linked object files.
1230 It does not modify any state in the target, only in the debugger. */
1234 add_symbol_file_command (args
, from_tty
)
1239 CORE_ADDR text_addr
;
1248 error ("add-symbol-file takes a file name and an address");
1251 /* Make a copy of the string that we can safely write into. */
1253 args
= strdup (args
);
1254 make_cleanup (free
, args
);
1256 /* Pick off any -option args and the file name. */
1258 while ((*args
!= '\000') && (name
== NULL
))
1260 while (isspace (*args
)) {args
++;}
1262 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
1263 if (*args
!= '\000')
1271 else if (STREQ (arg
, "-mapped"))
1275 else if (STREQ (arg
, "-readnow"))
1281 error ("unknown option `%s'", arg
);
1285 /* After picking off any options and the file name, args should be
1286 left pointing at the remainder of the command line, which should
1287 be the address expression to evaluate. */
1291 error ("add-symbol-file takes a file name");
1293 name
= tilde_expand (name
);
1294 make_cleanup (free
, name
);
1296 if (*args
!= '\000')
1298 text_addr
= parse_and_eval_address (args
);
1302 target_link(name
, &text_addr
);
1303 if (text_addr
== (CORE_ADDR
)-1)
1304 error("Don't know how to get text start location for this file");
1307 /* FIXME-32x64: Assumes text_addr fits in a long. */
1309 && (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
1310 name
, local_hex_string ((unsigned long)text_addr
))))
1311 error ("Not confirmed.");
1313 symbol_file_add (name
, from_tty
, text_addr
, 0, mapped
, readnow
,
1314 1, /* user_loaded */
1315 0); /* We'll guess it's ! is_solib */
1317 /* Getting new symbols may change our opinion about what is
1319 reinit_frame_cache ();
1323 add_shared_symbol_files_command (args
, from_tty
)
1327 #ifdef ADD_SHARED_SYMBOL_FILES
1328 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1330 error ("This command is not available in this configuration of GDB.");
1334 /* Re-read symbols if a symbol-file has changed. */
1338 struct objfile
*objfile
;
1341 struct stat new_statbuf
;
1344 /* With the addition of shared libraries, this should be modified,
1345 the load time should be saved in the partial symbol tables, since
1346 different tables may come from different source files. FIXME.
1347 This routine should then walk down each partial symbol table
1348 and see if the symbol table that it originates from has been changed */
1350 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
1351 if (objfile
->obfd
) {
1352 #ifdef IBM6000_TARGET
1353 /* If this object is from a shared library, then you should
1354 stat on the library name, not member name. */
1356 if (objfile
->obfd
->my_archive
)
1357 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1360 res
= stat (objfile
->name
, &new_statbuf
);
1362 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1363 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1367 new_modtime
= new_statbuf
.st_mtime
;
1368 if (new_modtime
!= objfile
->mtime
)
1370 struct cleanup
*old_cleanups
;
1371 struct section_offsets
*offsets
;
1373 int section_offsets_size
;
1374 char *obfd_filename
;
1376 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1379 /* There are various functions like symbol_file_add,
1380 symfile_bfd_open, syms_from_objfile, etc., which might
1381 appear to do what we want. But they have various other
1382 effects which we *don't* want. So we just do stuff
1383 ourselves. We don't worry about mapped files (for one thing,
1384 any mapped file will be out of date). */
1386 /* If we get an error, blow away this objfile (not sure if
1387 that is the correct response for things like shared
1389 old_cleanups
= make_cleanup ((make_cleanup_func
) free_objfile
,
1391 /* We need to do this whenever any symbols go away. */
1392 make_cleanup ((make_cleanup_func
) clear_symtab_users
, 0);
1394 /* Clean up any state BFD has sitting around. We don't need
1395 to close the descriptor but BFD lacks a way of closing the
1396 BFD without closing the descriptor. */
1397 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1398 if (!bfd_close (objfile
->obfd
))
1399 error ("Can't close BFD for %s: %s", objfile
->name
,
1400 bfd_errmsg (bfd_get_error ()));
1401 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1402 if (objfile
->obfd
== NULL
)
1403 error ("Can't open %s to read symbols.", objfile
->name
);
1404 /* bfd_openr sets cacheable to true, which is what we want. */
1405 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1406 error ("Can't read symbols from %s: %s.", objfile
->name
,
1407 bfd_errmsg (bfd_get_error ()));
1409 /* Save the offsets, we will nuke them with the rest of the
1411 num_offsets
= objfile
->num_sections
;
1412 section_offsets_size
=
1413 sizeof (struct section_offsets
)
1414 + sizeof (objfile
->section_offsets
->offsets
) * num_offsets
;
1415 offsets
= (struct section_offsets
*) alloca (section_offsets_size
);
1416 memcpy (offsets
, objfile
->section_offsets
, section_offsets_size
);
1418 /* Nuke all the state that we will re-read. Much of the following
1419 code which sets things to NULL really is necessary to tell
1420 other parts of GDB that there is nothing currently there. */
1422 /* FIXME: Do we have to free a whole linked list, or is this
1424 if (objfile
->global_psymbols
.list
)
1425 mfree (objfile
->md
, objfile
->global_psymbols
.list
);
1426 memset (&objfile
-> global_psymbols
, 0,
1427 sizeof (objfile
-> global_psymbols
));
1428 if (objfile
->static_psymbols
.list
)
1429 mfree (objfile
->md
, objfile
->static_psymbols
.list
);
1430 memset (&objfile
-> static_psymbols
, 0,
1431 sizeof (objfile
-> static_psymbols
));
1433 /* Free the obstacks for non-reusable objfiles */
1434 obstack_free (&objfile
-> psymbol_cache
.cache
, 0);
1435 memset (&objfile
-> psymbol_cache
, 0,
1436 sizeof (objfile
-> psymbol_cache
));
1437 obstack_free (&objfile
-> psymbol_obstack
, 0);
1438 obstack_free (&objfile
-> symbol_obstack
, 0);
1439 obstack_free (&objfile
-> type_obstack
, 0);
1440 objfile
->sections
= NULL
;
1441 objfile
->symtabs
= NULL
;
1442 objfile
->psymtabs
= NULL
;
1443 objfile
->free_psymtabs
= NULL
;
1444 objfile
->msymbols
= NULL
;
1445 objfile
->minimal_symbol_count
= 0;
1446 objfile
->fundamental_types
= NULL
;
1447 if (objfile
-> sf
!= NULL
)
1449 (*objfile
-> sf
-> sym_finish
) (objfile
);
1452 /* We never make this a mapped file. */
1453 objfile
-> md
= NULL
;
1454 /* obstack_specify_allocation also initializes the obstack so
1456 obstack_specify_allocation (&objfile
-> psymbol_cache
.cache
, 0, 0,
1458 obstack_specify_allocation (&objfile
-> psymbol_obstack
, 0, 0,
1460 obstack_specify_allocation (&objfile
-> symbol_obstack
, 0, 0,
1462 obstack_specify_allocation (&objfile
-> type_obstack
, 0, 0,
1464 if (build_objfile_section_table (objfile
))
1466 error ("Can't find the file sections in `%s': %s",
1467 objfile
-> name
, bfd_errmsg (bfd_get_error ()));
1470 /* We use the same section offsets as from last time. I'm not
1471 sure whether that is always correct for shared libraries. */
1472 objfile
->section_offsets
= (struct section_offsets
*)
1473 obstack_alloc (&objfile
-> psymbol_obstack
, section_offsets_size
);
1474 memcpy (objfile
->section_offsets
, offsets
, section_offsets_size
);
1475 objfile
->num_sections
= num_offsets
;
1477 /* What the hell is sym_new_init for, anyway? The concept of
1478 distinguishing between the main file and additional files
1479 in this way seems rather dubious. */
1480 if (objfile
== symfile_objfile
)
1482 (*objfile
->sf
->sym_new_init
) (objfile
);
1484 RESET_HP_UX_GLOBALS ();
1488 (*objfile
->sf
->sym_init
) (objfile
);
1489 clear_complaints (1, 1);
1490 /* The "mainline" parameter is a hideous hack; I think leaving it
1491 zero is OK since dbxread.c also does what it needs to do if
1492 objfile->global_psymbols.size is 0. */
1493 (*objfile
->sf
->sym_read
) (objfile
, objfile
->section_offsets
, 0);
1494 if (!have_partial_symbols () && !have_full_symbols ())
1497 printf_filtered ("(no debugging symbols found)\n");
1500 objfile
-> flags
|= OBJF_SYMS
;
1502 /* We're done reading the symbol file; finish off complaints. */
1503 clear_complaints (0, 1);
1505 /* Getting new symbols may change our opinion about what is
1508 reinit_frame_cache ();
1510 /* Discard cleanups as symbol reading was successful. */
1511 discard_cleanups (old_cleanups
);
1513 /* If the mtime has changed between the time we set new_modtime
1514 and now, we *want* this to be out of date, so don't call stat
1516 objfile
->mtime
= new_modtime
;
1519 /* Call this after reading in a new symbol table to give target
1520 dependant code a crack at the new symbols. For instance, this
1521 could be used to update the values of target-specific symbols GDB
1522 needs to keep track of (such as _sigtramp, or whatever). */
1524 TARGET_SYMFILE_POSTREAD (objfile
);
1530 clear_symtab_users ();
1538 } filename_language
;
1540 static filename_language
* filename_language_table
;
1541 static int fl_table_size
, fl_table_next
;
1544 add_filename_language (ext
, lang
)
1548 if (fl_table_next
>= fl_table_size
)
1550 fl_table_size
+= 10;
1551 filename_language_table
= realloc (filename_language_table
,
1555 filename_language_table
[fl_table_next
].ext
= strsave (ext
);
1556 filename_language_table
[fl_table_next
].lang
= lang
;
1560 static char *ext_args
;
1563 set_ext_lang_command (args
, from_tty
)
1568 char *cp
= ext_args
;
1571 /* First arg is filename extension, starting with '.' */
1573 error ("'%s': Filename extension must begin with '.'", ext_args
);
1575 /* Find end of first arg. */
1576 while (*cp
&& !isspace (*cp
))
1580 error ("'%s': two arguments required -- filename extension and language",
1583 /* Null-terminate first arg */
1586 /* Find beginning of second arg, which should be a source language. */
1587 while (*cp
&& isspace (*cp
))
1591 error ("'%s': two arguments required -- filename extension and language",
1594 /* Lookup the language from among those we know. */
1595 lang
= language_enum (cp
);
1597 /* Now lookup the filename extension: do we already know it? */
1598 for (i
= 0; i
< fl_table_next
; i
++)
1599 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
1602 if (i
>= fl_table_next
)
1604 /* new file extension */
1605 add_filename_language (ext_args
, lang
);
1609 /* redefining a previously known filename extension */
1612 /* query ("Really make files of type %s '%s'?", */
1613 /* ext_args, language_str (lang)); */
1615 free (filename_language_table
[i
].ext
);
1616 filename_language_table
[i
].ext
= strsave (ext_args
);
1617 filename_language_table
[i
].lang
= lang
;
1622 info_ext_lang_command (args
, from_tty
)
1628 printf_filtered ("Filename extensions and the languages they represent:");
1629 printf_filtered ("\n\n");
1630 for (i
= 0; i
< fl_table_next
; i
++)
1631 printf_filtered ("\t%s\t- %s\n",
1632 filename_language_table
[i
].ext
,
1633 language_str (filename_language_table
[i
].lang
));
1637 init_filename_language_table ()
1639 if (fl_table_size
== 0) /* protect against repetition */
1643 filename_language_table
=
1644 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
1645 add_filename_language (".c", language_c
);
1646 add_filename_language (".C", language_cplus
);
1647 add_filename_language (".cc", language_cplus
);
1648 add_filename_language (".cp", language_cplus
);
1649 add_filename_language (".cpp", language_cplus
);
1650 add_filename_language (".cxx", language_cplus
);
1651 add_filename_language (".c++", language_cplus
);
1652 add_filename_language (".java", language_java
);
1653 add_filename_language (".class", language_java
);
1654 add_filename_language (".ch", language_chill
);
1655 add_filename_language (".c186", language_chill
);
1656 add_filename_language (".c286", language_chill
);
1657 add_filename_language (".f", language_fortran
);
1658 add_filename_language (".F", language_fortran
);
1659 add_filename_language (".s", language_asm
);
1660 add_filename_language (".S", language_asm
);
1665 deduce_language_from_filename (filename
)
1671 if (filename
!= NULL
)
1672 if ((cp
= strrchr (filename
, '.')) != NULL
)
1673 for (i
= 0; i
< fl_table_next
; i
++)
1674 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
1675 return filename_language_table
[i
].lang
;
1677 return language_unknown
;
1682 Allocate and partly initialize a new symbol table. Return a pointer
1683 to it. error() if no space.
1685 Caller must set these fields:
1691 possibly free_named_symtabs (symtab->filename);
1695 allocate_symtab (filename
, objfile
)
1697 struct objfile
*objfile
;
1699 register struct symtab
*symtab
;
1701 symtab
= (struct symtab
*)
1702 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
1703 memset (symtab
, 0, sizeof (*symtab
));
1704 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
1705 &objfile
-> symbol_obstack
);
1706 symtab
-> fullname
= NULL
;
1707 symtab
-> language
= deduce_language_from_filename (filename
);
1708 symtab
-> debugformat
= obsavestring ("unknown", 7,
1709 &objfile
-> symbol_obstack
);
1711 /* Hook it to the objfile it comes from */
1713 symtab
-> objfile
= objfile
;
1714 symtab
-> next
= objfile
-> symtabs
;
1715 objfile
-> symtabs
= symtab
;
1717 /* FIXME: This should go away. It is only defined for the Z8000,
1718 and the Z8000 definition of this macro doesn't have anything to
1719 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
1720 here for convenience. */
1721 #ifdef INIT_EXTRA_SYMTAB_INFO
1722 INIT_EXTRA_SYMTAB_INFO (symtab
);
1728 struct partial_symtab
*
1729 allocate_psymtab (filename
, objfile
)
1731 struct objfile
*objfile
;
1733 struct partial_symtab
*psymtab
;
1735 if (objfile
-> free_psymtabs
)
1737 psymtab
= objfile
-> free_psymtabs
;
1738 objfile
-> free_psymtabs
= psymtab
-> next
;
1741 psymtab
= (struct partial_symtab
*)
1742 obstack_alloc (&objfile
-> psymbol_obstack
,
1743 sizeof (struct partial_symtab
));
1745 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1746 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1747 &objfile
-> psymbol_obstack
);
1748 psymtab
-> symtab
= NULL
;
1750 /* Prepend it to the psymtab list for the objfile it belongs to.
1751 Psymtabs are searched in most recent inserted -> least recent
1754 psymtab
-> objfile
= objfile
;
1755 psymtab
-> next
= objfile
-> psymtabs
;
1756 objfile
-> psymtabs
= psymtab
;
1759 struct partial_symtab
**prev_pst
;
1760 psymtab
-> objfile
= objfile
;
1761 psymtab
-> next
= NULL
;
1762 prev_pst
= &(objfile
-> psymtabs
);
1763 while ((*prev_pst
) != NULL
)
1764 prev_pst
= &((*prev_pst
) -> next
);
1765 (*prev_pst
) = psymtab
;
1773 discard_psymtab (pst
)
1774 struct partial_symtab
*pst
;
1776 struct partial_symtab
**prev_pst
;
1779 Empty psymtabs happen as a result of header files which don't
1780 have any symbols in them. There can be a lot of them. But this
1781 check is wrong, in that a psymtab with N_SLINE entries but
1782 nothing else is not empty, but we don't realize that. Fixing
1783 that without slowing things down might be tricky. */
1785 /* First, snip it out of the psymtab chain */
1787 prev_pst
= &(pst
->objfile
->psymtabs
);
1788 while ((*prev_pst
) != pst
)
1789 prev_pst
= &((*prev_pst
)->next
);
1790 (*prev_pst
) = pst
->next
;
1792 /* Next, put it on a free list for recycling */
1794 pst
->next
= pst
->objfile
->free_psymtabs
;
1795 pst
->objfile
->free_psymtabs
= pst
;
1799 /* Reset all data structures in gdb which may contain references to symbol
1803 clear_symtab_users ()
1805 /* Someday, we should do better than this, by only blowing away
1806 the things that really need to be blown. */
1807 clear_value_history ();
1809 clear_internalvars ();
1810 breakpoint_re_set ();
1811 set_default_breakpoint (0, 0, 0, 0);
1812 current_source_symtab
= 0;
1813 current_source_line
= 0;
1814 clear_pc_function_cache ();
1815 target_new_objfile (NULL
);
1818 /* clear_symtab_users_once:
1820 This function is run after symbol reading, or from a cleanup.
1821 If an old symbol table was obsoleted, the old symbol table
1822 has been blown away, but the other GDB data structures that may
1823 reference it have not yet been cleared or re-directed. (The old
1824 symtab was zapped, and the cleanup queued, in free_named_symtab()
1827 This function can be queued N times as a cleanup, or called
1828 directly; it will do all the work the first time, and then will be a
1829 no-op until the next time it is queued. This works by bumping a
1830 counter at queueing time. Much later when the cleanup is run, or at
1831 the end of symbol processing (in case the cleanup is discarded), if
1832 the queued count is greater than the "done-count", we do the work
1833 and set the done-count to the queued count. If the queued count is
1834 less than or equal to the done-count, we just ignore the call. This
1835 is needed because reading a single .o file will often replace many
1836 symtabs (one per .h file, for example), and we don't want to reset
1837 the breakpoints N times in the user's face.
1839 The reason we both queue a cleanup, and call it directly after symbol
1840 reading, is because the cleanup protects us in case of errors, but is
1841 discarded if symbol reading is successful. */
1844 /* FIXME: As free_named_symtabs is currently a big noop this function
1845 is no longer needed. */
1847 clear_symtab_users_once
PARAMS ((void));
1849 static int clear_symtab_users_queued
;
1850 static int clear_symtab_users_done
;
1853 clear_symtab_users_once ()
1855 /* Enforce once-per-`do_cleanups'-semantics */
1856 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1858 clear_symtab_users_done
= clear_symtab_users_queued
;
1860 clear_symtab_users ();
1864 /* Delete the specified psymtab, and any others that reference it. */
1867 cashier_psymtab (pst
)
1868 struct partial_symtab
*pst
;
1870 struct partial_symtab
*ps
, *pprev
= NULL
;
1873 /* Find its previous psymtab in the chain */
1874 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1881 /* Unhook it from the chain. */
1882 if (ps
== pst
->objfile
->psymtabs
)
1883 pst
->objfile
->psymtabs
= ps
->next
;
1885 pprev
->next
= ps
->next
;
1887 /* FIXME, we can't conveniently deallocate the entries in the
1888 partial_symbol lists (global_psymbols/static_psymbols) that
1889 this psymtab points to. These just take up space until all
1890 the psymtabs are reclaimed. Ditto the dependencies list and
1891 filename, which are all in the psymbol_obstack. */
1893 /* We need to cashier any psymtab that has this one as a dependency... */
1895 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1896 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1897 if (ps
->dependencies
[i
] == pst
) {
1898 cashier_psymtab (ps
);
1899 goto again
; /* Must restart, chain has been munged. */
1906 /* If a symtab or psymtab for filename NAME is found, free it along
1907 with any dependent breakpoints, displays, etc.
1908 Used when loading new versions of object modules with the "add-file"
1909 command. This is only called on the top-level symtab or psymtab's name;
1910 it is not called for subsidiary files such as .h files.
1912 Return value is 1 if we blew away the environment, 0 if not.
1913 FIXME. The return valu appears to never be used.
1915 FIXME. I think this is not the best way to do this. We should
1916 work on being gentler to the environment while still cleaning up
1917 all stray pointers into the freed symtab. */
1920 free_named_symtabs (name
)
1924 /* FIXME: With the new method of each objfile having it's own
1925 psymtab list, this function needs serious rethinking. In particular,
1926 why was it ever necessary to toss psymtabs with specific compilation
1927 unit filenames, as opposed to all psymtabs from a particular symbol
1929 Well, the answer is that some systems permit reloading of particular
1930 compilation units. We want to blow away any old info about these
1931 compilation units, regardless of which objfiles they arrived in. --gnu. */
1933 register struct symtab
*s
;
1934 register struct symtab
*prev
;
1935 register struct partial_symtab
*ps
;
1936 struct blockvector
*bv
;
1939 /* We only wack things if the symbol-reload switch is set. */
1940 if (!symbol_reloading
)
1943 /* Some symbol formats have trouble providing file names... */
1944 if (name
== 0 || *name
== '\0')
1947 /* Look for a psymtab with the specified name. */
1950 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1951 if (STREQ (name
, ps
->filename
)) {
1952 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1953 goto again2
; /* Must restart, chain has been munged */
1957 /* Look for a symtab with the specified name. */
1959 for (s
= symtab_list
; s
; s
= s
->next
)
1961 if (STREQ (name
, s
->filename
))
1968 if (s
== symtab_list
)
1969 symtab_list
= s
->next
;
1971 prev
->next
= s
->next
;
1973 /* For now, queue a delete for all breakpoints, displays, etc., whether
1974 or not they depend on the symtab being freed. This should be
1975 changed so that only those data structures affected are deleted. */
1977 /* But don't delete anything if the symtab is empty.
1978 This test is necessary due to a bug in "dbxread.c" that
1979 causes empty symtabs to be created for N_SO symbols that
1980 contain the pathname of the object file. (This problem
1981 has been fixed in GDB 3.9x). */
1983 bv
= BLOCKVECTOR (s
);
1984 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1985 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1986 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1988 complain (&oldsyms_complaint
, name
);
1990 clear_symtab_users_queued
++;
1991 make_cleanup (clear_symtab_users_once
, 0);
1994 complain (&empty_symtab_complaint
, name
);
2001 /* It is still possible that some breakpoints will be affected
2002 even though no symtab was found, since the file might have
2003 been compiled without debugging, and hence not be associated
2004 with a symtab. In order to handle this correctly, we would need
2005 to keep a list of text address ranges for undebuggable files.
2006 For now, we do nothing, since this is a fairly obscure case. */
2010 /* FIXME, what about the minimal symbol table? */
2017 /* Allocate and partially fill a partial symtab. It will be
2018 completely filled at the end of the symbol list.
2020 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2021 is the address relative to which its symbols are (incremental) or 0
2025 struct partial_symtab
*
2026 start_psymtab_common (objfile
, section_offsets
,
2027 filename
, textlow
, global_syms
, static_syms
)
2028 struct objfile
*objfile
;
2029 struct section_offsets
*section_offsets
;
2032 struct partial_symbol
**global_syms
;
2033 struct partial_symbol
**static_syms
;
2035 struct partial_symtab
*psymtab
;
2037 psymtab
= allocate_psymtab (filename
, objfile
);
2038 psymtab
-> section_offsets
= section_offsets
;
2039 psymtab
-> textlow
= textlow
;
2040 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
2041 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
2042 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
2046 /* Add a symbol with a long value to a psymtab.
2047 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
2050 add_psymbol_to_list (name
, namelength
, namespace, class, list
, val
, coreaddr
,
2054 namespace_enum
namespace;
2055 enum address_class
class;
2056 struct psymbol_allocation_list
*list
;
2057 long val
; /* Value as a long */
2058 CORE_ADDR coreaddr
; /* Value as a CORE_ADDR */
2059 enum language language
;
2060 struct objfile
*objfile
;
2062 register struct partial_symbol
*psym
;
2063 char *buf
= alloca (namelength
+ 1);
2064 /* psymbol is static so that there will be no uninitialized gaps in the
2065 structure which might contain random data, causing cache misses in
2067 static struct partial_symbol psymbol
;
2069 /* Create local copy of the partial symbol */
2070 memcpy (buf
, name
, namelength
);
2071 buf
[namelength
] = '\0';
2072 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, &objfile
->psymbol_cache
);
2073 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2076 SYMBOL_VALUE (&psymbol
) = val
;
2080 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2082 SYMBOL_SECTION (&psymbol
) = 0;
2083 SYMBOL_LANGUAGE (&psymbol
) = language
;
2084 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2085 PSYMBOL_CLASS (&psymbol
) = class;
2086 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2088 /* Stash the partial symbol away in the cache */
2089 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), &objfile
->psymbol_cache
);
2091 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2092 if (list
->next
>= list
->list
+ list
->size
)
2094 extend_psymbol_list (list
, objfile
);
2096 *list
->next
++ = psym
;
2097 OBJSTAT (objfile
, n_psyms
++);
2100 /* Add a symbol with a long value to a psymtab. This differs from
2101 * add_psymbol_to_list above in taking both a mangled and a demangled
2105 add_psymbol_with_dem_name_to_list (name
, namelength
, dem_name
, dem_namelength
,
2106 namespace, class, list
, val
, coreaddr
, language
, objfile
)
2111 namespace_enum
namespace;
2112 enum address_class
class;
2113 struct psymbol_allocation_list
*list
;
2114 long val
; /* Value as a long */
2115 CORE_ADDR coreaddr
; /* Value as a CORE_ADDR */
2116 enum language language
;
2117 struct objfile
*objfile
;
2119 register struct partial_symbol
*psym
;
2120 char *buf
= alloca (namelength
+ 1);
2121 /* psymbol is static so that there will be no uninitialized gaps in the
2122 structure which might contain random data, causing cache misses in
2124 static struct partial_symbol psymbol
;
2126 /* Create local copy of the partial symbol */
2128 memcpy (buf
, name
, namelength
);
2129 buf
[namelength
] = '\0';
2130 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, &objfile
->psymbol_cache
);
2132 buf
= alloca (dem_namelength
+ 1);
2133 memcpy (buf
, dem_name
, dem_namelength
);
2134 buf
[dem_namelength
] = '\0';
2139 case language_cplus
:
2140 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol
) =
2141 bcache (buf
, dem_namelength
+ 1, &objfile
->psymbol_cache
);
2143 case language_chill
:
2144 SYMBOL_CHILL_DEMANGLED_NAME (&psymbol
) =
2145 bcache (buf
, dem_namelength
+ 1, &objfile
->psymbol_cache
);
2147 /* FIXME What should be done for the default case? Ignoring for now. */
2150 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2153 SYMBOL_VALUE (&psymbol
) = val
;
2157 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2159 SYMBOL_SECTION (&psymbol
) = 0;
2160 SYMBOL_LANGUAGE (&psymbol
) = language
;
2161 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2162 PSYMBOL_CLASS (&psymbol
) = class;
2163 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2165 /* Stash the partial symbol away in the cache */
2166 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), &objfile
->psymbol_cache
);
2168 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2169 if (list
->next
>= list
->list
+ list
->size
)
2171 extend_psymbol_list (list
, objfile
);
2173 *list
->next
++ = psym
;
2174 OBJSTAT (objfile
, n_psyms
++);
2177 /* Initialize storage for partial symbols. */
2180 init_psymbol_list (objfile
, total_symbols
)
2181 struct objfile
*objfile
;
2184 /* Free any previously allocated psymbol lists. */
2186 if (objfile
-> global_psymbols
.list
)
2188 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
2190 if (objfile
-> static_psymbols
.list
)
2192 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
2195 /* Current best guess is that approximately a twentieth
2196 of the total symbols (in a debugging file) are global or static
2199 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
2200 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
2202 if (objfile
-> global_psymbols
.size
> 0)
2204 objfile
-> global_psymbols
.next
=
2205 objfile
-> global_psymbols
.list
= (struct partial_symbol
**)
2206 xmmalloc (objfile
-> md
, (objfile
-> global_psymbols
.size
2207 * sizeof (struct partial_symbol
*)));
2209 if (objfile
-> static_psymbols
.size
> 0)
2211 objfile
-> static_psymbols
.next
=
2212 objfile
-> static_psymbols
.list
= (struct partial_symbol
**)
2213 xmmalloc (objfile
-> md
, (objfile
-> static_psymbols
.size
2214 * sizeof (struct partial_symbol
*)));
2219 The following code implements an abstraction for debugging overlay sections.
2221 The target model is as follows:
2222 1) The gnu linker will permit multiple sections to be mapped into the
2223 same VMA, each with its own unique LMA (or load address).
2224 2) It is assumed that some runtime mechanism exists for mapping the
2225 sections, one by one, from the load address into the VMA address.
2226 3) This code provides a mechanism for gdb to keep track of which
2227 sections should be considered to be mapped from the VMA to the LMA.
2228 This information is used for symbol lookup, and memory read/write.
2229 For instance, if a section has been mapped then its contents
2230 should be read from the VMA, otherwise from the LMA.
2232 Two levels of debugger support for overlays are available. One is
2233 "manual", in which the debugger relies on the user to tell it which
2234 overlays are currently mapped. This level of support is
2235 implemented entirely in the core debugger, and the information about
2236 whether a section is mapped is kept in the objfile->obj_section table.
2238 The second level of support is "automatic", and is only available if
2239 the target-specific code provides functionality to read the target's
2240 overlay mapping table, and translate its contents for the debugger
2241 (by updating the mapped state information in the obj_section tables).
2243 The interface is as follows:
2245 overlay map <name> -- tell gdb to consider this section mapped
2246 overlay unmap <name> -- tell gdb to consider this section unmapped
2247 overlay list -- list the sections that GDB thinks are mapped
2248 overlay read-target -- get the target's state of what's mapped
2249 overlay off/manual/auto -- set overlay debugging state
2250 Functional interface:
2251 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2252 section, return that section.
2253 find_pc_overlay(pc): find any overlay section that contains
2254 the pc, either in its VMA or its LMA
2255 overlay_is_mapped(sect): true if overlay is marked as mapped
2256 section_is_overlay(sect): true if section's VMA != LMA
2257 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2258 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2259 overlay_mapped_address(...): map an address from section's LMA to VMA
2260 overlay_unmapped_address(...): map an address from section's VMA to LMA
2261 symbol_overlayed_address(...): Return a "current" address for symbol:
2262 either in VMA or LMA depending on whether
2263 the symbol's section is currently mapped
2266 /* Overlay debugging state: */
2268 int overlay_debugging
= 0; /* 0 == off, 1 == manual, -1 == auto */
2269 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
2271 /* Target vector for refreshing overlay mapped state */
2272 static void simple_overlay_update
PARAMS ((struct obj_section
*));
2273 void (*target_overlay_update
) PARAMS ((struct obj_section
*))
2274 = simple_overlay_update
;
2276 /* Function: section_is_overlay (SECTION)
2277 Returns true if SECTION has VMA not equal to LMA, ie.
2278 SECTION is loaded at an address different from where it will "run". */
2281 section_is_overlay (section
)
2284 if (overlay_debugging
)
2285 if (section
&& section
->lma
!= 0 &&
2286 section
->vma
!= section
->lma
)
2292 /* Function: overlay_invalidate_all (void)
2293 Invalidate the mapped state of all overlay sections (mark it as stale). */
2296 overlay_invalidate_all ()
2298 struct objfile
*objfile
;
2299 struct obj_section
*sect
;
2301 ALL_OBJSECTIONS (objfile
, sect
)
2302 if (section_is_overlay (sect
->the_bfd_section
))
2303 sect
->ovly_mapped
= -1;
2306 /* Function: overlay_is_mapped (SECTION)
2307 Returns true if section is an overlay, and is currently mapped.
2308 Private: public access is thru function section_is_mapped.
2310 Access to the ovly_mapped flag is restricted to this function, so
2311 that we can do automatic update. If the global flag
2312 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2313 overlay_invalidate_all. If the mapped state of the particular
2314 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2317 overlay_is_mapped (osect
)
2318 struct obj_section
*osect
;
2320 if (osect
== 0 || !section_is_overlay (osect
->the_bfd_section
))
2323 switch (overlay_debugging
)
2326 case 0: return 0; /* overlay debugging off */
2327 case -1: /* overlay debugging automatic */
2328 /* Unles there is a target_overlay_update function,
2329 there's really nothing useful to do here (can't really go auto) */
2330 if (target_overlay_update
)
2332 if (overlay_cache_invalid
)
2334 overlay_invalidate_all ();
2335 overlay_cache_invalid
= 0;
2337 if (osect
->ovly_mapped
== -1)
2338 (*target_overlay_update
) (osect
);
2340 /* fall thru to manual case */
2341 case 1: /* overlay debugging manual */
2342 return osect
->ovly_mapped
== 1;
2346 /* Function: section_is_mapped
2347 Returns true if section is an overlay, and is currently mapped. */
2350 section_is_mapped (section
)
2353 struct objfile
*objfile
;
2354 struct obj_section
*osect
;
2356 if (overlay_debugging
)
2357 if (section
&& section_is_overlay (section
))
2358 ALL_OBJSECTIONS (objfile
, osect
)
2359 if (osect
->the_bfd_section
== section
)
2360 return overlay_is_mapped (osect
);
2365 /* Function: pc_in_unmapped_range
2366 If PC falls into the lma range of SECTION, return true, else false. */
2369 pc_in_unmapped_range (pc
, section
)
2375 if (overlay_debugging
)
2376 if (section
&& section_is_overlay (section
))
2378 size
= bfd_get_section_size_before_reloc (section
);
2379 if (section
->lma
<= pc
&& pc
< section
->lma
+ size
)
2385 /* Function: pc_in_mapped_range
2386 If PC falls into the vma range of SECTION, return true, else false. */
2389 pc_in_mapped_range (pc
, section
)
2395 if (overlay_debugging
)
2396 if (section
&& section_is_overlay (section
))
2398 size
= bfd_get_section_size_before_reloc (section
);
2399 if (section
->vma
<= pc
&& pc
< section
->vma
+ size
)
2405 /* Function: overlay_unmapped_address (PC, SECTION)
2406 Returns the address corresponding to PC in the unmapped (load) range.
2407 May be the same as PC. */
2410 overlay_unmapped_address (pc
, section
)
2414 if (overlay_debugging
)
2415 if (section
&& section_is_overlay (section
) &&
2416 pc_in_mapped_range (pc
, section
))
2417 return pc
+ section
->lma
- section
->vma
;
2422 /* Function: overlay_mapped_address (PC, SECTION)
2423 Returns the address corresponding to PC in the mapped (runtime) range.
2424 May be the same as PC. */
2427 overlay_mapped_address (pc
, section
)
2431 if (overlay_debugging
)
2432 if (section
&& section_is_overlay (section
) &&
2433 pc_in_unmapped_range (pc
, section
))
2434 return pc
+ section
->vma
- section
->lma
;
2440 /* Function: symbol_overlayed_address
2441 Return one of two addresses (relative to the VMA or to the LMA),
2442 depending on whether the section is mapped or not. */
2445 symbol_overlayed_address (address
, section
)
2449 if (overlay_debugging
)
2451 /* If the symbol has no section, just return its regular address. */
2454 /* If the symbol's section is not an overlay, just return its address */
2455 if (!section_is_overlay (section
))
2457 /* If the symbol's section is mapped, just return its address */
2458 if (section_is_mapped (section
))
2461 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
2462 * then return its LOADED address rather than its vma address!!
2464 return overlay_unmapped_address (address
, section
);
2469 /* Function: find_pc_overlay (PC)
2470 Return the best-match overlay section for PC:
2471 If PC matches a mapped overlay section's VMA, return that section.
2472 Else if PC matches an unmapped section's VMA, return that section.
2473 Else if PC matches an unmapped section's LMA, return that section. */
2476 find_pc_overlay (pc
)
2479 struct objfile
*objfile
;
2480 struct obj_section
*osect
, *best_match
= NULL
;
2482 if (overlay_debugging
)
2483 ALL_OBJSECTIONS (objfile
, osect
)
2484 if (section_is_overlay (osect
->the_bfd_section
))
2486 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
))
2488 if (overlay_is_mapped (osect
))
2489 return osect
->the_bfd_section
;
2493 else if (pc_in_unmapped_range (pc
, osect
->the_bfd_section
))
2496 return best_match
? best_match
->the_bfd_section
: NULL
;
2499 /* Function: find_pc_mapped_section (PC)
2500 If PC falls into the VMA address range of an overlay section that is
2501 currently marked as MAPPED, return that section. Else return NULL. */
2504 find_pc_mapped_section (pc
)
2507 struct objfile
*objfile
;
2508 struct obj_section
*osect
;
2510 if (overlay_debugging
)
2511 ALL_OBJSECTIONS (objfile
, osect
)
2512 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
) &&
2513 overlay_is_mapped (osect
))
2514 return osect
->the_bfd_section
;
2519 /* Function: list_overlays_command
2520 Print a list of mapped sections and their PC ranges */
2523 list_overlays_command (args
, from_tty
)
2528 struct objfile
*objfile
;
2529 struct obj_section
*osect
;
2531 if (overlay_debugging
)
2532 ALL_OBJSECTIONS (objfile
, osect
)
2533 if (overlay_is_mapped (osect
))
2539 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
2540 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
2541 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
2542 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
2544 printf_filtered ("Section %s, loaded at ", name
);
2545 print_address_numeric (lma
, 1, gdb_stdout
);
2546 puts_filtered (" - ");
2547 print_address_numeric (lma
+ size
, 1, gdb_stdout
);
2548 printf_filtered (", mapped at ");
2549 print_address_numeric (vma
, 1, gdb_stdout
);
2550 puts_filtered (" - ");
2551 print_address_numeric (vma
+ size
, 1, gdb_stdout
);
2552 puts_filtered ("\n");
2557 printf_filtered ("No sections are mapped.\n");
2560 /* Function: map_overlay_command
2561 Mark the named section as mapped (ie. residing at its VMA address). */
2564 map_overlay_command (args
, from_tty
)
2568 struct objfile
*objfile
, *objfile2
;
2569 struct obj_section
*sec
, *sec2
;
2572 if (!overlay_debugging
)
2573 error ("Overlay debugging not enabled. Use the 'OVERLAY ON' command.");
2575 if (args
== 0 || *args
== 0)
2576 error ("Argument required: name of an overlay section");
2578 /* First, find a section matching the user supplied argument */
2579 ALL_OBJSECTIONS (objfile
, sec
)
2580 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
2582 /* Now, check to see if the section is an overlay. */
2583 bfdsec
= sec
->the_bfd_section
;
2584 if (!section_is_overlay (bfdsec
))
2585 continue; /* not an overlay section */
2587 /* Mark the overlay as "mapped" */
2588 sec
->ovly_mapped
= 1;
2590 /* Next, make a pass and unmap any sections that are
2591 overlapped by this new section: */
2592 ALL_OBJSECTIONS (objfile2
, sec2
)
2593 if (sec2
->ovly_mapped
&&
2595 sec
->the_bfd_section
!= sec2
->the_bfd_section
&&
2596 (pc_in_mapped_range (sec2
->addr
, sec
->the_bfd_section
) ||
2597 pc_in_mapped_range (sec2
->endaddr
, sec
->the_bfd_section
)))
2600 printf_filtered ("Note: section %s unmapped by overlap\n",
2601 bfd_section_name (objfile
->obfd
,
2602 sec2
->the_bfd_section
));
2603 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
2607 error ("No overlay section called %s", args
);
2610 /* Function: unmap_overlay_command
2611 Mark the overlay section as unmapped
2612 (ie. resident in its LMA address range, rather than the VMA range). */
2615 unmap_overlay_command (args
, from_tty
)
2619 struct objfile
*objfile
;
2620 struct obj_section
*sec
;
2622 if (!overlay_debugging
)
2623 error ("Overlay debugging not enabled. Use the 'OVERLAY ON' command.");
2625 if (args
== 0 || *args
== 0)
2626 error ("Argument required: name of an overlay section");
2628 /* First, find a section matching the user supplied argument */
2629 ALL_OBJSECTIONS (objfile
, sec
)
2630 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
2632 if (!sec
->ovly_mapped
)
2633 error ("Section %s is not mapped", args
);
2634 sec
->ovly_mapped
= 0;
2637 error ("No overlay section called %s", args
);
2640 /* Function: overlay_auto_command
2641 A utility command to turn on overlay debugging.
2642 Possibly this should be done via a set/show command. */
2645 overlay_auto_command (args
, from_tty
)
2649 overlay_debugging
= -1;
2651 printf_filtered ("Automatic overlay debugging enabled.");
2654 /* Function: overlay_manual_command
2655 A utility command to turn on overlay debugging.
2656 Possibly this should be done via a set/show command. */
2659 overlay_manual_command (args
, from_tty
)
2663 overlay_debugging
= 1;
2665 printf_filtered ("Overlay debugging enabled.");
2668 /* Function: overlay_off_command
2669 A utility command to turn on overlay debugging.
2670 Possibly this should be done via a set/show command. */
2673 overlay_off_command (args
, from_tty
)
2677 overlay_debugging
= 0;
2679 printf_filtered ("Overlay debugging disabled.");
2683 overlay_load_command (args
, from_tty
)
2687 if (target_overlay_update
)
2688 (*target_overlay_update
) (NULL
);
2690 error ("This target does not know how to read its overlay state.");
2693 /* Function: overlay_command
2694 A place-holder for a mis-typed command */
2696 /* Command list chain containing all defined "overlay" subcommands. */
2697 struct cmd_list_element
*overlaylist
;
2700 overlay_command (args
, from_tty
)
2705 ("\"overlay\" must be followed by the name of an overlay command.\n");
2706 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
2710 /* Target Overlays for the "Simplest" overlay manager:
2712 This is GDB's default target overlay layer. It works with the
2713 minimal overlay manager supplied as an example by Cygnus. The
2714 entry point is via a function pointer "target_overlay_update",
2715 so targets that use a different runtime overlay manager can
2716 substitute their own overlay_update function and take over the
2719 The overlay_update function pokes around in the target's data structures
2720 to see what overlays are mapped, and updates GDB's overlay mapping with
2723 In this simple implementation, the target data structures are as follows:
2724 unsigned _novlys; /# number of overlay sections #/
2725 unsigned _ovly_table[_novlys][4] = {
2726 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
2727 {..., ..., ..., ...},
2729 unsigned _novly_regions; /# number of overlay regions #/
2730 unsigned _ovly_region_table[_novly_regions][3] = {
2731 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
2734 These functions will attempt to update GDB's mappedness state in the
2735 symbol section table, based on the target's mappedness state.
2737 To do this, we keep a cached copy of the target's _ovly_table, and
2738 attempt to detect when the cached copy is invalidated. The main
2739 entry point is "simple_overlay_update(SECT), which looks up SECT in
2740 the cached table and re-reads only the entry for that section from
2741 the target (whenever possible).
2744 /* Cached, dynamically allocated copies of the target data structures: */
2745 static unsigned (*cache_ovly_table
)[4] = 0;
2747 static unsigned (*cache_ovly_region_table
)[3] = 0;
2749 static unsigned cache_novlys
= 0;
2751 static unsigned cache_novly_regions
= 0;
2753 static CORE_ADDR cache_ovly_table_base
= 0;
2755 static CORE_ADDR cache_ovly_region_table_base
= 0;
2757 enum ovly_index
{ VMA
, SIZE
, LMA
, MAPPED
};
2758 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
2760 /* Throw away the cached copy of _ovly_table */
2762 simple_free_overlay_table ()
2764 if (cache_ovly_table
)
2765 free(cache_ovly_table
);
2767 cache_ovly_table
= NULL
;
2768 cache_ovly_table_base
= 0;
2772 /* Throw away the cached copy of _ovly_region_table */
2774 simple_free_overlay_region_table ()
2776 if (cache_ovly_region_table
)
2777 free(cache_ovly_region_table
);
2778 cache_novly_regions
= 0;
2779 cache_ovly_region_table
= NULL
;
2780 cache_ovly_region_table_base
= 0;
2784 /* Read an array of ints from the target into a local buffer.
2785 Convert to host order. int LEN is number of ints */
2787 read_target_long_array (memaddr
, myaddr
, len
)
2789 unsigned int *myaddr
;
2792 char *buf
= alloca (len
* TARGET_LONG_BYTES
);
2795 read_memory (memaddr
, buf
, len
* TARGET_LONG_BYTES
);
2796 for (i
= 0; i
< len
; i
++)
2797 myaddr
[i
] = extract_unsigned_integer (TARGET_LONG_BYTES
* i
+ buf
,
2801 /* Find and grab a copy of the target _ovly_table
2802 (and _novlys, which is needed for the table's size) */
2804 simple_read_overlay_table ()
2806 struct minimal_symbol
*msym
;
2808 simple_free_overlay_table ();
2809 msym
= lookup_minimal_symbol ("_novlys", 0, 0);
2811 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
2813 return 0; /* failure */
2814 cache_ovly_table
= (void *) xmalloc (cache_novlys
* sizeof(*cache_ovly_table
));
2815 if (cache_ovly_table
!= NULL
)
2817 msym
= lookup_minimal_symbol ("_ovly_table", 0, 0);
2820 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
2821 read_target_long_array (cache_ovly_table_base
,
2822 (int *) cache_ovly_table
,
2826 return 0; /* failure */
2829 return 0; /* failure */
2830 return 1; /* SUCCESS */
2834 /* Find and grab a copy of the target _ovly_region_table
2835 (and _novly_regions, which is needed for the table's size) */
2837 simple_read_overlay_region_table ()
2839 struct minimal_symbol
*msym
;
2841 simple_free_overlay_region_table ();
2842 msym
= lookup_minimal_symbol ("_novly_regions", 0, 0);
2844 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
2846 return 0; /* failure */
2847 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
2848 if (cache_ovly_region_table
!= NULL
)
2850 msym
= lookup_minimal_symbol ("_ovly_region_table", 0, 0);
2853 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
2854 read_target_long_array (cache_ovly_region_table_base
,
2855 (int *) cache_ovly_region_table
,
2856 cache_novly_regions
* 3);
2859 return 0; /* failure */
2862 return 0; /* failure */
2863 return 1; /* SUCCESS */
2867 /* Function: simple_overlay_update_1
2868 A helper function for simple_overlay_update. Assuming a cached copy
2869 of _ovly_table exists, look through it to find an entry whose vma,
2870 lma and size match those of OSECT. Re-read the entry and make sure
2871 it still matches OSECT (else the table may no longer be valid).
2872 Set OSECT's mapped state to match the entry. Return: 1 for
2873 success, 0 for failure. */
2876 simple_overlay_update_1 (osect
)
2877 struct obj_section
*osect
;
2881 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
2882 for (i
= 0; i
< cache_novlys
; i
++)
2883 if (cache_ovly_table
[i
][VMA
] == osect
->the_bfd_section
->vma
&&
2884 cache_ovly_table
[i
][LMA
] == osect
->the_bfd_section
->lma
/* &&
2885 cache_ovly_table[i][SIZE] == size */)
2887 read_target_long_array (cache_ovly_table_base
+ i
* TARGET_LONG_BYTES
,
2888 (int *) cache_ovly_table
[i
], 4);
2889 if (cache_ovly_table
[i
][VMA
] == osect
->the_bfd_section
->vma
&&
2890 cache_ovly_table
[i
][LMA
] == osect
->the_bfd_section
->lma
/* &&
2891 cache_ovly_table[i][SIZE] == size */)
2893 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
2896 else /* Warning! Warning! Target's ovly table has changed! */
2902 /* Function: simple_overlay_update
2903 If OSECT is NULL, then update all sections' mapped state
2904 (after re-reading the entire target _ovly_table).
2905 If OSECT is non-NULL, then try to find a matching entry in the
2906 cached ovly_table and update only OSECT's mapped state.
2907 If a cached entry can't be found or the cache isn't valid, then
2908 re-read the entire cache, and go ahead and update all sections. */
2911 simple_overlay_update (osect
)
2912 struct obj_section
*osect
;
2914 struct objfile
*objfile
;
2916 /* Were we given an osect to look up? NULL means do all of them. */
2918 /* Have we got a cached copy of the target's overlay table? */
2919 if (cache_ovly_table
!= NULL
)
2920 /* Does its cached location match what's currently in the symtab? */
2921 if (cache_ovly_table_base
==
2922 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", 0, 0)))
2923 /* Then go ahead and try to look up this single section in the cache */
2924 if (simple_overlay_update_1 (osect
))
2925 /* Found it! We're done. */
2928 /* Cached table no good: need to read the entire table anew.
2929 Or else we want all the sections, in which case it's actually
2930 more efficient to read the whole table in one block anyway. */
2932 if (simple_read_overlay_table () == 0) /* read failed? No table? */
2934 warning ("Failed to read the target overlay mapping table.");
2937 /* Now may as well update all sections, even if only one was requested. */
2938 ALL_OBJSECTIONS (objfile
, osect
)
2939 if (section_is_overlay (osect
->the_bfd_section
))
2943 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
2944 for (i
= 0; i
< cache_novlys
; i
++)
2945 if (cache_ovly_table
[i
][VMA
] == osect
->the_bfd_section
->vma
&&
2946 cache_ovly_table
[i
][LMA
] == osect
->the_bfd_section
->lma
/* &&
2947 cache_ovly_table[i][SIZE] == size */)
2948 { /* obj_section matches i'th entry in ovly_table */
2949 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
2950 break; /* finished with inner for loop: break out */
2957 _initialize_symfile ()
2959 struct cmd_list_element
*c
;
2961 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
2962 "Load symbol table from executable file FILE.\n\
2963 The `file' command can also load symbol tables, as well as setting the file\n\
2964 to execute.", &cmdlist
);
2965 c
->completer
= filename_completer
;
2967 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
2968 "Usage: add-symbol-file FILE ADDR\n\
2969 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
2970 ADDR is the starting address of the file's text.",
2972 c
->completer
= filename_completer
;
2974 c
= add_cmd ("add-shared-symbol-files", class_files
,
2975 add_shared_symbol_files_command
,
2976 "Load the symbols from shared objects in the dynamic linker's link map.",
2978 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
2981 c
= add_cmd ("load", class_files
, load_command
,
2982 "Dynamically load FILE into the running program, and record its symbols\n\
2983 for access from GDB.", &cmdlist
);
2984 c
->completer
= filename_completer
;
2987 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
2988 (char *)&symbol_reloading
,
2989 "Set dynamic symbol table reloading multiple times in one run.",
2993 add_prefix_cmd ("overlay", class_support
, overlay_command
,
2994 "Commands for debugging overlays.", &overlaylist
,
2995 "overlay ", 0, &cmdlist
);
2997 add_com_alias ("ovly", "overlay", class_alias
, 1);
2998 add_com_alias ("ov", "overlay", class_alias
, 1);
3000 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3001 "Assert that an overlay section is mapped.", &overlaylist
);
3003 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3004 "Assert that an overlay section is unmapped.", &overlaylist
);
3006 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3007 "List mappings of overlay sections.", &overlaylist
);
3009 add_cmd ("manual", class_support
, overlay_manual_command
,
3010 "Enable overlay debugging.", &overlaylist
);
3011 add_cmd ("off", class_support
, overlay_off_command
,
3012 "Disable overlay debugging.", &overlaylist
);
3013 add_cmd ("auto", class_support
, overlay_auto_command
,
3014 "Enable automatic overlay debugging.", &overlaylist
);
3015 add_cmd ("load-target", class_support
, overlay_load_command
,
3016 "Read the overlay mapping state from the target.", &overlaylist
);
3018 /* Filename extension to source language lookup table: */
3019 init_filename_language_table ();
3020 c
= add_set_cmd ("extension-language", class_files
, var_string_noescape
,
3022 "Set mapping between filename extension and source language.\n\
3023 Usage: set extension-language .foo bar",
3025 c
->function
.cfunc
= set_ext_lang_command
;
3027 add_info ("extensions", info_ext_lang_command
,
3028 "All filename extensions associated with a source language.");