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. */
30 #include "breakpoint.h"
35 #include <sys/types.h>
40 /* Global variables owned by this file */
42 CORE_ADDR entry_point
; /* Where execution starts in symfile */
43 struct sym_fns
*symtab_fns
= NULL
; /* List of all available sym_fns. */
44 int readnow_symbol_files
; /* Read full symbols immediately */
46 /* External variables and functions referenced. */
48 extern int info_verbose
;
50 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
51 extern CORE_ADDR startup_file_end
; /* From blockframe.c */
53 /* Functions this file defines */
56 load_command
PARAMS ((char *, int));
59 add_symbol_file_command
PARAMS ((char *, int));
62 cashier_psymtab
PARAMS ((struct partial_symtab
*));
65 compare_psymbols
PARAMS ((const void *, const void *));
68 compare_symbols
PARAMS ((const void *, const void *));
71 symfile_bfd_open
PARAMS ((char *));
73 static struct sym_fns
*
74 symfile_init
PARAMS ((struct objfile
*));
77 clear_symtab_users_once
PARAMS ((void));
79 /* Saves the sym_fns of the current symbol table, so we can call
80 the right XXX_new_init function when we free it. FIXME. This
81 should be extended to calling the new_init function for each
82 existing symtab or psymtab, since the main symbol file and
83 subsequent added symbol files can have different types. */
85 static struct sym_fns
*symfile_fns
;
87 /* When we need to allocate a new type, we need to know which type_obstack
88 to allocate the type on, since there is one for each objfile. The places
89 where types are allocated are deeply buried in function call hierarchies
90 which know nothing about objfiles, so rather than trying to pass a
91 particular objfile down to them, we just do an end run around them and
92 set current_objfile to be whatever objfile we expect to be using at the
93 time types are being allocated. For instance, when we start reading
94 symbols for a particular objfile, we set current_objfile to point to that
95 objfile, and when we are done, we set it back to NULL, to ensure that we
96 never put a type someplace other than where we are expecting to put it.
97 FIXME: Maybe we should review the entire type handling system and
98 see if there is a better way to avoid this problem. */
100 struct objfile
*current_objfile
= NULL
;
102 /* The object file that the main symbol table was loaded from (e.g. the
103 argument to the "symbol-file" or "file" command). */
105 struct objfile
*symfile_objfile
= NULL
;
107 /* Structures with which to manage partial symbol allocation. */
109 struct psymbol_allocation_list global_psymbols
= {0}, static_psymbols
= {0};
111 /* Flag for whether user will be reloading symbols multiple times.
112 Defaults to ON for VxWorks, otherwise OFF. */
114 #ifdef SYMBOL_RELOADING_DEFAULT
115 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
117 int symbol_reloading
= 0;
120 /* Structure to manage complaints about symbol file contents. */
122 struct complaint complaint_root
[1] = {
123 {(char *) 0, 0, complaint_root
},
126 /* Some actual complaints. */
128 struct complaint oldsyms_complaint
= {
129 "Replacing old symbols for `%s'", 0, 0 };
131 struct complaint empty_symtab_complaint
= {
132 "Empty symbol table found for `%s'", 0, 0 };
135 /* In the following sort, we always make sure that
136 register debug symbol declarations always come before regular
137 debug symbol declarations (as might happen when parameters are
138 then put into registers by the compiler).
140 Since this function is called from within qsort, in an ANSI environment
141 it must conform to the prototype for qsort, which specifies that the
142 comparison function takes two "void *" pointers. */
145 compare_symbols (s1p
, s2p
)
149 register struct symbol
**s1
, **s2
;
150 register int namediff
;
152 s1
= (struct symbol
**) s1p
;
153 s2
= (struct symbol
**) s2p
;
155 /* Compare the initial characters. */
156 namediff
= SYMBOL_NAME (*s1
)[0] - SYMBOL_NAME (*s2
)[0];
157 if (namediff
!= 0) return namediff
;
159 /* If they match, compare the rest of the names. */
160 namediff
= strcmp (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
));
161 if (namediff
!= 0) return namediff
;
163 /* For symbols of the same name, registers should come first. */
164 return ((SYMBOL_CLASS (*s2
) == LOC_REGISTER
)
165 - (SYMBOL_CLASS (*s1
) == LOC_REGISTER
));
172 compare_psymbols -- compare two partial symbols by name
176 Given pointer to two partial symbol table entries, compare
177 them by name and return -N, 0, or +N (ala strcmp). Typically
178 used by sorting routines like qsort().
182 Does direct compare of first two characters before punting
183 and passing to strcmp for longer compares. Note that the
184 original version had a bug whereby two null strings or two
185 identically named one character strings would return the
186 comparison of memory following the null byte.
191 compare_psymbols (s1p
, s2p
)
195 register char *st1
= SYMBOL_NAME ((struct partial_symbol
*) s1p
);
196 register char *st2
= SYMBOL_NAME ((struct partial_symbol
*) s2p
);
198 if ((st1
[0] - st2
[0]) || !st1
[0])
200 return (st1
[0] - st2
[0]);
202 else if ((st1
[1] - st2
[1]) || !st1
[1])
204 return (st1
[1] - st2
[1]);
208 return (strcmp (st1
+ 2, st2
+ 2));
213 sort_pst_symbols (pst
)
214 struct partial_symtab
*pst
;
216 /* Sort the global list; don't sort the static list */
218 qsort (pst
-> objfile
-> global_psymbols
.list
+ pst
-> globals_offset
,
219 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
223 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
227 register struct block
*b
;
229 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
230 sizeof (struct symbol
*), compare_symbols
);
233 /* Call sort_symtab_syms to sort alphabetically
234 the symbols of each block of one symtab. */
238 register struct symtab
*s
;
240 register struct blockvector
*bv
;
243 register struct block
*b
;
247 bv
= BLOCKVECTOR (s
);
248 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
249 for (i
= 0; i
< nbl
; i
++)
251 b
= BLOCKVECTOR_BLOCK (bv
, i
);
252 if (BLOCK_SHOULD_SORT (b
))
258 sort_all_symtab_syms ()
260 register struct symtab
*s
;
261 register struct objfile
*objfile
;
263 for (objfile
= object_files
; objfile
!= NULL
; objfile
= objfile
-> next
)
265 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
267 sort_symtab_syms (s
);
272 /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
273 (and add a null character at the end in the copy).
274 Returns the address of the copy. */
277 obsavestring (ptr
, size
, obstackp
)
280 struct obstack
*obstackp
;
282 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
283 /* Open-coded bcopy--saves function call time.
284 These strings are usually short. */
286 register char *p1
= ptr
;
287 register char *p2
= p
;
288 char *end
= ptr
+ size
;
296 /* Concatenate strings S1, S2 and S3; return the new string.
297 Space is found in the symbol_obstack. */
300 obconcat (obstackp
, s1
, s2
, s3
)
301 struct obstack
*obstackp
;
302 const char *s1
, *s2
, *s3
;
304 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
305 register char *val
= (char *) obstack_alloc (obstackp
, len
);
312 /* Get the symbol table that corresponds to a partial_symtab.
313 This is fast after the first time you do it. In fact, there
314 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
318 psymtab_to_symtab (pst
)
319 register struct partial_symtab
*pst
;
321 /* If it's been looked up before, return it. */
325 /* If it has not yet been read in, read it. */
328 (*pst
->read_symtab
) (pst
);
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
;
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 if (!(bfd_get_file_flags (objfile
-> obfd
) & HAS_SYMS
))
364 /* Save startup file's range of PC addresses to help blockframe.c
365 decide where the bottom of the stack is. */
366 if (bfd_get_file_flags (objfile
-> obfd
) & EXEC_P
)
368 /* Executable file -- record its entry point so we'll recognize
369 the startup file because it contains the entry point. */
370 entry_point
= bfd_get_start_address (objfile
-> obfd
);
374 /* Examination of non-executable.o files. Short-circuit this stuff. */
375 /* ~0 will not be in any file, we hope. */
377 /* set the startup file to be an empty range. */
378 startup_file_start
= 0;
379 startup_file_end
= 0;
382 sf
= symfile_init (objfile
);
386 /* Since no error yet, throw away the old symbol table. */
389 free_objfile (symfile_objfile
);
390 symfile_objfile
= NULL
;
392 (*sf
->sym_new_init
) ();
394 /* For mainline, caller didn't know the specified address of the
395 text section. We fix that here. */
396 text_sect
= bfd_get_section_by_name (objfile
-> obfd
, ".text");
397 addr
= bfd_section_vma (objfile
-> obfd
, text_sect
);
400 /* Allow complaints to appear for this new file, and record how
403 clear_complaints(1, verbo
);
405 (*sf
->sym_read
) (sf
, addr
, mainline
);
407 /* Don't allow char * to have a typename (else would get caddr_t.) */
408 /* Ditto void *. FIXME should do this for all the builtin types. */
410 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
411 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
415 /* OK, make it the "real" symbol file. */
416 symfile_objfile
= objfile
;
420 /* If we have wiped out any old symbol tables, clean up. */
421 clear_symtab_users_once ();
423 /* We're done reading the symbol file; finish off complaints. */
424 clear_complaints(0, verbo
);
426 /* Fixup all the breakpoints that may have been redefined by this
429 breakpoint_re_set ();
432 /* Process a symbol file, as either the main file or as a dynamically
435 NAME is the file name (which will be tilde-expanded and made
436 absolute herein) (but we don't free or modify NAME itself).
437 FROM_TTY says how verbose to be. MAINLINE specifies whether this
438 is the main symbol file, or whether it's an extra symbol file such
439 as dynamically loaded code. If !mainline, ADDR is the address
440 where the text segment was loaded.
442 Upon success, returns a pointer to the objfile that was added.
443 Upon failure, jumps back to command level (never returns). */
446 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
)
454 struct objfile
*objfile
;
455 struct partial_symtab
*psymtab
;
457 /* Open a bfd for the file, then allocate a new objfile. */
459 objfile
= allocate_objfile (symfile_bfd_open (name
), mapped
);
461 /* There is a distinction between having no symbol table
462 (we refuse to read the file, leaving the old set of symbols around)
463 and having no debugging symbols in your symbol table (we read
464 the file and end up with a mostly empty symbol table, but with lots
465 of stuff in the minimal symbol table). */
467 if (!(bfd_get_file_flags (objfile
-> obfd
) & HAS_SYMS
))
469 error ("%s has no symbol-table", name
);
472 /* If the objfile uses a mapped symbol file, and we have a psymtab for
473 it, then skip reading any symbols at this time. */
475 if ((objfile
-> psymtabs
!= NULL
) && (objfile
-> flags
& OBJF_MAPPED
))
477 if (from_tty
|| info_verbose
)
479 printf_filtered ("Mapped symbols for %s.\n", name
);
485 if ((have_full_symbols () || have_partial_symbols ())
488 && !query ("Load new symbol table from \"%s\"? ", name
))
489 error ("Not confirmed.");
491 if (from_tty
|| info_verbose
)
493 printf_filtered ("Reading symbols from %s...", name
);
498 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
500 readnow
|= readnow_symbol_files
;
503 if (from_tty
|| info_verbose
)
505 printf_filtered ("expanding to full symbols...");
510 for (psymtab
= objfile
-> psymtabs
;
512 psymtab
= psymtab
-> next
)
514 (void) psymtab_to_symtab (psymtab
);
518 if (from_tty
|| info_verbose
)
520 printf_filtered ("done.\n");
527 /* This is the symbol-file command. Read the file, analyze its symbols,
528 and add a struct symtab to a symtab list. */
531 symbol_file_command (args
, from_tty
)
537 struct cleanup
*cleanups
;
538 struct objfile
*objfile
;
546 if ((have_full_symbols () || have_partial_symbols ())
548 && !query ("Discard symbol table from `%s'? ",
549 symfile_objfile
-> name
))
550 error ("Not confirmed.");
551 free_all_objfiles ();
552 symfile_objfile
= NULL
;
553 /* FIXME, this does not account for the main file and subsequent
554 files (shared libs, dynloads, etc) having different formats.
555 It only calls the cleanup routine for the main file's format. */
558 (*symfile_fns
-> sym_new_init
) ();
565 if ((argv
= buildargv (args
)) == NULL
)
569 cleanups
= make_cleanup (freeargv
, (char *) argv
);
570 while (*argv
!= NULL
)
572 if (strcmp (*argv
, "-mapped") == 0)
576 else if (strcmp (*argv
, "-readnow") == 0)
580 else if (**argv
== '-')
582 error ("unknown option `%s'", *argv
);
593 error ("no symbol file name was specified");
597 /* Getting new symbols may change our opinion about what is
599 reinit_frame_cache ();
600 objfile
= symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1,
603 do_cleanups (cleanups
);
607 /* Open file specified by NAME and hand it off to BFD for preliminary
608 analysis. Result is a newly initialized bfd *, which includes a newly
609 malloc'd` copy of NAME (tilde-expanded and made absolute).
610 In case of trouble, error() is called. */
613 symfile_bfd_open (name
)
620 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
622 /* Look down path for it, allocate 2nd new malloc'd copy. */
623 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
, 0, &absolute_name
);
626 make_cleanup (free
, name
);
627 perror_with_name (name
);
629 free (name
); /* Free 1st new malloc'd copy */
630 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
632 sym_bfd
= bfd_fdopenr (name
, NULL
, desc
);
636 make_cleanup (free
, name
);
637 error ("\"%s\": can't open to read symbols: %s.", name
,
638 bfd_errmsg (bfd_error
));
641 if (!bfd_check_format (sym_bfd
, bfd_object
))
643 bfd_close (sym_bfd
); /* This also closes desc */
644 make_cleanup (free
, name
);
645 error ("\"%s\": can't read symbols: %s.", name
,
646 bfd_errmsg (bfd_error
));
652 /* Link a new symtab_fns into the global symtab_fns list.
653 Called by various _initialize routines. */
659 sf
->next
= symtab_fns
;
664 /* Initialize to read symbols from the symbol file sym_bfd. It either
665 returns or calls error(). The result is a malloc'd struct sym_fns
666 that contains cached information about the symbol file. */
668 static struct sym_fns
*
669 symfile_init (objfile
)
670 struct objfile
*objfile
;
672 struct sym_fns
*sf
, *sf2
;
674 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
676 if (!strncmp (bfd_get_target (objfile
-> obfd
), sf
->sym_name
, sf
->sym_namelen
))
678 sf2
= (struct sym_fns
*)xmalloc (sizeof (*sf2
));
679 /* FIXME, who frees this? */
681 sf2
->objfile
= objfile
;
682 sf2
->sym_bfd
= objfile
-> obfd
;
683 sf2
->sym_private
= 0; /* Not alloc'd yet */
684 (*sf2
->sym_init
) (sf2
);
688 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
689 bfd_get_target (objfile
-> obfd
));
690 return 0; /* Appease lint. */
693 /* This function runs the load command of our current target. */
696 load_command (arg
, from_tty
)
700 target_load (arg
, from_tty
);
703 /* This function allows the addition of incrementally linked object files.
704 It does not modify any state in the target, only in the debugger. */
708 add_symbol_file_command (args
, from_tty
)
722 error ("add-symbol-file takes a file name and an address");
725 /* Make a copy of the string that we can safely write into. */
727 args
= strdup (args
);
728 make_cleanup (free
, args
);
730 /* Pick off any -option args and the file name. */
732 while ((*args
!= '\000') && (name
== NULL
))
734 while (isspace (*args
)) {args
++;}
736 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
745 else if (strcmp (arg
, "-mapped") == 0)
749 else if (strcmp (arg
, "-readnow") == 0)
755 error ("unknown option `%s'", arg
);
759 /* After picking off any options and the file name, args should be
760 left pointing at the remainder of the command line, which should
761 be the address expression to evaluate. */
763 if ((name
== NULL
) || (*args
== '\000') )
765 error ("add-symbol-file takes a file name and an address");
767 name
= tilde_expand (name
);
768 make_cleanup (free
, name
);
770 text_addr
= parse_and_eval_address (args
);
772 if (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
773 name
, local_hex_string (text_addr
)))
774 error ("Not confirmed.");
776 /* Getting new symbols may change our opinion about what is
779 reinit_frame_cache ();
781 (void) symbol_file_add (name
, 0, text_addr
, 0, mapped
, readnow
);
784 /* Re-read symbols if a symbol-file has changed. */
788 struct objfile
*objfile
;
791 struct stat new_statbuf
;
794 /* With the addition of shared libraries, this should be modified,
795 the load time should be saved in the partial symbol tables, since
796 different tables may come from different source files. FIXME.
797 This routine should then walk down each partial symbol table
798 and see if the symbol table that it originates from has been changed */
801 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
804 /* If this object is from a shared library, then you should
805 stat on the library name, not member name. */
807 if (objfile
->obfd
->my_archive
)
808 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
811 res
= stat (objfile
->name
, &new_statbuf
);
813 /* FIXME, should use print_sys_errmsg but it's not filtered. */
814 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
818 new_modtime
= new_statbuf
.st_mtime
;
819 if (new_modtime
!= objfile
->mtime
) {
820 printf_filtered ("`%s' has changed; re-reading symbols.\n",
822 /* FIXME, this should use a different command...that would only
823 affect this objfile's symbols, and would reset objfile->mtime.
824 (objfile->mtime = new_modtime;)
825 HOWEVER, that command isn't written yet -- so call symbol_file_
826 command, and restart the scan from the top, because it munges
827 the object_files list. */
828 symbol_file_command (objfile
->name
, 0);
830 goto the_big_top
; /* Start over. */
836 breakpoint_re_set ();
839 /* Functions to handle complaints during symbol reading. */
841 /* How many complaints about a particular thing should be printed before
842 we stop whining about it? Default is no whining at all, since so many
843 systems have ill-constructed symbol files. */
845 static unsigned stop_whining
= 0;
847 /* Should each complaint be self explanatory, or should we assume that
848 a series of complaints is being produced?
849 case 0: self explanatory message.
850 case 1: First message of a series that must start off with explanation.
851 case 2: Subsequent message, when user already knows we are reading
852 symbols and we can just state our piece. */
854 static int complaint_series
= 0;
856 /* Print a complaint about the input symbols, and link the complaint block
857 into a chain for later handling. */
860 complain (complaint
, val
)
861 struct complaint
*complaint
;
864 complaint
->counter
++;
865 if (complaint
->next
== 0) {
866 complaint
->next
= complaint_root
->next
;
867 complaint_root
->next
= complaint
;
869 if (complaint
->counter
> stop_whining
)
873 switch (complaint_series
+ (info_verbose
<< 1)) {
875 /* Isolated messages, must be self-explanatory. */
877 puts_filtered ("During symbol reading, ");
879 printf_filtered (complaint
->message
, val
);
880 puts_filtered (".\n");
883 /* First of a series, without `set verbose'. */
885 puts_filtered ("During symbol reading...");
886 printf_filtered (complaint
->message
, val
);
887 puts_filtered ("...");
892 /* Subsequent messages of a series, or messages under `set verbose'.
893 (We'll already have produced a "Reading in symbols for XXX..." message
894 and will clean up at the end with a newline.) */
896 printf_filtered (complaint
->message
, val
);
897 puts_filtered ("...");
902 /* Clear out all complaint counters that have ever been incremented.
903 If sym_reading is 1, be less verbose about successive complaints,
904 since the messages are appearing all together during a command that
905 reads symbols (rather than scattered around as psymtabs get fleshed
906 out into symtabs at random times). If noisy is 1, we are in a
907 noisy symbol reading command, and our caller will print enough
908 context for the user to figure it out. */
911 clear_complaints (sym_reading
, noisy
)
917 for (p
= complaint_root
->next
; p
!= complaint_root
; p
= p
->next
)
920 if (!sym_reading
&& !noisy
&& complaint_series
> 1) {
921 /* Terminate previous series, since caller won't. */
922 puts_filtered ("\n");
925 complaint_series
= sym_reading
? 1 + noisy
: 0;
929 deduce_language_from_filename (filename
)
932 char *c
= strrchr (filename
, '.');
934 if (!c
) ; /* Get default. */
935 else if(!strcmp(c
,".mod"))
937 else if(!strcmp(c
,".c"))
939 else if(!strcmp(c
,".cc") || !strcmp(c
,".C"))
940 return language_cplus
;
942 return language_unknown
; /* default */
947 Allocate and partly initialize a new symbol table. Return a pointer
948 to it. error() if no space.
950 Caller must set these fields:
956 initialize any EXTRA_SYMTAB_INFO
957 possibly free_named_symtabs (symtab->filename);
961 allocate_symtab (filename
, objfile
)
963 struct objfile
*objfile
;
965 register struct symtab
*symtab
;
967 symtab
= (struct symtab
*)
968 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
969 (void) memset (symtab
, 0, sizeof (*symtab
));
970 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
971 &objfile
-> symbol_obstack
);
972 symtab
-> fullname
= NULL
;
973 symtab
-> language
= deduce_language_from_filename (filename
);
975 /* Hook it to the objfile it comes from */
977 symtab
-> objfile
= objfile
;
978 symtab
-> next
= objfile
-> symtabs
;
979 objfile
-> symtabs
= symtab
;
981 #ifdef INIT_EXTRA_SYMTAB_INFO
982 INIT_EXTRA_SYMTAB_INFO (symtab
);
988 struct partial_symtab
*
989 allocate_psymtab (filename
, objfile
)
991 struct objfile
*objfile
;
993 struct partial_symtab
*psymtab
;
995 if (objfile
-> free_psymtabs
)
997 psymtab
= objfile
-> free_psymtabs
;
998 objfile
-> free_psymtabs
= psymtab
-> next
;
1001 psymtab
= (struct partial_symtab
*)
1002 obstack_alloc (&objfile
-> psymbol_obstack
,
1003 sizeof (struct partial_symtab
));
1005 (void) memset (psymtab
, 0, sizeof (struct partial_symtab
));
1006 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1007 &objfile
-> psymbol_obstack
);
1008 psymtab
-> symtab
= NULL
;
1010 /* Hook it to the objfile it comes from */
1012 psymtab
-> objfile
= objfile
;
1013 psymtab
-> next
= objfile
-> psymtabs
;
1014 objfile
-> psymtabs
= psymtab
;
1020 /* clear_symtab_users_once:
1022 This function is run after symbol reading, or from a cleanup.
1023 If an old symbol table was obsoleted, the old symbol table
1024 has been blown away, but the other GDB data structures that may
1025 reference it have not yet been cleared or re-directed. (The old
1026 symtab was zapped, and the cleanup queued, in free_named_symtab()
1029 This function can be queued N times as a cleanup, or called
1030 directly; it will do all the work the first time, and then will be a
1031 no-op until the next time it is queued. This works by bumping a
1032 counter at queueing time. Much later when the cleanup is run, or at
1033 the end of symbol processing (in case the cleanup is discarded), if
1034 the queued count is greater than the "done-count", we do the work
1035 and set the done-count to the queued count. If the queued count is
1036 less than or equal to the done-count, we just ignore the call. This
1037 is needed because reading a single .o file will often replace many
1038 symtabs (one per .h file, for example), and we don't want to reset
1039 the breakpoints N times in the user's face.
1041 The reason we both queue a cleanup, and call it directly after symbol
1042 reading, is because the cleanup protects us in case of errors, but is
1043 discarded if symbol reading is successful. */
1045 static int clear_symtab_users_queued
;
1046 static int clear_symtab_users_done
;
1049 clear_symtab_users_once ()
1051 /* Enforce once-per-`do_cleanups'-semantics */
1052 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1054 clear_symtab_users_done
= clear_symtab_users_queued
;
1056 printf ("Resetting debugger state after updating old symbol tables\n");
1058 /* Someday, we should do better than this, by only blowing away
1059 the things that really need to be blown. */
1060 clear_value_history ();
1062 clear_internalvars ();
1063 breakpoint_re_set ();
1064 set_default_breakpoint (0, 0, 0, 0);
1065 current_source_symtab
= 0;
1068 /* Delete the specified psymtab, and any others that reference it. */
1071 cashier_psymtab (pst
)
1072 struct partial_symtab
*pst
;
1074 struct partial_symtab
*ps
, *pprev
;
1077 /* Find its previous psymtab in the chain */
1078 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1085 /* Unhook it from the chain. */
1086 if (ps
== pst
->objfile
->psymtabs
)
1087 pst
->objfile
->psymtabs
= ps
->next
;
1089 pprev
->next
= ps
->next
;
1091 /* FIXME, we can't conveniently deallocate the entries in the
1092 partial_symbol lists (global_psymbols/static_psymbols) that
1093 this psymtab points to. These just take up space until all
1094 the psymtabs are reclaimed. Ditto the dependencies list and
1095 filename, which are all in the psymbol_obstack. */
1097 /* We need to cashier any psymtab that has this one as a dependency... */
1099 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1100 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1101 if (ps
->dependencies
[i
] == pst
) {
1102 cashier_psymtab (ps
);
1103 goto again
; /* Must restart, chain has been munged. */
1110 /* If a symtab or psymtab for filename NAME is found, free it along
1111 with any dependent breakpoints, displays, etc.
1112 Used when loading new versions of object modules with the "add-file"
1113 command. This is only called on the top-level symtab or psymtab's name;
1114 it is not called for subsidiary files such as .h files.
1116 Return value is 1 if we blew away the environment, 0 if not.
1117 FIXME. The return valu appears to never be used.
1119 FIXME. I think this is not the best way to do this. We should
1120 work on being gentler to the environment while still cleaning up
1121 all stray pointers into the freed symtab. */
1124 free_named_symtabs (name
)
1127 register struct symtab
*s
;
1128 register struct symtab
*prev
;
1129 register struct partial_symtab
*ps
;
1130 struct blockvector
*bv
;
1134 /* FIXME: With the new method of each objfile having it's own
1135 psymtab list, this function needs serious rethinking. In particular,
1136 why was it ever necessary to toss psymtabs with specific compilation
1137 unit filenames, as opposed to all psymtabs from a particular symbol
1140 /* We only wack things if the symbol-reload switch is set. */
1141 if (!symbol_reloading
)
1144 /* Some symbol formats have trouble providing file names... */
1145 if (name
== 0 || *name
== '\0')
1148 /* Look for a psymtab with the specified name. */
1151 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1152 if (!strcmp (name
, ps
->filename
)) {
1153 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1154 goto again2
; /* Must restart, chain has been munged */
1158 /* Look for a symtab with the specified name. */
1160 for (s
= symtab_list
; s
; s
= s
->next
)
1162 if (!strcmp (name
, s
->filename
))
1169 if (s
== symtab_list
)
1170 symtab_list
= s
->next
;
1172 prev
->next
= s
->next
;
1174 /* For now, queue a delete for all breakpoints, displays, etc., whether
1175 or not they depend on the symtab being freed. This should be
1176 changed so that only those data structures affected are deleted. */
1178 /* But don't delete anything if the symtab is empty.
1179 This test is necessary due to a bug in "dbxread.c" that
1180 causes empty symtabs to be created for N_SO symbols that
1181 contain the pathname of the object file. (This problem
1182 has been fixed in GDB 3.9x). */
1184 bv
= BLOCKVECTOR (s
);
1185 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1186 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1187 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1189 complain (&oldsyms_complaint
, name
);
1191 clear_symtab_users_queued
++;
1192 make_cleanup (clear_symtab_users_once
, 0);
1195 complain (&empty_symtab_complaint
, name
);
1202 /* It is still possible that some breakpoints will be affected
1203 even though no symtab was found, since the file might have
1204 been compiled without debugging, and hence not be associated
1205 with a symtab. In order to handle this correctly, we would need
1206 to keep a list of text address ranges for undebuggable files.
1207 For now, we do nothing, since this is a fairly obscure case. */
1211 /* FIXME, what about the minimal symbol table? */
1218 /* Allocate and partially fill a partial symtab. It will be
1219 completely filled at the end of the symbol list.
1221 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1222 is the address relative to which its symbols are (incremental) or 0
1226 struct partial_symtab
*
1227 start_psymtab_common (objfile
, addr
,
1228 filename
, textlow
, global_syms
, static_syms
)
1229 struct objfile
*objfile
;
1233 struct partial_symbol
*global_syms
;
1234 struct partial_symbol
*static_syms
;
1236 struct partial_symtab
*psymtab
;
1238 psymtab
= allocate_psymtab (filename
, objfile
);
1239 psymtab
-> addr
= addr
;
1240 psymtab
-> textlow
= textlow
;
1241 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
1242 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
1243 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
1249 _initialize_symfile ()
1252 add_com ("symbol-file", class_files
, symbol_file_command
,
1253 "Load symbol table from executable file FILE.\n\
1254 The `file' command can also load symbol tables, as well as setting the file\n\
1257 add_com ("add-symbol-file", class_files
, add_symbol_file_command
,
1258 "Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
1259 The second argument provides the starting address of the file's text.");
1261 add_com ("load", class_files
, load_command
,
1262 "Dynamically load FILE into the running program, and record its symbols\n\
1263 for access from GDB.");
1266 (add_set_cmd ("complaints", class_support
, var_zinteger
,
1267 (char *)&stop_whining
,
1268 "Set max number of complaints about incorrect symbols.",
1273 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
1274 (char *)&symbol_reloading
,
1275 "Set dynamic symbol table reloading multiple times in one run.",