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 */
52 int readnow_symbol_files
; /* Read full symbols immediately */
54 struct complaint oldsyms_complaint
= {
55 "Replacing old symbols for `%s'", 0, 0
58 struct complaint empty_symtab_complaint
= {
59 "Empty symbol table found for `%s'", 0, 0
62 /* External variables and functions referenced. */
64 extern int info_verbose
;
66 /* Functions this file defines */
69 set_initial_language
PARAMS ((void));
72 load_command
PARAMS ((char *, int));
75 add_symbol_file_command
PARAMS ((char *, int));
78 cashier_psymtab
PARAMS ((struct partial_symtab
*));
81 compare_psymbols
PARAMS ((const void *, const void *));
84 compare_symbols
PARAMS ((const void *, const void *));
87 symfile_bfd_open
PARAMS ((char *));
90 find_sym_fns
PARAMS ((struct objfile
*));
92 /* List of all available sym_fns. On gdb startup, each object file reader
93 calls add_symtab_fns() to register information on each format it is
96 static struct sym_fns
*symtab_fns
= NULL
;
98 /* Structures with which to manage partial symbol allocation. */
100 struct psymbol_allocation_list global_psymbols
= {0}, static_psymbols
= {0};
102 /* Flag for whether user will be reloading symbols multiple times.
103 Defaults to ON for VxWorks, otherwise OFF. */
105 #ifdef SYMBOL_RELOADING_DEFAULT
106 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
108 int symbol_reloading
= 0;
112 /* Since this function is called from within qsort, in an ANSI environment
113 it must conform to the prototype for qsort, which specifies that the
114 comparison function takes two "void *" pointers. */
117 compare_symbols (s1p
, s2p
)
121 register struct symbol
**s1
, **s2
;
123 s1
= (struct symbol
**) s1p
;
124 s2
= (struct symbol
**) s2p
;
126 return (STRCMP (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
)));
133 compare_psymbols -- compare two partial symbols by name
137 Given pointer to two partial symbol table entries, compare
138 them by name and return -N, 0, or +N (ala strcmp). Typically
139 used by sorting routines like qsort().
143 Does direct compare of first two characters before punting
144 and passing to strcmp for longer compares. Note that the
145 original version had a bug whereby two null strings or two
146 identically named one character strings would return the
147 comparison of memory following the null byte.
152 compare_psymbols (s1p
, s2p
)
156 register char *st1
= SYMBOL_NAME ((struct partial_symbol
*) s1p
);
157 register char *st2
= SYMBOL_NAME ((struct partial_symbol
*) s2p
);
159 if ((st1
[0] - st2
[0]) || !st1
[0])
161 return (st1
[0] - st2
[0]);
163 else if ((st1
[1] - st2
[1]) || !st1
[1])
165 return (st1
[1] - st2
[1]);
169 return (STRCMP (st1
+ 2, st2
+ 2));
174 sort_pst_symbols (pst
)
175 struct partial_symtab
*pst
;
177 /* Sort the global list; don't sort the static list */
179 qsort (pst
-> objfile
-> global_psymbols
.list
+ pst
-> globals_offset
,
180 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
184 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
188 register struct block
*b
;
190 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
191 sizeof (struct symbol
*), compare_symbols
);
194 /* Call sort_symtab_syms to sort alphabetically
195 the symbols of each block of one symtab. */
199 register struct symtab
*s
;
201 register struct blockvector
*bv
;
204 register struct block
*b
;
208 bv
= BLOCKVECTOR (s
);
209 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
210 for (i
= 0; i
< nbl
; i
++)
212 b
= BLOCKVECTOR_BLOCK (bv
, i
);
213 if (BLOCK_SHOULD_SORT (b
))
218 /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
219 (and add a null character at the end in the copy).
220 Returns the address of the copy. */
223 obsavestring (ptr
, size
, obstackp
)
226 struct obstack
*obstackp
;
228 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
229 /* Open-coded memcpy--saves function call time.
230 These strings are usually short. */
232 register char *p1
= ptr
;
233 register char *p2
= p
;
234 char *end
= ptr
+ size
;
242 /* Concatenate strings S1, S2 and S3; return the new string.
243 Space is found in the symbol_obstack. */
246 obconcat (obstackp
, s1
, s2
, s3
)
247 struct obstack
*obstackp
;
248 const char *s1
, *s2
, *s3
;
250 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
251 register char *val
= (char *) obstack_alloc (obstackp
, len
);
258 /* Get the symbol table that corresponds to a partial_symtab.
259 This is fast after the first time you do it. In fact, there
260 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
264 psymtab_to_symtab (pst
)
265 register struct partial_symtab
*pst
;
267 /* If it's been looked up before, return it. */
271 /* If it has not yet been read in, read it. */
274 (*pst
->read_symtab
) (pst
);
280 /* Initialize entry point information for this objfile. */
283 init_entry_point_info (objfile
)
284 struct objfile
*objfile
;
286 /* Save startup file's range of PC addresses to help blockframe.c
287 decide where the bottom of the stack is. */
289 if (bfd_get_file_flags (objfile
-> obfd
) & EXEC_P
)
291 /* Executable file -- record its entry point so we'll recognize
292 the startup file because it contains the entry point. */
293 objfile
-> ei
.entry_point
= bfd_get_start_address (objfile
-> obfd
);
297 /* Examination of non-executable.o files. Short-circuit this stuff. */
298 /* ~0 will not be in any file, we hope. */
299 objfile
-> ei
.entry_point
= ~0;
300 /* set the startup file to be an empty range. */
301 objfile
-> ei
.entry_file_lowpc
= 0;
302 objfile
-> ei
.entry_file_highpc
= 0;
306 /* Get current entry point address. */
309 entry_point_address()
311 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
314 /* Remember the lowest-addressed loadable section we've seen.
315 This function is called via bfd_map_over_sections. */
317 #if 0 /* Not used yet */
319 find_lowest_section (abfd
, sect
, obj
)
324 asection
**lowest
= (asection
**)obj
;
326 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
329 *lowest
= sect
; /* First loadable section */
330 else if (bfd_section_vma (abfd
, *lowest
) >= bfd_section_vma (abfd
, sect
))
331 *lowest
= sect
; /* A lower loadable section */
335 /* Process a symbol file, as either the main file or as a dynamically
338 NAME is the file name (which will be tilde-expanded and made
339 absolute herein) (but we don't free or modify NAME itself).
340 FROM_TTY says how verbose to be. MAINLINE specifies whether this
341 is the main symbol file, or whether it's an extra symbol file such
342 as dynamically loaded code. If !mainline, ADDR is the address
343 where the text segment was loaded. If VERBO, the caller has printed
344 a verbose message about the symbol reading (and complaints can be
345 more terse about it). */
348 syms_from_objfile (objfile
, addr
, mainline
, verbo
)
349 struct objfile
*objfile
;
354 struct section_offsets
*section_offsets
;
355 asection
*lowest_sect
;
356 struct cleanup
*old_chain
;
358 init_entry_point_info (objfile
);
359 find_sym_fns (objfile
);
361 /* Make sure that partially constructed symbol tables will be cleaned up
362 if an error occurs during symbol reading. */
363 old_chain
= make_cleanup (free_objfile
, objfile
);
367 /* We will modify the main symbol table, make sure that all its users
368 will be cleaned up if an error occurs during symbol reading. */
369 make_cleanup (clear_symtab_users
, 0);
371 /* Since no error yet, throw away the old symbol table. */
373 if (symfile_objfile
!= NULL
)
375 free_objfile (symfile_objfile
);
376 symfile_objfile
= NULL
;
379 /* Currently we keep symbols from the add-symbol-file command.
380 If the user wants to get rid of them, they should do "symbol-file"
381 without arguments first. Not sure this is the best behavior
384 (*objfile
-> sf
-> sym_new_init
) (objfile
);
387 /* Convert addr into an offset rather than an absolute address.
388 We find the lowest address of a loaded segment in the objfile,
389 and assume that <addr> is where that got loaded. Due to historical
390 precedent, we warn if that doesn't happen to be the ".text"
395 addr
= 0; /* No offset from objfile addresses. */
399 lowest_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
402 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
406 if (lowest_sect
== 0)
407 warning ("no loadable sections found in added symbol-file %s",
409 else if (0 == bfd_get_section_name (objfile
->obfd
, lowest_sect
)
411 bfd_get_section_name (objfile
->obfd
, lowest_sect
)))
412 /* FIXME-32x64--assumes bfd_vma fits in long. */
413 warning ("Lowest section in %s is %s at 0x%lx",
415 bfd_section_name (objfile
->obfd
, lowest_sect
),
416 (unsigned long) bfd_section_vma (objfile
->obfd
, lowest_sect
));
419 addr
-= bfd_section_vma (objfile
->obfd
, lowest_sect
);
422 /* Initialize symbol reading routines for this objfile, allow complaints to
423 appear for this new file, and record how verbose to be, then do the
424 initial symbol reading for this file. */
426 (*objfile
-> sf
-> sym_init
) (objfile
);
427 clear_complaints (1, verbo
);
429 section_offsets
= (*objfile
-> sf
-> sym_offsets
) (objfile
, addr
);
430 objfile
->section_offsets
= section_offsets
;
432 #ifndef IBM6000_TARGET
433 /* This is a SVR4/SunOS specific hack, I think. In any event, it
434 screws RS/6000. sym_offsets should be doing this sort of thing,
435 because it knows the mapping between bfd sections and
437 /* This is a hack. As far as I can tell, section offsets are not
438 target dependent. They are all set to addr with a couple of
439 exceptions. The exceptions are sysvr4 shared libraries, whose
440 offsets are kept in solib structures anyway and rs6000 xcoff
441 which handles shared libraries in a completely unique way.
443 Section offsets are built similarly, except that they are built
444 by adding addr in all cases because there is no clear mapping
445 from section_offsets into actual sections. Note that solib.c
446 has a different algorythm for finding section offsets.
448 These should probably all be collapsed into some target
449 independent form of shared library support. FIXME. */
453 struct obj_section
*s
;
455 for (s
= objfile
->sections
; s
< objfile
->sections_end
; ++s
)
457 s
->addr
-= s
->offset
;
459 s
->endaddr
-= s
->offset
;
464 #endif /* not IBM6000_TARGET */
466 (*objfile
-> sf
-> sym_read
) (objfile
, section_offsets
, mainline
);
468 /* Don't allow char * to have a typename (else would get caddr_t).
469 Ditto void *. FIXME: Check whether this is now done by all the
470 symbol readers themselves (many of them now do), and if so remove
473 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
474 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
476 /* Mark the objfile has having had initial symbol read attempted. Note
477 that this does not mean we found any symbols... */
479 objfile
-> flags
|= OBJF_SYMS
;
481 /* Discard cleanups as symbol reading was successful. */
483 discard_cleanups (old_chain
);
486 /* Perform required actions after either reading in the initial
487 symbols for a new objfile, or mapping in the symbols from a reusable
491 new_symfile_objfile (objfile
, mainline
, verbo
)
492 struct objfile
*objfile
;
497 /* If this is the main symbol file we have to clean up all users of the
498 old main symbol file. Otherwise it is sufficient to fixup all the
499 breakpoints that may have been redefined by this symbol file. */
502 /* OK, make it the "real" symbol file. */
503 symfile_objfile
= objfile
;
505 clear_symtab_users ();
509 breakpoint_re_set ();
512 /* We're done reading the symbol file; finish off complaints. */
513 clear_complaints (0, verbo
);
516 /* Process a symbol file, as either the main file or as a dynamically
519 NAME is the file name (which will be tilde-expanded and made
520 absolute herein) (but we don't free or modify NAME itself).
521 FROM_TTY says how verbose to be. MAINLINE specifies whether this
522 is the main symbol file, or whether it's an extra symbol file such
523 as dynamically loaded code. If !mainline, ADDR is the address
524 where the text segment was loaded.
526 Upon success, returns a pointer to the objfile that was added.
527 Upon failure, jumps back to command level (never returns). */
530 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
)
538 struct objfile
*objfile
;
539 struct partial_symtab
*psymtab
;
542 /* Open a bfd for the file, and give user a chance to burp if we'd be
543 interactively wiping out any existing symbols. */
545 abfd
= symfile_bfd_open (name
);
547 if ((have_full_symbols () || have_partial_symbols ())
550 && !query ("Load new symbol table from \"%s\"? ", name
))
551 error ("Not confirmed.");
553 objfile
= allocate_objfile (abfd
, mapped
);
555 /* If the objfile uses a mapped symbol file, and we have a psymtab for
556 it, then skip reading any symbols at this time. */
558 if ((objfile
-> flags
& OBJF_MAPPED
) && (objfile
-> flags
& OBJF_SYMS
))
560 /* We mapped in an existing symbol table file that already has had
561 initial symbol reading performed, so we can skip that part. Notify
562 the user that instead of reading the symbols, they have been mapped.
564 if (from_tty
|| info_verbose
)
566 printf_filtered ("Mapped symbols for %s...", name
);
568 gdb_flush (gdb_stdout
);
570 init_entry_point_info (objfile
);
571 find_sym_fns (objfile
);
575 /* We either created a new mapped symbol table, mapped an existing
576 symbol table file which has not had initial symbol reading
577 performed, or need to read an unmapped symbol table. */
578 if (from_tty
|| info_verbose
)
580 printf_filtered ("Reading symbols from %s...", name
);
582 gdb_flush (gdb_stdout
);
584 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
587 /* We now have at least a partial symbol table. Check to see if the
588 user requested that all symbols be read on initial access via either
589 the gdb startup command line or on a per symbol file basis. Expand
590 all partial symbol tables for this objfile if so. */
592 if (readnow
|| readnow_symbol_files
)
594 if (from_tty
|| info_verbose
)
596 printf_filtered ("expanding to full symbols...");
598 gdb_flush (gdb_stdout
);
601 for (psymtab
= objfile
-> psymtabs
;
603 psymtab
= psymtab
-> next
)
605 psymtab_to_symtab (psymtab
);
609 if (from_tty
|| info_verbose
)
611 printf_filtered ("done.\n");
612 gdb_flush (gdb_stdout
);
615 new_symfile_objfile (objfile
, mainline
, from_tty
);
617 /* Getting new symbols may change our opinion about what is
620 reinit_frame_cache ();
625 /* This is the symbol-file command. Read the file, analyze its symbols,
626 and add a struct symtab to a symtab list. */
629 symbol_file_command (args
, from_tty
)
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
);
685 error ("no symbol file name was specified");
689 symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1, mapped
, readnow
);
690 set_initial_language ();
692 do_cleanups (cleanups
);
696 /* Set the initial language.
698 A better solution would be to record the language in the psymtab when reading
699 partial symbols, and then use it (if known) to set the language. This would
700 be a win for formats that encode the language in an easily discoverable place,
701 such as DWARF. For stabs, we can jump through hoops looking for specially
702 named symbols or try to intuit the language from the specific type of stabs
703 we find, but we can't do that until later when we read in full symbols.
707 set_initial_language ()
709 struct partial_symtab
*pst
;
710 enum language lang
= language_unknown
;
712 pst
= find_main_psymtab ();
715 if (pst
-> filename
!= NULL
)
717 lang
= deduce_language_from_filename (pst
-> filename
);
719 if (lang
== language_unknown
)
721 /* Make C the default language */
725 expected_language
= current_language
; /* Don't warn the user */
729 /* Open file specified by NAME and hand it off to BFD for preliminary
730 analysis. Result is a newly initialized bfd *, which includes a newly
731 malloc'd` copy of NAME (tilde-expanded and made absolute).
732 In case of trouble, error() is called. */
735 symfile_bfd_open (name
)
742 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
744 /* Look down path for it, allocate 2nd new malloc'd copy. */
745 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
748 make_cleanup (free
, name
);
749 perror_with_name (name
);
751 free (name
); /* Free 1st new malloc'd copy */
752 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
753 /* It'll be freed in free_objfile(). */
755 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
759 make_cleanup (free
, name
);
760 error ("\"%s\": can't open to read symbols: %s.", name
,
761 bfd_errmsg (bfd_get_error ()));
763 sym_bfd
->cacheable
= true;
765 if (!bfd_check_format (sym_bfd
, bfd_object
))
767 bfd_close (sym_bfd
); /* This also closes desc */
768 make_cleanup (free
, name
);
769 error ("\"%s\": can't read symbols: %s.", name
,
770 bfd_errmsg (bfd_get_error ()));
776 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
777 startup by the _initialize routine in each object file format reader,
778 to register information about each format the the reader is prepared
785 sf
->next
= symtab_fns
;
790 /* Initialize to read symbols from the symbol file sym_bfd. It either
791 returns or calls error(). The result is an initialized struct sym_fns
792 in the objfile structure, that contains cached information about the
796 find_sym_fns (objfile
)
797 struct objfile
*objfile
;
800 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
-> obfd
);
801 char *our_target
= bfd_get_target (objfile
-> obfd
);
803 /* Special kludge for RS/6000. See xcoffread.c. */
804 if (STREQ (our_target
, "aixcoff-rs6000"))
805 our_flavour
= (enum bfd_flavour
)-1;
807 /* Special kludge for apollo. See dstread.c. */
808 if (STREQN (our_target
, "apollo", 6))
809 our_flavour
= (enum bfd_flavour
)-2;
811 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
-> next
)
813 if (our_flavour
== sf
-> sym_flavour
)
819 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
820 bfd_get_target (objfile
-> obfd
));
823 /* This function runs the load command of our current target. */
826 load_command (arg
, from_tty
)
830 target_load (arg
, from_tty
);
833 /* This version of "load" should be usable for any target. Currently
834 it is just used for remote targets, not inftarg.c or core files,
835 on the theory that only in that case is it useful.
837 Avoiding xmodem and the like seems like a win (a) because we don't have
838 to worry about finding it, and (b) On VMS, fork() is very slow and so
839 we don't want to run a subprocess. On the other hand, I'm not sure how
840 performance compares. */
842 generic_load (filename
, from_tty
)
846 struct cleanup
*old_cleanups
;
850 if (filename
== NULL
)
851 filename
= get_exec_file (1);
853 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
854 if (loadfile_bfd
== NULL
)
856 perror_with_name (filename
);
859 old_cleanups
= make_cleanup (bfd_close
, loadfile_bfd
);
861 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
863 error ("\"%s\" is not an object file: %s", filename
,
864 bfd_errmsg (bfd_get_error ()));
867 for (s
= loadfile_bfd
->sections
; s
; s
= s
->next
)
869 if (s
->flags
& SEC_LOAD
)
873 size
= bfd_get_section_size_before_reloc (s
);
877 struct cleanup
*old_chain
;
880 buffer
= xmalloc (size
);
881 old_chain
= make_cleanup (free
, buffer
);
883 vma
= bfd_get_section_vma (loadfile_bfd
, s
);
885 /* Is this really necessary? I guess it gives the user something
886 to look at during a long download. */
887 printf_filtered ("Loading section %s, size 0x%lx vma ",
888 bfd_get_section_name (loadfile_bfd
, s
),
889 (unsigned long) size
);
890 print_address_numeric (vma
, gdb_stdout
);
891 printf_filtered ("\n");
893 bfd_get_section_contents (loadfile_bfd
, s
, buffer
, 0, size
);
895 target_write_memory (vma
, buffer
, size
);
897 do_cleanups (old_chain
);
902 /* We were doing this in remote-mips.c, I suspect it is right
903 for other targets too. */
904 write_pc (loadfile_bfd
->start_address
);
906 /* FIXME: are we supposed to call symbol_file_add or not? According to
907 a comment from remote-mips.c (where a call to symbol_file_add was
908 commented out), making the call confuses GDB if more than one file is
909 loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
912 do_cleanups (old_cleanups
);
915 /* This function allows the addition of incrementally linked object files.
916 It does not modify any state in the target, only in the debugger. */
920 add_symbol_file_command (args
, from_tty
)
934 error ("add-symbol-file takes a file name and an address");
937 /* Make a copy of the string that we can safely write into. */
939 args
= strdup (args
);
940 make_cleanup (free
, args
);
942 /* Pick off any -option args and the file name. */
944 while ((*args
!= '\000') && (name
== NULL
))
946 while (isspace (*args
)) {args
++;}
948 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
957 else if (STREQ (arg
, "-mapped"))
961 else if (STREQ (arg
, "-readnow"))
967 error ("unknown option `%s'", arg
);
971 /* After picking off any options and the file name, args should be
972 left pointing at the remainder of the command line, which should
973 be the address expression to evaluate. */
975 if ((name
== NULL
) || (*args
== '\000') )
977 error ("add-symbol-file takes a file name and an address");
979 name
= tilde_expand (name
);
980 make_cleanup (free
, name
);
982 text_addr
= parse_and_eval_address (args
);
984 /* FIXME-32x64: Assumes text_addr fits in a long. */
985 if (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
986 name
, local_hex_string ((unsigned long)text_addr
)))
987 error ("Not confirmed.");
989 symbol_file_add (name
, 0, text_addr
, 0, mapped
, readnow
);
992 /* Re-read symbols if a symbol-file has changed. */
996 struct objfile
*objfile
;
999 struct stat new_statbuf
;
1002 /* With the addition of shared libraries, this should be modified,
1003 the load time should be saved in the partial symbol tables, since
1004 different tables may come from different source files. FIXME.
1005 This routine should then walk down each partial symbol table
1006 and see if the symbol table that it originates from has been changed */
1008 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
1009 if (objfile
->obfd
) {
1010 #ifdef IBM6000_TARGET
1011 /* If this object is from a shared library, then you should
1012 stat on the library name, not member name. */
1014 if (objfile
->obfd
->my_archive
)
1015 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1018 res
= stat (objfile
->name
, &new_statbuf
);
1020 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1021 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1025 new_modtime
= new_statbuf
.st_mtime
;
1026 if (new_modtime
!= objfile
->mtime
)
1028 struct cleanup
*old_cleanups
;
1029 struct section_offsets
*offsets
;
1031 int section_offsets_size
;
1033 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1036 /* There are various functions like symbol_file_add,
1037 symfile_bfd_open, syms_from_objfile, etc., which might
1038 appear to do what we want. But they have various other
1039 effects which we *don't* want. So we just do stuff
1040 ourselves. We don't worry about mapped files (for one thing,
1041 any mapped file will be out of date). */
1043 /* If we get an error, blow away this objfile (not sure if
1044 that is the correct response for things like shared
1046 old_cleanups
= make_cleanup (free_objfile
, objfile
);
1047 /* We need to do this whenever any symbols go away. */
1048 make_cleanup (clear_symtab_users
, 0);
1050 /* Clean up any state BFD has sitting around. We don't need
1051 to close the descriptor but BFD lacks a way of closing the
1052 BFD without closing the descriptor. */
1053 if (!bfd_close (objfile
->obfd
))
1054 error ("Can't close BFD for %s.", objfile
->name
);
1055 objfile
->obfd
= bfd_openr (objfile
->name
, gnutarget
);
1056 if (objfile
->obfd
== NULL
)
1057 error ("Can't open %s to read symbols.", objfile
->name
);
1058 /* bfd_openr sets cacheable to true, which is what we want. */
1059 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1060 error ("Can't read symbols from %s: %s.", objfile
->name
,
1061 bfd_errmsg (bfd_get_error ()));
1063 /* Save the offsets, we will nuke them with the rest of the
1065 num_offsets
= objfile
->num_sections
;
1066 section_offsets_size
=
1067 sizeof (struct section_offsets
)
1068 + sizeof (objfile
->section_offsets
->offsets
) * num_offsets
;
1069 offsets
= (struct section_offsets
*) alloca (section_offsets_size
);
1070 memcpy (offsets
, objfile
->section_offsets
, section_offsets_size
);
1072 /* Nuke all the state that we will re-read. Much of the following
1073 code which sets things to NULL really is necessary to tell
1074 other parts of GDB that there is nothing currently there. */
1076 /* FIXME: Do we have to free a whole linked list, or is this
1078 if (objfile
->global_psymbols
.list
)
1079 mfree (objfile
->md
, objfile
->global_psymbols
.list
);
1080 objfile
->global_psymbols
.list
= NULL
;
1081 objfile
->global_psymbols
.size
= 0;
1082 if (objfile
->static_psymbols
.list
)
1083 mfree (objfile
->md
, objfile
->static_psymbols
.list
);
1084 objfile
->static_psymbols
.list
= NULL
;
1085 objfile
->static_psymbols
.size
= 0;
1087 /* Free the obstacks for non-reusable objfiles */
1088 obstack_free (&objfile
-> psymbol_obstack
, 0);
1089 obstack_free (&objfile
-> symbol_obstack
, 0);
1090 obstack_free (&objfile
-> type_obstack
, 0);
1091 objfile
->sections
= NULL
;
1092 objfile
->symtabs
= NULL
;
1093 objfile
->psymtabs
= NULL
;
1094 objfile
->free_psymtabs
= NULL
;
1095 objfile
->msymbols
= NULL
;
1096 objfile
->minimal_symbol_count
= 0;
1097 objfile
->fundamental_types
= NULL
;
1098 if (objfile
-> sf
!= NULL
)
1100 (*objfile
-> sf
-> sym_finish
) (objfile
);
1103 /* We never make this a mapped file. */
1104 objfile
-> md
= NULL
;
1105 /* obstack_specify_allocation also initializes the obstack so
1107 obstack_specify_allocation (&objfile
-> psymbol_obstack
, 0, 0,
1109 obstack_specify_allocation (&objfile
-> symbol_obstack
, 0, 0,
1111 obstack_specify_allocation (&objfile
-> type_obstack
, 0, 0,
1113 if (build_objfile_section_table (objfile
))
1115 error ("Can't find the file sections in `%s': %s",
1116 objfile
-> name
, bfd_errmsg (bfd_get_error ()));
1119 /* We use the same section offsets as from last time. I'm not
1120 sure whether that is always correct for shared libraries. */
1121 objfile
->section_offsets
= (struct section_offsets
*)
1122 obstack_alloc (&objfile
-> psymbol_obstack
, section_offsets_size
);
1123 memcpy (objfile
->section_offsets
, offsets
, section_offsets_size
);
1124 objfile
->num_sections
= num_offsets
;
1126 /* What the hell is sym_new_init for, anyway? The concept of
1127 distinguishing between the main file and additional files
1128 in this way seems rather dubious. */
1129 if (objfile
== symfile_objfile
)
1130 (*objfile
->sf
->sym_new_init
) (objfile
);
1132 (*objfile
->sf
->sym_init
) (objfile
);
1133 clear_complaints (1, 1);
1134 /* The "mainline" parameter is a hideous hack; I think leaving it
1135 zero is OK since dbxread.c also does what it needs to do if
1136 objfile->global_psymbols.size is 0. */
1137 (*objfile
->sf
->sym_read
) (objfile
, objfile
->section_offsets
, 0);
1138 objfile
-> flags
|= OBJF_SYMS
;
1140 /* We're done reading the symbol file; finish off complaints. */
1141 clear_complaints (0, 1);
1143 /* Getting new symbols may change our opinion about what is
1146 reinit_frame_cache ();
1148 /* Discard cleanups as symbol reading was successful. */
1149 discard_cleanups (old_cleanups
);
1151 /* If the mtime has changed between the time we set new_modtime
1152 and now, we *want* this to be out of date, so don't call stat
1154 objfile
->mtime
= new_modtime
;
1161 clear_symtab_users ();
1166 deduce_language_from_filename (filename
)
1173 else if (0 == (c
= strrchr (filename
, '.')))
1174 ; /* Get default. */
1175 else if (STREQ(c
,".mod"))
1177 else if (STREQ(c
,".c"))
1179 else if (STREQ (c
,".cc") || STREQ (c
,".C") || STREQ (c
, ".cxx"))
1180 return language_cplus
;
1181 else if (STREQ (c
,".ch") || STREQ (c
,".c186") || STREQ (c
,".c286"))
1182 return language_chill
;
1184 return language_unknown
; /* default */
1189 Allocate and partly initialize a new symbol table. Return a pointer
1190 to it. error() if no space.
1192 Caller must set these fields:
1198 initialize any EXTRA_SYMTAB_INFO
1199 possibly free_named_symtabs (symtab->filename);
1203 allocate_symtab (filename
, objfile
)
1205 struct objfile
*objfile
;
1207 register struct symtab
*symtab
;
1209 symtab
= (struct symtab
*)
1210 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
1211 memset (symtab
, 0, sizeof (*symtab
));
1212 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
1213 &objfile
-> symbol_obstack
);
1214 symtab
-> fullname
= NULL
;
1215 symtab
-> language
= deduce_language_from_filename (filename
);
1217 /* Hook it to the objfile it comes from */
1219 symtab
-> objfile
= objfile
;
1220 symtab
-> next
= objfile
-> symtabs
;
1221 objfile
-> symtabs
= symtab
;
1223 #ifdef INIT_EXTRA_SYMTAB_INFO
1224 INIT_EXTRA_SYMTAB_INFO (symtab
);
1230 struct partial_symtab
*
1231 allocate_psymtab (filename
, objfile
)
1233 struct objfile
*objfile
;
1235 struct partial_symtab
*psymtab
;
1237 if (objfile
-> free_psymtabs
)
1239 psymtab
= objfile
-> free_psymtabs
;
1240 objfile
-> free_psymtabs
= psymtab
-> next
;
1243 psymtab
= (struct partial_symtab
*)
1244 obstack_alloc (&objfile
-> psymbol_obstack
,
1245 sizeof (struct partial_symtab
));
1247 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1248 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1249 &objfile
-> psymbol_obstack
);
1250 psymtab
-> symtab
= NULL
;
1252 /* Hook it to the objfile it comes from */
1254 psymtab
-> objfile
= objfile
;
1255 psymtab
-> next
= objfile
-> psymtabs
;
1256 objfile
-> psymtabs
= psymtab
;
1262 /* Reset all data structures in gdb which may contain references to symbol
1266 clear_symtab_users ()
1268 /* Someday, we should do better than this, by only blowing away
1269 the things that really need to be blown. */
1270 clear_value_history ();
1272 clear_internalvars ();
1273 breakpoint_re_set ();
1274 set_default_breakpoint (0, 0, 0, 0);
1275 current_source_symtab
= 0;
1276 current_source_line
= 0;
1277 clear_pc_function_cache ();
1280 /* clear_symtab_users_once:
1282 This function is run after symbol reading, or from a cleanup.
1283 If an old symbol table was obsoleted, the old symbol table
1284 has been blown away, but the other GDB data structures that may
1285 reference it have not yet been cleared or re-directed. (The old
1286 symtab was zapped, and the cleanup queued, in free_named_symtab()
1289 This function can be queued N times as a cleanup, or called
1290 directly; it will do all the work the first time, and then will be a
1291 no-op until the next time it is queued. This works by bumping a
1292 counter at queueing time. Much later when the cleanup is run, or at
1293 the end of symbol processing (in case the cleanup is discarded), if
1294 the queued count is greater than the "done-count", we do the work
1295 and set the done-count to the queued count. If the queued count is
1296 less than or equal to the done-count, we just ignore the call. This
1297 is needed because reading a single .o file will often replace many
1298 symtabs (one per .h file, for example), and we don't want to reset
1299 the breakpoints N times in the user's face.
1301 The reason we both queue a cleanup, and call it directly after symbol
1302 reading, is because the cleanup protects us in case of errors, but is
1303 discarded if symbol reading is successful. */
1306 /* FIXME: As free_named_symtabs is currently a big noop this function
1307 is no longer needed. */
1309 clear_symtab_users_once
PARAMS ((void));
1311 static int clear_symtab_users_queued
;
1312 static int clear_symtab_users_done
;
1315 clear_symtab_users_once ()
1317 /* Enforce once-per-`do_cleanups'-semantics */
1318 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1320 clear_symtab_users_done
= clear_symtab_users_queued
;
1322 clear_symtab_users ();
1326 /* Delete the specified psymtab, and any others that reference it. */
1329 cashier_psymtab (pst
)
1330 struct partial_symtab
*pst
;
1332 struct partial_symtab
*ps
, *pprev
= NULL
;
1335 /* Find its previous psymtab in the chain */
1336 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1343 /* Unhook it from the chain. */
1344 if (ps
== pst
->objfile
->psymtabs
)
1345 pst
->objfile
->psymtabs
= ps
->next
;
1347 pprev
->next
= ps
->next
;
1349 /* FIXME, we can't conveniently deallocate the entries in the
1350 partial_symbol lists (global_psymbols/static_psymbols) that
1351 this psymtab points to. These just take up space until all
1352 the psymtabs are reclaimed. Ditto the dependencies list and
1353 filename, which are all in the psymbol_obstack. */
1355 /* We need to cashier any psymtab that has this one as a dependency... */
1357 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1358 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1359 if (ps
->dependencies
[i
] == pst
) {
1360 cashier_psymtab (ps
);
1361 goto again
; /* Must restart, chain has been munged. */
1368 /* If a symtab or psymtab for filename NAME is found, free it along
1369 with any dependent breakpoints, displays, etc.
1370 Used when loading new versions of object modules with the "add-file"
1371 command. This is only called on the top-level symtab or psymtab's name;
1372 it is not called for subsidiary files such as .h files.
1374 Return value is 1 if we blew away the environment, 0 if not.
1375 FIXME. The return valu appears to never be used.
1377 FIXME. I think this is not the best way to do this. We should
1378 work on being gentler to the environment while still cleaning up
1379 all stray pointers into the freed symtab. */
1382 free_named_symtabs (name
)
1386 /* FIXME: With the new method of each objfile having it's own
1387 psymtab list, this function needs serious rethinking. In particular,
1388 why was it ever necessary to toss psymtabs with specific compilation
1389 unit filenames, as opposed to all psymtabs from a particular symbol
1391 Well, the answer is that some systems permit reloading of particular
1392 compilation units. We want to blow away any old info about these
1393 compilation units, regardless of which objfiles they arrived in. --gnu. */
1395 register struct symtab
*s
;
1396 register struct symtab
*prev
;
1397 register struct partial_symtab
*ps
;
1398 struct blockvector
*bv
;
1401 /* We only wack things if the symbol-reload switch is set. */
1402 if (!symbol_reloading
)
1405 /* Some symbol formats have trouble providing file names... */
1406 if (name
== 0 || *name
== '\0')
1409 /* Look for a psymtab with the specified name. */
1412 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1413 if (STREQ (name
, ps
->filename
)) {
1414 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1415 goto again2
; /* Must restart, chain has been munged */
1419 /* Look for a symtab with the specified name. */
1421 for (s
= symtab_list
; s
; s
= s
->next
)
1423 if (STREQ (name
, s
->filename
))
1430 if (s
== symtab_list
)
1431 symtab_list
= s
->next
;
1433 prev
->next
= s
->next
;
1435 /* For now, queue a delete for all breakpoints, displays, etc., whether
1436 or not they depend on the symtab being freed. This should be
1437 changed so that only those data structures affected are deleted. */
1439 /* But don't delete anything if the symtab is empty.
1440 This test is necessary due to a bug in "dbxread.c" that
1441 causes empty symtabs to be created for N_SO symbols that
1442 contain the pathname of the object file. (This problem
1443 has been fixed in GDB 3.9x). */
1445 bv
= BLOCKVECTOR (s
);
1446 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1447 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1448 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1450 complain (&oldsyms_complaint
, name
);
1452 clear_symtab_users_queued
++;
1453 make_cleanup (clear_symtab_users_once
, 0);
1456 complain (&empty_symtab_complaint
, name
);
1463 /* It is still possible that some breakpoints will be affected
1464 even though no symtab was found, since the file might have
1465 been compiled without debugging, and hence not be associated
1466 with a symtab. In order to handle this correctly, we would need
1467 to keep a list of text address ranges for undebuggable files.
1468 For now, we do nothing, since this is a fairly obscure case. */
1472 /* FIXME, what about the minimal symbol table? */
1479 /* Allocate and partially fill a partial symtab. It will be
1480 completely filled at the end of the symbol list.
1482 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1483 is the address relative to which its symbols are (incremental) or 0
1487 struct partial_symtab
*
1488 start_psymtab_common (objfile
, section_offsets
,
1489 filename
, textlow
, global_syms
, static_syms
)
1490 struct objfile
*objfile
;
1491 struct section_offsets
*section_offsets
;
1494 struct partial_symbol
*global_syms
;
1495 struct partial_symbol
*static_syms
;
1497 struct partial_symtab
*psymtab
;
1499 psymtab
= allocate_psymtab (filename
, objfile
);
1500 psymtab
-> section_offsets
= section_offsets
;
1501 psymtab
-> textlow
= textlow
;
1502 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
1503 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
1504 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
1508 /* Debugging versions of functions that are usually inline macros
1511 #if !INLINE_ADD_PSYMBOL
1513 /* Add a symbol with a long value to a psymtab.
1514 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
1517 add_psymbol_to_list (name
, namelength
, namespace, class, list
, val
, language
,
1521 enum namespace namespace;
1522 enum address_class
class;
1523 struct psymbol_allocation_list
*list
;
1525 enum language language
;
1526 struct objfile
*objfile
;
1528 register struct partial_symbol
*psym
;
1529 register char *demangled_name
;
1531 if (list
->next
>= list
->list
+ list
->size
)
1533 extend_psymbol_list (list
,objfile
);
1535 psym
= list
->next
++;
1537 SYMBOL_NAME (psym
) =
1538 (char *) obstack_alloc (&objfile
->psymbol_obstack
, namelength
+ 1);
1539 memcpy (SYMBOL_NAME (psym
), name
, namelength
);
1540 SYMBOL_NAME (psym
)[namelength
] = '\0';
1541 SYMBOL_VALUE (psym
) = val
;
1542 SYMBOL_LANGUAGE (psym
) = language
;
1543 PSYMBOL_NAMESPACE (psym
) = namespace;
1544 PSYMBOL_CLASS (psym
) = class;
1545 SYMBOL_INIT_DEMANGLED_NAME (psym
, &objfile
->psymbol_obstack
);
1548 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1551 add_psymbol_addr_to_list (name
, namelength
, namespace, class, list
, val
,
1555 enum namespace namespace;
1556 enum address_class
class;
1557 struct psymbol_allocation_list
*list
;
1559 enum language language
;
1560 struct objfile
*objfile
;
1562 register struct partial_symbol
*psym
;
1563 register char *demangled_name
;
1565 if (list
->next
>= list
->list
+ list
->size
)
1567 extend_psymbol_list (list
,objfile
);
1569 psym
= list
->next
++;
1571 SYMBOL_NAME (psym
) =
1572 (char *) obstack_alloc (&objfile
->psymbol_obstack
, namelength
+ 1);
1573 memcpy (SYMBOL_NAME (psym
), name
, namelength
);
1574 SYMBOL_NAME (psym
)[namelength
] = '\0';
1575 SYMBOL_VALUE_ADDRESS (psym
) = val
;
1576 SYMBOL_LANGUAGE (psym
) = language
;
1577 PSYMBOL_NAMESPACE (psym
) = namespace;
1578 PSYMBOL_CLASS (psym
) = class;
1579 SYMBOL_INIT_DEMANGLED_NAME (psym
, &objfile
->psymbol_obstack
);
1582 #endif /* !INLINE_ADD_PSYMBOL */
1586 _initialize_symfile ()
1588 struct cmd_list_element
*c
;
1590 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
1591 "Load symbol table from executable file FILE.\n\
1592 The `file' command can also load symbol tables, as well as setting the file\n\
1593 to execute.", &cmdlist
);
1594 c
->completer
= filename_completer
;
1596 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
1597 "Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
1598 The second argument provides the starting address of the file's text.",
1600 c
->completer
= filename_completer
;
1602 c
= add_cmd ("load", class_files
, load_command
,
1603 "Dynamically load FILE into the running program, and record its symbols\n\
1604 for access from GDB.", &cmdlist
);
1605 c
->completer
= filename_completer
;
1608 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
1609 (char *)&symbol_reloading
,
1610 "Set dynamic symbol table reloading multiple times in one run.",