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>
42 /* Global variables owned by this file */
44 int readnow_symbol_files
; /* Read full symbols immediately */
46 /* External variables and functions referenced. */
48 extern int info_verbose
;
50 /* Functions this file defines */
53 load_command
PARAMS ((char *, int));
56 add_symbol_file_command
PARAMS ((char *, int));
59 cashier_psymtab
PARAMS ((struct partial_symtab
*));
62 compare_psymbols
PARAMS ((const void *, const void *));
65 compare_symbols
PARAMS ((const void *, const void *));
68 symfile_bfd_open
PARAMS ((char *));
71 find_sym_fns
PARAMS ((struct objfile
*));
74 clear_symtab_users_once
PARAMS ((void));
76 /* List of all available sym_fns. On gdb startup, each object file reader
77 calls add_symtab_fns() to register information on each format it is
80 static struct sym_fns
*symtab_fns
= NULL
;
82 /* Structures with which to manage partial symbol allocation. */
84 struct psymbol_allocation_list global_psymbols
= {0}, static_psymbols
= {0};
86 /* Flag for whether user will be reloading symbols multiple times.
87 Defaults to ON for VxWorks, otherwise OFF. */
89 #ifdef SYMBOL_RELOADING_DEFAULT
90 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
92 int symbol_reloading
= 0;
95 /* Structure to manage complaints about symbol file contents. */
97 struct complaint complaint_root
[1] = {
98 {(char *) 0, 0, complaint_root
},
101 /* Some actual complaints. */
103 struct complaint oldsyms_complaint
= {
104 "Replacing old symbols for `%s'", 0, 0 };
106 struct complaint empty_symtab_complaint
= {
107 "Empty symbol table found for `%s'", 0, 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 /* Process a symbol file, as either the main file or as a dynamically
338 NAME is the file name (which will be tilde-expanded and made
339 absolute herein) (but we don't free or modify NAME itself).
340 FROM_TTY says how verbose to be. MAINLINE specifies whether this
341 is the main symbol file, or whether it's an extra symbol file such
342 as dynamically loaded code. If !mainline, ADDR is the address
343 where the text segment was loaded. If VERBO, the caller has printed
344 a verbose message about the symbol reading (and complaints can be
345 more terse about it). */
348 syms_from_objfile (objfile
, addr
, mainline
, verbo
)
349 struct objfile
*objfile
;
356 /* There is a distinction between having no symbol table
357 (we refuse to read the file, leaving the old set of symbols around)
358 and having no debugging symbols in your symbol table (we read
359 the file and end up with a mostly empty symbol table).
361 FIXME: This strategy works correctly when the debugging symbols are
362 intermixed with "normal" symbols. However, when the debugging symbols
363 are separate, such as with ELF/DWARF, it is perfectly plausible for
364 the symbol table to be missing but still have all the DWARF info
365 intact. Thus in general it is wrong to assume that having no symbol
366 table implies no debugging information. */
368 if (!(bfd_get_file_flags (objfile
-> obfd
) & HAS_SYMS
))
371 init_entry_point_info (objfile
);
372 find_sym_fns (objfile
);
376 /* Since no error yet, throw away the old symbol table. */
378 if (symfile_objfile
!= NULL
)
380 free_objfile (symfile_objfile
);
381 symfile_objfile
= NULL
;
384 (*objfile
-> sf
-> sym_new_init
) (objfile
);
386 /* For mainline, caller didn't know the specified address of the
387 text section. We fix that here. */
389 text_sect
= bfd_get_section_by_name (objfile
-> obfd
, ".text");
390 addr
= bfd_section_vma (objfile
-> obfd
, text_sect
);
393 /* Initialize symbol reading routines for this objfile, allow complaints to
394 appear for this new file, and record how verbose to be, then do the
395 initial symbol reading for this file. */
397 (*objfile
-> sf
-> sym_init
) (objfile
);
398 clear_complaints (1, verbo
);
399 (*objfile
-> sf
-> sym_read
) (objfile
, addr
, mainline
);
401 /* Don't allow char * to have a typename (else would get caddr_t.) */
402 /* Ditto void *. FIXME should do this for all the builtin types. */
404 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
405 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
407 /* Mark the objfile has having had initial symbol read attempted. Note
408 that this does not mean we found any symbols... */
410 objfile
-> flags
|= OBJF_SYMS
;
413 /* Perform required actions immediately after either reading in the initial
414 symbols for a new objfile, or mapping in the symbols from a reusable
418 new_symfile_objfile (objfile
, mainline
, verbo
)
419 struct objfile
*objfile
;
425 /* OK, make it the "real" symbol file. */
426 symfile_objfile
= objfile
;
429 /* If we have wiped out any old symbol tables, clean up. */
430 clear_symtab_users_once ();
432 /* We're done reading the symbol file; finish off complaints. */
433 clear_complaints (0, verbo
);
435 /* Fixup all the breakpoints that may have been redefined by this
438 breakpoint_re_set ();
441 /* Process a symbol file, as either the main file or as a dynamically
444 NAME is the file name (which will be tilde-expanded and made
445 absolute herein) (but we don't free or modify NAME itself).
446 FROM_TTY says how verbose to be. MAINLINE specifies whether this
447 is the main symbol file, or whether it's an extra symbol file such
448 as dynamically loaded code. If !mainline, ADDR is the address
449 where the text segment was loaded.
451 Upon success, returns a pointer to the objfile that was added.
452 Upon failure, jumps back to command level (never returns). */
455 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
)
463 struct objfile
*objfile
;
464 struct partial_symtab
*psymtab
;
467 /* Open a bfd for the file and then check to see if the file has a
468 symbol table. There is a distinction between having no symbol table
469 (we refuse to read the file, leaving the old set of symbols around)
470 and having no debugging symbols in the symbol table (we read the file
471 and end up with a mostly empty symbol table, but with lots of stuff in
472 the minimal symbol table). We need to make the decision about whether
473 to continue with the file before allocating and building a objfile.
475 FIXME: This strategy works correctly when the debugging symbols are
476 intermixed with "normal" symbols. However, when the debugging symbols
477 are separate, such as with ELF/DWARF, it is perfectly plausible for
478 the symbol table to be missing but still have all the DWARF info
479 intact. Thus in general it is wrong to assume that having no symbol
480 table implies no debugging information. */
482 abfd
= symfile_bfd_open (name
);
483 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
485 error ("%s has no symbol-table", name
);
488 if ((have_full_symbols () || have_partial_symbols ())
491 && !query ("Load new symbol table from \"%s\"? ", name
))
492 error ("Not confirmed.");
494 objfile
= allocate_objfile (abfd
, mapped
);
496 /* If the objfile uses a mapped symbol file, and we have a psymtab for
497 it, then skip reading any symbols at this time. */
499 if ((objfile
-> flags
& OBJF_MAPPED
) && (objfile
-> flags
& OBJF_SYMS
))
501 /* We mapped in an existing symbol table file that already has had
502 initial symbol reading performed, so we can skip that part. Notify
503 the user that instead of reading the symbols, they have been mapped.
505 if (from_tty
|| info_verbose
)
507 printf_filtered ("Mapped symbols for %s...", name
);
511 init_entry_point_info (objfile
);
512 find_sym_fns (objfile
);
516 /* We either created a new mapped symbol table, mapped an existing
517 symbol table file which has not had initial symbol reading
518 performed, or need to read an unmapped symbol table. */
519 if (from_tty
|| info_verbose
)
521 printf_filtered ("Reading symbols from %s...", name
);
525 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
528 new_symfile_objfile (objfile
, mainline
, from_tty
);
530 /* We now have at least a partial symbol table. Check to see if the
531 user requested that all symbols be read on initial access via either
532 the gdb startup command line or on a per symbol file basis. Expand
533 all partial symbol tables for this objfile if so. */
535 if (readnow
|| readnow_symbol_files
)
537 if (from_tty
|| info_verbose
)
539 printf_filtered ("expanding to full symbols...");
544 for (psymtab
= objfile
-> psymtabs
;
546 psymtab
= psymtab
-> next
)
548 (void) psymtab_to_symtab (psymtab
);
552 if (from_tty
|| info_verbose
)
554 printf_filtered ("done.\n");
561 /* This is the symbol-file command. Read the file, analyze its symbols,
562 and add a struct symtab to a symtab list. */
565 symbol_file_command (args
, from_tty
)
571 struct cleanup
*cleanups
;
579 if ((have_full_symbols () || have_partial_symbols ())
581 && !query ("Discard symbol table from `%s'? ",
582 symfile_objfile
-> name
))
583 error ("Not confirmed.");
584 free_all_objfiles ();
585 symfile_objfile
= NULL
;
588 printf ("No symbol file now.\n");
593 if ((argv
= buildargv (args
)) == NULL
)
597 cleanups
= make_cleanup (freeargv
, (char *) argv
);
598 while (*argv
!= NULL
)
600 if (strcmp (*argv
, "-mapped") == 0)
604 else if (strcmp (*argv
, "-readnow") == 0)
608 else if (**argv
== '-')
610 error ("unknown option `%s'", *argv
);
621 error ("no symbol file name was specified");
625 /* Getting new symbols may change our opinion about what is
627 reinit_frame_cache ();
628 (void) symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1,
631 do_cleanups (cleanups
);
635 /* Open file specified by NAME and hand it off to BFD for preliminary
636 analysis. Result is a newly initialized bfd *, which includes a newly
637 malloc'd` copy of NAME (tilde-expanded and made absolute).
638 In case of trouble, error() is called. */
641 symfile_bfd_open (name
)
648 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
650 /* Look down path for it, allocate 2nd new malloc'd copy. */
651 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
, 0, &absolute_name
);
654 make_cleanup (free
, name
);
655 perror_with_name (name
);
657 free (name
); /* Free 1st new malloc'd copy */
658 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
659 /* It'll be freed in free_objfile(). */
661 sym_bfd
= bfd_fdopenr (name
, NULL
, desc
);
665 make_cleanup (free
, name
);
666 error ("\"%s\": can't open to read symbols: %s.", name
,
667 bfd_errmsg (bfd_error
));
670 if (!bfd_check_format (sym_bfd
, bfd_object
))
672 bfd_close (sym_bfd
); /* This also closes desc */
673 make_cleanup (free
, name
);
674 error ("\"%s\": can't read symbols: %s.", name
,
675 bfd_errmsg (bfd_error
));
681 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
682 startup by the _initialize routine in each object file format reader,
683 to register information about each format the the reader is prepared
690 sf
->next
= symtab_fns
;
695 /* Initialize to read symbols from the symbol file sym_bfd. It either
696 returns or calls error(). The result is an initialized struct sym_fns
697 in the objfile structure, that contains cached information about the
701 find_sym_fns (objfile
)
702 struct objfile
*objfile
;
706 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
-> next
)
708 if (strncmp (bfd_get_target (objfile
-> obfd
),
709 sf
-> sym_name
, sf
-> sym_namelen
) == 0)
715 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
716 bfd_get_target (objfile
-> obfd
));
719 /* This function runs the load command of our current target. */
722 load_command (arg
, from_tty
)
726 target_load (arg
, from_tty
);
729 /* This function allows the addition of incrementally linked object files.
730 It does not modify any state in the target, only in the debugger. */
734 add_symbol_file_command (args
, from_tty
)
748 error ("add-symbol-file takes a file name and an address");
751 /* Make a copy of the string that we can safely write into. */
753 args
= strdup (args
);
754 make_cleanup (free
, args
);
756 /* Pick off any -option args and the file name. */
758 while ((*args
!= '\000') && (name
== NULL
))
760 while (isspace (*args
)) {args
++;}
762 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
771 else if (strcmp (arg
, "-mapped") == 0)
775 else if (strcmp (arg
, "-readnow") == 0)
781 error ("unknown option `%s'", arg
);
785 /* After picking off any options and the file name, args should be
786 left pointing at the remainder of the command line, which should
787 be the address expression to evaluate. */
789 if ((name
== NULL
) || (*args
== '\000') )
791 error ("add-symbol-file takes a file name and an address");
793 name
= tilde_expand (name
);
794 make_cleanup (free
, name
);
796 text_addr
= parse_and_eval_address (args
);
798 if (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
799 name
, local_hex_string (text_addr
)))
800 error ("Not confirmed.");
802 /* Getting new symbols may change our opinion about what is
805 reinit_frame_cache ();
807 (void) symbol_file_add (name
, 0, text_addr
, 0, mapped
, readnow
);
810 /* Re-read symbols if a symbol-file has changed. */
814 struct objfile
*objfile
;
817 struct stat new_statbuf
;
820 /* With the addition of shared libraries, this should be modified,
821 the load time should be saved in the partial symbol tables, since
822 different tables may come from different source files. FIXME.
823 This routine should then walk down each partial symbol table
824 and see if the symbol table that it originates from has been changed */
827 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
829 #ifdef IBM6000_TARGET
830 /* If this object is from a shared library, then you should
831 stat on the library name, not member name. */
833 if (objfile
->obfd
->my_archive
)
834 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
837 res
= stat (objfile
->name
, &new_statbuf
);
839 /* FIXME, should use print_sys_errmsg but it's not filtered. */
840 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
844 new_modtime
= new_statbuf
.st_mtime
;
845 if (new_modtime
!= objfile
->mtime
) {
846 printf_filtered ("`%s' has changed; re-reading symbols.\n",
848 /* FIXME, this should use a different command...that would only
849 affect this objfile's symbols, and would reset objfile->mtime.
850 (objfile->mtime = new_modtime;)
851 HOWEVER, that command isn't written yet -- so call symbol_file_
852 command, and restart the scan from the top, because it munges
853 the object_files list. */
854 symbol_file_command (objfile
->name
, 0);
856 goto the_big_top
; /* Start over. */
862 breakpoint_re_set ();
865 /* Functions to handle complaints during symbol reading. */
867 /* How many complaints about a particular thing should be printed before
868 we stop whining about it? Default is no whining at all, since so many
869 systems have ill-constructed symbol files. */
871 static unsigned stop_whining
= 0;
873 /* Should each complaint be self explanatory, or should we assume that
874 a series of complaints is being produced?
875 case 0: self explanatory message.
876 case 1: First message of a series that must start off with explanation.
877 case 2: Subsequent message, when user already knows we are reading
878 symbols and we can just state our piece. */
880 static int complaint_series
= 0;
882 /* Print a complaint about the input symbols, and link the complaint block
883 into a chain for later handling. */
886 complain (complaint
, val
)
887 struct complaint
*complaint
;
890 complaint
->counter
++;
891 if (complaint
->next
== 0) {
892 complaint
->next
= complaint_root
->next
;
893 complaint_root
->next
= complaint
;
895 if (complaint
->counter
> stop_whining
)
899 switch (complaint_series
+ (info_verbose
<< 1)) {
901 /* Isolated messages, must be self-explanatory. */
903 puts_filtered ("During symbol reading, ");
905 printf_filtered (complaint
->message
, val
);
906 puts_filtered (".\n");
909 /* First of a series, without `set verbose'. */
911 puts_filtered ("During symbol reading...");
912 printf_filtered (complaint
->message
, val
);
913 puts_filtered ("...");
918 /* Subsequent messages of a series, or messages under `set verbose'.
919 (We'll already have produced a "Reading in symbols for XXX..." message
920 and will clean up at the end with a newline.) */
922 printf_filtered (complaint
->message
, val
);
923 puts_filtered ("...");
928 /* Clear out all complaint counters that have ever been incremented.
929 If sym_reading is 1, be less verbose about successive complaints,
930 since the messages are appearing all together during a command that
931 reads symbols (rather than scattered around as psymtabs get fleshed
932 out into symtabs at random times). If noisy is 1, we are in a
933 noisy symbol reading command, and our caller will print enough
934 context for the user to figure it out. */
937 clear_complaints (sym_reading
, noisy
)
943 for (p
= complaint_root
->next
; p
!= complaint_root
; p
= p
->next
)
946 if (!sym_reading
&& !noisy
&& complaint_series
> 1) {
947 /* Terminate previous series, since caller won't. */
948 puts_filtered ("\n");
951 complaint_series
= sym_reading
? 1 + noisy
: 0;
955 deduce_language_from_filename (filename
)
958 char *c
= strrchr (filename
, '.');
960 if (!c
) ; /* Get default. */
961 else if(!strcmp(c
,".mod"))
963 else if(!strcmp(c
,".c"))
965 else if(!strcmp(c
,".cc") || !strcmp(c
,".C"))
966 return language_cplus
;
968 return language_unknown
; /* default */
973 Allocate and partly initialize a new symbol table. Return a pointer
974 to it. error() if no space.
976 Caller must set these fields:
982 initialize any EXTRA_SYMTAB_INFO
983 possibly free_named_symtabs (symtab->filename);
987 allocate_symtab (filename
, objfile
)
989 struct objfile
*objfile
;
991 register struct symtab
*symtab
;
993 symtab
= (struct symtab
*)
994 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
995 (void) memset (symtab
, 0, sizeof (*symtab
));
996 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
997 &objfile
-> symbol_obstack
);
998 symtab
-> fullname
= NULL
;
999 symtab
-> language
= deduce_language_from_filename (filename
);
1001 /* Hook it to the objfile it comes from */
1003 symtab
-> objfile
= objfile
;
1004 symtab
-> next
= objfile
-> symtabs
;
1005 objfile
-> symtabs
= symtab
;
1007 #ifdef INIT_EXTRA_SYMTAB_INFO
1008 INIT_EXTRA_SYMTAB_INFO (symtab
);
1014 struct partial_symtab
*
1015 allocate_psymtab (filename
, objfile
)
1017 struct objfile
*objfile
;
1019 struct partial_symtab
*psymtab
;
1021 if (objfile
-> free_psymtabs
)
1023 psymtab
= objfile
-> free_psymtabs
;
1024 objfile
-> free_psymtabs
= psymtab
-> next
;
1027 psymtab
= (struct partial_symtab
*)
1028 obstack_alloc (&objfile
-> psymbol_obstack
,
1029 sizeof (struct partial_symtab
));
1031 (void) memset (psymtab
, 0, sizeof (struct partial_symtab
));
1032 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1033 &objfile
-> psymbol_obstack
);
1034 psymtab
-> symtab
= NULL
;
1036 /* Hook it to the objfile it comes from */
1038 psymtab
-> objfile
= objfile
;
1039 psymtab
-> next
= objfile
-> psymtabs
;
1040 objfile
-> psymtabs
= psymtab
;
1046 /* clear_symtab_users_once:
1048 This function is run after symbol reading, or from a cleanup.
1049 If an old symbol table was obsoleted, the old symbol table
1050 has been blown away, but the other GDB data structures that may
1051 reference it have not yet been cleared or re-directed. (The old
1052 symtab was zapped, and the cleanup queued, in free_named_symtab()
1055 This function can be queued N times as a cleanup, or called
1056 directly; it will do all the work the first time, and then will be a
1057 no-op until the next time it is queued. This works by bumping a
1058 counter at queueing time. Much later when the cleanup is run, or at
1059 the end of symbol processing (in case the cleanup is discarded), if
1060 the queued count is greater than the "done-count", we do the work
1061 and set the done-count to the queued count. If the queued count is
1062 less than or equal to the done-count, we just ignore the call. This
1063 is needed because reading a single .o file will often replace many
1064 symtabs (one per .h file, for example), and we don't want to reset
1065 the breakpoints N times in the user's face.
1067 The reason we both queue a cleanup, and call it directly after symbol
1068 reading, is because the cleanup protects us in case of errors, but is
1069 discarded if symbol reading is successful. */
1071 static int clear_symtab_users_queued
;
1072 static int clear_symtab_users_done
;
1075 clear_symtab_users_once ()
1077 /* Enforce once-per-`do_cleanups'-semantics */
1078 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1080 clear_symtab_users_done
= clear_symtab_users_queued
;
1082 printf ("Resetting debugger state after updating old symbol tables\n");
1084 /* Someday, we should do better than this, by only blowing away
1085 the things that really need to be blown. */
1086 clear_value_history ();
1088 clear_internalvars ();
1089 breakpoint_re_set ();
1090 set_default_breakpoint (0, 0, 0, 0);
1091 current_source_symtab
= 0;
1094 /* Delete the specified psymtab, and any others that reference it. */
1097 cashier_psymtab (pst
)
1098 struct partial_symtab
*pst
;
1100 struct partial_symtab
*ps
, *pprev
;
1103 /* Find its previous psymtab in the chain */
1104 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1111 /* Unhook it from the chain. */
1112 if (ps
== pst
->objfile
->psymtabs
)
1113 pst
->objfile
->psymtabs
= ps
->next
;
1115 pprev
->next
= ps
->next
;
1117 /* FIXME, we can't conveniently deallocate the entries in the
1118 partial_symbol lists (global_psymbols/static_psymbols) that
1119 this psymtab points to. These just take up space until all
1120 the psymtabs are reclaimed. Ditto the dependencies list and
1121 filename, which are all in the psymbol_obstack. */
1123 /* We need to cashier any psymtab that has this one as a dependency... */
1125 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1126 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1127 if (ps
->dependencies
[i
] == pst
) {
1128 cashier_psymtab (ps
);
1129 goto again
; /* Must restart, chain has been munged. */
1136 /* If a symtab or psymtab for filename NAME is found, free it along
1137 with any dependent breakpoints, displays, etc.
1138 Used when loading new versions of object modules with the "add-file"
1139 command. This is only called on the top-level symtab or psymtab's name;
1140 it is not called for subsidiary files such as .h files.
1142 Return value is 1 if we blew away the environment, 0 if not.
1143 FIXME. The return valu appears to never be used.
1145 FIXME. I think this is not the best way to do this. We should
1146 work on being gentler to the environment while still cleaning up
1147 all stray pointers into the freed symtab. */
1150 free_named_symtabs (name
)
1154 /* FIXME: With the new method of each objfile having it's own
1155 psymtab list, this function needs serious rethinking. In particular,
1156 why was it ever necessary to toss psymtabs with specific compilation
1157 unit filenames, as opposed to all psymtabs from a particular symbol
1159 Well, the answer is that some systems permit reloading of particular
1160 compilation units. We want to blow away any old info about these
1161 compilation units, regardless of which objfiles they arrived in. --gnu. */
1163 register struct symtab
*s
;
1164 register struct symtab
*prev
;
1165 register struct partial_symtab
*ps
;
1166 struct blockvector
*bv
;
1169 /* We only wack things if the symbol-reload switch is set. */
1170 if (!symbol_reloading
)
1173 /* Some symbol formats have trouble providing file names... */
1174 if (name
== 0 || *name
== '\0')
1177 /* Look for a psymtab with the specified name. */
1180 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1181 if (!strcmp (name
, ps
->filename
)) {
1182 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1183 goto again2
; /* Must restart, chain has been munged */
1187 /* Look for a symtab with the specified name. */
1189 for (s
= symtab_list
; s
; s
= s
->next
)
1191 if (!strcmp (name
, s
->filename
))
1198 if (s
== symtab_list
)
1199 symtab_list
= s
->next
;
1201 prev
->next
= s
->next
;
1203 /* For now, queue a delete for all breakpoints, displays, etc., whether
1204 or not they depend on the symtab being freed. This should be
1205 changed so that only those data structures affected are deleted. */
1207 /* But don't delete anything if the symtab is empty.
1208 This test is necessary due to a bug in "dbxread.c" that
1209 causes empty symtabs to be created for N_SO symbols that
1210 contain the pathname of the object file. (This problem
1211 has been fixed in GDB 3.9x). */
1213 bv
= BLOCKVECTOR (s
);
1214 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1215 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1216 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1218 complain (&oldsyms_complaint
, name
);
1220 clear_symtab_users_queued
++;
1221 make_cleanup (clear_symtab_users_once
, 0);
1224 complain (&empty_symtab_complaint
, name
);
1231 /* It is still possible that some breakpoints will be affected
1232 even though no symtab was found, since the file might have
1233 been compiled without debugging, and hence not be associated
1234 with a symtab. In order to handle this correctly, we would need
1235 to keep a list of text address ranges for undebuggable files.
1236 For now, we do nothing, since this is a fairly obscure case. */
1240 /* FIXME, what about the minimal symbol table? */
1247 /* Allocate and partially fill a partial symtab. It will be
1248 completely filled at the end of the symbol list.
1250 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1251 is the address relative to which its symbols are (incremental) or 0
1255 struct partial_symtab
*
1256 start_psymtab_common (objfile
, addr
,
1257 filename
, textlow
, global_syms
, static_syms
)
1258 struct objfile
*objfile
;
1262 struct partial_symbol
*global_syms
;
1263 struct partial_symbol
*static_syms
;
1265 struct partial_symtab
*psymtab
;
1267 psymtab
= allocate_psymtab (filename
, objfile
);
1268 psymtab
-> addr
= addr
;
1269 psymtab
-> textlow
= textlow
;
1270 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
1271 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
1272 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
1276 /* Debugging versions of functions that are usually inline macros
1279 #if 0 /* Don't quite work nowadays... */
1281 /* Add a symbol with a long value to a psymtab.
1282 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
1285 add_psymbol_to_list (name
, namelength
, namespace, class, list
, val
)
1288 enum namespace namespace;
1289 enum address_class
class;
1290 struct psymbol_allocation_list
*list
;
1293 ADD_PSYMBOL_VT_TO_LIST (name
, namelength
, namespace, class, (*list
), val
,
1297 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1300 add_psymbol_addr_to_list (name
, namelength
, namespace, class, list
, val
)
1303 enum namespace namespace;
1304 enum address_class
class;
1305 struct psymbol_allocation_list
*list
;
1308 ADD_PSYMBOL_VT_TO_LIST (name
, namelength
, namespace, class, (*list
), val
,
1309 SYMBOL_VALUE_ADDRESS
);
1315 _initialize_symfile ()
1318 add_com ("symbol-file", class_files
, symbol_file_command
,
1319 "Load symbol table from executable file FILE.\n\
1320 The `file' command can also load symbol tables, as well as setting the file\n\
1323 add_com ("add-symbol-file", class_files
, add_symbol_file_command
,
1324 "Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
1325 The second argument provides the starting address of the file's text.");
1327 add_com ("load", class_files
, load_command
,
1328 "Dynamically load FILE into the running program, and record its symbols\n\
1329 for access from GDB.");
1332 (add_set_cmd ("complaints", class_support
, var_zinteger
,
1333 (char *)&stop_whining
,
1334 "Set max number of complaints about incorrect symbols.",
1339 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
1340 (char *)&symbol_reloading
,
1341 "Set dynamic symbol table reloading multiple times in one run.",