1 /* Generic symbol file reading for the GNU debugger, GDB.
2 Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
3 Contributed by Cygnus Support, using pieces from other GDB modules.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
31 #include "breakpoint.h"
33 #include "complaints.h"
39 #include <sys/types.h>
49 /* Global variables owned by this file */
51 int readnow_symbol_files
; /* Read full symbols immediately */
53 struct complaint oldsyms_complaint
= {
54 "Replacing old symbols for `%s'", 0, 0
57 struct complaint empty_symtab_complaint
= {
58 "Empty symbol table found for `%s'", 0, 0
61 /* External variables and functions referenced. */
63 extern int info_verbose
;
65 /* Functions this file defines */
68 set_initial_language
PARAMS ((void));
71 load_command
PARAMS ((char *, int));
74 add_symbol_file_command
PARAMS ((char *, int));
77 cashier_psymtab
PARAMS ((struct partial_symtab
*));
80 compare_psymbols
PARAMS ((const void *, const void *));
83 compare_symbols
PARAMS ((const void *, const void *));
86 symfile_bfd_open
PARAMS ((char *));
89 find_sym_fns
PARAMS ((struct objfile
*));
92 clear_symtab_users_once
PARAMS ((void));
94 /* List of all available sym_fns. On gdb startup, each object file reader
95 calls add_symtab_fns() to register information on each format it is
98 static struct sym_fns
*symtab_fns
= NULL
;
100 /* Structures with which to manage partial symbol allocation. */
102 struct psymbol_allocation_list global_psymbols
= {0}, static_psymbols
= {0};
104 /* Flag for whether user will be reloading symbols multiple times.
105 Defaults to ON for VxWorks, otherwise OFF. */
107 #ifdef SYMBOL_RELOADING_DEFAULT
108 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
110 int symbol_reloading
= 0;
114 /* In the following sort, we always make sure that
115 register debug symbol declarations always come before regular
116 debug symbol declarations (as might happen when parameters are
117 then put into registers by the compiler).
119 Since this function is called from within qsort, in an ANSI environment
120 it must conform to the prototype for qsort, which specifies that the
121 comparison function takes two "void *" pointers. */
124 compare_symbols (s1p
, s2p
)
128 register struct symbol
**s1
, **s2
;
129 register int namediff
;
131 s1
= (struct symbol
**) s1p
;
132 s2
= (struct symbol
**) s2p
;
134 /* Compare the initial characters. */
135 namediff
= SYMBOL_NAME (*s1
)[0] - SYMBOL_NAME (*s2
)[0];
136 if (namediff
!= 0) return namediff
;
138 /* If they match, compare the rest of the names. */
139 namediff
= STRCMP (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
));
140 if (namediff
!= 0) return namediff
;
142 /* For symbols of the same name, registers should come first. */
143 return ((SYMBOL_CLASS (*s2
) == LOC_REGISTER
)
144 - (SYMBOL_CLASS (*s1
) == LOC_REGISTER
));
151 compare_psymbols -- compare two partial symbols by name
155 Given pointer to two partial symbol table entries, compare
156 them by name and return -N, 0, or +N (ala strcmp). Typically
157 used by sorting routines like qsort().
161 Does direct compare of first two characters before punting
162 and passing to strcmp for longer compares. Note that the
163 original version had a bug whereby two null strings or two
164 identically named one character strings would return the
165 comparison of memory following the null byte.
170 compare_psymbols (s1p
, s2p
)
174 register char *st1
= SYMBOL_NAME ((struct partial_symbol
*) s1p
);
175 register char *st2
= SYMBOL_NAME ((struct partial_symbol
*) s2p
);
177 if ((st1
[0] - st2
[0]) || !st1
[0])
179 return (st1
[0] - st2
[0]);
181 else if ((st1
[1] - st2
[1]) || !st1
[1])
183 return (st1
[1] - st2
[1]);
187 return (STRCMP (st1
+ 2, st2
+ 2));
192 sort_pst_symbols (pst
)
193 struct partial_symtab
*pst
;
195 /* Sort the global list; don't sort the static list */
197 qsort (pst
-> objfile
-> global_psymbols
.list
+ pst
-> globals_offset
,
198 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
202 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
206 register struct block
*b
;
208 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
209 sizeof (struct symbol
*), compare_symbols
);
212 /* Call sort_symtab_syms to sort alphabetically
213 the symbols of each block of one symtab. */
217 register struct symtab
*s
;
219 register struct blockvector
*bv
;
222 register struct block
*b
;
226 bv
= BLOCKVECTOR (s
);
227 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
228 for (i
= 0; i
< nbl
; i
++)
230 b
= BLOCKVECTOR_BLOCK (bv
, i
);
231 if (BLOCK_SHOULD_SORT (b
))
237 sort_all_symtab_syms ()
239 register struct symtab
*s
;
240 register struct objfile
*objfile
;
242 for (objfile
= object_files
; objfile
!= NULL
; objfile
= objfile
-> next
)
244 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
)
246 sort_symtab_syms (s
);
251 /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
252 (and add a null character at the end in the copy).
253 Returns the address of the copy. */
256 obsavestring (ptr
, size
, obstackp
)
259 struct obstack
*obstackp
;
261 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
262 /* Open-coded bcopy--saves function call time.
263 These strings are usually short. */
265 register char *p1
= ptr
;
266 register char *p2
= p
;
267 char *end
= ptr
+ size
;
275 /* Concatenate strings S1, S2 and S3; return the new string.
276 Space is found in the symbol_obstack. */
279 obconcat (obstackp
, s1
, s2
, s3
)
280 struct obstack
*obstackp
;
281 const char *s1
, *s2
, *s3
;
283 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
284 register char *val
= (char *) obstack_alloc (obstackp
, len
);
291 /* Get the symbol table that corresponds to a partial_symtab.
292 This is fast after the first time you do it. In fact, there
293 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
297 psymtab_to_symtab (pst
)
298 register struct partial_symtab
*pst
;
300 /* If it's been looked up before, return it. */
304 /* If it has not yet been read in, read it. */
307 (*pst
->read_symtab
) (pst
);
313 /* Initialize entry point information for this objfile. */
316 init_entry_point_info (objfile
)
317 struct objfile
*objfile
;
319 /* Save startup file's range of PC addresses to help blockframe.c
320 decide where the bottom of the stack is. */
322 if (bfd_get_file_flags (objfile
-> obfd
) & EXEC_P
)
324 /* Executable file -- record its entry point so we'll recognize
325 the startup file because it contains the entry point. */
326 objfile
-> ei
.entry_point
= bfd_get_start_address (objfile
-> obfd
);
330 /* Examination of non-executable.o files. Short-circuit this stuff. */
331 /* ~0 will not be in any file, we hope. */
332 objfile
-> ei
.entry_point
= ~0;
333 /* set the startup file to be an empty range. */
334 objfile
-> ei
.entry_file_lowpc
= 0;
335 objfile
-> ei
.entry_file_highpc
= 0;
339 /* Remember the lowest-addressed loadable section we've seen.
340 This function is called via bfd_map_over_sections. */
342 #if 0 /* Not used yet */
344 find_lowest_section (abfd
, sect
, obj
)
349 asection
**lowest
= (asection
**)obj
;
351 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
354 *lowest
= sect
; /* First loadable section */
355 else if (bfd_section_vma (abfd
, *lowest
) >= bfd_section_vma (abfd
, sect
))
356 *lowest
= sect
; /* A lower loadable section */
360 /* Process a symbol file, as either the main file or as a dynamically
363 NAME is the file name (which will be tilde-expanded and made
364 absolute herein) (but we don't free or modify NAME itself).
365 FROM_TTY says how verbose to be. MAINLINE specifies whether this
366 is the main symbol file, or whether it's an extra symbol file such
367 as dynamically loaded code. If !mainline, ADDR is the address
368 where the text segment was loaded. If VERBO, the caller has printed
369 a verbose message about the symbol reading (and complaints can be
370 more terse about it). */
373 syms_from_objfile (objfile
, addr
, mainline
, verbo
)
374 struct objfile
*objfile
;
379 struct section_offsets
*section_offsets
;
380 asection
*lowest_sect
;
382 init_entry_point_info (objfile
);
383 find_sym_fns (objfile
);
387 /* Since no error yet, throw away the old symbol table. */
389 if (symfile_objfile
!= NULL
)
391 free_objfile (symfile_objfile
);
392 symfile_objfile
= NULL
;
395 (*objfile
-> sf
-> sym_new_init
) (objfile
);
398 /* Convert addr into an offset rather than an absolute address.
399 We find the lowest address of a loaded segment in the objfile,
400 and assume that <addr> is where that got loaded. Due to historical
401 precedent, we warn if that doesn't happen to be the ".text"
406 addr
= 0; /* No offset from objfile addresses. */
410 lowest_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
413 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
417 if (lowest_sect
== 0)
418 warning ("no loadable sections found in added symbol-file %s",
420 else if (0 == bfd_get_section_name (objfile
->obfd
, lowest_sect
)
422 bfd_get_section_name (objfile
->obfd
, lowest_sect
)))
423 warning ("Lowest section in %s is %s at 0x%x",
425 bfd_section_name (objfile
->obfd
, lowest_sect
),
426 bfd_section_vma (objfile
->obfd
, lowest_sect
));
429 addr
-= bfd_section_vma (objfile
->obfd
, lowest_sect
);
432 /* Initialize symbol reading routines for this objfile, allow complaints to
433 appear for this new file, and record how verbose to be, then do the
434 initial symbol reading for this file. */
436 (*objfile
-> sf
-> sym_init
) (objfile
);
437 clear_complaints (1, verbo
);
439 /* If objfile->sf->sym_offsets doesn't set this, we don't care
441 objfile
->num_sections
= 0; /* krp-FIXME: why zero? */
442 section_offsets
= (*objfile
-> sf
-> sym_offsets
) (objfile
, addr
);
443 objfile
->section_offsets
= section_offsets
;
445 (*objfile
-> sf
-> sym_read
) (objfile
, section_offsets
, mainline
);
447 /* Don't allow char * to have a typename (else would get caddr_t.) */
448 /* Ditto void *. FIXME should do this for all the builtin types. */
450 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
451 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
453 /* Mark the objfile has having had initial symbol read attempted. Note
454 that this does not mean we found any symbols... */
456 objfile
-> flags
|= OBJF_SYMS
;
459 /* Perform required actions immediately after either reading in the initial
460 symbols for a new objfile, or mapping in the symbols from a reusable
464 new_symfile_objfile (objfile
, mainline
, verbo
)
465 struct objfile
*objfile
;
471 /* OK, make it the "real" symbol file. */
472 symfile_objfile
= objfile
;
475 /* If we have wiped out any old symbol tables, clean up. */
476 clear_symtab_users_once ();
478 /* We're done reading the symbol file; finish off complaints. */
479 clear_complaints (0, verbo
);
481 /* Fixup all the breakpoints that may have been redefined by this
484 breakpoint_re_set ();
487 /* Process a symbol file, as either the main file or as a dynamically
490 NAME is the file name (which will be tilde-expanded and made
491 absolute herein) (but we don't free or modify NAME itself).
492 FROM_TTY says how verbose to be. MAINLINE specifies whether this
493 is the main symbol file, or whether it's an extra symbol file such
494 as dynamically loaded code. If !mainline, ADDR is the address
495 where the text segment was loaded.
497 Upon success, returns a pointer to the objfile that was added.
498 Upon failure, jumps back to command level (never returns). */
501 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
)
509 struct objfile
*objfile
;
510 struct partial_symtab
*psymtab
;
513 /* Open a bfd for the file, and give user a chance to burp if we'd be
514 interactively wiping out any existing symbols. */
516 abfd
= symfile_bfd_open (name
);
518 if ((have_full_symbols () || have_partial_symbols ())
521 && !query ("Load new symbol table from \"%s\"? ", name
))
522 error ("Not confirmed.");
524 /* Getting new symbols may change our opinion about what is
527 reinit_frame_cache ();
529 objfile
= allocate_objfile (abfd
, mapped
);
531 /* If the objfile uses a mapped symbol file, and we have a psymtab for
532 it, then skip reading any symbols at this time. */
534 if ((objfile
-> flags
& OBJF_MAPPED
) && (objfile
-> flags
& OBJF_SYMS
))
536 /* We mapped in an existing symbol table file that already has had
537 initial symbol reading performed, so we can skip that part. Notify
538 the user that instead of reading the symbols, they have been mapped.
540 if (from_tty
|| info_verbose
)
542 printf_filtered ("Mapped symbols for %s...", name
);
546 init_entry_point_info (objfile
);
547 find_sym_fns (objfile
);
551 /* We either created a new mapped symbol table, mapped an existing
552 symbol table file which has not had initial symbol reading
553 performed, or need to read an unmapped symbol table. */
554 if (from_tty
|| info_verbose
)
556 printf_filtered ("Reading symbols from %s...", name
);
560 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
563 new_symfile_objfile (objfile
, mainline
, from_tty
);
565 /* We now have at least a partial symbol table. Check to see if the
566 user requested that all symbols be read on initial access via either
567 the gdb startup command line or on a per symbol file basis. Expand
568 all partial symbol tables for this objfile if so. */
570 if (readnow
|| readnow_symbol_files
)
572 if (from_tty
|| info_verbose
)
574 printf_filtered ("expanding to full symbols...");
579 for (psymtab
= objfile
-> psymtabs
;
581 psymtab
= psymtab
-> next
)
583 psymtab_to_symtab (psymtab
);
587 if (from_tty
|| info_verbose
)
589 printf_filtered ("done.\n");
596 /* This is the symbol-file command. Read the file, analyze its symbols,
597 and add a struct symtab to a symtab list. */
600 symbol_file_command (args
, from_tty
)
606 struct cleanup
*cleanups
;
614 if ((have_full_symbols () || have_partial_symbols ())
616 && !query ("Discard symbol table from `%s'? ",
617 symfile_objfile
-> name
))
618 error ("Not confirmed.");
619 free_all_objfiles ();
620 symfile_objfile
= NULL
;
621 current_source_symtab
= NULL
;
622 current_source_line
= 0;
625 printf ("No symbol file now.\n");
630 if ((argv
= buildargv (args
)) == NULL
)
634 cleanups
= make_cleanup (freeargv
, (char *) argv
);
635 while (*argv
!= NULL
)
637 if (STREQ (*argv
, "-mapped"))
641 else if (STREQ (*argv
, "-readnow"))
645 else if (**argv
== '-')
647 error ("unknown option `%s'", *argv
);
658 error ("no symbol file name was specified");
662 symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1, mapped
, readnow
);
663 set_initial_language ();
665 do_cleanups (cleanups
);
669 /* Set the initial language.
671 A better solution would be to record the language in the psymtab when reading
672 partial symbols, and then use it (if known) to set the language. This would
673 be a win for formats that encode the language in an easily discoverable place,
674 such as DWARF. For stabs, we can jump through hoops looking for specially
675 named symbols or try to intuit the language from the specific type of stabs
676 we find, but we can't do that until later when we read in full symbols.
680 set_initial_language ()
682 struct partial_symtab
*pst
;
683 enum language lang
= language_unknown
;
685 pst
= find_main_psymtab ();
688 if (pst
-> filename
!= NULL
)
690 lang
= deduce_language_from_filename (pst
-> filename
);
692 if (lang
== language_unknown
)
694 /* Make C the default language */
698 expected_language
= current_language
; /* Don't warn the user */
702 /* Open file specified by NAME and hand it off to BFD for preliminary
703 analysis. Result is a newly initialized bfd *, which includes a newly
704 malloc'd` copy of NAME (tilde-expanded and made absolute).
705 In case of trouble, error() is called. */
708 symfile_bfd_open (name
)
715 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
717 /* Look down path for it, allocate 2nd new malloc'd copy. */
718 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
721 make_cleanup (free
, name
);
722 perror_with_name (name
);
724 free (name
); /* Free 1st new malloc'd copy */
725 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
726 /* It'll be freed in free_objfile(). */
728 sym_bfd
= bfd_fdopenr (name
, NULL
, desc
);
732 make_cleanup (free
, name
);
733 error ("\"%s\": can't open to read symbols: %s.", name
,
734 bfd_errmsg (bfd_error
));
736 sym_bfd
->cacheable
= true;
738 if (!bfd_check_format (sym_bfd
, bfd_object
))
740 bfd_close (sym_bfd
); /* This also closes desc */
741 make_cleanup (free
, name
);
742 error ("\"%s\": can't read symbols: %s.", name
,
743 bfd_errmsg (bfd_error
));
749 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
750 startup by the _initialize routine in each object file format reader,
751 to register information about each format the the reader is prepared
758 sf
->next
= symtab_fns
;
763 /* Initialize to read symbols from the symbol file sym_bfd. It either
764 returns or calls error(). The result is an initialized struct sym_fns
765 in the objfile structure, that contains cached information about the
769 find_sym_fns (objfile
)
770 struct objfile
*objfile
;
774 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
-> next
)
776 if (strncmp (bfd_get_target (objfile
-> obfd
),
777 sf
-> sym_name
, sf
-> sym_namelen
) == 0)
783 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
784 bfd_get_target (objfile
-> obfd
));
787 /* This function runs the load command of our current target. */
790 load_command (arg
, from_tty
)
794 target_load (arg
, from_tty
);
797 /* This function allows the addition of incrementally linked object files.
798 It does not modify any state in the target, only in the debugger. */
802 add_symbol_file_command (args
, from_tty
)
816 error ("add-symbol-file takes a file name and an address");
819 /* Make a copy of the string that we can safely write into. */
821 args
= strdup (args
);
822 make_cleanup (free
, args
);
824 /* Pick off any -option args and the file name. */
826 while ((*args
!= '\000') && (name
== NULL
))
828 while (isspace (*args
)) {args
++;}
830 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
839 else if (STREQ (arg
, "-mapped"))
843 else if (STREQ (arg
, "-readnow"))
849 error ("unknown option `%s'", arg
);
853 /* After picking off any options and the file name, args should be
854 left pointing at the remainder of the command line, which should
855 be the address expression to evaluate. */
857 if ((name
== NULL
) || (*args
== '\000') )
859 error ("add-symbol-file takes a file name and an address");
861 name
= tilde_expand (name
);
862 make_cleanup (free
, name
);
864 text_addr
= parse_and_eval_address (args
);
866 if (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
867 name
, local_hex_string (text_addr
)))
868 error ("Not confirmed.");
870 symbol_file_add (name
, 0, text_addr
, 0, mapped
, readnow
);
873 /* Re-read symbols if a symbol-file has changed. */
877 struct objfile
*objfile
;
880 struct stat new_statbuf
;
883 /* With the addition of shared libraries, this should be modified,
884 the load time should be saved in the partial symbol tables, since
885 different tables may come from different source files. FIXME.
886 This routine should then walk down each partial symbol table
887 and see if the symbol table that it originates from has been changed */
890 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
892 #ifdef IBM6000_TARGET
893 /* If this object is from a shared library, then you should
894 stat on the library name, not member name. */
896 if (objfile
->obfd
->my_archive
)
897 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
900 res
= stat (objfile
->name
, &new_statbuf
);
902 /* FIXME, should use print_sys_errmsg but it's not filtered. */
903 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
907 new_modtime
= new_statbuf
.st_mtime
;
908 if (new_modtime
!= objfile
->mtime
) {
909 printf_filtered ("`%s' has changed; re-reading symbols.\n",
911 /* FIXME, this should use a different command...that would only
912 affect this objfile's symbols, and would reset objfile->mtime.
913 (objfile->mtime = new_modtime;)
914 HOWEVER, that command isn't written yet -- so call symbol_file_
915 command, and restart the scan from the top, because it munges
916 the object_files list. */
917 symbol_file_command (objfile
->name
, 0);
919 goto the_big_top
; /* Start over. */
925 breakpoint_re_set ();
930 deduce_language_from_filename (filename
)
937 else if (0 == (c
= strrchr (filename
, '.')))
939 else if(STREQ(c
,".mod"))
941 else if(STREQ(c
,".c"))
943 else if(STREQ(c
,".cc") || STREQ(c
,".C"))
944 return language_cplus
;
945 /* start-sanitize-chill */
946 else if(STREQ(c
,".ch") || STREQ(c
,".c186") || STREQ(c
,".c286"))
947 return language_chill
;
948 /* end-sanitize-chill */
950 return language_unknown
; /* default */
955 Allocate and partly initialize a new symbol table. Return a pointer
956 to it. error() if no space.
958 Caller must set these fields:
964 initialize any EXTRA_SYMTAB_INFO
965 possibly free_named_symtabs (symtab->filename);
969 allocate_symtab (filename
, objfile
)
971 struct objfile
*objfile
;
973 register struct symtab
*symtab
;
975 symtab
= (struct symtab
*)
976 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
977 memset (symtab
, 0, sizeof (*symtab
));
978 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
979 &objfile
-> symbol_obstack
);
980 symtab
-> fullname
= NULL
;
981 symtab
-> language
= deduce_language_from_filename (filename
);
983 /* Hook it to the objfile it comes from */
985 symtab
-> objfile
= objfile
;
986 symtab
-> next
= objfile
-> symtabs
;
987 objfile
-> symtabs
= symtab
;
989 #ifdef INIT_EXTRA_SYMTAB_INFO
990 INIT_EXTRA_SYMTAB_INFO (symtab
);
996 struct partial_symtab
*
997 allocate_psymtab (filename
, objfile
)
999 struct objfile
*objfile
;
1001 struct partial_symtab
*psymtab
;
1003 if (objfile
-> free_psymtabs
)
1005 psymtab
= objfile
-> free_psymtabs
;
1006 objfile
-> free_psymtabs
= psymtab
-> next
;
1009 psymtab
= (struct partial_symtab
*)
1010 obstack_alloc (&objfile
-> psymbol_obstack
,
1011 sizeof (struct partial_symtab
));
1013 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1014 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1015 &objfile
-> psymbol_obstack
);
1016 psymtab
-> symtab
= NULL
;
1018 /* Hook it to the objfile it comes from */
1020 psymtab
-> objfile
= objfile
;
1021 psymtab
-> next
= objfile
-> psymtabs
;
1022 objfile
-> psymtabs
= psymtab
;
1028 /* clear_symtab_users_once:
1030 This function is run after symbol reading, or from a cleanup.
1031 If an old symbol table was obsoleted, the old symbol table
1032 has been blown away, but the other GDB data structures that may
1033 reference it have not yet been cleared or re-directed. (The old
1034 symtab was zapped, and the cleanup queued, in free_named_symtab()
1037 This function can be queued N times as a cleanup, or called
1038 directly; it will do all the work the first time, and then will be a
1039 no-op until the next time it is queued. This works by bumping a
1040 counter at queueing time. Much later when the cleanup is run, or at
1041 the end of symbol processing (in case the cleanup is discarded), if
1042 the queued count is greater than the "done-count", we do the work
1043 and set the done-count to the queued count. If the queued count is
1044 less than or equal to the done-count, we just ignore the call. This
1045 is needed because reading a single .o file will often replace many
1046 symtabs (one per .h file, for example), and we don't want to reset
1047 the breakpoints N times in the user's face.
1049 The reason we both queue a cleanup, and call it directly after symbol
1050 reading, is because the cleanup protects us in case of errors, but is
1051 discarded if symbol reading is successful. */
1053 static int clear_symtab_users_queued
;
1054 static int clear_symtab_users_done
;
1057 clear_symtab_users_once ()
1059 /* Enforce once-per-`do_cleanups'-semantics */
1060 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1062 clear_symtab_users_done
= clear_symtab_users_queued
;
1064 printf ("Resetting debugger state after updating old symbol tables\n");
1066 /* Someday, we should do better than this, by only blowing away
1067 the things that really need to be blown. */
1068 clear_value_history ();
1070 clear_internalvars ();
1071 breakpoint_re_set ();
1072 set_default_breakpoint (0, 0, 0, 0);
1073 current_source_symtab
= 0;
1076 /* Delete the specified psymtab, and any others that reference it. */
1079 cashier_psymtab (pst
)
1080 struct partial_symtab
*pst
;
1082 struct partial_symtab
*ps
, *pprev
;
1085 /* Find its previous psymtab in the chain */
1086 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1093 /* Unhook it from the chain. */
1094 if (ps
== pst
->objfile
->psymtabs
)
1095 pst
->objfile
->psymtabs
= ps
->next
;
1097 pprev
->next
= ps
->next
;
1099 /* FIXME, we can't conveniently deallocate the entries in the
1100 partial_symbol lists (global_psymbols/static_psymbols) that
1101 this psymtab points to. These just take up space until all
1102 the psymtabs are reclaimed. Ditto the dependencies list and
1103 filename, which are all in the psymbol_obstack. */
1105 /* We need to cashier any psymtab that has this one as a dependency... */
1107 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1108 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1109 if (ps
->dependencies
[i
] == pst
) {
1110 cashier_psymtab (ps
);
1111 goto again
; /* Must restart, chain has been munged. */
1118 /* If a symtab or psymtab for filename NAME is found, free it along
1119 with any dependent breakpoints, displays, etc.
1120 Used when loading new versions of object modules with the "add-file"
1121 command. This is only called on the top-level symtab or psymtab's name;
1122 it is not called for subsidiary files such as .h files.
1124 Return value is 1 if we blew away the environment, 0 if not.
1125 FIXME. The return valu appears to never be used.
1127 FIXME. I think this is not the best way to do this. We should
1128 work on being gentler to the environment while still cleaning up
1129 all stray pointers into the freed symtab. */
1132 free_named_symtabs (name
)
1136 /* FIXME: With the new method of each objfile having it's own
1137 psymtab list, this function needs serious rethinking. In particular,
1138 why was it ever necessary to toss psymtabs with specific compilation
1139 unit filenames, as opposed to all psymtabs from a particular symbol
1141 Well, the answer is that some systems permit reloading of particular
1142 compilation units. We want to blow away any old info about these
1143 compilation units, regardless of which objfiles they arrived in. --gnu. */
1145 register struct symtab
*s
;
1146 register struct symtab
*prev
;
1147 register struct partial_symtab
*ps
;
1148 struct blockvector
*bv
;
1151 /* We only wack things if the symbol-reload switch is set. */
1152 if (!symbol_reloading
)
1155 /* Some symbol formats have trouble providing file names... */
1156 if (name
== 0 || *name
== '\0')
1159 /* Look for a psymtab with the specified name. */
1162 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1163 if (STREQ (name
, ps
->filename
)) {
1164 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1165 goto again2
; /* Must restart, chain has been munged */
1169 /* Look for a symtab with the specified name. */
1171 for (s
= symtab_list
; s
; s
= s
->next
)
1173 if (STREQ (name
, s
->filename
))
1180 if (s
== symtab_list
)
1181 symtab_list
= s
->next
;
1183 prev
->next
= s
->next
;
1185 /* For now, queue a delete for all breakpoints, displays, etc., whether
1186 or not they depend on the symtab being freed. This should be
1187 changed so that only those data structures affected are deleted. */
1189 /* But don't delete anything if the symtab is empty.
1190 This test is necessary due to a bug in "dbxread.c" that
1191 causes empty symtabs to be created for N_SO symbols that
1192 contain the pathname of the object file. (This problem
1193 has been fixed in GDB 3.9x). */
1195 bv
= BLOCKVECTOR (s
);
1196 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1197 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1198 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1200 complain (&oldsyms_complaint
, name
);
1202 clear_symtab_users_queued
++;
1203 make_cleanup (clear_symtab_users_once
, 0);
1206 complain (&empty_symtab_complaint
, name
);
1213 /* It is still possible that some breakpoints will be affected
1214 even though no symtab was found, since the file might have
1215 been compiled without debugging, and hence not be associated
1216 with a symtab. In order to handle this correctly, we would need
1217 to keep a list of text address ranges for undebuggable files.
1218 For now, we do nothing, since this is a fairly obscure case. */
1222 /* FIXME, what about the minimal symbol table? */
1229 /* Allocate and partially fill a partial symtab. It will be
1230 completely filled at the end of the symbol list.
1232 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1233 is the address relative to which its symbols are (incremental) or 0
1237 struct partial_symtab
*
1238 start_psymtab_common (objfile
, section_offsets
,
1239 filename
, textlow
, global_syms
, static_syms
)
1240 struct objfile
*objfile
;
1241 struct section_offsets
*section_offsets
;
1244 struct partial_symbol
*global_syms
;
1245 struct partial_symbol
*static_syms
;
1247 struct partial_symtab
*psymtab
;
1249 psymtab
= allocate_psymtab (filename
, objfile
);
1250 psymtab
-> section_offsets
= section_offsets
;
1251 psymtab
-> textlow
= textlow
;
1252 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
1253 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
1254 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
1258 /* Debugging versions of functions that are usually inline macros
1261 #if !INLINE_ADD_PSYMBOL
1263 /* Add a symbol with a long value to a psymtab.
1264 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
1267 add_psymbol_to_list (name
, namelength
, namespace, class, list
, val
, language
,
1271 enum namespace namespace;
1272 enum address_class
class;
1273 struct psymbol_allocation_list
*list
;
1275 enum language language
;
1276 struct objfile
*objfile
;
1278 register struct partial_symbol
*psym
;
1279 register char *demangled_name
;
1281 if (list
->next
>= list
->list
+ list
->size
)
1283 extend_psymbol_list (list
,objfile
);
1285 psym
= list
->next
++;
1287 SYMBOL_NAME (psym
) =
1288 (char *) obstack_alloc (&objfile
->psymbol_obstack
, namelength
+ 1);
1289 memcpy (SYMBOL_NAME (psym
), name
, namelength
);
1290 SYMBOL_NAME (psym
)[namelength
] = '\0';
1291 SYMBOL_VALUE (psym
) = val
;
1292 SYMBOL_LANGUAGE (psym
) = language
;
1293 PSYMBOL_NAMESPACE (psym
) = namespace;
1294 PSYMBOL_CLASS (psym
) = class;
1295 SYMBOL_INIT_DEMANGLED_NAME (psym
, &objfile
->psymbol_obstack
);
1298 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1301 add_psymbol_addr_to_list (name
, namelength
, namespace, class, list
, val
,
1305 enum namespace namespace;
1306 enum address_class
class;
1307 struct psymbol_allocation_list
*list
;
1309 enum language language
;
1310 struct objfile
*objfile
;
1312 register struct partial_symbol
*psym
;
1313 register char *demangled_name
;
1315 if (list
->next
>= list
->list
+ list
->size
)
1317 extend_psymbol_list (list
,objfile
);
1319 psym
= list
->next
++;
1321 SYMBOL_NAME (psym
) =
1322 (char *) obstack_alloc (&objfile
->psymbol_obstack
, namelength
+ 1);
1323 memcpy (SYMBOL_NAME (psym
), name
, namelength
);
1324 SYMBOL_NAME (psym
)[namelength
] = '\0';
1325 SYMBOL_VALUE_ADDRESS (psym
) = val
;
1326 SYMBOL_LANGUAGE (psym
) = language
;
1327 PSYMBOL_NAMESPACE (psym
) = namespace;
1328 PSYMBOL_CLASS (psym
) = class;
1329 SYMBOL_INIT_DEMANGLED_NAME (psym
, &objfile
->psymbol_obstack
);
1332 #endif /* !INLINE_ADD_PSYMBOL */
1334 /* Returns a section whose range includes PC or NULL if none found. */
1336 struct section_table
*
1340 struct section_table
*s
;
1342 s
= find_pc_section_from_targets(pc
);
1344 s
= find_pc_section_from_so_list(pc
);
1351 _initialize_symfile ()
1354 add_com ("symbol-file", class_files
, symbol_file_command
,
1355 "Load symbol table from executable file FILE.\n\
1356 The `file' command can also load symbol tables, as well as setting the file\n\
1359 add_com ("add-symbol-file", class_files
, add_symbol_file_command
,
1360 "Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
1361 The second argument provides the starting address of the file's text.");
1363 add_com ("load", class_files
, load_command
,
1364 "Dynamically load FILE into the running program, and record its symbols\n\
1365 for access from GDB.");
1368 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
1369 (char *)&symbol_reloading
,
1370 "Set dynamic symbol table reloading multiple times in one run.",