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"
36 #include <sys/types.h>
41 /* Global variables owned by this file */
43 int readnow_symbol_files
; /* Read full symbols immediately */
45 /* External variables and functions referenced. */
47 extern int info_verbose
;
49 /* Functions this file defines */
52 load_command
PARAMS ((char *, int));
55 add_symbol_file_command
PARAMS ((char *, int));
58 cashier_psymtab
PARAMS ((struct partial_symtab
*));
61 compare_psymbols
PARAMS ((const void *, const void *));
64 compare_symbols
PARAMS ((const void *, const void *));
67 symfile_bfd_open
PARAMS ((char *));
70 find_sym_fns
PARAMS ((struct objfile
*));
73 clear_symtab_users_once
PARAMS ((void));
75 /* List of all available sym_fns. On gdb startup, each object file reader
76 calls add_symtab_fns() to register information on each format it is
79 static struct sym_fns
*symtab_fns
= NULL
;
81 /* Structures with which to manage partial symbol allocation. */
83 struct psymbol_allocation_list global_psymbols
= {0}, static_psymbols
= {0};
85 /* Flag for whether user will be reloading symbols multiple times.
86 Defaults to ON for VxWorks, otherwise OFF. */
88 #ifdef SYMBOL_RELOADING_DEFAULT
89 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
91 int symbol_reloading
= 0;
94 /* Structure to manage complaints about symbol file contents. */
96 struct complaint complaint_root
[1] = {
97 {(char *) 0, 0, complaint_root
},
100 /* Some actual complaints. */
102 struct complaint oldsyms_complaint
= {
103 "Replacing old symbols for `%s'", 0, 0 };
105 struct complaint empty_symtab_complaint
= {
106 "Empty symbol table found for `%s'", 0, 0 };
109 /* In the following sort, we always make sure that
110 register debug symbol declarations always come before regular
111 debug symbol declarations (as might happen when parameters are
112 then put into registers by the compiler).
114 Since this function is called from within qsort, in an ANSI environment
115 it must conform to the prototype for qsort, which specifies that the
116 comparison function takes two "void *" pointers. */
119 compare_symbols (s1p
, s2p
)
123 register struct symbol
**s1
, **s2
;
124 register int namediff
;
126 s1
= (struct symbol
**) s1p
;
127 s2
= (struct symbol
**) s2p
;
129 /* Compare the initial characters. */
130 namediff
= SYMBOL_NAME (*s1
)[0] - SYMBOL_NAME (*s2
)[0];
131 if (namediff
!= 0) return namediff
;
133 /* If they match, compare the rest of the names. */
134 namediff
= strcmp (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
));
135 if (namediff
!= 0) return namediff
;
137 /* For symbols of the same name, registers should come first. */
138 return ((SYMBOL_CLASS (*s2
) == LOC_REGISTER
)
139 - (SYMBOL_CLASS (*s1
) == LOC_REGISTER
));
146 compare_psymbols -- compare two partial symbols by name
150 Given pointer to two partial symbol table entries, compare
151 them by name and return -N, 0, or +N (ala strcmp). Typically
152 used by sorting routines like qsort().
156 Does direct compare of first two characters before punting
157 and passing to strcmp for longer compares. Note that the
158 original version had a bug whereby two null strings or two
159 identically named one character strings would return the
160 comparison of memory following the null byte.
165 compare_psymbols (s1p
, s2p
)
169 register char *st1
= SYMBOL_NAME ((struct partial_symbol
*) s1p
);
170 register char *st2
= SYMBOL_NAME ((struct partial_symbol
*) s2p
);
172 if ((st1
[0] - st2
[0]) || !st1
[0])
174 return (st1
[0] - st2
[0]);
176 else if ((st1
[1] - st2
[1]) || !st1
[1])
178 return (st1
[1] - st2
[1]);
182 return (strcmp (st1
+ 2, st2
+ 2));
187 sort_pst_symbols (pst
)
188 struct partial_symtab
*pst
;
190 /* Sort the global list; don't sort the static list */
192 qsort (pst
-> objfile
-> global_psymbols
.list
+ pst
-> globals_offset
,
193 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
197 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
201 register struct block
*b
;
203 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
204 sizeof (struct symbol
*), compare_symbols
);
207 /* Call sort_symtab_syms to sort alphabetically
208 the symbols of each block of one symtab. */
212 register struct symtab
*s
;
214 register struct blockvector
*bv
;
217 register struct block
*b
;
221 bv
= BLOCKVECTOR (s
);
222 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
223 for (i
= 0; i
< nbl
; i
++)
225 b
= BLOCKVECTOR_BLOCK (bv
, i
);
226 if (BLOCK_SHOULD_SORT (b
))
232 sort_all_symtab_syms ()
234 register struct symtab
*s
;
235 register struct objfile
*objfile
;
237 for (objfile
= object_files
; objfile
!= NULL
; objfile
= objfile
-> next
)
239 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
241 sort_symtab_syms (s
);
246 /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
247 (and add a null character at the end in the copy).
248 Returns the address of the copy. */
251 obsavestring (ptr
, size
, obstackp
)
254 struct obstack
*obstackp
;
256 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
257 /* Open-coded bcopy--saves function call time.
258 These strings are usually short. */
260 register char *p1
= ptr
;
261 register char *p2
= p
;
262 char *end
= ptr
+ size
;
270 /* Concatenate strings S1, S2 and S3; return the new string.
271 Space is found in the symbol_obstack. */
274 obconcat (obstackp
, s1
, s2
, s3
)
275 struct obstack
*obstackp
;
276 const char *s1
, *s2
, *s3
;
278 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
279 register char *val
= (char *) obstack_alloc (obstackp
, len
);
286 /* Get the symbol table that corresponds to a partial_symtab.
287 This is fast after the first time you do it. In fact, there
288 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
292 psymtab_to_symtab (pst
)
293 register struct partial_symtab
*pst
;
295 /* If it's been looked up before, return it. */
299 /* If it has not yet been read in, read it. */
302 (*pst
->read_symtab
) (pst
);
308 /* Initialize entry point information for this objfile. */
311 init_entry_point_info (objfile
)
312 struct objfile
*objfile
;
314 /* Save startup file's range of PC addresses to help blockframe.c
315 decide where the bottom of the stack is. */
317 if (bfd_get_file_flags (objfile
-> obfd
) & EXEC_P
)
319 /* Executable file -- record its entry point so we'll recognize
320 the startup file because it contains the entry point. */
321 objfile
-> ei
.entry_point
= bfd_get_start_address (objfile
-> obfd
);
325 /* Examination of non-executable.o files. Short-circuit this stuff. */
326 /* ~0 will not be in any file, we hope. */
327 objfile
-> ei
.entry_point
= ~0;
328 /* set the startup file to be an empty range. */
329 objfile
-> ei
.entry_file_lowpc
= 0;
330 objfile
-> ei
.entry_file_highpc
= 0;
334 /* Process a symbol file, as either the main file or as a dynamically
337 NAME is the file name (which will be tilde-expanded and made
338 absolute herein) (but we don't free or modify NAME itself).
339 FROM_TTY says how verbose to be. MAINLINE specifies whether this
340 is the main symbol file, or whether it's an extra symbol file such
341 as dynamically loaded code. If !mainline, ADDR is the address
342 where the text segment was loaded. If VERBO, the caller has printed
343 a verbose message about the symbol reading (and complaints can be
344 more terse about it). */
347 syms_from_objfile (objfile
, addr
, mainline
, verbo
)
348 struct objfile
*objfile
;
355 /* There is a distinction between having no symbol table
356 (we refuse to read the file, leaving the old set of symbols around)
357 and having no debugging symbols in your symbol table (we read
358 the file and end up with a mostly empty symbol table).
360 FIXME: This strategy works correctly when the debugging symbols are
361 intermixed with "normal" symbols. However, when the debugging symbols
362 are separate, such as with ELF/DWARF, it is perfectly plausible for
363 the symbol table to be missing but still have all the DWARF info
364 intact. Thus in general it is wrong to assume that having no symbol
365 table implies no debugging information. */
367 if (!(bfd_get_file_flags (objfile
-> obfd
) & HAS_SYMS
))
370 init_entry_point_info (objfile
);
371 find_sym_fns (objfile
);
375 /* Since no error yet, throw away the old symbol table. */
377 if (symfile_objfile
!= NULL
)
379 free_objfile (symfile_objfile
);
380 symfile_objfile
= NULL
;
383 (*objfile
-> sf
-> sym_new_init
) (objfile
);
385 /* For mainline, caller didn't know the specified address of the
386 text section. We fix that here. */
388 text_sect
= bfd_get_section_by_name (objfile
-> obfd
, ".text");
389 addr
= bfd_section_vma (objfile
-> obfd
, text_sect
);
392 /* Initialize symbol reading routines for this objfile, allow complaints to
393 appear for this new file, and record how verbose to be, then do the
394 initial symbol reading for this file. */
396 (*objfile
-> sf
-> sym_init
) (objfile
);
397 clear_complaints (1, verbo
);
398 (*objfile
-> sf
-> sym_read
) (objfile
, addr
, mainline
);
400 /* Don't allow char * to have a typename (else would get caddr_t.) */
401 /* Ditto void *. FIXME should do this for all the builtin types. */
403 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
404 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
408 /* OK, make it the "real" symbol file. */
409 symfile_objfile
= objfile
;
412 /* If we have wiped out any old symbol tables, clean up. */
413 clear_symtab_users_once ();
415 /* We're done reading the symbol file; finish off complaints. */
416 clear_complaints (0, verbo
);
418 /* Fixup all the breakpoints that may have been redefined by this
421 breakpoint_re_set ();
424 /* Process a symbol file, as either the main file or as a dynamically
427 NAME is the file name (which will be tilde-expanded and made
428 absolute herein) (but we don't free or modify NAME itself).
429 FROM_TTY says how verbose to be. MAINLINE specifies whether this
430 is the main symbol file, or whether it's an extra symbol file such
431 as dynamically loaded code. If !mainline, ADDR is the address
432 where the text segment was loaded.
434 Upon success, returns a pointer to the objfile that was added.
435 Upon failure, jumps back to command level (never returns). */
438 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
)
446 struct objfile
*objfile
;
447 struct partial_symtab
*psymtab
;
451 /* Open a bfd for the file and then check to see if the file has a
452 symbol table. There is a distinction between having no symbol table
453 (we refuse to read the file, leaving the old set of symbols around)
454 and having no debugging symbols in the symbol table (we read the file
455 and end up with a mostly empty symbol table, but with lots of stuff in
456 the minimal symbol table). We need to make the decision about whether
457 to continue with the file before allocating and building a objfile.
459 FIXME: This strategy works correctly when the debugging symbols are
460 intermixed with "normal" symbols. However, when the debugging symbols
461 are separate, such as with ELF/DWARF, it is perfectly plausible for
462 the symbol table to be missing but still have all the DWARF info
463 intact. Thus in general it is wrong to assume that having no symbol
464 table implies no debugging information. */
466 abfd
= symfile_bfd_open (name
);
467 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
469 error ("%s has no symbol-table", name
);
472 if ((have_full_symbols () || have_partial_symbols ())
475 && !query ("Load new symbol table from \"%s\"? ", name
))
476 error ("Not confirmed.");
478 objfile
= allocate_objfile (abfd
, mapped
);
480 /* If the objfile uses a mapped symbol file, and we have a psymtab for
481 it, then skip reading any symbols at this time. */
483 if ((objfile
-> flags
& OBJF_MAPPED
) && (objfile
-> flags
& OBJF_SYMS
))
485 /* We mapped in an existing symbol table file that already has had
486 initial symbol reading performed, so we can skip that part. Notify
487 the user that instead of reading the symbols, they have been mapped.
489 if (from_tty
|| info_verbose
)
491 printf_filtered ("Mapped symbols for %s...", name
);
498 /* We either created a new mapped symbol table, mapped an existing
499 symbol table file which has not had initial symbol reading
500 performed, or need to read an unmapped symbol table. */
501 if (from_tty
|| info_verbose
)
503 printf_filtered ("Reading symbols from %s...", name
);
507 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
508 objfile
-> flags
|= OBJF_SYMS
;
511 /* We now have at least a partial symbol table. Check to see if the
512 user requested that all symbols be read on initial access via either
513 the gdb startup command line or on a per symbol file basis. Expand
514 all partial symbol tables for this objfile if so. */
516 if (readnow
|| readnow_symbol_files
)
518 if (from_tty
|| info_verbose
)
520 printf_filtered ("expanding to full symbols...");
525 for (psymtab
= objfile
-> psymtabs
;
527 psymtab
= psymtab
-> next
)
529 (void) psymtab_to_symtab (psymtab
);
533 if (from_tty
|| info_verbose
)
535 printf_filtered ("done.\n");
542 /* This is the symbol-file command. Read the file, analyze its symbols,
543 and add a struct symtab to a symtab list. */
546 symbol_file_command (args
, from_tty
)
552 struct cleanup
*cleanups
;
553 struct objfile
*objfile
;
561 if ((have_full_symbols () || have_partial_symbols ())
563 && !query ("Discard symbol table from `%s'? ",
564 symfile_objfile
-> name
))
565 error ("Not confirmed.");
566 free_all_objfiles ();
567 symfile_objfile
= NULL
;
571 if ((argv
= buildargv (args
)) == NULL
)
575 cleanups
= make_cleanup (freeargv
, (char *) argv
);
576 while (*argv
!= NULL
)
578 if (strcmp (*argv
, "-mapped") == 0)
582 else if (strcmp (*argv
, "-readnow") == 0)
586 else if (**argv
== '-')
588 error ("unknown option `%s'", *argv
);
599 error ("no symbol file name was specified");
603 /* Getting new symbols may change our opinion about what is
605 reinit_frame_cache ();
606 objfile
= symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1,
609 do_cleanups (cleanups
);
613 /* Open file specified by NAME and hand it off to BFD for preliminary
614 analysis. Result is a newly initialized bfd *, which includes a newly
615 malloc'd` copy of NAME (tilde-expanded and made absolute).
616 In case of trouble, error() is called. */
619 symfile_bfd_open (name
)
626 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
628 /* Look down path for it, allocate 2nd new malloc'd copy. */
629 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
, 0, &absolute_name
);
632 make_cleanup (free
, name
);
633 perror_with_name (name
);
635 free (name
); /* Free 1st new malloc'd copy */
636 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
638 sym_bfd
= bfd_fdopenr (name
, NULL
, desc
);
642 make_cleanup (free
, name
);
643 error ("\"%s\": can't open to read symbols: %s.", name
,
644 bfd_errmsg (bfd_error
));
647 if (!bfd_check_format (sym_bfd
, bfd_object
))
649 bfd_close (sym_bfd
); /* This also closes desc */
650 make_cleanup (free
, name
);
651 error ("\"%s\": can't read symbols: %s.", name
,
652 bfd_errmsg (bfd_error
));
658 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
659 startup by the _initialize routine in each object file format reader,
660 to register information about each format the the reader is prepared
667 sf
->next
= symtab_fns
;
672 /* Initialize to read symbols from the symbol file sym_bfd. It either
673 returns or calls error(). The result is an initialized struct sym_fns
674 in the objfile structure, that contains cached information about the
678 find_sym_fns (objfile
)
679 struct objfile
*objfile
;
681 struct sym_fns
*sf
, *sf2
;
683 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
-> next
)
685 if (strncmp (bfd_get_target (objfile
-> obfd
),
686 sf
-> sym_name
, sf
-> sym_namelen
) == 0)
692 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
693 bfd_get_target (objfile
-> obfd
));
696 /* This function runs the load command of our current target. */
699 load_command (arg
, from_tty
)
703 target_load (arg
, from_tty
);
706 /* This function allows the addition of incrementally linked object files.
707 It does not modify any state in the target, only in the debugger. */
711 add_symbol_file_command (args
, from_tty
)
725 error ("add-symbol-file takes a file name and an address");
728 /* Make a copy of the string that we can safely write into. */
730 args
= strdup (args
);
731 make_cleanup (free
, args
);
733 /* Pick off any -option args and the file name. */
735 while ((*args
!= '\000') && (name
== NULL
))
737 while (isspace (*args
)) {args
++;}
739 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
748 else if (strcmp (arg
, "-mapped") == 0)
752 else if (strcmp (arg
, "-readnow") == 0)
758 error ("unknown option `%s'", arg
);
762 /* After picking off any options and the file name, args should be
763 left pointing at the remainder of the command line, which should
764 be the address expression to evaluate. */
766 if ((name
== NULL
) || (*args
== '\000') )
768 error ("add-symbol-file takes a file name and an address");
770 name
= tilde_expand (name
);
771 make_cleanup (free
, name
);
773 text_addr
= parse_and_eval_address (args
);
775 if (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
776 name
, local_hex_string (text_addr
)))
777 error ("Not confirmed.");
779 /* Getting new symbols may change our opinion about what is
782 reinit_frame_cache ();
784 (void) symbol_file_add (name
, 0, text_addr
, 0, mapped
, readnow
);
787 /* Re-read symbols if a symbol-file has changed. */
791 struct objfile
*objfile
;
794 struct stat new_statbuf
;
797 /* With the addition of shared libraries, this should be modified,
798 the load time should be saved in the partial symbol tables, since
799 different tables may come from different source files. FIXME.
800 This routine should then walk down each partial symbol table
801 and see if the symbol table that it originates from has been changed */
804 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
806 #ifdef IBM6000_TARGET
807 /* If this object is from a shared library, then you should
808 stat on the library name, not member name. */
810 if (objfile
->obfd
->my_archive
)
811 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
814 res
= stat (objfile
->name
, &new_statbuf
);
816 /* FIXME, should use print_sys_errmsg but it's not filtered. */
817 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
821 new_modtime
= new_statbuf
.st_mtime
;
822 if (new_modtime
!= objfile
->mtime
) {
823 printf_filtered ("`%s' has changed; re-reading symbols.\n",
825 /* FIXME, this should use a different command...that would only
826 affect this objfile's symbols, and would reset objfile->mtime.
827 (objfile->mtime = new_modtime;)
828 HOWEVER, that command isn't written yet -- so call symbol_file_
829 command, and restart the scan from the top, because it munges
830 the object_files list. */
831 symbol_file_command (objfile
->name
, 0);
833 goto the_big_top
; /* Start over. */
839 breakpoint_re_set ();
842 /* Functions to handle complaints during symbol reading. */
844 /* How many complaints about a particular thing should be printed before
845 we stop whining about it? Default is no whining at all, since so many
846 systems have ill-constructed symbol files. */
848 static unsigned stop_whining
= 0;
850 /* Should each complaint be self explanatory, or should we assume that
851 a series of complaints is being produced?
852 case 0: self explanatory message.
853 case 1: First message of a series that must start off with explanation.
854 case 2: Subsequent message, when user already knows we are reading
855 symbols and we can just state our piece. */
857 static int complaint_series
= 0;
859 /* Print a complaint about the input symbols, and link the complaint block
860 into a chain for later handling. */
863 complain (complaint
, val
)
864 struct complaint
*complaint
;
867 complaint
->counter
++;
868 if (complaint
->next
== 0) {
869 complaint
->next
= complaint_root
->next
;
870 complaint_root
->next
= complaint
;
872 if (complaint
->counter
> stop_whining
)
876 switch (complaint_series
+ (info_verbose
<< 1)) {
878 /* Isolated messages, must be self-explanatory. */
880 puts_filtered ("During symbol reading, ");
882 printf_filtered (complaint
->message
, val
);
883 puts_filtered (".\n");
886 /* First of a series, without `set verbose'. */
888 puts_filtered ("During symbol reading...");
889 printf_filtered (complaint
->message
, val
);
890 puts_filtered ("...");
895 /* Subsequent messages of a series, or messages under `set verbose'.
896 (We'll already have produced a "Reading in symbols for XXX..." message
897 and will clean up at the end with a newline.) */
899 printf_filtered (complaint
->message
, val
);
900 puts_filtered ("...");
905 /* Clear out all complaint counters that have ever been incremented.
906 If sym_reading is 1, be less verbose about successive complaints,
907 since the messages are appearing all together during a command that
908 reads symbols (rather than scattered around as psymtabs get fleshed
909 out into symtabs at random times). If noisy is 1, we are in a
910 noisy symbol reading command, and our caller will print enough
911 context for the user to figure it out. */
914 clear_complaints (sym_reading
, noisy
)
920 for (p
= complaint_root
->next
; p
!= complaint_root
; p
= p
->next
)
923 if (!sym_reading
&& !noisy
&& complaint_series
> 1) {
924 /* Terminate previous series, since caller won't. */
925 puts_filtered ("\n");
928 complaint_series
= sym_reading
? 1 + noisy
: 0;
932 deduce_language_from_filename (filename
)
935 char *c
= strrchr (filename
, '.');
937 if (!c
) ; /* Get default. */
938 else if(!strcmp(c
,".mod"))
940 else if(!strcmp(c
,".c"))
942 else if(!strcmp(c
,".cc") || !strcmp(c
,".C"))
943 return language_cplus
;
945 return language_unknown
; /* default */
950 Allocate and partly initialize a new symbol table. Return a pointer
951 to it. error() if no space.
953 Caller must set these fields:
959 initialize any EXTRA_SYMTAB_INFO
960 possibly free_named_symtabs (symtab->filename);
964 allocate_symtab (filename
, objfile
)
966 struct objfile
*objfile
;
968 register struct symtab
*symtab
;
970 symtab
= (struct symtab
*)
971 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
972 (void) memset (symtab
, 0, sizeof (*symtab
));
973 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
974 &objfile
-> symbol_obstack
);
975 symtab
-> fullname
= NULL
;
976 symtab
-> language
= deduce_language_from_filename (filename
);
978 /* Hook it to the objfile it comes from */
980 symtab
-> objfile
= objfile
;
981 symtab
-> next
= objfile
-> symtabs
;
982 objfile
-> symtabs
= symtab
;
984 #ifdef INIT_EXTRA_SYMTAB_INFO
985 INIT_EXTRA_SYMTAB_INFO (symtab
);
991 struct partial_symtab
*
992 allocate_psymtab (filename
, objfile
)
994 struct objfile
*objfile
;
996 struct partial_symtab
*psymtab
;
998 if (objfile
-> free_psymtabs
)
1000 psymtab
= objfile
-> free_psymtabs
;
1001 objfile
-> free_psymtabs
= psymtab
-> next
;
1004 psymtab
= (struct partial_symtab
*)
1005 obstack_alloc (&objfile
-> psymbol_obstack
,
1006 sizeof (struct partial_symtab
));
1008 (void) memset (psymtab
, 0, sizeof (struct partial_symtab
));
1009 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1010 &objfile
-> psymbol_obstack
);
1011 psymtab
-> symtab
= NULL
;
1013 /* Hook it to the objfile it comes from */
1015 psymtab
-> objfile
= objfile
;
1016 psymtab
-> next
= objfile
-> psymtabs
;
1017 objfile
-> psymtabs
= psymtab
;
1023 /* clear_symtab_users_once:
1025 This function is run after symbol reading, or from a cleanup.
1026 If an old symbol table was obsoleted, the old symbol table
1027 has been blown away, but the other GDB data structures that may
1028 reference it have not yet been cleared or re-directed. (The old
1029 symtab was zapped, and the cleanup queued, in free_named_symtab()
1032 This function can be queued N times as a cleanup, or called
1033 directly; it will do all the work the first time, and then will be a
1034 no-op until the next time it is queued. This works by bumping a
1035 counter at queueing time. Much later when the cleanup is run, or at
1036 the end of symbol processing (in case the cleanup is discarded), if
1037 the queued count is greater than the "done-count", we do the work
1038 and set the done-count to the queued count. If the queued count is
1039 less than or equal to the done-count, we just ignore the call. This
1040 is needed because reading a single .o file will often replace many
1041 symtabs (one per .h file, for example), and we don't want to reset
1042 the breakpoints N times in the user's face.
1044 The reason we both queue a cleanup, and call it directly after symbol
1045 reading, is because the cleanup protects us in case of errors, but is
1046 discarded if symbol reading is successful. */
1048 static int clear_symtab_users_queued
;
1049 static int clear_symtab_users_done
;
1052 clear_symtab_users_once ()
1054 /* Enforce once-per-`do_cleanups'-semantics */
1055 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1057 clear_symtab_users_done
= clear_symtab_users_queued
;
1059 printf ("Resetting debugger state after updating old symbol tables\n");
1061 /* Someday, we should do better than this, by only blowing away
1062 the things that really need to be blown. */
1063 clear_value_history ();
1065 clear_internalvars ();
1066 breakpoint_re_set ();
1067 set_default_breakpoint (0, 0, 0, 0);
1068 current_source_symtab
= 0;
1071 /* Delete the specified psymtab, and any others that reference it. */
1074 cashier_psymtab (pst
)
1075 struct partial_symtab
*pst
;
1077 struct partial_symtab
*ps
, *pprev
;
1080 /* Find its previous psymtab in the chain */
1081 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1088 /* Unhook it from the chain. */
1089 if (ps
== pst
->objfile
->psymtabs
)
1090 pst
->objfile
->psymtabs
= ps
->next
;
1092 pprev
->next
= ps
->next
;
1094 /* FIXME, we can't conveniently deallocate the entries in the
1095 partial_symbol lists (global_psymbols/static_psymbols) that
1096 this psymtab points to. These just take up space until all
1097 the psymtabs are reclaimed. Ditto the dependencies list and
1098 filename, which are all in the psymbol_obstack. */
1100 /* We need to cashier any psymtab that has this one as a dependency... */
1102 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1103 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1104 if (ps
->dependencies
[i
] == pst
) {
1105 cashier_psymtab (ps
);
1106 goto again
; /* Must restart, chain has been munged. */
1113 /* If a symtab or psymtab for filename NAME is found, free it along
1114 with any dependent breakpoints, displays, etc.
1115 Used when loading new versions of object modules with the "add-file"
1116 command. This is only called on the top-level symtab or psymtab's name;
1117 it is not called for subsidiary files such as .h files.
1119 Return value is 1 if we blew away the environment, 0 if not.
1120 FIXME. The return valu appears to never be used.
1122 FIXME. I think this is not the best way to do this. We should
1123 work on being gentler to the environment while still cleaning up
1124 all stray pointers into the freed symtab. */
1127 free_named_symtabs (name
)
1130 register struct symtab
*s
;
1131 register struct symtab
*prev
;
1132 register struct partial_symtab
*ps
;
1133 struct blockvector
*bv
;
1137 /* FIXME: With the new method of each objfile having it's own
1138 psymtab list, this function needs serious rethinking. In particular,
1139 why was it ever necessary to toss psymtabs with specific compilation
1140 unit filenames, as opposed to all psymtabs from a particular symbol
1143 /* We only wack things if the symbol-reload switch is set. */
1144 if (!symbol_reloading
)
1147 /* Some symbol formats have trouble providing file names... */
1148 if (name
== 0 || *name
== '\0')
1151 /* Look for a psymtab with the specified name. */
1154 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1155 if (!strcmp (name
, ps
->filename
)) {
1156 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1157 goto again2
; /* Must restart, chain has been munged */
1161 /* Look for a symtab with the specified name. */
1163 for (s
= symtab_list
; s
; s
= s
->next
)
1165 if (!strcmp (name
, s
->filename
))
1172 if (s
== symtab_list
)
1173 symtab_list
= s
->next
;
1175 prev
->next
= s
->next
;
1177 /* For now, queue a delete for all breakpoints, displays, etc., whether
1178 or not they depend on the symtab being freed. This should be
1179 changed so that only those data structures affected are deleted. */
1181 /* But don't delete anything if the symtab is empty.
1182 This test is necessary due to a bug in "dbxread.c" that
1183 causes empty symtabs to be created for N_SO symbols that
1184 contain the pathname of the object file. (This problem
1185 has been fixed in GDB 3.9x). */
1187 bv
= BLOCKVECTOR (s
);
1188 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1189 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1190 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1192 complain (&oldsyms_complaint
, name
);
1194 clear_symtab_users_queued
++;
1195 make_cleanup (clear_symtab_users_once
, 0);
1198 complain (&empty_symtab_complaint
, name
);
1205 /* It is still possible that some breakpoints will be affected
1206 even though no symtab was found, since the file might have
1207 been compiled without debugging, and hence not be associated
1208 with a symtab. In order to handle this correctly, we would need
1209 to keep a list of text address ranges for undebuggable files.
1210 For now, we do nothing, since this is a fairly obscure case. */
1214 /* FIXME, what about the minimal symbol table? */
1221 /* Allocate and partially fill a partial symtab. It will be
1222 completely filled at the end of the symbol list.
1224 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1225 is the address relative to which its symbols are (incremental) or 0
1229 struct partial_symtab
*
1230 start_psymtab_common (objfile
, addr
,
1231 filename
, textlow
, global_syms
, static_syms
)
1232 struct objfile
*objfile
;
1236 struct partial_symbol
*global_syms
;
1237 struct partial_symbol
*static_syms
;
1239 struct partial_symtab
*psymtab
;
1241 psymtab
= allocate_psymtab (filename
, objfile
);
1242 psymtab
-> addr
= addr
;
1243 psymtab
-> textlow
= textlow
;
1244 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
1245 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
1246 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
1252 _initialize_symfile ()
1255 add_com ("symbol-file", class_files
, symbol_file_command
,
1256 "Load symbol table from executable file FILE.\n\
1257 The `file' command can also load symbol tables, as well as setting the file\n\
1260 add_com ("add-symbol-file", class_files
, add_symbol_file_command
,
1261 "Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
1262 The second argument provides the starting address of the file's text.");
1264 add_com ("load", class_files
, load_command
,
1265 "Dynamically load FILE into the running program, and record its symbols\n\
1266 for access from GDB.");
1269 (add_set_cmd ("complaints", class_support
, var_zinteger
,
1270 (char *)&stop_whining
,
1271 "Set max number of complaints about incorrect symbols.",
1276 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
1277 (char *)&symbol_reloading
,
1278 "Set dynamic symbol table reloading multiple times in one run.",