1 /* Generic symbol file reading for the GNU debugger, GDB.
2 Copyright 1990, 1991 Free Software Foundation, Inc.
3 Contributed by Cygnus Support, using pieces from other GDB modules.
5 This file is part of GDB.
7 GDB 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 1, or (at your option)
12 GDB 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 GDB; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
31 #include "breakpoint.h"
36 #include <sys/types.h>
41 extern int info_verbose
;
45 extern char *getenv ();
47 /* Functions this file defines */
48 static bfd
*symfile_open();
49 static struct sym_fns
*symfile_init();
50 static void clear_symtab_users_once();
52 /* List of all available sym_fns. */
54 struct sym_fns
*symtab_fns
= NULL
;
56 /* Saves the sym_fns of the current symbol table, so we can call
57 the right sym_discard function when we free it. */
59 static struct sym_fns
*symfile_fns
;
61 /* Allocate an obstack to hold objects that should be freed
62 when we load a new symbol table.
63 This includes the symbols made by dbxread
64 and the types that are not permanent. */
66 struct obstack obstack1
;
68 struct obstack
*symbol_obstack
= &obstack1
;
70 /* This obstack will be used for partial_symbol objects. It can
71 probably actually be the same as the symbol_obstack above, but I'd
72 like to keep them seperate for now. If I want to later, I'll
73 replace one with the other. */
75 struct obstack obstack2
;
77 struct obstack
*psymbol_obstack
= &obstack2
;
79 /* File name symbols were loaded from. */
83 /* The modification date of the file when they were loaded. */
85 long /* really time_t */ symfile_mtime
= 0;
87 /* Structures with which to manage partial symbol allocation. */
89 struct psymbol_allocation_list global_psymbols
= {0}, static_psymbols
= {0};
91 /* Structure to manage complaints about symbol file contents. */
93 struct complaint complaint_root
[1] = {
94 {(char *)0, 0, complaint_root
},
97 /* Some actual complaints. */
99 struct complaint oldsyms_complaint
= {
100 "Replacing old symbols for `%s'", 0, 0 };
102 struct complaint empty_symtab_complaint
= {
103 "Empty symbol table found for `%s'", 0, 0 };
106 /* In the following sort, we always make sure that
107 register debug symbol declarations always come before regular
108 debug symbol declarations (as might happen when parameters are
109 then put into registers by the compiler). */
112 compare_symbols (s1
, s2
)
113 struct symbol
**s1
, **s2
;
115 register int namediff
;
117 /* Compare the initial characters. */
118 namediff
= SYMBOL_NAME (*s1
)[0] - SYMBOL_NAME (*s2
)[0];
119 if (namediff
!= 0) return namediff
;
121 /* If they match, compare the rest of the names. */
122 namediff
= strcmp (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
));
123 if (namediff
!= 0) return namediff
;
125 /* For symbols of the same name, registers should come first. */
126 return ((SYMBOL_CLASS (*s2
) == LOC_REGISTER
)
127 - (SYMBOL_CLASS (*s1
) == LOC_REGISTER
));
130 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
134 register struct block
*b
;
136 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
137 sizeof (struct symbol
*), compare_symbols
);
140 /* Call sort_symtab_syms to sort alphabetically
141 the symbols of each block of one symtab. */
145 register struct symtab
*s
;
147 register struct blockvector
*bv
= BLOCKVECTOR (s
);
148 int nbl
= BLOCKVECTOR_NBLOCKS (bv
);
150 register struct block
*b
;
152 for (i
= 0; i
< nbl
; i
++)
154 b
= BLOCKVECTOR_BLOCK (bv
, i
);
155 if (BLOCK_SHOULD_SORT (b
))
161 sort_all_symtab_syms ()
163 register struct symtab
*s
;
165 for (s
= symtab_list
; s
; s
= s
->next
)
167 sort_symtab_syms (s
);
171 /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
172 (and add a null character at the end in the copy).
173 Returns the address of the copy. */
176 obsavestring (ptr
, size
)
180 register char *p
= (char *) obstack_alloc (symbol_obstack
, size
+ 1);
181 /* Open-coded bcopy--saves function call time.
182 These strings are usually short. */
184 register char *p1
= ptr
;
185 register char *p2
= p
;
186 char *end
= ptr
+ size
;
194 /* Concatenate strings S1, S2 and S3; return the new string.
195 Space is found in the symbol_obstack. */
198 obconcat (s1
, s2
, s3
)
201 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
202 register char *val
= (char *) obstack_alloc (symbol_obstack
, len
);
209 /* Accumulate the misc functions in bunches of 127.
210 At the end, copy them all into one newly allocated structure. */
212 #define MISC_BUNCH_SIZE 127
216 struct misc_bunch
*next
;
217 struct misc_function contents
[MISC_BUNCH_SIZE
];
220 /* Bunch currently being filled up.
221 The next field points to chain of filled bunches. */
223 static struct misc_bunch
*misc_bunch
;
225 /* Number of slots filled in current bunch. */
227 static int misc_bunch_index
;
229 /* Total number of misc functions recorded so far. */
231 static int misc_count
;
238 misc_bunch_index
= MISC_BUNCH_SIZE
;
242 prim_record_misc_function (name
, address
, misc_type
)
245 enum misc_function_type misc_type
;
247 register struct misc_bunch
*new;
249 if (misc_bunch_index
== MISC_BUNCH_SIZE
)
251 new = (struct misc_bunch
*) xmalloc (sizeof (struct misc_bunch
));
252 misc_bunch_index
= 0;
253 new->next
= misc_bunch
;
256 misc_bunch
->contents
[misc_bunch_index
].name
= name
;
257 misc_bunch
->contents
[misc_bunch_index
].address
= address
;
258 misc_bunch
->contents
[misc_bunch_index
].type
= misc_type
;
259 misc_bunch
->contents
[misc_bunch_index
].misc_info
= 0;
265 compare_misc_functions (fn1
, fn2
)
266 struct misc_function
*fn1
, *fn2
;
268 /* Return a signed result based on unsigned comparisons
269 so that we sort into unsigned numeric order. */
270 if (fn1
->address
< fn2
->address
)
272 if (fn1
->address
> fn2
->address
)
279 discard_misc_bunches (foo
)
282 register struct misc_bunch
*next
;
286 next
= misc_bunch
->next
;
292 /* INCLINK nonzero means bunches are from an incrementally-linked file.
293 Add them to the existing bunches.
294 Otherwise INCLINK is zero, and we start from scratch. */
296 condense_misc_bunches (inclink
)
300 register struct misc_bunch
*bunch
;
305 = (struct misc_function
*)
306 xrealloc (misc_function_vector
, (misc_count
+ misc_function_count
)
307 * sizeof (struct misc_function
));
308 j
= misc_function_count
;
313 = (struct misc_function
*)
314 xmalloc (misc_count
* sizeof (struct misc_function
));
321 for (i
= 0; i
< misc_bunch_index
; i
++, j
++)
323 misc_function_vector
[j
] = bunch
->contents
[i
];
324 #ifdef NAMES_HAVE_UNDERSCORE
325 if (misc_function_vector
[j
].name
[0] == '_')
326 misc_function_vector
[j
].name
++;
330 misc_bunch_index
= MISC_BUNCH_SIZE
;
333 if (misc_function_count
+ misc_count
!= j
) /* DEBUG */
334 printf_filtered ("Function counts are off! %d + %d != %d\n",
335 misc_function_count
, misc_count
, j
);
337 misc_function_count
= j
;
339 /* Sort the misc functions by address. */
341 qsort (misc_function_vector
, misc_function_count
,
342 sizeof (struct misc_function
),
343 compare_misc_functions
);
347 /* Get the symbol table that corresponds to a partial_symtab.
348 This is fast after the first time you do it. In fact, there
349 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
353 psymtab_to_symtab (pst
)
354 register struct partial_symtab
*pst
;
356 register struct symtab
*result
;
358 /* If it's been looked up before, return it. */
362 /* If it has not yet been read in, read it. */
365 (*pst
->read_symtab
) (pst
);
368 /* Search through list for correct name. */
369 for (result
= symtab_list
; result
; result
= result
->next
)
370 if (!strcmp (result
->filename
, pst
->filename
))
372 pst
->symtab
= result
; /* Remember where it was. */
379 /* Process a symbol file, as either the main file or as a dynamically
382 NAME is the file name (which will be tilde-expanded and made
383 absolute herein) (but we don't free or modify NAME itself).
384 FROM_TTY says how verbose to be. MAINLINE specifies whether this
385 is the main symbol file, or whether it's an extra symbol file such
386 as dynamically loaded code. If !mainline, ADDR is the address
387 where the text segment was loaded. */
390 symbol_file_add (name
, from_tty
, addr
, mainline
)
401 sym_bfd
= symfile_open (name
);
403 entry_point
= bfd_get_start_address (sym_bfd
);
406 symfile_mtime
= bfd_get_mtime (sym_bfd
);
408 /* There is a distinction between having no symbol table
409 (we refuse to read the file, leaving the old set of symbols around)
410 and having no debugging symbols in your symbol table (we read
411 the file and end up with a mostly empty symbol table). */
413 if (!(bfd_get_file_flags (sym_bfd
) & HAS_SYMS
))
415 error ("%s has no symbol-table", name
);
418 if ((symtab_list
|| partial_symtab_list
)
421 && !query ("Load new symbol table from \"%s\"? ", name
))
422 error ("Not confirmed.");
426 printf_filtered ("Reading symbol data from %s...", name
);
431 sf
= symfile_init (sym_bfd
);
432 realname
= bfd_get_filename (sym_bfd
);
433 realname
= savestring (realname
, strlen (realname
));
434 /* FIXME, this probably creates a storage leak... */
438 /* Since no error yet, throw away the old symbol table. */
444 free_all_psymtabs ();
446 (*sf
->sym_new_init
) ();
448 /* For mainline, caller didn't know the specified address of the
449 text section. We fix that here. */
450 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
451 addr
= bfd_section_vma (sym_bfd
, text_sect
);
454 clear_complaints(); /* Allow complaints to appear for this new file. */
456 (*sf
->sym_read
) (sf
, addr
, mainline
);
458 /* Don't allow char * to have a typename (else would get caddr_t.) */
459 /* Ditto void *. FIXME should do this for all the builtin types. */
461 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
462 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
466 /* OK, make it the "real" symbol file. */
471 /* If we have wiped out any old symbol tables, clean up. */
472 clear_symtab_users_once ();
476 printf_filtered ("done.\n");
481 /* This is the symbol-file command. Read the file, analyze its symbols,
482 and add a struct symtab to symtab_list. */
485 symbol_file_command (name
, from_tty
)
494 if ((symtab_list
|| partial_symtab_list
)
496 && !query ("Discard symbol table from `%s'? ", symfile
))
497 error ("Not confirmed.");
502 free_all_psymtabs ();
503 /* FIXME, this does not account for the main file and subsequent
504 files (shared libs, dynloads, etc) having different formats.
505 It only calls the cleanup routine for the main file's format. */
507 (*symfile_fns
->sym_new_init
) ();
514 /* Getting new symbols may change our opinion about what is
516 reinit_frame_cache ();
518 symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1);
521 /* Open NAME and hand it off to BFD for preliminary analysis. Result
522 is a BFD *, which includes a new copy of NAME dynamically allocated
523 (which will be freed by the cleanup chain). In case of trouble,
524 error() is called. */
534 name
= tilde_expand (name
);
535 make_cleanup (free
, name
);
537 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
, 0, &absolute_name
);
539 perror_with_name (name
);
542 make_cleanup (free
, absolute_name
);
543 name
= absolute_name
;
546 sym_bfd
= bfd_fdopenr (name
, NULL
, desc
);
550 error ("Could not open `%s' to read symbols: %s",
551 name
, bfd_errmsg (bfd_error
));
553 make_cleanup (bfd_close
, sym_bfd
);
555 if (!bfd_check_format (sym_bfd
, bfd_object
))
556 error ("\"%s\": can't read symbols: %s.",
557 name
, bfd_errmsg (bfd_error
));
562 /* Link a new symtab_fns into the global symtab_fns list.
563 Called by various _initialize routines. */
569 sf
->next
= symtab_fns
;
574 /* Initialize to read symbols from the symbol file sym_bfd. It either
575 returns or calls error(). The result is a malloc'd struct sym_fns
576 that contains cached information about the symbol file. */
578 static struct sym_fns
*
579 symfile_init (sym_bfd
)
582 struct sym_fns
*sf
, *sf2
;
584 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
586 if (!strncmp (bfd_get_target (sym_bfd
), sf
->sym_name
, sf
->sym_namelen
))
588 sf2
= (struct sym_fns
*)xmalloc (sizeof (*sf2
));
589 /* FIXME, who frees this? */
591 sf2
->sym_bfd
= sym_bfd
;
592 sf2
->sym_private
= 0; /* Not alloc'd yet */
593 (*sf2
->sym_init
) (sf2
);
597 error ("I'm sorry, Dave, I can't do that. Symbol format unknown.");
598 return 0; /* Appease lint. */
601 /* This function runs the load command of our current target. */
604 load_command (arg
, from_tty
)
608 target_load (arg
, from_tty
);
611 /* This function runs the add_syms command of our current target. */
614 add_symbol_file_command (args
, from_tty
)
618 /* Getting new symbols may change our opinion about what is
620 reinit_frame_cache ();
622 target_add_syms (args
, from_tty
);
625 /* This function allows the addition of incrementally linked object files. */
629 add_syms_addr_command (arg_string
, from_tty
)
637 error ("add-symbol-file takes a file name and an address");
639 arg_string
= tilde_expand (arg_string
);
640 make_cleanup (free
, arg_string
);
642 for( ; *arg_string
== ' '; arg_string
++ );
644 for( ; *arg_string
&& *arg_string
!= ' ' ; arg_string
++ );
645 *arg_string
++ = (char) 0;
648 error ("add-symbol-file takes a file name and an address");
650 text_addr
= parse_and_eval_address (arg_string
);
654 if (!query ("add symbol table from file \"%s\" at text_addr = 0x%x\n",
656 error ("Not confirmed.");
658 symbol_file_add (name
, 0, text_addr
, 0);
661 /* Re-read symbols if the symbol-file has changed. */
667 /* With the addition of shared libraries, this should be modified,
668 the load time should be saved in the partial symbol tables, since
669 different tables may come from different source files. FIXME.
670 This routine should then walk down each partial symbol table
671 and see if the symbol table that it originates from has been changed
674 if (stat (symfile
, &symstat
) < 0)
675 /* Can't read symbol-file. Assume it is up to date. */
678 if (symstat
.st_mtime
> symfile_mtime
)
680 printf_filtered ("Symbol file has changed; re-reading symbols.\n");
681 symbol_file_command (symfile
, 0);
682 breakpoint_re_set ();
686 /* This function is really horrible, but to avoid it, there would need
687 to be more filling in of forward references. */
689 fill_in_vptr_fieldno (type
)
692 if (TYPE_VPTR_FIELDNO (type
) < 0)
695 for (i
= 1; i
< TYPE_N_BASECLASSES (type
); i
++)
697 fill_in_vptr_fieldno (TYPE_BASECLASS (type
, i
));
698 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
)) >= 0)
700 TYPE_VPTR_FIELDNO (type
)
701 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, i
));
702 TYPE_VPTR_BASETYPE (type
)
703 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type
, i
));
710 /* Functions to handle complaints during symbol reading. */
712 /* How many complaints about a particular thing should be printed before
713 we stop whining about it? */
715 static unsigned stop_whining
= 1;
717 /* Print a complaint about the input symbols, and link the complaint block
718 into a chain for later handling. Result is 1 if the complaint was
719 printed, 0 if it was suppressed. */
722 complain (complaint
, val
)
723 struct complaint
*complaint
;
726 complaint
->counter
++;
727 if (complaint
->next
== 0) {
728 complaint
->next
= complaint_root
->next
;
729 complaint_root
->next
= complaint
;
731 if (complaint
->counter
> stop_whining
)
735 puts_filtered ("During symbol reading...");
737 printf_filtered (complaint
->message
, val
);
738 puts_filtered ("...");
741 puts_filtered ("\n");
745 /* Clear out all complaint counters that have ever been incremented. */
752 for (p
= complaint_root
->next
; p
!= complaint_root
; p
= p
->next
)
756 /* clear_symtab_users_once:
758 This function is run after symbol reading, or from a cleanup.
759 If an old symbol table was obsoleted, the old symbol table
760 has been blown away, but the other GDB data structures that may
761 reference it have not yet been cleared or re-directed. (The old
762 symtab was zapped, and the cleanup queued, in free_named_symtab()
765 This function can be queued N times as a cleanup, or called
766 directly; it will do all the work the first time, and then will be a
767 no-op until the next time it is queued. This works by bumping a
768 counter at queueing time. Much later when the cleanup is run, or at
769 the end of symbol processing (in case the cleanup is discarded), if
770 the queued count is greater than the "done-count", we do the work
771 and set the done-count to the queued count. If the queued count is
772 less than or equal to the done-count, we just ignore the call. This
773 is needed because reading a single .o file will often replace many
774 symtabs (one per .h file, for example), and we don't want to reset
775 the breakpoints N times in the user's face.
777 The reason we both queue a cleanup, and call it directly after symbol
778 reading, is because the cleanup protects us in case of errors, but is
779 discarded if symbol reading is successful. */
781 static int clear_symtab_users_queued
;
782 static int clear_symtab_users_done
;
785 clear_symtab_users_once ()
787 /* Enforce once-per-`do_cleanups'-semantics */
788 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
790 clear_symtab_users_done
= clear_symtab_users_queued
;
792 printf ("Resetting debugger state after updating old symbol tables\n");
794 /* Someday, we should do better than this, by only blowing away
795 the things that really need to be blown. */
796 clear_value_history ();
798 clear_internalvars ();
799 breakpoint_re_set ();
800 set_default_breakpoint (0, 0, 0, 0);
801 current_source_symtab
= 0;
804 /* Delete the specified psymtab, and any others that reference it. */
807 cashier_psymtab (pst
)
808 struct partial_symtab
*pst
;
810 struct partial_symtab
*ps
, *pprev
;
813 /* Find its previous psymtab in the chain */
814 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
821 /* Unhook it from the chain. */
822 if (ps
== partial_symtab_list
)
823 partial_symtab_list
= ps
->next
;
825 pprev
->next
= ps
->next
;
827 /* FIXME, we can't conveniently deallocate the entries in the
828 partial_symbol lists (global_psymbols/static_psymbols) that
829 this psymtab points to. These just take up space until all
830 the psymtabs are reclaimed. Ditto the dependencies list and
831 filename, which are all in the psymbol_obstack. */
833 /* We need to cashier any psymtab that has this one as a dependency... */
835 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
836 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
837 if (ps
->dependencies
[i
] == pst
) {
838 cashier_psymtab (ps
);
839 goto again
; /* Must restart, chain has been munged. */
846 /* If a symtab or psymtab for filename NAME is found, free it along
847 with any dependent breakpoints, displays, etc.
848 Used when loading new versions of object modules with the "add-file"
849 command. This is only called on the top-level symtab or psymtab's name;
850 it is not called for subsidiary files such as .h files.
852 Return value is 1 if we blew away the environment, 0 if not.
854 FIXME. I think this is not the best way to do this. We should
855 work on being gentler to the environment while still cleaning up
856 all stray pointers into the freed symtab. */
859 free_named_symtabs (name
)
862 register struct symtab
*s
;
863 register struct symtab
*prev
;
864 register struct partial_symtab
*ps
;
865 struct blockvector
*bv
;
868 /* Look for a psymtab with the specified name. */
871 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
872 if (!strcmp (name
, ps
->filename
)) {
873 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
874 goto again2
; /* Must restart, chain has been munged */
878 /* Look for a symtab with the specified name. */
880 for (s
= symtab_list
; s
; s
= s
->next
)
882 if (!strcmp (name
, s
->filename
))
889 if (s
== symtab_list
)
890 symtab_list
= s
->next
;
892 prev
->next
= s
->next
;
894 /* For now, queue a delete for all breakpoints, displays, etc., whether
895 or not they depend on the symtab being freed. This should be
896 changed so that only those data structures affected are deleted. */
898 /* But don't delete anything if the symtab is empty.
899 This test is necessary due to a bug in "dbxread.c" that
900 causes empty symtabs to be created for N_SO symbols that
901 contain the pathname of the object file. (This problem
902 has been fixed in GDB 3.9x). */
905 if (BLOCKLIST_NBLOCKS (bv
) > 2
906 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
907 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
909 complain (&oldsyms_complaint
, name
);
911 clear_symtab_users_queued
++;
912 make_cleanup (clear_symtab_users_once
, 0);
915 complain (&empty_symtab_complaint
, name
);
921 /* It is still possible that some breakpoints will be affected
922 even though no symtab was found, since the file might have
923 been compiled without debugging, and hence not be associated
924 with a symtab. In order to handle this correctly, we would need
925 to keep a list of text address ranges for undebuggable files.
926 For now, we do nothing, since this is a fairly obscure case. */
929 /* FIXME, what about the misc function vector? */
934 _initialize_symfile ()
937 add_com ("symbol-file", class_files
, symbol_file_command
,
938 "Load symbol table from executable file FILE.\n\
939 The `file' command can also load symbol tables, as well as setting the file\n\
942 add_com ("add-symbol-file", class_files
, add_symbol_file_command
,
943 "Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
944 The second argument provides the starting address of the file's text.");
946 add_com ("load", class_files
, load_command
,
947 "Dynamically load FILE into the running program, and record its symbols\n\
948 for access from GDB.");
951 (add_set_cmd ("complaints", class_support
, var_uinteger
,
952 (char *)&stop_whining
,
953 "Set max number of complaints about incorrect symbols.",
957 obstack_init (symbol_obstack
);
958 obstack_init (psymbol_obstack
);