1 /* Generic symbol file reading for the GNU debugger, GDB.
2 Copyright 1990, 1991, 1992 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
31 #include "breakpoint.h"
33 #include "complaints.h"
39 #include <sys/types.h>
45 /* Global variables owned by this file */
47 int readnow_symbol_files
; /* Read full symbols immediately */
49 struct complaint oldsyms_complaint
= {
50 "Replacing old symbols for `%s'", 0, 0
53 struct complaint empty_symtab_complaint
= {
54 "Empty symbol table found for `%s'", 0, 0
57 /* External variables and functions referenced. */
59 extern int info_verbose
;
61 /* Functions this file defines */
64 set_initial_language
PARAMS ((void));
67 load_command
PARAMS ((char *, int));
70 add_symbol_file_command
PARAMS ((char *, int));
73 cashier_psymtab
PARAMS ((struct partial_symtab
*));
76 compare_psymbols
PARAMS ((const void *, const void *));
79 compare_symbols
PARAMS ((const void *, const void *));
82 symfile_bfd_open
PARAMS ((char *));
85 find_sym_fns
PARAMS ((struct objfile
*));
88 clear_symtab_users_once
PARAMS ((void));
90 /* List of all available sym_fns. On gdb startup, each object file reader
91 calls add_symtab_fns() to register information on each format it is
94 static struct sym_fns
*symtab_fns
= NULL
;
96 /* Structures with which to manage partial symbol allocation. */
98 struct psymbol_allocation_list global_psymbols
= {0}, static_psymbols
= {0};
100 /* Flag for whether user will be reloading symbols multiple times.
101 Defaults to ON for VxWorks, otherwise OFF. */
103 #ifdef SYMBOL_RELOADING_DEFAULT
104 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
106 int symbol_reloading
= 0;
110 /* In the following sort, we always make sure that
111 register debug symbol declarations always come before regular
112 debug symbol declarations (as might happen when parameters are
113 then put into registers by the compiler).
115 Since this function is called from within qsort, in an ANSI environment
116 it must conform to the prototype for qsort, which specifies that the
117 comparison function takes two "void *" pointers. */
120 compare_symbols (s1p
, s2p
)
124 register struct symbol
**s1
, **s2
;
125 register int namediff
;
127 s1
= (struct symbol
**) s1p
;
128 s2
= (struct symbol
**) s2p
;
130 /* Compare the initial characters. */
131 namediff
= SYMBOL_NAME (*s1
)[0] - SYMBOL_NAME (*s2
)[0];
132 if (namediff
!= 0) return namediff
;
134 /* If they match, compare the rest of the names. */
135 namediff
= STRCMP (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
));
136 if (namediff
!= 0) return namediff
;
138 /* For symbols of the same name, registers should come first. */
139 return ((SYMBOL_CLASS (*s2
) == LOC_REGISTER
)
140 - (SYMBOL_CLASS (*s1
) == LOC_REGISTER
));
147 compare_psymbols -- compare two partial symbols by name
151 Given pointer to two partial symbol table entries, compare
152 them by name and return -N, 0, or +N (ala strcmp). Typically
153 used by sorting routines like qsort().
157 Does direct compare of first two characters before punting
158 and passing to strcmp for longer compares. Note that the
159 original version had a bug whereby two null strings or two
160 identically named one character strings would return the
161 comparison of memory following the null byte.
166 compare_psymbols (s1p
, s2p
)
170 register char *st1
= SYMBOL_NAME ((struct partial_symbol
*) s1p
);
171 register char *st2
= SYMBOL_NAME ((struct partial_symbol
*) s2p
);
173 if ((st1
[0] - st2
[0]) || !st1
[0])
175 return (st1
[0] - st2
[0]);
177 else if ((st1
[1] - st2
[1]) || !st1
[1])
179 return (st1
[1] - st2
[1]);
183 return (STRCMP (st1
+ 2, st2
+ 2));
188 sort_pst_symbols (pst
)
189 struct partial_symtab
*pst
;
191 /* Sort the global list; don't sort the static list */
193 qsort (pst
-> objfile
-> global_psymbols
.list
+ pst
-> globals_offset
,
194 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
198 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
202 register struct block
*b
;
204 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
205 sizeof (struct symbol
*), compare_symbols
);
208 /* Call sort_symtab_syms to sort alphabetically
209 the symbols of each block of one symtab. */
213 register struct symtab
*s
;
215 register struct blockvector
*bv
;
218 register struct block
*b
;
222 bv
= BLOCKVECTOR (s
);
223 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
224 for (i
= 0; i
< nbl
; i
++)
226 b
= BLOCKVECTOR_BLOCK (bv
, i
);
227 if (BLOCK_SHOULD_SORT (b
))
233 sort_all_symtab_syms ()
235 register struct symtab
*s
;
236 register struct objfile
*objfile
;
238 for (objfile
= object_files
; objfile
!= NULL
; objfile
= objfile
-> next
)
240 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
242 sort_symtab_syms (s
);
247 /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
248 (and add a null character at the end in the copy).
249 Returns the address of the copy. */
252 obsavestring (ptr
, size
, obstackp
)
255 struct obstack
*obstackp
;
257 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
258 /* Open-coded bcopy--saves function call time.
259 These strings are usually short. */
261 register char *p1
= ptr
;
262 register char *p2
= p
;
263 char *end
= ptr
+ size
;
271 /* Concatenate strings S1, S2 and S3; return the new string.
272 Space is found in the symbol_obstack. */
275 obconcat (obstackp
, s1
, s2
, s3
)
276 struct obstack
*obstackp
;
277 const char *s1
, *s2
, *s3
;
279 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
280 register char *val
= (char *) obstack_alloc (obstackp
, len
);
287 /* Get the symbol table that corresponds to a partial_symtab.
288 This is fast after the first time you do it. In fact, there
289 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
293 psymtab_to_symtab (pst
)
294 register struct partial_symtab
*pst
;
296 /* If it's been looked up before, return it. */
300 /* If it has not yet been read in, read it. */
303 (*pst
->read_symtab
) (pst
);
309 /* Initialize entry point information for this objfile. */
312 init_entry_point_info (objfile
)
313 struct objfile
*objfile
;
315 /* Save startup file's range of PC addresses to help blockframe.c
316 decide where the bottom of the stack is. */
318 if (bfd_get_file_flags (objfile
-> obfd
) & EXEC_P
)
320 /* Executable file -- record its entry point so we'll recognize
321 the startup file because it contains the entry point. */
322 objfile
-> ei
.entry_point
= bfd_get_start_address (objfile
-> obfd
);
326 /* Examination of non-executable.o files. Short-circuit this stuff. */
327 /* ~0 will not be in any file, we hope. */
328 objfile
-> ei
.entry_point
= ~0;
329 /* set the startup file to be an empty range. */
330 objfile
-> ei
.entry_file_lowpc
= 0;
331 objfile
-> ei
.entry_file_highpc
= 0;
335 /* Remember the lowest-addressed loadable section we've seen.
336 This function is called via bfd_map_over_sections. */
338 #if 0 /* Not used yet */
340 find_lowest_section (abfd
, sect
, obj
)
345 asection
**lowest
= (asection
**)obj
;
347 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
350 *lowest
= sect
; /* First loadable section */
351 else if (bfd_section_vma (abfd
, *lowest
) >= bfd_section_vma (abfd
, sect
))
352 *lowest
= sect
; /* A lower loadable section */
356 /* Process a symbol file, as either the main file or as a dynamically
359 NAME is the file name (which will be tilde-expanded and made
360 absolute herein) (but we don't free or modify NAME itself).
361 FROM_TTY says how verbose to be. MAINLINE specifies whether this
362 is the main symbol file, or whether it's an extra symbol file such
363 as dynamically loaded code. If !mainline, ADDR is the address
364 where the text segment was loaded. If VERBO, the caller has printed
365 a verbose message about the symbol reading (and complaints can be
366 more terse about it). */
369 syms_from_objfile (objfile
, addr
, mainline
, verbo
)
370 struct objfile
*objfile
;
375 struct section_offsets
*section_offsets
;
376 asection
*lowest_sect
;
378 /* There is a distinction between having no symbol table
379 (we refuse to read the file, leaving the old set of symbols around)
380 and having no debugging symbols in your symbol table (we read
381 the file and end up with a mostly empty symbol table).
383 FIXME: This strategy works correctly when the debugging symbols are
384 intermixed with "normal" symbols. However, when the debugging symbols
385 are separate, such as with ELF/DWARF, it is perfectly plausible for
386 the symbol table to be missing but still have all the DWARF info
387 intact. Thus in general it is wrong to assume that having no symbol
388 table implies no debugging information. */
390 if (!(bfd_get_file_flags (objfile
-> obfd
) & HAS_SYMS
))
393 init_entry_point_info (objfile
);
394 find_sym_fns (objfile
);
398 /* Since no error yet, throw away the old symbol table. */
400 if (symfile_objfile
!= NULL
)
402 free_objfile (symfile_objfile
);
403 symfile_objfile
= NULL
;
406 (*objfile
-> sf
-> sym_new_init
) (objfile
);
409 /* Convert addr into an offset rather than an absolute address.
410 We find the lowest address of a loaded segment in the objfile,
411 and assume that <addr> is where that got loaded. Due to historical
412 precedent, we warn if that doesn't happen to be the ".text"
417 addr
= 0; /* No offset from objfile addresses. */
421 lowest_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
424 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
428 if (lowest_sect
== 0)
429 warning ("no loadable sections found in added symbol-file %s",
431 else if (0 == bfd_get_section_name (objfile
->obfd
, lowest_sect
)
433 bfd_get_section_name (objfile
->obfd
, lowest_sect
)))
434 warning ("Lowest section in %s is %s at 0x%x",
436 bfd_section_name (objfile
->obfd
, lowest_sect
),
437 bfd_section_vma (objfile
->obfd
, lowest_sect
));
440 addr
-= bfd_section_vma (objfile
->obfd
, lowest_sect
);
444 /* Debugging check inserted for testing elimination of NAMES_HAVE_UNDERSCORE.
445 Complain if the dynamic setting of NAMES_HAVE_UNDERSCORE from BFD
446 doesn't match the static setting from the GDB config files, but only
447 if we are using the first BFD target (the default target selected by
448 the same configuration that decided whether NAMES_HAVE_UNDERSCORE is
449 defined or not). For other targets (such as when the user sets GNUTARGET
450 or we are reading a "foreign" object file), it is likely that the value
451 of bfd_get_symbol_leading_char has no relation to the value of
452 NAMES_HAVE_UNDERSCORE for the target for which this gdb was built.
453 Hack alert: the only way to currently do this with bfd is to ask it to
454 produce a list of known target names and compare the first one in the
455 list with the one for the bfd we are using.
456 FIXME: Remove this check after a round of testing.
457 -- gnu@cygnus.com, 16dec92 */
458 char **targets
= bfd_target_list ();
459 if (targets
!= NULL
&& *targets
!= NULL
)
461 if (bfd_get_symbol_leading_char (objfile
->obfd
) !=
462 #ifdef NAMES_HAVE_UNDERSCORE
467 && STREQ (bfd_get_target (objfile
->obfd
), *targets
))
469 fprintf (stderr
, "GDB internal error! NAMES_HAVE_UNDERSCORE set wrong for %s BFD:\n%s\n",
470 bfd_get_target (objfile
->obfd
),
471 bfd_get_filename (objfile
->obfd
));
475 /* End of debugging check. FIXME. */
478 /* Initialize symbol reading routines for this objfile, allow complaints to
479 appear for this new file, and record how verbose to be, then do the
480 initial symbol reading for this file. */
482 (*objfile
-> sf
-> sym_init
) (objfile
);
483 clear_complaints (1, verbo
);
484 section_offsets
= (*objfile
-> sf
-> sym_offsets
) (objfile
, addr
);
485 (*objfile
-> sf
-> sym_read
) (objfile
, section_offsets
, mainline
);
487 /* Don't allow char * to have a typename (else would get caddr_t.) */
488 /* Ditto void *. FIXME should do this for all the builtin types. */
490 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
491 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
493 /* Mark the objfile has having had initial symbol read attempted. Note
494 that this does not mean we found any symbols... */
496 objfile
-> flags
|= OBJF_SYMS
;
499 /* Perform required actions immediately after either reading in the initial
500 symbols for a new objfile, or mapping in the symbols from a reusable
504 new_symfile_objfile (objfile
, mainline
, verbo
)
505 struct objfile
*objfile
;
511 /* OK, make it the "real" symbol file. */
512 symfile_objfile
= objfile
;
515 /* If we have wiped out any old symbol tables, clean up. */
516 clear_symtab_users_once ();
518 /* We're done reading the symbol file; finish off complaints. */
519 clear_complaints (0, verbo
);
521 /* Fixup all the breakpoints that may have been redefined by this
524 breakpoint_re_set ();
527 /* Process a symbol file, as either the main file or as a dynamically
530 NAME is the file name (which will be tilde-expanded and made
531 absolute herein) (but we don't free or modify NAME itself).
532 FROM_TTY says how verbose to be. MAINLINE specifies whether this
533 is the main symbol file, or whether it's an extra symbol file such
534 as dynamically loaded code. If !mainline, ADDR is the address
535 where the text segment was loaded.
537 Upon success, returns a pointer to the objfile that was added.
538 Upon failure, jumps back to command level (never returns). */
541 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
)
549 struct objfile
*objfile
;
550 struct partial_symtab
*psymtab
;
553 /* Open a bfd for the file and then check to see if the file has a
554 symbol table. There is a distinction between having no symbol table
555 (we refuse to read the file, leaving the old set of symbols around)
556 and having no debugging symbols in the symbol table (we read the file
557 and end up with a mostly empty symbol table, but with lots of stuff in
558 the minimal symbol table). We need to make the decision about whether
559 to continue with the file before allocating and building a objfile.
561 FIXME: This strategy works correctly when the debugging symbols are
562 intermixed with "normal" symbols. However, when the debugging symbols
563 are separate, such as with ELF/DWARF, it is perfectly plausible for
564 the symbol table to be missing but still have all the DWARF info
565 intact. Thus in general it is wrong to assume that having no symbol
566 table implies no debugging information. */
568 abfd
= symfile_bfd_open (name
);
569 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
571 error ("%s has no symbol-table", name
);
574 if ((have_full_symbols () || have_partial_symbols ())
577 && !query ("Load new symbol table from \"%s\"? ", name
))
578 error ("Not confirmed.");
580 /* Getting new symbols may change our opinion about what is
583 reinit_frame_cache ();
585 objfile
= allocate_objfile (abfd
, mapped
);
587 /* If the objfile uses a mapped symbol file, and we have a psymtab for
588 it, then skip reading any symbols at this time. */
590 if ((objfile
-> flags
& OBJF_MAPPED
) && (objfile
-> flags
& OBJF_SYMS
))
592 /* We mapped in an existing symbol table file that already has had
593 initial symbol reading performed, so we can skip that part. Notify
594 the user that instead of reading the symbols, they have been mapped.
596 if (from_tty
|| info_verbose
)
598 printf_filtered ("Mapped symbols for %s...", name
);
602 init_entry_point_info (objfile
);
603 find_sym_fns (objfile
);
607 /* We either created a new mapped symbol table, mapped an existing
608 symbol table file which has not had initial symbol reading
609 performed, or need to read an unmapped symbol table. */
610 if (from_tty
|| info_verbose
)
612 printf_filtered ("Reading symbols from %s...", name
);
616 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
619 new_symfile_objfile (objfile
, mainline
, from_tty
);
621 /* We now have at least a partial symbol table. Check to see if the
622 user requested that all symbols be read on initial access via either
623 the gdb startup command line or on a per symbol file basis. Expand
624 all partial symbol tables for this objfile if so. */
626 if (readnow
|| readnow_symbol_files
)
628 if (from_tty
|| info_verbose
)
630 printf_filtered ("expanding to full symbols...");
635 for (psymtab
= objfile
-> psymtabs
;
637 psymtab
= psymtab
-> next
)
639 psymtab_to_symtab (psymtab
);
643 if (from_tty
|| info_verbose
)
645 printf_filtered ("done.\n");
652 /* This is the symbol-file command. Read the file, analyze its symbols,
653 and add a struct symtab to a symtab list. */
656 symbol_file_command (args
, from_tty
)
662 struct cleanup
*cleanups
;
670 if ((have_full_symbols () || have_partial_symbols ())
672 && !query ("Discard symbol table from `%s'? ",
673 symfile_objfile
-> name
))
674 error ("Not confirmed.");
675 free_all_objfiles ();
676 symfile_objfile
= NULL
;
677 current_source_symtab
= NULL
;
678 current_source_line
= 0;
681 printf ("No symbol file now.\n");
686 if ((argv
= buildargv (args
)) == NULL
)
690 cleanups
= make_cleanup (freeargv
, (char *) argv
);
691 while (*argv
!= NULL
)
693 if (STREQ (*argv
, "-mapped"))
697 else if (STREQ (*argv
, "-readnow"))
701 else if (**argv
== '-')
703 error ("unknown option `%s'", *argv
);
714 error ("no symbol file name was specified");
718 symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1, mapped
, readnow
);
719 set_initial_language ();
721 do_cleanups (cleanups
);
725 /* Set the initial language.
727 A better solution would be to record the language in the psymtab when reading
728 partial symbols, and then use it (if known) to set the language. This would
729 be a win for formats that encode the language in an easily discoverable place,
730 such as DWARF. For stabs, we can jump through hoops looking for specially
731 named symbols or try to intuit the language from the specific type of stabs
732 we find, but we can't do that until later when we read in full symbols.
736 set_initial_language ()
738 struct partial_symtab
*pst
;
739 enum language lang
= language_unknown
;
741 pst
= find_main_psymtab ();
744 if (pst
-> filename
!= NULL
)
746 lang
= deduce_language_from_filename (pst
-> filename
);
748 if (lang
== language_unknown
)
750 /* Make C the default language */
754 expected_language
= current_language
; /* Don't warn the user */
758 /* Open file specified by NAME and hand it off to BFD for preliminary
759 analysis. Result is a newly initialized bfd *, which includes a newly
760 malloc'd` copy of NAME (tilde-expanded and made absolute).
761 In case of trouble, error() is called. */
764 symfile_bfd_open (name
)
771 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
773 /* Look down path for it, allocate 2nd new malloc'd copy. */
774 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
, 0, &absolute_name
);
777 make_cleanup (free
, name
);
778 perror_with_name (name
);
780 free (name
); /* Free 1st new malloc'd copy */
781 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
782 /* It'll be freed in free_objfile(). */
784 sym_bfd
= bfd_fdopenr (name
, NULL
, desc
);
788 make_cleanup (free
, name
);
789 error ("\"%s\": can't open to read symbols: %s.", name
,
790 bfd_errmsg (bfd_error
));
792 sym_bfd
->cacheable
= true;
794 if (!bfd_check_format (sym_bfd
, bfd_object
))
796 bfd_close (sym_bfd
); /* This also closes desc */
797 make_cleanup (free
, name
);
798 error ("\"%s\": can't read symbols: %s.", name
,
799 bfd_errmsg (bfd_error
));
805 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
806 startup by the _initialize routine in each object file format reader,
807 to register information about each format the the reader is prepared
814 sf
->next
= symtab_fns
;
819 /* Initialize to read symbols from the symbol file sym_bfd. It either
820 returns or calls error(). The result is an initialized struct sym_fns
821 in the objfile structure, that contains cached information about the
825 find_sym_fns (objfile
)
826 struct objfile
*objfile
;
830 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
-> next
)
832 if (strncmp (bfd_get_target (objfile
-> obfd
),
833 sf
-> sym_name
, sf
-> sym_namelen
) == 0)
839 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
840 bfd_get_target (objfile
-> obfd
));
843 /* This function runs the load command of our current target. */
846 load_command (arg
, from_tty
)
850 target_load (arg
, from_tty
);
853 /* This function allows the addition of incrementally linked object files.
854 It does not modify any state in the target, only in the debugger. */
858 add_symbol_file_command (args
, from_tty
)
872 error ("add-symbol-file takes a file name and an address");
875 /* Make a copy of the string that we can safely write into. */
877 args
= strdup (args
);
878 make_cleanup (free
, args
);
880 /* Pick off any -option args and the file name. */
882 while ((*args
!= '\000') && (name
== NULL
))
884 while (isspace (*args
)) {args
++;}
886 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
895 else if (STREQ (arg
, "-mapped"))
899 else if (STREQ (arg
, "-readnow"))
905 error ("unknown option `%s'", arg
);
909 /* After picking off any options and the file name, args should be
910 left pointing at the remainder of the command line, which should
911 be the address expression to evaluate. */
913 if ((name
== NULL
) || (*args
== '\000') )
915 error ("add-symbol-file takes a file name and an address");
917 name
= tilde_expand (name
);
918 make_cleanup (free
, name
);
920 text_addr
= parse_and_eval_address (args
);
922 if (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
923 name
, local_hex_string (text_addr
)))
924 error ("Not confirmed.");
926 symbol_file_add (name
, 0, text_addr
, 0, mapped
, readnow
);
929 /* Re-read symbols if a symbol-file has changed. */
933 struct objfile
*objfile
;
936 struct stat new_statbuf
;
939 /* With the addition of shared libraries, this should be modified,
940 the load time should be saved in the partial symbol tables, since
941 different tables may come from different source files. FIXME.
942 This routine should then walk down each partial symbol table
943 and see if the symbol table that it originates from has been changed */
946 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
948 #ifdef IBM6000_TARGET
949 /* If this object is from a shared library, then you should
950 stat on the library name, not member name. */
952 if (objfile
->obfd
->my_archive
)
953 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
956 res
= stat (objfile
->name
, &new_statbuf
);
958 /* FIXME, should use print_sys_errmsg but it's not filtered. */
959 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
963 new_modtime
= new_statbuf
.st_mtime
;
964 if (new_modtime
!= objfile
->mtime
) {
965 printf_filtered ("`%s' has changed; re-reading symbols.\n",
967 /* FIXME, this should use a different command...that would only
968 affect this objfile's symbols, and would reset objfile->mtime.
969 (objfile->mtime = new_modtime;)
970 HOWEVER, that command isn't written yet -- so call symbol_file_
971 command, and restart the scan from the top, because it munges
972 the object_files list. */
973 symbol_file_command (objfile
->name
, 0);
975 goto the_big_top
; /* Start over. */
981 breakpoint_re_set ();
986 deduce_language_from_filename (filename
)
989 char *c
= strrchr (filename
, '.');
991 if (!c
) ; /* Get default. */
992 else if(STREQ(c
,".mod"))
994 else if(STREQ(c
,".c"))
996 else if(STREQ(c
,".cc") || STREQ(c
,".C"))
997 return language_cplus
;
998 /* start-sanitize-chill */
999 else if(STREQ(c
,".ch") || STREQ(c
,".c186") || STREQ(c
,".c286"))
1000 return language_chill
;
1001 /* end-sanitize-chill */
1003 return language_unknown
; /* default */
1008 Allocate and partly initialize a new symbol table. Return a pointer
1009 to it. error() if no space.
1011 Caller must set these fields:
1017 initialize any EXTRA_SYMTAB_INFO
1018 possibly free_named_symtabs (symtab->filename);
1022 allocate_symtab (filename
, objfile
)
1024 struct objfile
*objfile
;
1026 register struct symtab
*symtab
;
1028 symtab
= (struct symtab
*)
1029 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
1030 memset (symtab
, 0, sizeof (*symtab
));
1031 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
1032 &objfile
-> symbol_obstack
);
1033 symtab
-> fullname
= NULL
;
1034 symtab
-> language
= deduce_language_from_filename (filename
);
1036 /* Hook it to the objfile it comes from */
1038 symtab
-> objfile
= objfile
;
1039 symtab
-> next
= objfile
-> symtabs
;
1040 objfile
-> symtabs
= symtab
;
1042 #ifdef INIT_EXTRA_SYMTAB_INFO
1043 INIT_EXTRA_SYMTAB_INFO (symtab
);
1049 struct partial_symtab
*
1050 allocate_psymtab (filename
, objfile
)
1052 struct objfile
*objfile
;
1054 struct partial_symtab
*psymtab
;
1056 if (objfile
-> free_psymtabs
)
1058 psymtab
= objfile
-> free_psymtabs
;
1059 objfile
-> free_psymtabs
= psymtab
-> next
;
1062 psymtab
= (struct partial_symtab
*)
1063 obstack_alloc (&objfile
-> psymbol_obstack
,
1064 sizeof (struct partial_symtab
));
1066 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1067 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1068 &objfile
-> psymbol_obstack
);
1069 psymtab
-> symtab
= NULL
;
1071 /* Hook it to the objfile it comes from */
1073 psymtab
-> objfile
= objfile
;
1074 psymtab
-> next
= objfile
-> psymtabs
;
1075 objfile
-> psymtabs
= psymtab
;
1081 /* clear_symtab_users_once:
1083 This function is run after symbol reading, or from a cleanup.
1084 If an old symbol table was obsoleted, the old symbol table
1085 has been blown away, but the other GDB data structures that may
1086 reference it have not yet been cleared or re-directed. (The old
1087 symtab was zapped, and the cleanup queued, in free_named_symtab()
1090 This function can be queued N times as a cleanup, or called
1091 directly; it will do all the work the first time, and then will be a
1092 no-op until the next time it is queued. This works by bumping a
1093 counter at queueing time. Much later when the cleanup is run, or at
1094 the end of symbol processing (in case the cleanup is discarded), if
1095 the queued count is greater than the "done-count", we do the work
1096 and set the done-count to the queued count. If the queued count is
1097 less than or equal to the done-count, we just ignore the call. This
1098 is needed because reading a single .o file will often replace many
1099 symtabs (one per .h file, for example), and we don't want to reset
1100 the breakpoints N times in the user's face.
1102 The reason we both queue a cleanup, and call it directly after symbol
1103 reading, is because the cleanup protects us in case of errors, but is
1104 discarded if symbol reading is successful. */
1106 static int clear_symtab_users_queued
;
1107 static int clear_symtab_users_done
;
1110 clear_symtab_users_once ()
1112 /* Enforce once-per-`do_cleanups'-semantics */
1113 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1115 clear_symtab_users_done
= clear_symtab_users_queued
;
1117 printf ("Resetting debugger state after updating old symbol tables\n");
1119 /* Someday, we should do better than this, by only blowing away
1120 the things that really need to be blown. */
1121 clear_value_history ();
1123 clear_internalvars ();
1124 breakpoint_re_set ();
1125 set_default_breakpoint (0, 0, 0, 0);
1126 current_source_symtab
= 0;
1129 /* Delete the specified psymtab, and any others that reference it. */
1132 cashier_psymtab (pst
)
1133 struct partial_symtab
*pst
;
1135 struct partial_symtab
*ps
, *pprev
;
1138 /* Find its previous psymtab in the chain */
1139 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1146 /* Unhook it from the chain. */
1147 if (ps
== pst
->objfile
->psymtabs
)
1148 pst
->objfile
->psymtabs
= ps
->next
;
1150 pprev
->next
= ps
->next
;
1152 /* FIXME, we can't conveniently deallocate the entries in the
1153 partial_symbol lists (global_psymbols/static_psymbols) that
1154 this psymtab points to. These just take up space until all
1155 the psymtabs are reclaimed. Ditto the dependencies list and
1156 filename, which are all in the psymbol_obstack. */
1158 /* We need to cashier any psymtab that has this one as a dependency... */
1160 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1161 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1162 if (ps
->dependencies
[i
] == pst
) {
1163 cashier_psymtab (ps
);
1164 goto again
; /* Must restart, chain has been munged. */
1171 /* If a symtab or psymtab for filename NAME is found, free it along
1172 with any dependent breakpoints, displays, etc.
1173 Used when loading new versions of object modules with the "add-file"
1174 command. This is only called on the top-level symtab or psymtab's name;
1175 it is not called for subsidiary files such as .h files.
1177 Return value is 1 if we blew away the environment, 0 if not.
1178 FIXME. The return valu appears to never be used.
1180 FIXME. I think this is not the best way to do this. We should
1181 work on being gentler to the environment while still cleaning up
1182 all stray pointers into the freed symtab. */
1185 free_named_symtabs (name
)
1189 /* FIXME: With the new method of each objfile having it's own
1190 psymtab list, this function needs serious rethinking. In particular,
1191 why was it ever necessary to toss psymtabs with specific compilation
1192 unit filenames, as opposed to all psymtabs from a particular symbol
1194 Well, the answer is that some systems permit reloading of particular
1195 compilation units. We want to blow away any old info about these
1196 compilation units, regardless of which objfiles they arrived in. --gnu. */
1198 register struct symtab
*s
;
1199 register struct symtab
*prev
;
1200 register struct partial_symtab
*ps
;
1201 struct blockvector
*bv
;
1204 /* We only wack things if the symbol-reload switch is set. */
1205 if (!symbol_reloading
)
1208 /* Some symbol formats have trouble providing file names... */
1209 if (name
== 0 || *name
== '\0')
1212 /* Look for a psymtab with the specified name. */
1215 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1216 if (STREQ (name
, ps
->filename
)) {
1217 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1218 goto again2
; /* Must restart, chain has been munged */
1222 /* Look for a symtab with the specified name. */
1224 for (s
= symtab_list
; s
; s
= s
->next
)
1226 if (STREQ (name
, s
->filename
))
1233 if (s
== symtab_list
)
1234 symtab_list
= s
->next
;
1236 prev
->next
= s
->next
;
1238 /* For now, queue a delete for all breakpoints, displays, etc., whether
1239 or not they depend on the symtab being freed. This should be
1240 changed so that only those data structures affected are deleted. */
1242 /* But don't delete anything if the symtab is empty.
1243 This test is necessary due to a bug in "dbxread.c" that
1244 causes empty symtabs to be created for N_SO symbols that
1245 contain the pathname of the object file. (This problem
1246 has been fixed in GDB 3.9x). */
1248 bv
= BLOCKVECTOR (s
);
1249 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1250 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1251 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1253 complain (&oldsyms_complaint
, name
);
1255 clear_symtab_users_queued
++;
1256 make_cleanup (clear_symtab_users_once
, 0);
1259 complain (&empty_symtab_complaint
, name
);
1266 /* It is still possible that some breakpoints will be affected
1267 even though no symtab was found, since the file might have
1268 been compiled without debugging, and hence not be associated
1269 with a symtab. In order to handle this correctly, we would need
1270 to keep a list of text address ranges for undebuggable files.
1271 For now, we do nothing, since this is a fairly obscure case. */
1275 /* FIXME, what about the minimal symbol table? */
1282 /* Allocate and partially fill a partial symtab. It will be
1283 completely filled at the end of the symbol list.
1285 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1286 is the address relative to which its symbols are (incremental) or 0
1290 struct partial_symtab
*
1291 start_psymtab_common (objfile
, section_offsets
,
1292 filename
, textlow
, global_syms
, static_syms
)
1293 struct objfile
*objfile
;
1294 struct section_offsets
*section_offsets
;
1297 struct partial_symbol
*global_syms
;
1298 struct partial_symbol
*static_syms
;
1300 struct partial_symtab
*psymtab
;
1302 psymtab
= allocate_psymtab (filename
, objfile
);
1303 psymtab
-> section_offsets
= section_offsets
;
1304 psymtab
-> textlow
= textlow
;
1305 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
1306 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
1307 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
1311 /* Debugging versions of functions that are usually inline macros
1314 #if !INLINE_ADD_PSYMBOL
1316 /* Add a symbol with a long value to a psymtab.
1317 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
1320 add_psymbol_to_list (name
, namelength
, namespace, class, list
, val
, language
,
1324 enum namespace namespace;
1325 enum address_class
class;
1326 struct psymbol_allocation_list
*list
;
1328 enum language language
;
1329 struct objfile
*objfile
;
1331 register struct partial_symbol
*psym
;
1332 register char *demangled_name
;
1334 if (list
->next
>= list
->list
+ list
->size
)
1336 extend_psymbol_list (list
,objfile
);
1338 psym
= list
->next
++;
1340 SYMBOL_NAME (psym
) =
1341 (char *) obstack_alloc (&objfile
->psymbol_obstack
, namelength
+ 1);
1342 memcpy (SYMBOL_NAME (psym
), name
, namelength
);
1343 SYMBOL_NAME (psym
)[namelength
] = '\0';
1344 SYMBOL_VALUE (psym
) = val
;
1345 SYMBOL_LANGUAGE (psym
) = language
;
1346 PSYMBOL_NAMESPACE (psym
) = namespace;
1347 PSYMBOL_CLASS (psym
) = class;
1348 if (language
== language_cplus
)
1351 cplus_demangle (SYMBOL_NAME (psym
), DMGL_PARAMS
| DMGL_ANSI
);
1352 if (demangled_name
== NULL
)
1354 SYMBOL_DEMANGLED_NAME (psym
) = NULL
;
1358 SYMBOL_DEMANGLED_NAME (psym
) =
1359 obsavestring (demangled_name
, strlen (demangled_name
),
1360 &objfile
->psymbol_obstack
);
1361 free (demangled_name
);
1366 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1369 add_psymbol_addr_to_list (name
, namelength
, namespace, class, list
, val
,
1373 enum namespace namespace;
1374 enum address_class
class;
1375 struct psymbol_allocation_list
*list
;
1377 enum language language
;
1378 struct objfile
*objfile
;
1380 register struct partial_symbol
*psym
;
1381 register char *demangled_name
;
1383 if (list
->next
>= list
->list
+ list
->size
)
1385 extend_psymbol_list (list
,objfile
);
1387 psym
= list
->next
++;
1389 SYMBOL_NAME (psym
) =
1390 (char *) obstack_alloc (&objfile
->psymbol_obstack
, namelength
+ 1);
1391 memcpy (SYMBOL_NAME (psym
), name
, namelength
);
1392 SYMBOL_NAME (psym
)[namelength
] = '\0';
1393 SYMBOL_VALUE_ADDRESS (psym
) = val
;
1394 SYMBOL_LANGUAGE (psym
) = language
;
1395 PSYMBOL_NAMESPACE (psym
) = namespace;
1396 PSYMBOL_CLASS (psym
) = class;
1397 if (language
== language_cplus
)
1400 cplus_demangle (SYMBOL_NAME (psym
), DMGL_PARAMS
| DMGL_ANSI
);
1401 if (demangled_name
== NULL
)
1403 SYMBOL_DEMANGLED_NAME (psym
) = NULL
;
1407 SYMBOL_DEMANGLED_NAME (psym
) =
1408 obsavestring (demangled_name
, strlen (demangled_name
),
1409 &objfile
->psymbol_obstack
);
1410 free (demangled_name
);
1415 #endif /* !INLINE_ADD_PSYMBOL */
1419 _initialize_symfile ()
1422 add_com ("symbol-file", class_files
, symbol_file_command
,
1423 "Load symbol table from executable file FILE.\n\
1424 The `file' command can also load symbol tables, as well as setting the file\n\
1427 add_com ("add-symbol-file", class_files
, add_symbol_file_command
,
1428 "Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
1429 The second argument provides the starting address of the file's text.");
1431 add_com ("load", class_files
, load_command
,
1432 "Dynamically load FILE into the running program, and record its symbols\n\
1433 for access from GDB.");
1436 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
1437 (char *)&symbol_reloading
,
1438 "Set dynamic symbol table reloading multiple times in one run.",