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"
35 #include "inferior.h" /* for write_pc */
40 #include <sys/types.h>
50 /* 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
*));
91 /* List of all available sym_fns. On gdb startup, each object file reader
92 calls add_symtab_fns() to register information on each format it is
95 static struct sym_fns
*symtab_fns
= NULL
;
97 /* Structures with which to manage partial symbol allocation. */
99 struct psymbol_allocation_list global_psymbols
= {0}, static_psymbols
= {0};
101 /* Flag for whether user will be reloading symbols multiple times.
102 Defaults to ON for VxWorks, otherwise OFF. */
104 #ifdef SYMBOL_RELOADING_DEFAULT
105 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
107 int symbol_reloading
= 0;
111 /* Since this function is called from within qsort, in an ANSI environment
112 it must conform to the prototype for qsort, which specifies that the
113 comparison function takes two "void *" pointers. */
116 compare_symbols (s1p
, s2p
)
120 register struct symbol
**s1
, **s2
;
122 s1
= (struct symbol
**) s1p
;
123 s2
= (struct symbol
**) s2p
;
125 return (STRCMP (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
)));
132 compare_psymbols -- compare two partial symbols by name
136 Given pointer to two partial symbol table entries, compare
137 them by name and return -N, 0, or +N (ala strcmp). Typically
138 used by sorting routines like qsort().
142 Does direct compare of first two characters before punting
143 and passing to strcmp for longer compares. Note that the
144 original version had a bug whereby two null strings or two
145 identically named one character strings would return the
146 comparison of memory following the null byte.
151 compare_psymbols (s1p
, s2p
)
155 register char *st1
= SYMBOL_NAME ((struct partial_symbol
*) s1p
);
156 register char *st2
= SYMBOL_NAME ((struct partial_symbol
*) s2p
);
158 if ((st1
[0] - st2
[0]) || !st1
[0])
160 return (st1
[0] - st2
[0]);
162 else if ((st1
[1] - st2
[1]) || !st1
[1])
164 return (st1
[1] - st2
[1]);
168 return (STRCMP (st1
+ 2, st2
+ 2));
173 sort_pst_symbols (pst
)
174 struct partial_symtab
*pst
;
176 /* Sort the global list; don't sort the static list */
178 qsort (pst
-> objfile
-> global_psymbols
.list
+ pst
-> globals_offset
,
179 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
183 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
187 register struct block
*b
;
189 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
190 sizeof (struct symbol
*), compare_symbols
);
193 /* Call sort_symtab_syms to sort alphabetically
194 the symbols of each block of one symtab. */
198 register struct symtab
*s
;
200 register struct blockvector
*bv
;
203 register struct block
*b
;
207 bv
= BLOCKVECTOR (s
);
208 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
209 for (i
= 0; i
< nbl
; i
++)
211 b
= BLOCKVECTOR_BLOCK (bv
, i
);
212 if (BLOCK_SHOULD_SORT (b
))
217 /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
218 (and add a null character at the end in the copy).
219 Returns the address of the copy. */
222 obsavestring (ptr
, size
, obstackp
)
225 struct obstack
*obstackp
;
227 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
228 /* Open-coded memcpy--saves function call time.
229 These strings are usually short. */
231 register char *p1
= ptr
;
232 register char *p2
= p
;
233 char *end
= ptr
+ size
;
241 /* Concatenate strings S1, S2 and S3; return the new string.
242 Space is found in the symbol_obstack. */
245 obconcat (obstackp
, s1
, s2
, s3
)
246 struct obstack
*obstackp
;
247 const char *s1
, *s2
, *s3
;
249 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
250 register char *val
= (char *) obstack_alloc (obstackp
, len
);
257 /* Get the symbol table that corresponds to a partial_symtab.
258 This is fast after the first time you do it. In fact, there
259 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
263 psymtab_to_symtab (pst
)
264 register struct partial_symtab
*pst
;
266 /* If it's been looked up before, return it. */
270 /* If it has not yet been read in, read it. */
273 (*pst
->read_symtab
) (pst
);
279 /* Initialize entry point information for this objfile. */
282 init_entry_point_info (objfile
)
283 struct objfile
*objfile
;
285 /* Save startup file's range of PC addresses to help blockframe.c
286 decide where the bottom of the stack is. */
288 if (bfd_get_file_flags (objfile
-> obfd
) & EXEC_P
)
290 /* Executable file -- record its entry point so we'll recognize
291 the startup file because it contains the entry point. */
292 objfile
-> ei
.entry_point
= bfd_get_start_address (objfile
-> obfd
);
296 /* Examination of non-executable.o files. Short-circuit this stuff. */
297 /* ~0 will not be in any file, we hope. */
298 objfile
-> ei
.entry_point
= ~0;
299 /* set the startup file to be an empty range. */
300 objfile
-> ei
.entry_file_lowpc
= 0;
301 objfile
-> ei
.entry_file_highpc
= 0;
305 /* Get current entry point address. */
308 entry_point_address()
310 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
313 /* Remember the lowest-addressed loadable section we've seen.
314 This function is called via bfd_map_over_sections. */
316 #if 0 /* Not used yet */
318 find_lowest_section (abfd
, sect
, obj
)
323 asection
**lowest
= (asection
**)obj
;
325 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
328 *lowest
= sect
; /* First loadable section */
329 else if (bfd_section_vma (abfd
, *lowest
) >= bfd_section_vma (abfd
, sect
))
330 *lowest
= sect
; /* A lower loadable section */
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
;
353 struct section_offsets
*section_offsets
;
354 asection
*lowest_sect
;
355 struct cleanup
*old_chain
;
357 init_entry_point_info (objfile
);
358 find_sym_fns (objfile
);
360 /* Make sure that partially constructed symbol tables will be cleaned up
361 if an error occurs during symbol reading. */
362 old_chain
= make_cleanup (free_objfile
, objfile
);
366 /* We will modify the main symbol table, make sure that all its users
367 will be cleaned up if an error occurs during symbol reading. */
368 make_cleanup (clear_symtab_users
, 0);
370 /* Since no error yet, throw away the old symbol table. */
372 if (symfile_objfile
!= NULL
)
374 free_objfile (symfile_objfile
);
375 symfile_objfile
= NULL
;
378 /* Currently we keep symbols from the add-symbol-file command.
379 If the user wants to get rid of them, they should do "symbol-file"
380 without arguments first. Not sure this is the best behavior
383 (*objfile
-> sf
-> sym_new_init
) (objfile
);
386 /* Convert addr into an offset rather than an absolute address.
387 We find the lowest address of a loaded segment in the objfile,
388 and assume that <addr> is where that got loaded. Due to historical
389 precedent, we warn if that doesn't happen to be the ".text"
394 addr
= 0; /* No offset from objfile addresses. */
398 lowest_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
401 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
405 if (lowest_sect
== 0)
406 warning ("no loadable sections found in added symbol-file %s",
408 else if (0 == bfd_get_section_name (objfile
->obfd
, lowest_sect
)
410 bfd_get_section_name (objfile
->obfd
, lowest_sect
)))
411 /* FIXME-32x64--assumes bfd_vma fits in long. */
412 warning ("Lowest section in %s is %s at 0x%lx",
414 bfd_section_name (objfile
->obfd
, lowest_sect
),
415 (unsigned long) bfd_section_vma (objfile
->obfd
, lowest_sect
));
418 addr
-= bfd_section_vma (objfile
->obfd
, lowest_sect
);
421 /* Initialize symbol reading routines for this objfile, allow complaints to
422 appear for this new file, and record how verbose to be, then do the
423 initial symbol reading for this file. */
425 (*objfile
-> sf
-> sym_init
) (objfile
);
426 clear_complaints (1, verbo
);
428 section_offsets
= (*objfile
-> sf
-> sym_offsets
) (objfile
, addr
);
429 objfile
->section_offsets
= section_offsets
;
431 #ifndef IBM6000_TARGET
432 /* This is a SVR4/SunOS specific hack, I think. In any event, it
433 screws RS/6000. sym_offsets should be doing this sort of thing,
434 because it knows the mapping between bfd sections and
436 /* This is a hack. As far as I can tell, section offsets are not
437 target dependent. They are all set to addr with a couple of
438 exceptions. The exceptions are sysvr4 shared libraries, whose
439 offsets are kept in solib structures anyway and rs6000 xcoff
440 which handles shared libraries in a completely unique way.
442 Section offsets are built similarly, except that they are built
443 by adding addr in all cases because there is no clear mapping
444 from section_offsets into actual sections. Note that solib.c
445 has a different algorythm for finding section offsets.
447 These should probably all be collapsed into some target
448 independent form of shared library support. FIXME. */
452 struct obj_section
*s
;
454 for (s
= objfile
->sections
; s
< objfile
->sections_end
; ++s
)
456 s
->addr
-= s
->offset
;
458 s
->endaddr
-= s
->offset
;
463 #endif /* not IBM6000_TARGET */
465 (*objfile
-> sf
-> sym_read
) (objfile
, section_offsets
, mainline
);
467 /* Don't allow char * to have a typename (else would get caddr_t).
468 Ditto void *. FIXME: Check whether this is now done by all the
469 symbol readers themselves (many of them now do), and if so remove
472 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
473 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
475 /* Mark the objfile has having had initial symbol read attempted. Note
476 that this does not mean we found any symbols... */
478 objfile
-> flags
|= OBJF_SYMS
;
480 /* Discard cleanups as symbol reading was successful. */
482 discard_cleanups (old_chain
);
485 /* Perform required actions after either reading in the initial
486 symbols for a new objfile, or mapping in the symbols from a reusable
490 new_symfile_objfile (objfile
, mainline
, verbo
)
491 struct objfile
*objfile
;
496 /* If this is the main symbol file we have to clean up all users of the
497 old main symbol file. Otherwise it is sufficient to fixup all the
498 breakpoints that may have been redefined by this symbol file. */
501 /* OK, make it the "real" symbol file. */
502 symfile_objfile
= objfile
;
504 clear_symtab_users ();
508 breakpoint_re_set ();
511 /* We're done reading the symbol file; finish off complaints. */
512 clear_complaints (0, verbo
);
515 /* Process a symbol file, as either the main file or as a dynamically
518 NAME is the file name (which will be tilde-expanded and made
519 absolute herein) (but we don't free or modify NAME itself).
520 FROM_TTY says how verbose to be. MAINLINE specifies whether this
521 is the main symbol file, or whether it's an extra symbol file such
522 as dynamically loaded code. If !mainline, ADDR is the address
523 where the text segment was loaded.
525 Upon success, returns a pointer to the objfile that was added.
526 Upon failure, jumps back to command level (never returns). */
529 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
)
537 struct objfile
*objfile
;
538 struct partial_symtab
*psymtab
;
541 /* Open a bfd for the file, and give user a chance to burp if we'd be
542 interactively wiping out any existing symbols. */
544 abfd
= symfile_bfd_open (name
);
546 if ((have_full_symbols () || have_partial_symbols ())
549 && !query ("Load new symbol table from \"%s\"? ", name
))
550 error ("Not confirmed.");
552 objfile
= allocate_objfile (abfd
, mapped
);
554 /* If the objfile uses a mapped symbol file, and we have a psymtab for
555 it, then skip reading any symbols at this time. */
557 if ((objfile
-> flags
& OBJF_MAPPED
) && (objfile
-> flags
& OBJF_SYMS
))
559 /* We mapped in an existing symbol table file that already has had
560 initial symbol reading performed, so we can skip that part. Notify
561 the user that instead of reading the symbols, they have been mapped.
563 if (from_tty
|| info_verbose
)
565 printf_filtered ("Mapped symbols for %s...", name
);
567 gdb_flush (gdb_stdout
);
569 init_entry_point_info (objfile
);
570 find_sym_fns (objfile
);
574 /* We either created a new mapped symbol table, mapped an existing
575 symbol table file which has not had initial symbol reading
576 performed, or need to read an unmapped symbol table. */
577 if (from_tty
|| info_verbose
)
579 printf_filtered ("Reading symbols from %s...", name
);
581 gdb_flush (gdb_stdout
);
583 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
586 /* We now have at least a partial symbol table. Check to see if the
587 user requested that all symbols be read on initial access via either
588 the gdb startup command line or on a per symbol file basis. Expand
589 all partial symbol tables for this objfile if so. */
591 if (readnow
|| readnow_symbol_files
)
593 if (from_tty
|| info_verbose
)
595 printf_filtered ("expanding to full symbols...");
597 gdb_flush (gdb_stdout
);
600 for (psymtab
= objfile
-> psymtabs
;
602 psymtab
= psymtab
-> next
)
604 psymtab_to_symtab (psymtab
);
608 if (from_tty
|| info_verbose
)
610 printf_filtered ("done.\n");
611 gdb_flush (gdb_stdout
);
614 new_symfile_objfile (objfile
, mainline
, from_tty
);
616 /* Getting new symbols may change our opinion about what is
619 reinit_frame_cache ();
624 /* This is the symbol-file command. Read the file, analyze its symbols,
625 and add a struct symtab to a symtab list. */
628 symbol_file_command (args
, from_tty
)
634 CORE_ADDR text_relocation
= 0; /* text_relocation */
635 struct cleanup
*cleanups
;
643 if ((have_full_symbols () || have_partial_symbols ())
645 && !query ("Discard symbol table from `%s'? ",
646 symfile_objfile
-> name
))
647 error ("Not confirmed.");
648 free_all_objfiles ();
649 symfile_objfile
= NULL
;
652 printf_unfiltered ("No symbol file now.\n");
657 if ((argv
= buildargv (args
)) == NULL
)
661 cleanups
= make_cleanup (freeargv
, (char *) argv
);
662 while (*argv
!= NULL
)
664 if (STREQ (*argv
, "-mapped"))
668 else if (STREQ (*argv
, "-readnow"))
672 else if (**argv
== '-')
674 error ("unknown option `%s'", *argv
);
682 /* this is for rombug remote only, to get the text relocation by
683 using link command */
684 p
= strrchr(name
, '/');
688 target_link(p
, &text_relocation
);
690 if (text_relocation
== (CORE_ADDR
)0)
692 else if (text_relocation
== (CORE_ADDR
)-1)
693 symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1, mapped
, readno
696 symbol_file_add (name
, from_tty
, (CORE_ADDR
)text_relocation
, 0,
698 set_initial_language ();
705 error ("no symbol file name was specified");
707 do_cleanups (cleanups
);
711 /* Set the initial language.
713 A better solution would be to record the language in the psymtab when reading
714 partial symbols, and then use it (if known) to set the language. This would
715 be a win for formats that encode the language in an easily discoverable place,
716 such as DWARF. For stabs, we can jump through hoops looking for specially
717 named symbols or try to intuit the language from the specific type of stabs
718 we find, but we can't do that until later when we read in full symbols.
722 set_initial_language ()
724 struct partial_symtab
*pst
;
725 enum language lang
= language_unknown
;
727 pst
= find_main_psymtab ();
730 if (pst
-> filename
!= NULL
)
732 lang
= deduce_language_from_filename (pst
-> filename
);
734 if (lang
== language_unknown
)
736 /* Make C the default language */
740 expected_language
= current_language
; /* Don't warn the user */
744 /* Open file specified by NAME and hand it off to BFD for preliminary
745 analysis. Result is a newly initialized bfd *, which includes a newly
746 malloc'd` copy of NAME (tilde-expanded and made absolute).
747 In case of trouble, error() is called. */
750 symfile_bfd_open (name
)
757 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
759 /* Look down path for it, allocate 2nd new malloc'd copy. */
760 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
763 make_cleanup (free
, name
);
764 perror_with_name (name
);
766 free (name
); /* Free 1st new malloc'd copy */
767 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
768 /* It'll be freed in free_objfile(). */
770 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
774 make_cleanup (free
, name
);
775 error ("\"%s\": can't open to read symbols: %s.", name
,
776 bfd_errmsg (bfd_get_error ()));
778 sym_bfd
->cacheable
= true;
780 if (!bfd_check_format (sym_bfd
, bfd_object
))
782 bfd_close (sym_bfd
); /* This also closes desc */
783 make_cleanup (free
, name
);
784 error ("\"%s\": can't read symbols: %s.", name
,
785 bfd_errmsg (bfd_get_error ()));
791 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
792 startup by the _initialize routine in each object file format reader,
793 to register information about each format the the reader is prepared
800 sf
->next
= symtab_fns
;
805 /* Initialize to read symbols from the symbol file sym_bfd. It either
806 returns or calls error(). The result is an initialized struct sym_fns
807 in the objfile structure, that contains cached information about the
811 find_sym_fns (objfile
)
812 struct objfile
*objfile
;
815 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
-> obfd
);
816 char *our_target
= bfd_get_target (objfile
-> obfd
);
818 /* Special kludge for RS/6000. See xcoffread.c. */
819 if (STREQ (our_target
, "aixcoff-rs6000"))
820 our_flavour
= (enum bfd_flavour
)-1;
822 /* Special kludge for apollo. See dstread.c. */
823 if (STREQN (our_target
, "apollo", 6))
824 our_flavour
= (enum bfd_flavour
)-2;
826 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
-> next
)
828 if (our_flavour
== sf
-> sym_flavour
)
834 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
835 bfd_get_target (objfile
-> obfd
));
838 /* This function runs the load command of our current target. */
841 load_command (arg
, from_tty
)
845 target_load (arg
, from_tty
);
848 /* This version of "load" should be usable for any target. Currently
849 it is just used for remote targets, not inftarg.c or core files,
850 on the theory that only in that case is it useful.
852 Avoiding xmodem and the like seems like a win (a) because we don't have
853 to worry about finding it, and (b) On VMS, fork() is very slow and so
854 we don't want to run a subprocess. On the other hand, I'm not sure how
855 performance compares. */
857 generic_load (filename
, from_tty
)
861 struct cleanup
*old_cleanups
;
865 if (filename
== NULL
)
866 filename
= get_exec_file (1);
868 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
869 if (loadfile_bfd
== NULL
)
871 perror_with_name (filename
);
874 old_cleanups
= make_cleanup (bfd_close
, loadfile_bfd
);
876 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
878 error ("\"%s\" is not an object file: %s", filename
,
879 bfd_errmsg (bfd_get_error ()));
882 for (s
= loadfile_bfd
->sections
; s
; s
= s
->next
)
884 if (s
->flags
& SEC_LOAD
)
888 size
= bfd_get_section_size_before_reloc (s
);
892 struct cleanup
*old_chain
;
895 buffer
= xmalloc (size
);
896 old_chain
= make_cleanup (free
, buffer
);
898 vma
= bfd_get_section_vma (loadfile_bfd
, s
);
900 /* Is this really necessary? I guess it gives the user something
901 to look at during a long download. */
902 printf_filtered ("Loading section %s, size 0x%lx vma ",
903 bfd_get_section_name (loadfile_bfd
, s
),
904 (unsigned long) size
);
905 print_address_numeric (vma
, gdb_stdout
);
906 printf_filtered ("\n");
908 bfd_get_section_contents (loadfile_bfd
, s
, buffer
, 0, size
);
910 target_write_memory (vma
, buffer
, size
);
912 do_cleanups (old_chain
);
917 /* We were doing this in remote-mips.c, I suspect it is right
918 for other targets too. */
919 write_pc (loadfile_bfd
->start_address
);
921 /* FIXME: are we supposed to call symbol_file_add or not? According to
922 a comment from remote-mips.c (where a call to symbol_file_add was
923 commented out), making the call confuses GDB if more than one file is
924 loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
927 do_cleanups (old_cleanups
);
930 /* This function allows the addition of incrementally linked object files.
931 It does not modify any state in the target, only in the debugger. */
935 add_symbol_file_command (args
, from_tty
)
949 error ("add-symbol-file takes a file name and an address");
952 /* Make a copy of the string that we can safely write into. */
954 args
= strdup (args
);
955 make_cleanup (free
, args
);
957 /* Pick off any -option args and the file name. */
959 while ((*args
!= '\000') && (name
== NULL
))
961 while (isspace (*args
)) {args
++;}
963 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
972 else if (STREQ (arg
, "-mapped"))
976 else if (STREQ (arg
, "-readnow"))
982 error ("unknown option `%s'", arg
);
986 /* After picking off any options and the file name, args should be
987 left pointing at the remainder of the command line, which should
988 be the address expression to evaluate. */
992 error ("add-symbol-file takes a file name");
994 name
= tilde_expand (name
);
995 make_cleanup (free
, name
);
999 text_addr
= parse_and_eval_address (args
);
1003 target_link(name
, &text_addr
);
1004 if (text_addr
== (CORE_ADDR
)-1)
1005 error("Don't know how to get text start location for this file");
1008 /* FIXME-32x64: Assumes text_addr fits in a long. */
1009 if (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
1010 name
, local_hex_string ((unsigned long)text_addr
)))
1011 error ("Not confirmed.");
1013 symbol_file_add (name
, 0, text_addr
, 0, mapped
, readnow
);
1016 /* Re-read symbols if a symbol-file has changed. */
1020 struct objfile
*objfile
;
1023 struct stat new_statbuf
;
1026 /* With the addition of shared libraries, this should be modified,
1027 the load time should be saved in the partial symbol tables, since
1028 different tables may come from different source files. FIXME.
1029 This routine should then walk down each partial symbol table
1030 and see if the symbol table that it originates from has been changed */
1032 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
1033 if (objfile
->obfd
) {
1034 #ifdef IBM6000_TARGET
1035 /* If this object is from a shared library, then you should
1036 stat on the library name, not member name. */
1038 if (objfile
->obfd
->my_archive
)
1039 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1042 res
= stat (objfile
->name
, &new_statbuf
);
1044 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1045 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1049 new_modtime
= new_statbuf
.st_mtime
;
1050 if (new_modtime
!= objfile
->mtime
)
1052 struct cleanup
*old_cleanups
;
1053 struct section_offsets
*offsets
;
1055 int section_offsets_size
;
1057 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1060 /* There are various functions like symbol_file_add,
1061 symfile_bfd_open, syms_from_objfile, etc., which might
1062 appear to do what we want. But they have various other
1063 effects which we *don't* want. So we just do stuff
1064 ourselves. We don't worry about mapped files (for one thing,
1065 any mapped file will be out of date). */
1067 /* If we get an error, blow away this objfile (not sure if
1068 that is the correct response for things like shared
1070 old_cleanups
= make_cleanup (free_objfile
, objfile
);
1071 /* We need to do this whenever any symbols go away. */
1072 make_cleanup (clear_symtab_users
, 0);
1074 /* Clean up any state BFD has sitting around. We don't need
1075 to close the descriptor but BFD lacks a way of closing the
1076 BFD without closing the descriptor. */
1077 if (!bfd_close (objfile
->obfd
))
1078 error ("Can't close BFD for %s.", objfile
->name
);
1079 objfile
->obfd
= bfd_openr (objfile
->name
, gnutarget
);
1080 if (objfile
->obfd
== NULL
)
1081 error ("Can't open %s to read symbols.", objfile
->name
);
1082 /* bfd_openr sets cacheable to true, which is what we want. */
1083 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1084 error ("Can't read symbols from %s: %s.", objfile
->name
,
1085 bfd_errmsg (bfd_get_error ()));
1087 /* Save the offsets, we will nuke them with the rest of the
1089 num_offsets
= objfile
->num_sections
;
1090 section_offsets_size
=
1091 sizeof (struct section_offsets
)
1092 + sizeof (objfile
->section_offsets
->offsets
) * num_offsets
;
1093 offsets
= (struct section_offsets
*) alloca (section_offsets_size
);
1094 memcpy (offsets
, objfile
->section_offsets
, section_offsets_size
);
1096 /* Nuke all the state that we will re-read. Much of the following
1097 code which sets things to NULL really is necessary to tell
1098 other parts of GDB that there is nothing currently there. */
1100 /* FIXME: Do we have to free a whole linked list, or is this
1102 if (objfile
->global_psymbols
.list
)
1103 mfree (objfile
->md
, objfile
->global_psymbols
.list
);
1104 objfile
->global_psymbols
.list
= NULL
;
1105 objfile
->global_psymbols
.next
= NULL
;
1106 objfile
->global_psymbols
.size
= 0;
1107 if (objfile
->static_psymbols
.list
)
1108 mfree (objfile
->md
, objfile
->static_psymbols
.list
);
1109 objfile
->static_psymbols
.list
= NULL
;
1110 objfile
->static_psymbols
.next
= NULL
;
1111 objfile
->static_psymbols
.size
= 0;
1113 /* Free the obstacks for non-reusable objfiles */
1114 obstack_free (&objfile
-> psymbol_obstack
, 0);
1115 obstack_free (&objfile
-> symbol_obstack
, 0);
1116 obstack_free (&objfile
-> type_obstack
, 0);
1117 objfile
->sections
= NULL
;
1118 objfile
->symtabs
= NULL
;
1119 objfile
->psymtabs
= NULL
;
1120 objfile
->free_psymtabs
= NULL
;
1121 objfile
->msymbols
= NULL
;
1122 objfile
->minimal_symbol_count
= 0;
1123 objfile
->fundamental_types
= NULL
;
1124 if (objfile
-> sf
!= NULL
)
1126 (*objfile
-> sf
-> sym_finish
) (objfile
);
1129 /* We never make this a mapped file. */
1130 objfile
-> md
= NULL
;
1131 /* obstack_specify_allocation also initializes the obstack so
1133 obstack_specify_allocation (&objfile
-> psymbol_obstack
, 0, 0,
1135 obstack_specify_allocation (&objfile
-> symbol_obstack
, 0, 0,
1137 obstack_specify_allocation (&objfile
-> type_obstack
, 0, 0,
1139 if (build_objfile_section_table (objfile
))
1141 error ("Can't find the file sections in `%s': %s",
1142 objfile
-> name
, bfd_errmsg (bfd_get_error ()));
1145 /* We use the same section offsets as from last time. I'm not
1146 sure whether that is always correct for shared libraries. */
1147 objfile
->section_offsets
= (struct section_offsets
*)
1148 obstack_alloc (&objfile
-> psymbol_obstack
, section_offsets_size
);
1149 memcpy (objfile
->section_offsets
, offsets
, section_offsets_size
);
1150 objfile
->num_sections
= num_offsets
;
1152 /* What the hell is sym_new_init for, anyway? The concept of
1153 distinguishing between the main file and additional files
1154 in this way seems rather dubious. */
1155 if (objfile
== symfile_objfile
)
1156 (*objfile
->sf
->sym_new_init
) (objfile
);
1158 (*objfile
->sf
->sym_init
) (objfile
);
1159 clear_complaints (1, 1);
1160 /* The "mainline" parameter is a hideous hack; I think leaving it
1161 zero is OK since dbxread.c also does what it needs to do if
1162 objfile->global_psymbols.size is 0. */
1163 (*objfile
->sf
->sym_read
) (objfile
, objfile
->section_offsets
, 0);
1164 objfile
-> flags
|= OBJF_SYMS
;
1166 /* We're done reading the symbol file; finish off complaints. */
1167 clear_complaints (0, 1);
1169 /* Getting new symbols may change our opinion about what is
1172 reinit_frame_cache ();
1174 /* Discard cleanups as symbol reading was successful. */
1175 discard_cleanups (old_cleanups
);
1177 /* If the mtime has changed between the time we set new_modtime
1178 and now, we *want* this to be out of date, so don't call stat
1180 objfile
->mtime
= new_modtime
;
1187 clear_symtab_users ();
1192 deduce_language_from_filename (filename
)
1199 else if (0 == (c
= strrchr (filename
, '.')))
1200 ; /* Get default. */
1201 else if (STREQ(c
,".mod"))
1203 else if (STREQ(c
,".c"))
1205 else if (STREQ (c
,".cc") || STREQ (c
,".C") || STREQ (c
, ".cxx"))
1206 return language_cplus
;
1207 else if (STREQ (c
,".ch") || STREQ (c
,".c186") || STREQ (c
,".c286"))
1208 return language_chill
;
1210 return language_unknown
; /* default */
1215 Allocate and partly initialize a new symbol table. Return a pointer
1216 to it. error() if no space.
1218 Caller must set these fields:
1224 initialize any EXTRA_SYMTAB_INFO
1225 possibly free_named_symtabs (symtab->filename);
1229 allocate_symtab (filename
, objfile
)
1231 struct objfile
*objfile
;
1233 register struct symtab
*symtab
;
1235 symtab
= (struct symtab
*)
1236 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
1237 memset (symtab
, 0, sizeof (*symtab
));
1238 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
1239 &objfile
-> symbol_obstack
);
1240 symtab
-> fullname
= NULL
;
1241 symtab
-> language
= deduce_language_from_filename (filename
);
1243 /* Hook it to the objfile it comes from */
1245 symtab
-> objfile
= objfile
;
1246 symtab
-> next
= objfile
-> symtabs
;
1247 objfile
-> symtabs
= symtab
;
1249 #ifdef INIT_EXTRA_SYMTAB_INFO
1250 INIT_EXTRA_SYMTAB_INFO (symtab
);
1256 struct partial_symtab
*
1257 allocate_psymtab (filename
, objfile
)
1259 struct objfile
*objfile
;
1261 struct partial_symtab
*psymtab
;
1263 if (objfile
-> free_psymtabs
)
1265 psymtab
= objfile
-> free_psymtabs
;
1266 objfile
-> free_psymtabs
= psymtab
-> next
;
1269 psymtab
= (struct partial_symtab
*)
1270 obstack_alloc (&objfile
-> psymbol_obstack
,
1271 sizeof (struct partial_symtab
));
1273 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1274 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1275 &objfile
-> psymbol_obstack
);
1276 psymtab
-> symtab
= NULL
;
1278 /* Hook it to the objfile it comes from */
1280 psymtab
-> objfile
= objfile
;
1281 psymtab
-> next
= objfile
-> psymtabs
;
1282 objfile
-> psymtabs
= psymtab
;
1288 /* Reset all data structures in gdb which may contain references to symbol
1292 clear_symtab_users ()
1294 /* Someday, we should do better than this, by only blowing away
1295 the things that really need to be blown. */
1296 clear_value_history ();
1298 clear_internalvars ();
1299 breakpoint_re_set ();
1300 set_default_breakpoint (0, 0, 0, 0);
1301 current_source_symtab
= 0;
1302 current_source_line
= 0;
1303 clear_pc_function_cache ();
1306 /* clear_symtab_users_once:
1308 This function is run after symbol reading, or from a cleanup.
1309 If an old symbol table was obsoleted, the old symbol table
1310 has been blown away, but the other GDB data structures that may
1311 reference it have not yet been cleared or re-directed. (The old
1312 symtab was zapped, and the cleanup queued, in free_named_symtab()
1315 This function can be queued N times as a cleanup, or called
1316 directly; it will do all the work the first time, and then will be a
1317 no-op until the next time it is queued. This works by bumping a
1318 counter at queueing time. Much later when the cleanup is run, or at
1319 the end of symbol processing (in case the cleanup is discarded), if
1320 the queued count is greater than the "done-count", we do the work
1321 and set the done-count to the queued count. If the queued count is
1322 less than or equal to the done-count, we just ignore the call. This
1323 is needed because reading a single .o file will often replace many
1324 symtabs (one per .h file, for example), and we don't want to reset
1325 the breakpoints N times in the user's face.
1327 The reason we both queue a cleanup, and call it directly after symbol
1328 reading, is because the cleanup protects us in case of errors, but is
1329 discarded if symbol reading is successful. */
1332 /* FIXME: As free_named_symtabs is currently a big noop this function
1333 is no longer needed. */
1335 clear_symtab_users_once
PARAMS ((void));
1337 static int clear_symtab_users_queued
;
1338 static int clear_symtab_users_done
;
1341 clear_symtab_users_once ()
1343 /* Enforce once-per-`do_cleanups'-semantics */
1344 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1346 clear_symtab_users_done
= clear_symtab_users_queued
;
1348 clear_symtab_users ();
1352 /* Delete the specified psymtab, and any others that reference it. */
1355 cashier_psymtab (pst
)
1356 struct partial_symtab
*pst
;
1358 struct partial_symtab
*ps
, *pprev
= NULL
;
1361 /* Find its previous psymtab in the chain */
1362 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1369 /* Unhook it from the chain. */
1370 if (ps
== pst
->objfile
->psymtabs
)
1371 pst
->objfile
->psymtabs
= ps
->next
;
1373 pprev
->next
= ps
->next
;
1375 /* FIXME, we can't conveniently deallocate the entries in the
1376 partial_symbol lists (global_psymbols/static_psymbols) that
1377 this psymtab points to. These just take up space until all
1378 the psymtabs are reclaimed. Ditto the dependencies list and
1379 filename, which are all in the psymbol_obstack. */
1381 /* We need to cashier any psymtab that has this one as a dependency... */
1383 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1384 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1385 if (ps
->dependencies
[i
] == pst
) {
1386 cashier_psymtab (ps
);
1387 goto again
; /* Must restart, chain has been munged. */
1394 /* If a symtab or psymtab for filename NAME is found, free it along
1395 with any dependent breakpoints, displays, etc.
1396 Used when loading new versions of object modules with the "add-file"
1397 command. This is only called on the top-level symtab or psymtab's name;
1398 it is not called for subsidiary files such as .h files.
1400 Return value is 1 if we blew away the environment, 0 if not.
1401 FIXME. The return valu appears to never be used.
1403 FIXME. I think this is not the best way to do this. We should
1404 work on being gentler to the environment while still cleaning up
1405 all stray pointers into the freed symtab. */
1408 free_named_symtabs (name
)
1412 /* FIXME: With the new method of each objfile having it's own
1413 psymtab list, this function needs serious rethinking. In particular,
1414 why was it ever necessary to toss psymtabs with specific compilation
1415 unit filenames, as opposed to all psymtabs from a particular symbol
1417 Well, the answer is that some systems permit reloading of particular
1418 compilation units. We want to blow away any old info about these
1419 compilation units, regardless of which objfiles they arrived in. --gnu. */
1421 register struct symtab
*s
;
1422 register struct symtab
*prev
;
1423 register struct partial_symtab
*ps
;
1424 struct blockvector
*bv
;
1427 /* We only wack things if the symbol-reload switch is set. */
1428 if (!symbol_reloading
)
1431 /* Some symbol formats have trouble providing file names... */
1432 if (name
== 0 || *name
== '\0')
1435 /* Look for a psymtab with the specified name. */
1438 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1439 if (STREQ (name
, ps
->filename
)) {
1440 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1441 goto again2
; /* Must restart, chain has been munged */
1445 /* Look for a symtab with the specified name. */
1447 for (s
= symtab_list
; s
; s
= s
->next
)
1449 if (STREQ (name
, s
->filename
))
1456 if (s
== symtab_list
)
1457 symtab_list
= s
->next
;
1459 prev
->next
= s
->next
;
1461 /* For now, queue a delete for all breakpoints, displays, etc., whether
1462 or not they depend on the symtab being freed. This should be
1463 changed so that only those data structures affected are deleted. */
1465 /* But don't delete anything if the symtab is empty.
1466 This test is necessary due to a bug in "dbxread.c" that
1467 causes empty symtabs to be created for N_SO symbols that
1468 contain the pathname of the object file. (This problem
1469 has been fixed in GDB 3.9x). */
1471 bv
= BLOCKVECTOR (s
);
1472 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1473 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1474 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1476 complain (&oldsyms_complaint
, name
);
1478 clear_symtab_users_queued
++;
1479 make_cleanup (clear_symtab_users_once
, 0);
1482 complain (&empty_symtab_complaint
, name
);
1489 /* It is still possible that some breakpoints will be affected
1490 even though no symtab was found, since the file might have
1491 been compiled without debugging, and hence not be associated
1492 with a symtab. In order to handle this correctly, we would need
1493 to keep a list of text address ranges for undebuggable files.
1494 For now, we do nothing, since this is a fairly obscure case. */
1498 /* FIXME, what about the minimal symbol table? */
1505 /* Allocate and partially fill a partial symtab. It will be
1506 completely filled at the end of the symbol list.
1508 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1509 is the address relative to which its symbols are (incremental) or 0
1513 struct partial_symtab
*
1514 start_psymtab_common (objfile
, section_offsets
,
1515 filename
, textlow
, global_syms
, static_syms
)
1516 struct objfile
*objfile
;
1517 struct section_offsets
*section_offsets
;
1520 struct partial_symbol
*global_syms
;
1521 struct partial_symbol
*static_syms
;
1523 struct partial_symtab
*psymtab
;
1525 psymtab
= allocate_psymtab (filename
, objfile
);
1526 psymtab
-> section_offsets
= section_offsets
;
1527 psymtab
-> textlow
= textlow
;
1528 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
1529 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
1530 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
1534 /* Debugging versions of functions that are usually inline macros
1537 #if !INLINE_ADD_PSYMBOL
1539 /* Add a symbol with a long value to a psymtab.
1540 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
1543 add_psymbol_to_list (name
, namelength
, namespace, class, list
, val
, language
,
1547 enum namespace namespace;
1548 enum address_class
class;
1549 struct psymbol_allocation_list
*list
;
1551 enum language language
;
1552 struct objfile
*objfile
;
1554 register struct partial_symbol
*psym
;
1555 register char *demangled_name
;
1557 if (list
->next
>= list
->list
+ list
->size
)
1559 extend_psymbol_list (list
,objfile
);
1561 psym
= list
->next
++;
1563 SYMBOL_NAME (psym
) =
1564 (char *) obstack_alloc (&objfile
->psymbol_obstack
, namelength
+ 1);
1565 memcpy (SYMBOL_NAME (psym
), name
, namelength
);
1566 SYMBOL_NAME (psym
)[namelength
] = '\0';
1567 SYMBOL_VALUE (psym
) = val
;
1568 SYMBOL_LANGUAGE (psym
) = language
;
1569 PSYMBOL_NAMESPACE (psym
) = namespace;
1570 PSYMBOL_CLASS (psym
) = class;
1571 SYMBOL_INIT_DEMANGLED_NAME (psym
, &objfile
->psymbol_obstack
);
1574 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1577 add_psymbol_addr_to_list (name
, namelength
, namespace, class, list
, val
,
1581 enum namespace namespace;
1582 enum address_class
class;
1583 struct psymbol_allocation_list
*list
;
1585 enum language language
;
1586 struct objfile
*objfile
;
1588 register struct partial_symbol
*psym
;
1589 register char *demangled_name
;
1591 if (list
->next
>= list
->list
+ list
->size
)
1593 extend_psymbol_list (list
,objfile
);
1595 psym
= list
->next
++;
1597 SYMBOL_NAME (psym
) =
1598 (char *) obstack_alloc (&objfile
->psymbol_obstack
, namelength
+ 1);
1599 memcpy (SYMBOL_NAME (psym
), name
, namelength
);
1600 SYMBOL_NAME (psym
)[namelength
] = '\0';
1601 SYMBOL_VALUE_ADDRESS (psym
) = val
;
1602 SYMBOL_LANGUAGE (psym
) = language
;
1603 PSYMBOL_NAMESPACE (psym
) = namespace;
1604 PSYMBOL_CLASS (psym
) = class;
1605 SYMBOL_INIT_DEMANGLED_NAME (psym
, &objfile
->psymbol_obstack
);
1608 #endif /* !INLINE_ADD_PSYMBOL */
1612 _initialize_symfile ()
1614 struct cmd_list_element
*c
;
1616 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
1617 "Load symbol table from executable file FILE.\n\
1618 The `file' command can also load symbol tables, as well as setting the file\n\
1619 to execute.", &cmdlist
);
1620 c
->completer
= filename_completer
;
1622 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
1623 "Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
1624 The second argument provides the starting address of the file's text.",
1626 c
->completer
= filename_completer
;
1628 c
= add_cmd ("load", class_files
, load_command
,
1629 "Dynamically load FILE into the running program, and record its symbols\n\
1630 for access from GDB.", &cmdlist
);
1631 c
->completer
= filename_completer
;
1634 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
1635 (char *)&symbol_reloading
,
1636 "Set dynamic symbol table reloading multiple times in one run.",