1 /* Generic symbol file reading for the GNU debugger, GDB.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support, using pieces from other GDB modules.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
32 #include "breakpoint.h"
34 #include "complaints.h"
36 #include "inferior.h" /* for write_pc */
41 #include <sys/types.h>
43 #include "gdb_string.h"
54 /* Global variables owned by this file */
55 int readnow_symbol_files
; /* Read full symbols immediately */
57 struct complaint oldsyms_complaint
= {
58 "Replacing old symbols for `%s'", 0, 0
61 struct complaint empty_symtab_complaint
= {
62 "Empty symbol table found for `%s'", 0, 0
65 /* External variables and functions referenced. */
67 extern int info_verbose
;
69 /* Functions this file defines */
72 set_initial_language
PARAMS ((void));
75 load_command
PARAMS ((char *, int));
78 add_symbol_file_command
PARAMS ((char *, int));
81 add_shared_symbol_files_command
PARAMS ((char *, int));
84 cashier_psymtab
PARAMS ((struct partial_symtab
*));
87 compare_psymbols
PARAMS ((const void *, const void *));
90 compare_symbols
PARAMS ((const void *, const void *));
93 symfile_bfd_open
PARAMS ((char *));
96 find_sym_fns
PARAMS ((struct objfile
*));
98 /* List of all available sym_fns. On gdb startup, each object file reader
99 calls add_symtab_fns() to register information on each format it is
102 static struct sym_fns
*symtab_fns
= NULL
;
104 /* Flag for whether user will be reloading symbols multiple times.
105 Defaults to ON for VxWorks, otherwise OFF. */
107 #ifdef SYMBOL_RELOADING_DEFAULT
108 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
110 int symbol_reloading
= 0;
113 /* If true, then shared library symbols will be added automatically
114 when the inferior is created, new libraries are loaded, or when
115 attaching to the inferior. This is almost always what users
116 will want to have happen; but for very large programs, the startup
117 time will be excessive, and so if this is a problem, the user can
118 clear this flag and then add the shared library symbols as needed.
119 Note that there is a potential for confusion, since if the shared
120 library symbols are not loaded, commands like "info fun" will *not*
121 report all the functions that are actually present. */
123 int auto_solib_add
= 1;
126 /* Since this function is called from within qsort, in an ANSI environment
127 it must conform to the prototype for qsort, which specifies that the
128 comparison function takes two "void *" pointers. */
131 compare_symbols (s1p
, s2p
)
135 register struct symbol
**s1
, **s2
;
137 s1
= (struct symbol
**) s1p
;
138 s2
= (struct symbol
**) s2p
;
140 return (STRCMP (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
)));
147 compare_psymbols -- compare two partial symbols by name
151 Given pointers to pointers to two partial symbol table entries,
152 compare them by name and return -N, 0, or +N (ala strcmp).
153 Typically used by sorting routines like qsort().
157 Does direct compare of first two characters before punting
158 and passing to strcmp for longer compares. Note that the
159 original version had a bug whereby two null strings or two
160 identically named one character strings would return the
161 comparison of memory following the null byte.
166 compare_psymbols (s1p
, s2p
)
170 register char *st1
= SYMBOL_NAME (*(struct partial_symbol
**) s1p
);
171 register char *st2
= SYMBOL_NAME (*(struct partial_symbol
**) s2p
);
173 if ((st1
[0] - st2
[0]) || !st1
[0])
175 return (st1
[0] - st2
[0]);
177 else if ((st1
[1] - st2
[1]) || !st1
[1])
179 return (st1
[1] - st2
[1]);
183 return (STRCMP (st1
+ 2, st2
+ 2));
188 sort_pst_symbols (pst
)
189 struct partial_symtab
*pst
;
191 /* Sort the global list; don't sort the static list */
193 qsort (pst
-> objfile
-> global_psymbols
.list
+ pst
-> globals_offset
,
194 pst
-> n_global_syms
, sizeof (struct partial_symbol
*),
198 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
202 register struct block
*b
;
204 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
205 sizeof (struct symbol
*), compare_symbols
);
208 /* Call sort_symtab_syms to sort alphabetically
209 the symbols of each block of one symtab. */
213 register struct symtab
*s
;
215 register struct blockvector
*bv
;
218 register struct block
*b
;
222 bv
= BLOCKVECTOR (s
);
223 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
224 for (i
= 0; i
< nbl
; i
++)
226 b
= BLOCKVECTOR_BLOCK (bv
, i
);
227 if (BLOCK_SHOULD_SORT (b
))
232 /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
233 (and add a null character at the end in the copy).
234 Returns the address of the copy. */
237 obsavestring (ptr
, size
, obstackp
)
240 struct obstack
*obstackp
;
242 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
243 /* Open-coded memcpy--saves function call time.
244 These strings are usually short. */
246 register char *p1
= ptr
;
247 register char *p2
= p
;
248 char *end
= ptr
+ size
;
256 /* Concatenate strings S1, S2 and S3; return the new string.
257 Space is found in the symbol_obstack. */
260 obconcat (obstackp
, s1
, s2
, s3
)
261 struct obstack
*obstackp
;
262 const char *s1
, *s2
, *s3
;
264 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
265 register char *val
= (char *) obstack_alloc (obstackp
, len
);
272 /* True if we are nested inside psymtab_to_symtab. */
274 int currently_reading_symtab
= 0;
277 decrement_reading_symtab (dummy
)
280 currently_reading_symtab
--;
283 /* Get the symbol table that corresponds to a partial_symtab.
284 This is fast after the first time you do it. In fact, there
285 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
289 psymtab_to_symtab (pst
)
290 register struct partial_symtab
*pst
;
292 /* If it's been looked up before, return it. */
296 /* If it has not yet been read in, read it. */
299 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
300 currently_reading_symtab
++;
301 (*pst
->read_symtab
) (pst
);
302 do_cleanups (back_to
);
308 /* Initialize entry point information for this objfile. */
311 init_entry_point_info (objfile
)
312 struct objfile
*objfile
;
314 /* Save startup file's range of PC addresses to help blockframe.c
315 decide where the bottom of the stack is. */
317 if (bfd_get_file_flags (objfile
-> obfd
) & EXEC_P
)
319 /* Executable file -- record its entry point so we'll recognize
320 the startup file because it contains the entry point. */
321 objfile
-> ei
.entry_point
= bfd_get_start_address (objfile
-> obfd
);
325 /* Examination of non-executable.o files. Short-circuit this stuff. */
326 objfile
-> ei
.entry_point
= INVALID_ENTRY_POINT
;
328 objfile
-> ei
.entry_file_lowpc
= INVALID_ENTRY_LOWPC
;
329 objfile
-> ei
.entry_file_highpc
= INVALID_ENTRY_HIGHPC
;
330 objfile
-> ei
.entry_func_lowpc
= INVALID_ENTRY_LOWPC
;
331 objfile
-> ei
.entry_func_highpc
= INVALID_ENTRY_HIGHPC
;
332 objfile
-> ei
.main_func_lowpc
= INVALID_ENTRY_LOWPC
;
333 objfile
-> ei
.main_func_highpc
= INVALID_ENTRY_HIGHPC
;
336 /* Get current entry point address. */
339 entry_point_address()
341 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
344 /* Remember the lowest-addressed loadable section we've seen.
345 This function is called via bfd_map_over_sections.
347 In case of equal vmas, the section with the largest size becomes the
348 lowest-addressed loadable section.
350 If the vmas and sizes are equal, the last section is considered the
351 lowest-addressed loadable section. */
354 find_lowest_section (abfd
, sect
, obj
)
359 asection
**lowest
= (asection
**)obj
;
361 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
364 *lowest
= sect
; /* First loadable section */
365 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
366 *lowest
= sect
; /* A lower loadable section */
367 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
368 && (bfd_section_size (abfd
, (*lowest
))
369 <= bfd_section_size (abfd
, sect
)))
373 /* Process a symbol file, as either the main file or as a dynamically
376 NAME is the file name (which will be tilde-expanded and made
377 absolute herein) (but we don't free or modify NAME itself).
378 FROM_TTY says how verbose to be. MAINLINE specifies whether this
379 is the main symbol file, or whether it's an extra symbol file such
380 as dynamically loaded code. If !mainline, ADDR is the address
381 where the text segment was loaded. If VERBO, the caller has printed
382 a verbose message about the symbol reading (and complaints can be
383 more terse about it). */
386 syms_from_objfile (objfile
, addr
, mainline
, verbo
)
387 struct objfile
*objfile
;
392 struct section_offsets
*section_offsets
;
393 asection
*lowest_sect
;
394 struct cleanup
*old_chain
;
396 init_entry_point_info (objfile
);
397 find_sym_fns (objfile
);
399 /* Make sure that partially constructed symbol tables will be cleaned up
400 if an error occurs during symbol reading. */
401 old_chain
= make_cleanup (free_objfile
, objfile
);
405 /* We will modify the main symbol table, make sure that all its users
406 will be cleaned up if an error occurs during symbol reading. */
407 make_cleanup (clear_symtab_users
, 0);
409 /* Since no error yet, throw away the old symbol table. */
411 if (symfile_objfile
!= NULL
)
413 free_objfile (symfile_objfile
);
414 symfile_objfile
= NULL
;
417 /* Currently we keep symbols from the add-symbol-file command.
418 If the user wants to get rid of them, they should do "symbol-file"
419 without arguments first. Not sure this is the best behavior
422 (*objfile
-> sf
-> sym_new_init
) (objfile
);
425 /* Convert addr into an offset rather than an absolute address.
426 We find the lowest address of a loaded segment in the objfile,
427 and assume that <addr> is where that got loaded. Due to historical
428 precedent, we warn if that doesn't happen to be a text segment. */
432 addr
= 0; /* No offset from objfile addresses. */
436 lowest_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
437 if (lowest_sect
== NULL
)
438 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
441 if (lowest_sect
== NULL
)
442 warning ("no loadable sections found in added symbol-file %s",
444 else if ((bfd_get_section_flags (objfile
->obfd
, lowest_sect
) & SEC_CODE
)
446 /* FIXME-32x64--assumes bfd_vma fits in long. */
447 warning ("Lowest section in %s is %s at 0x%lx",
449 bfd_section_name (objfile
->obfd
, lowest_sect
),
450 (unsigned long) bfd_section_vma (objfile
->obfd
, lowest_sect
));
453 addr
-= bfd_section_vma (objfile
->obfd
, lowest_sect
);
456 /* Initialize symbol reading routines for this objfile, allow complaints to
457 appear for this new file, and record how verbose to be, then do the
458 initial symbol reading for this file. */
460 (*objfile
-> sf
-> sym_init
) (objfile
);
461 clear_complaints (1, verbo
);
463 section_offsets
= (*objfile
-> sf
-> sym_offsets
) (objfile
, addr
);
464 objfile
->section_offsets
= section_offsets
;
466 #ifndef IBM6000_TARGET
467 /* This is a SVR4/SunOS specific hack, I think. In any event, it
468 screws RS/6000. sym_offsets should be doing this sort of thing,
469 because it knows the mapping between bfd sections and
471 /* This is a hack. As far as I can tell, section offsets are not
472 target dependent. They are all set to addr with a couple of
473 exceptions. The exceptions are sysvr4 shared libraries, whose
474 offsets are kept in solib structures anyway and rs6000 xcoff
475 which handles shared libraries in a completely unique way.
477 Section offsets are built similarly, except that they are built
478 by adding addr in all cases because there is no clear mapping
479 from section_offsets into actual sections. Note that solib.c
480 has a different algorythm for finding section offsets.
482 These should probably all be collapsed into some target
483 independent form of shared library support. FIXME. */
487 struct obj_section
*s
;
489 for (s
= objfile
->sections
; s
< objfile
->sections_end
; ++s
)
491 s
->addr
-= s
->offset
;
493 s
->endaddr
-= s
->offset
;
498 #endif /* not IBM6000_TARGET */
500 (*objfile
-> sf
-> sym_read
) (objfile
, section_offsets
, mainline
);
502 if (!have_partial_symbols () && !have_full_symbols ())
505 printf_filtered ("(no debugging symbols found)...");
509 /* Don't allow char * to have a typename (else would get caddr_t).
510 Ditto void *. FIXME: Check whether this is now done by all the
511 symbol readers themselves (many of them now do), and if so remove
514 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
515 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
517 /* Mark the objfile has having had initial symbol read attempted. Note
518 that this does not mean we found any symbols... */
520 objfile
-> flags
|= OBJF_SYMS
;
522 /* Discard cleanups as symbol reading was successful. */
524 discard_cleanups (old_chain
);
526 /* Call this after reading in a new symbol table to give target dependant code
527 a crack at the new symbols. For instance, this could be used to update the
528 values of target-specific symbols GDB needs to keep track of (such as
529 _sigtramp, or whatever). */
531 TARGET_SYMFILE_POSTREAD (objfile
);
534 /* Perform required actions after either reading in the initial
535 symbols for a new objfile, or mapping in the symbols from a reusable
539 new_symfile_objfile (objfile
, mainline
, verbo
)
540 struct objfile
*objfile
;
545 /* If this is the main symbol file we have to clean up all users of the
546 old main symbol file. Otherwise it is sufficient to fixup all the
547 breakpoints that may have been redefined by this symbol file. */
550 /* OK, make it the "real" symbol file. */
551 symfile_objfile
= objfile
;
553 clear_symtab_users ();
557 breakpoint_re_set ();
560 /* We're done reading the symbol file; finish off complaints. */
561 clear_complaints (0, verbo
);
564 /* Process a symbol file, as either the main file or as a dynamically
567 NAME is the file name (which will be tilde-expanded and made
568 absolute herein) (but we don't free or modify NAME itself).
569 FROM_TTY says how verbose to be. MAINLINE specifies whether this
570 is the main symbol file, or whether it's an extra symbol file such
571 as dynamically loaded code. If !mainline, ADDR is the address
572 where the text segment was loaded.
574 Upon success, returns a pointer to the objfile that was added.
575 Upon failure, jumps back to command level (never returns). */
578 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
)
586 struct objfile
*objfile
;
587 struct partial_symtab
*psymtab
;
590 /* Open a bfd for the file, and give user a chance to burp if we'd be
591 interactively wiping out any existing symbols. */
593 abfd
= symfile_bfd_open (name
);
595 if ((have_full_symbols () || have_partial_symbols ())
598 && !query ("Load new symbol table from \"%s\"? ", name
))
599 error ("Not confirmed.");
601 objfile
= allocate_objfile (abfd
, mapped
);
603 /* If the objfile uses a mapped symbol file, and we have a psymtab for
604 it, then skip reading any symbols at this time. */
606 if ((objfile
-> flags
& OBJF_MAPPED
) && (objfile
-> flags
& OBJF_SYMS
))
608 /* We mapped in an existing symbol table file that already has had
609 initial symbol reading performed, so we can skip that part. Notify
610 the user that instead of reading the symbols, they have been mapped.
612 if (from_tty
|| info_verbose
)
614 printf_filtered ("Mapped symbols for %s...", name
);
616 gdb_flush (gdb_stdout
);
618 init_entry_point_info (objfile
);
619 find_sym_fns (objfile
);
623 /* We either created a new mapped symbol table, mapped an existing
624 symbol table file which has not had initial symbol reading
625 performed, or need to read an unmapped symbol table. */
626 if (from_tty
|| info_verbose
)
628 printf_filtered ("Reading symbols from %s...", name
);
630 gdb_flush (gdb_stdout
);
632 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
635 /* We now have at least a partial symbol table. Check to see if the
636 user requested that all symbols be read on initial access via either
637 the gdb startup command line or on a per symbol file basis. Expand
638 all partial symbol tables for this objfile if so. */
640 if (readnow
|| readnow_symbol_files
)
642 if (from_tty
|| info_verbose
)
644 printf_filtered ("expanding to full symbols...");
646 gdb_flush (gdb_stdout
);
649 for (psymtab
= objfile
-> psymtabs
;
651 psymtab
= psymtab
-> next
)
653 psymtab_to_symtab (psymtab
);
657 if (from_tty
|| info_verbose
)
659 printf_filtered ("done.\n");
660 gdb_flush (gdb_stdout
);
663 new_symfile_objfile (objfile
, mainline
, from_tty
);
668 /* This is the symbol-file command. Read the file, analyze its
669 symbols, and add a struct symtab to a symtab list. The syntax of
670 the command is rather bizarre--(1) buildargv implements various
671 quoting conventions which are undocumented and have little or
672 nothing in common with the way things are quoted (or not quoted)
673 elsewhere in GDB, (2) options are used, which are not generally
674 used in GDB (perhaps "set mapped on", "set readnow on" would be
675 better), (3) the order of options matters, which is contrary to GNU
676 conventions (because it is confusing and inconvenient). */
679 symbol_file_command (args
, from_tty
)
685 CORE_ADDR text_relocation
= 0; /* text_relocation */
686 struct cleanup
*cleanups
;
694 if ((have_full_symbols () || have_partial_symbols ())
696 && !query ("Discard symbol table from `%s'? ",
697 symfile_objfile
-> name
))
698 error ("Not confirmed.");
699 free_all_objfiles ();
700 symfile_objfile
= NULL
;
703 printf_unfiltered ("No symbol file now.\n");
708 if ((argv
= buildargv (args
)) == NULL
)
712 cleanups
= make_cleanup (freeargv
, (char *) argv
);
713 while (*argv
!= NULL
)
715 if (STREQ (*argv
, "-mapped"))
719 else if (STREQ (*argv
, "-readnow"))
723 else if (**argv
== '-')
725 error ("unknown option `%s'", *argv
);
733 /* this is for rombug remote only, to get the text relocation by
734 using link command */
735 p
= strrchr(name
, '/');
739 target_link(p
, &text_relocation
);
741 if (text_relocation
== (CORE_ADDR
)0)
743 else if (text_relocation
== (CORE_ADDR
)-1)
744 symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1, mapped
,
747 symbol_file_add (name
, from_tty
, (CORE_ADDR
)text_relocation
,
750 /* Getting new symbols may change our opinion about what is
752 reinit_frame_cache ();
754 set_initial_language ();
761 error ("no symbol file name was specified");
763 do_cleanups (cleanups
);
767 /* Set the initial language.
769 A better solution would be to record the language in the psymtab when reading
770 partial symbols, and then use it (if known) to set the language. This would
771 be a win for formats that encode the language in an easily discoverable place,
772 such as DWARF. For stabs, we can jump through hoops looking for specially
773 named symbols or try to intuit the language from the specific type of stabs
774 we find, but we can't do that until later when we read in full symbols.
778 set_initial_language ()
780 struct partial_symtab
*pst
;
781 enum language lang
= language_unknown
;
783 pst
= find_main_psymtab ();
786 if (pst
-> filename
!= NULL
)
788 lang
= deduce_language_from_filename (pst
-> filename
);
790 if (lang
== language_unknown
)
792 /* Make C the default language */
796 expected_language
= current_language
; /* Don't warn the user */
800 /* Open file specified by NAME and hand it off to BFD for preliminary
801 analysis. Result is a newly initialized bfd *, which includes a newly
802 malloc'd` copy of NAME (tilde-expanded and made absolute).
803 In case of trouble, error() is called. */
806 symfile_bfd_open (name
)
813 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
815 /* Look down path for it, allocate 2nd new malloc'd copy. */
816 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
819 make_cleanup (free
, name
);
820 perror_with_name (name
);
822 free (name
); /* Free 1st new malloc'd copy */
823 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
824 /* It'll be freed in free_objfile(). */
826 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
830 make_cleanup (free
, name
);
831 error ("\"%s\": can't open to read symbols: %s.", name
,
832 bfd_errmsg (bfd_get_error ()));
834 sym_bfd
->cacheable
= true;
836 if (!bfd_check_format (sym_bfd
, bfd_object
))
838 /* FIXME: should be checking for errors from bfd_close (for one thing,
839 on error it does not free all the storage associated with the
841 bfd_close (sym_bfd
); /* This also closes desc */
842 make_cleanup (free
, name
);
843 error ("\"%s\": can't read symbols: %s.", name
,
844 bfd_errmsg (bfd_get_error ()));
850 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
851 startup by the _initialize routine in each object file format reader,
852 to register information about each format the the reader is prepared
859 sf
->next
= symtab_fns
;
864 /* Initialize to read symbols from the symbol file sym_bfd. It either
865 returns or calls error(). The result is an initialized struct sym_fns
866 in the objfile structure, that contains cached information about the
870 find_sym_fns (objfile
)
871 struct objfile
*objfile
;
874 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
-> obfd
);
875 char *our_target
= bfd_get_target (objfile
-> obfd
);
877 /* Special kludge for RS/6000 and PowerMac. See xcoffread.c. */
878 if (STREQ (our_target
, "aixcoff-rs6000") ||
879 STREQ (our_target
, "xcoff-powermac"))
880 our_flavour
= (enum bfd_flavour
)-1;
882 /* Special kludge for apollo. See dstread.c. */
883 if (STREQN (our_target
, "apollo", 6))
884 our_flavour
= (enum bfd_flavour
)-2;
886 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
-> next
)
888 if (our_flavour
== sf
-> sym_flavour
)
894 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
895 bfd_get_target (objfile
-> obfd
));
898 /* This function runs the load command of our current target. */
901 load_command (arg
, from_tty
)
906 arg
= get_exec_file (1);
907 target_load (arg
, from_tty
);
910 /* This version of "load" should be usable for any target. Currently
911 it is just used for remote targets, not inftarg.c or core files,
912 on the theory that only in that case is it useful.
914 Avoiding xmodem and the like seems like a win (a) because we don't have
915 to worry about finding it, and (b) On VMS, fork() is very slow and so
916 we don't want to run a subprocess. On the other hand, I'm not sure how
917 performance compares. */
919 generic_load (filename
, from_tty
)
923 struct cleanup
*old_cleanups
;
927 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
928 if (loadfile_bfd
== NULL
)
930 perror_with_name (filename
);
933 /* FIXME: should be checking for errors from bfd_close (for one thing,
934 on error it does not free all the storage associated with the
936 old_cleanups
= make_cleanup (bfd_close
, loadfile_bfd
);
938 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
940 error ("\"%s\" is not an object file: %s", filename
,
941 bfd_errmsg (bfd_get_error ()));
944 for (s
= loadfile_bfd
->sections
; s
; s
= s
->next
)
946 if (s
->flags
& SEC_LOAD
)
950 size
= bfd_get_section_size_before_reloc (s
);
954 struct cleanup
*old_chain
;
957 buffer
= xmalloc (size
);
958 old_chain
= make_cleanup (free
, buffer
);
960 vma
= bfd_get_section_vma (loadfile_bfd
, s
);
962 /* Is this really necessary? I guess it gives the user something
963 to look at during a long download. */
964 printf_filtered ("Loading section %s, size 0x%lx vma ",
965 bfd_get_section_name (loadfile_bfd
, s
),
966 (unsigned long) size
);
967 print_address_numeric (vma
, 1, gdb_stdout
);
968 printf_filtered ("\n");
970 bfd_get_section_contents (loadfile_bfd
, s
, buffer
, 0, size
);
972 target_write_memory (vma
, buffer
, size
);
974 do_cleanups (old_chain
);
979 /* We were doing this in remote-mips.c, I suspect it is right
980 for other targets too. */
981 write_pc (loadfile_bfd
->start_address
);
983 /* FIXME: are we supposed to call symbol_file_add or not? According to
984 a comment from remote-mips.c (where a call to symbol_file_add was
985 commented out), making the call confuses GDB if more than one file is
986 loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
989 do_cleanups (old_cleanups
);
992 /* This function allows the addition of incrementally linked object files.
993 It does not modify any state in the target, only in the debugger. */
997 add_symbol_file_command (args
, from_tty
)
1002 CORE_ADDR text_addr
;
1011 error ("add-symbol-file takes a file name and an address");
1014 /* Make a copy of the string that we can safely write into. */
1016 args
= strdup (args
);
1017 make_cleanup (free
, args
);
1019 /* Pick off any -option args and the file name. */
1021 while ((*args
!= '\000') && (name
== NULL
))
1023 while (isspace (*args
)) {args
++;}
1025 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
1026 if (*args
!= '\000')
1034 else if (STREQ (arg
, "-mapped"))
1038 else if (STREQ (arg
, "-readnow"))
1044 error ("unknown option `%s'", arg
);
1048 /* After picking off any options and the file name, args should be
1049 left pointing at the remainder of the command line, which should
1050 be the address expression to evaluate. */
1054 error ("add-symbol-file takes a file name");
1056 name
= tilde_expand (name
);
1057 make_cleanup (free
, name
);
1059 if (*args
!= '\000')
1061 text_addr
= parse_and_eval_address (args
);
1065 target_link(name
, &text_addr
);
1066 if (text_addr
== (CORE_ADDR
)-1)
1067 error("Don't know how to get text start location for this file");
1070 /* FIXME-32x64: Assumes text_addr fits in a long. */
1071 if (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
1072 name
, local_hex_string ((unsigned long)text_addr
)))
1073 error ("Not confirmed.");
1075 symbol_file_add (name
, 0, text_addr
, 0, mapped
, readnow
);
1077 /* Getting new symbols may change our opinion about what is
1079 reinit_frame_cache ();
1083 add_shared_symbol_files_command (args
, from_tty
)
1087 #ifdef ADD_SHARED_SYMBOL_FILES
1088 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1090 error ("This command is not available in this configuration of GDB.");
1094 /* Re-read symbols if a symbol-file has changed. */
1098 struct objfile
*objfile
;
1101 struct stat new_statbuf
;
1104 /* With the addition of shared libraries, this should be modified,
1105 the load time should be saved in the partial symbol tables, since
1106 different tables may come from different source files. FIXME.
1107 This routine should then walk down each partial symbol table
1108 and see if the symbol table that it originates from has been changed */
1110 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
1111 if (objfile
->obfd
) {
1112 #ifdef IBM6000_TARGET
1113 /* If this object is from a shared library, then you should
1114 stat on the library name, not member name. */
1116 if (objfile
->obfd
->my_archive
)
1117 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1120 res
= stat (objfile
->name
, &new_statbuf
);
1122 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1123 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1127 new_modtime
= new_statbuf
.st_mtime
;
1128 if (new_modtime
!= objfile
->mtime
)
1130 struct cleanup
*old_cleanups
;
1131 struct section_offsets
*offsets
;
1133 int section_offsets_size
;
1134 char *obfd_filename
;
1136 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1139 /* There are various functions like symbol_file_add,
1140 symfile_bfd_open, syms_from_objfile, etc., which might
1141 appear to do what we want. But they have various other
1142 effects which we *don't* want. So we just do stuff
1143 ourselves. We don't worry about mapped files (for one thing,
1144 any mapped file will be out of date). */
1146 /* If we get an error, blow away this objfile (not sure if
1147 that is the correct response for things like shared
1149 old_cleanups
= make_cleanup (free_objfile
, objfile
);
1150 /* We need to do this whenever any symbols go away. */
1151 make_cleanup (clear_symtab_users
, 0);
1153 /* Clean up any state BFD has sitting around. We don't need
1154 to close the descriptor but BFD lacks a way of closing the
1155 BFD without closing the descriptor. */
1156 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1157 if (!bfd_close (objfile
->obfd
))
1158 error ("Can't close BFD for %s: %s", objfile
->name
,
1159 bfd_errmsg (bfd_get_error ()));
1160 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1161 if (objfile
->obfd
== NULL
)
1162 error ("Can't open %s to read symbols.", objfile
->name
);
1163 /* bfd_openr sets cacheable to true, which is what we want. */
1164 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1165 error ("Can't read symbols from %s: %s.", objfile
->name
,
1166 bfd_errmsg (bfd_get_error ()));
1168 /* Save the offsets, we will nuke them with the rest of the
1170 num_offsets
= objfile
->num_sections
;
1171 section_offsets_size
=
1172 sizeof (struct section_offsets
)
1173 + sizeof (objfile
->section_offsets
->offsets
) * num_offsets
;
1174 offsets
= (struct section_offsets
*) alloca (section_offsets_size
);
1175 memcpy (offsets
, objfile
->section_offsets
, section_offsets_size
);
1177 /* Nuke all the state that we will re-read. Much of the following
1178 code which sets things to NULL really is necessary to tell
1179 other parts of GDB that there is nothing currently there. */
1181 /* FIXME: Do we have to free a whole linked list, or is this
1183 if (objfile
->global_psymbols
.list
)
1184 mfree (objfile
->md
, objfile
->global_psymbols
.list
);
1185 objfile
->global_psymbols
.list
= NULL
;
1186 objfile
->global_psymbols
.next
= NULL
;
1187 objfile
->global_psymbols
.size
= 0;
1188 if (objfile
->static_psymbols
.list
)
1189 mfree (objfile
->md
, objfile
->static_psymbols
.list
);
1190 objfile
->static_psymbols
.list
= NULL
;
1191 objfile
->static_psymbols
.next
= NULL
;
1192 objfile
->static_psymbols
.size
= 0;
1194 /* Free the obstacks for non-reusable objfiles */
1195 obstack_free (&objfile
-> psymbol_cache
.cache
, 0);
1196 obstack_free (&objfile
-> psymbol_obstack
, 0);
1197 obstack_free (&objfile
-> symbol_obstack
, 0);
1198 obstack_free (&objfile
-> type_obstack
, 0);
1199 objfile
->sections
= NULL
;
1200 objfile
->symtabs
= NULL
;
1201 objfile
->psymtabs
= NULL
;
1202 objfile
->free_psymtabs
= NULL
;
1203 objfile
->msymbols
= NULL
;
1204 objfile
->minimal_symbol_count
= 0;
1205 objfile
->fundamental_types
= NULL
;
1206 if (objfile
-> sf
!= NULL
)
1208 (*objfile
-> sf
-> sym_finish
) (objfile
);
1211 /* We never make this a mapped file. */
1212 objfile
-> md
= NULL
;
1213 /* obstack_specify_allocation also initializes the obstack so
1215 obstack_specify_allocation (&objfile
-> psymbol_cache
.cache
, 0, 0,
1217 obstack_specify_allocation (&objfile
-> psymbol_obstack
, 0, 0,
1219 obstack_specify_allocation (&objfile
-> symbol_obstack
, 0, 0,
1221 obstack_specify_allocation (&objfile
-> type_obstack
, 0, 0,
1223 if (build_objfile_section_table (objfile
))
1225 error ("Can't find the file sections in `%s': %s",
1226 objfile
-> name
, bfd_errmsg (bfd_get_error ()));
1229 /* We use the same section offsets as from last time. I'm not
1230 sure whether that is always correct for shared libraries. */
1231 objfile
->section_offsets
= (struct section_offsets
*)
1232 obstack_alloc (&objfile
-> psymbol_obstack
, section_offsets_size
);
1233 memcpy (objfile
->section_offsets
, offsets
, section_offsets_size
);
1234 objfile
->num_sections
= num_offsets
;
1236 /* What the hell is sym_new_init for, anyway? The concept of
1237 distinguishing between the main file and additional files
1238 in this way seems rather dubious. */
1239 if (objfile
== symfile_objfile
)
1240 (*objfile
->sf
->sym_new_init
) (objfile
);
1242 (*objfile
->sf
->sym_init
) (objfile
);
1243 clear_complaints (1, 1);
1244 /* The "mainline" parameter is a hideous hack; I think leaving it
1245 zero is OK since dbxread.c also does what it needs to do if
1246 objfile->global_psymbols.size is 0. */
1247 (*objfile
->sf
->sym_read
) (objfile
, objfile
->section_offsets
, 0);
1248 if (!have_partial_symbols () && !have_full_symbols ())
1251 printf_filtered ("(no debugging symbols found)\n");
1254 objfile
-> flags
|= OBJF_SYMS
;
1256 /* We're done reading the symbol file; finish off complaints. */
1257 clear_complaints (0, 1);
1259 /* Getting new symbols may change our opinion about what is
1262 reinit_frame_cache ();
1264 /* Discard cleanups as symbol reading was successful. */
1265 discard_cleanups (old_cleanups
);
1267 /* If the mtime has changed between the time we set new_modtime
1268 and now, we *want* this to be out of date, so don't call stat
1270 objfile
->mtime
= new_modtime
;
1273 /* Call this after reading in a new symbol table to give target
1274 dependant code a crack at the new symbols. For instance, this
1275 could be used to update the values of target-specific symbols GDB
1276 needs to keep track of (such as _sigtramp, or whatever). */
1278 TARGET_SYMFILE_POSTREAD (objfile
);
1284 clear_symtab_users ();
1289 deduce_language_from_filename (filename
)
1296 else if (0 == (c
= strrchr (filename
, '.')))
1297 ; /* Get default. */
1298 else if (STREQ (c
, ".c"))
1300 else if (STREQ (c
, ".cc") || STREQ (c
, ".C") || STREQ (c
, ".cxx")
1301 || STREQ (c
, ".cpp") || STREQ (c
, ".cp") || STREQ (c
, ".c++"))
1302 return language_cplus
;
1303 else if (STREQ (c
, ".ch") || STREQ (c
, ".c186") || STREQ (c
, ".c286"))
1304 return language_chill
;
1305 else if (STREQ (c
, ".f") || STREQ (c
, ".F"))
1306 return language_fortran
;
1307 else if (STREQ (c
, ".mod"))
1309 else if (STREQ (c
, ".s") || STREQ (c
, ".S"))
1310 return language_asm
;
1312 return language_unknown
; /* default */
1317 Allocate and partly initialize a new symbol table. Return a pointer
1318 to it. error() if no space.
1320 Caller must set these fields:
1326 initialize any EXTRA_SYMTAB_INFO
1327 possibly free_named_symtabs (symtab->filename);
1331 allocate_symtab (filename
, objfile
)
1333 struct objfile
*objfile
;
1335 register struct symtab
*symtab
;
1337 symtab
= (struct symtab
*)
1338 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
1339 memset (symtab
, 0, sizeof (*symtab
));
1340 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
1341 &objfile
-> symbol_obstack
);
1342 symtab
-> fullname
= NULL
;
1343 symtab
-> language
= deduce_language_from_filename (filename
);
1345 /* Hook it to the objfile it comes from */
1347 symtab
-> objfile
= objfile
;
1348 symtab
-> next
= objfile
-> symtabs
;
1349 objfile
-> symtabs
= symtab
;
1351 #ifdef INIT_EXTRA_SYMTAB_INFO
1352 INIT_EXTRA_SYMTAB_INFO (symtab
);
1358 struct partial_symtab
*
1359 allocate_psymtab (filename
, objfile
)
1361 struct objfile
*objfile
;
1363 struct partial_symtab
*psymtab
;
1365 if (objfile
-> free_psymtabs
)
1367 psymtab
= objfile
-> free_psymtabs
;
1368 objfile
-> free_psymtabs
= psymtab
-> next
;
1371 psymtab
= (struct partial_symtab
*)
1372 obstack_alloc (&objfile
-> psymbol_obstack
,
1373 sizeof (struct partial_symtab
));
1375 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1376 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1377 &objfile
-> psymbol_obstack
);
1378 psymtab
-> symtab
= NULL
;
1380 /* Hook it to the objfile it comes from */
1382 psymtab
-> objfile
= objfile
;
1383 psymtab
-> next
= objfile
-> psymtabs
;
1384 objfile
-> psymtabs
= psymtab
;
1390 /* Reset all data structures in gdb which may contain references to symbol
1394 clear_symtab_users ()
1396 /* Someday, we should do better than this, by only blowing away
1397 the things that really need to be blown. */
1398 clear_value_history ();
1400 clear_internalvars ();
1401 breakpoint_re_set ();
1402 set_default_breakpoint (0, 0, 0, 0);
1403 current_source_symtab
= 0;
1404 current_source_line
= 0;
1405 clear_pc_function_cache ();
1408 /* clear_symtab_users_once:
1410 This function is run after symbol reading, or from a cleanup.
1411 If an old symbol table was obsoleted, the old symbol table
1412 has been blown away, but the other GDB data structures that may
1413 reference it have not yet been cleared or re-directed. (The old
1414 symtab was zapped, and the cleanup queued, in free_named_symtab()
1417 This function can be queued N times as a cleanup, or called
1418 directly; it will do all the work the first time, and then will be a
1419 no-op until the next time it is queued. This works by bumping a
1420 counter at queueing time. Much later when the cleanup is run, or at
1421 the end of symbol processing (in case the cleanup is discarded), if
1422 the queued count is greater than the "done-count", we do the work
1423 and set the done-count to the queued count. If the queued count is
1424 less than or equal to the done-count, we just ignore the call. This
1425 is needed because reading a single .o file will often replace many
1426 symtabs (one per .h file, for example), and we don't want to reset
1427 the breakpoints N times in the user's face.
1429 The reason we both queue a cleanup, and call it directly after symbol
1430 reading, is because the cleanup protects us in case of errors, but is
1431 discarded if symbol reading is successful. */
1434 /* FIXME: As free_named_symtabs is currently a big noop this function
1435 is no longer needed. */
1437 clear_symtab_users_once
PARAMS ((void));
1439 static int clear_symtab_users_queued
;
1440 static int clear_symtab_users_done
;
1443 clear_symtab_users_once ()
1445 /* Enforce once-per-`do_cleanups'-semantics */
1446 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1448 clear_symtab_users_done
= clear_symtab_users_queued
;
1450 clear_symtab_users ();
1454 /* Delete the specified psymtab, and any others that reference it. */
1457 cashier_psymtab (pst
)
1458 struct partial_symtab
*pst
;
1460 struct partial_symtab
*ps
, *pprev
= NULL
;
1463 /* Find its previous psymtab in the chain */
1464 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1471 /* Unhook it from the chain. */
1472 if (ps
== pst
->objfile
->psymtabs
)
1473 pst
->objfile
->psymtabs
= ps
->next
;
1475 pprev
->next
= ps
->next
;
1477 /* FIXME, we can't conveniently deallocate the entries in the
1478 partial_symbol lists (global_psymbols/static_psymbols) that
1479 this psymtab points to. These just take up space until all
1480 the psymtabs are reclaimed. Ditto the dependencies list and
1481 filename, which are all in the psymbol_obstack. */
1483 /* We need to cashier any psymtab that has this one as a dependency... */
1485 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1486 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1487 if (ps
->dependencies
[i
] == pst
) {
1488 cashier_psymtab (ps
);
1489 goto again
; /* Must restart, chain has been munged. */
1496 /* If a symtab or psymtab for filename NAME is found, free it along
1497 with any dependent breakpoints, displays, etc.
1498 Used when loading new versions of object modules with the "add-file"
1499 command. This is only called on the top-level symtab or psymtab's name;
1500 it is not called for subsidiary files such as .h files.
1502 Return value is 1 if we blew away the environment, 0 if not.
1503 FIXME. The return valu appears to never be used.
1505 FIXME. I think this is not the best way to do this. We should
1506 work on being gentler to the environment while still cleaning up
1507 all stray pointers into the freed symtab. */
1510 free_named_symtabs (name
)
1514 /* FIXME: With the new method of each objfile having it's own
1515 psymtab list, this function needs serious rethinking. In particular,
1516 why was it ever necessary to toss psymtabs with specific compilation
1517 unit filenames, as opposed to all psymtabs from a particular symbol
1519 Well, the answer is that some systems permit reloading of particular
1520 compilation units. We want to blow away any old info about these
1521 compilation units, regardless of which objfiles they arrived in. --gnu. */
1523 register struct symtab
*s
;
1524 register struct symtab
*prev
;
1525 register struct partial_symtab
*ps
;
1526 struct blockvector
*bv
;
1529 /* We only wack things if the symbol-reload switch is set. */
1530 if (!symbol_reloading
)
1533 /* Some symbol formats have trouble providing file names... */
1534 if (name
== 0 || *name
== '\0')
1537 /* Look for a psymtab with the specified name. */
1540 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1541 if (STREQ (name
, ps
->filename
)) {
1542 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1543 goto again2
; /* Must restart, chain has been munged */
1547 /* Look for a symtab with the specified name. */
1549 for (s
= symtab_list
; s
; s
= s
->next
)
1551 if (STREQ (name
, s
->filename
))
1558 if (s
== symtab_list
)
1559 symtab_list
= s
->next
;
1561 prev
->next
= s
->next
;
1563 /* For now, queue a delete for all breakpoints, displays, etc., whether
1564 or not they depend on the symtab being freed. This should be
1565 changed so that only those data structures affected are deleted. */
1567 /* But don't delete anything if the symtab is empty.
1568 This test is necessary due to a bug in "dbxread.c" that
1569 causes empty symtabs to be created for N_SO symbols that
1570 contain the pathname of the object file. (This problem
1571 has been fixed in GDB 3.9x). */
1573 bv
= BLOCKVECTOR (s
);
1574 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1575 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1576 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1578 complain (&oldsyms_complaint
, name
);
1580 clear_symtab_users_queued
++;
1581 make_cleanup (clear_symtab_users_once
, 0);
1584 complain (&empty_symtab_complaint
, name
);
1591 /* It is still possible that some breakpoints will be affected
1592 even though no symtab was found, since the file might have
1593 been compiled without debugging, and hence not be associated
1594 with a symtab. In order to handle this correctly, we would need
1595 to keep a list of text address ranges for undebuggable files.
1596 For now, we do nothing, since this is a fairly obscure case. */
1600 /* FIXME, what about the minimal symbol table? */
1607 /* Allocate and partially fill a partial symtab. It will be
1608 completely filled at the end of the symbol list.
1610 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1611 is the address relative to which its symbols are (incremental) or 0
1615 struct partial_symtab
*
1616 start_psymtab_common (objfile
, section_offsets
,
1617 filename
, textlow
, global_syms
, static_syms
)
1618 struct objfile
*objfile
;
1619 struct section_offsets
*section_offsets
;
1622 struct partial_symbol
**global_syms
;
1623 struct partial_symbol
**static_syms
;
1625 struct partial_symtab
*psymtab
;
1627 psymtab
= allocate_psymtab (filename
, objfile
);
1628 psymtab
-> section_offsets
= section_offsets
;
1629 psymtab
-> textlow
= textlow
;
1630 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
1631 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
1632 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
1636 /* Debugging versions of functions that are usually inline macros
1639 #if !INLINE_ADD_PSYMBOL
1641 /* Add a symbol with a long value to a psymtab.
1642 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
1645 add_psymbol_to_list (name
, namelength
, namespace, class, list
, val
, language
,
1649 namespace_enum
namespace;
1650 enum address_class
class;
1651 struct psymbol_allocation_list
*list
;
1653 enum language language
;
1654 struct objfile
*objfile
;
1656 register struct partial_symbol
*psym
;
1657 char *buf
= alloca (namelength
+ 1);
1658 struct partial_symbol psymbol
;
1660 /* Create local copy of the partial symbol */
1661 memcpy (buf
, name
, namelength
);
1662 buf
[namelength
] = '\0';
1663 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, &objfile
->psymbol_cache
);
1664 SYMBOL_VALUE (&psymbol
) = val
;
1665 SYMBOL_SECTION (&psymbol
) = 0;
1666 SYMBOL_LANGUAGE (&psymbol
) = language
;
1667 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
1668 PSYMBOL_CLASS (&psymbol
) = class;
1669 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
1671 /* Stash the partial symbol away in the cache */
1672 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), &objfile
->psymbol_cache
);
1674 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1675 if (list
->next
>= list
->list
+ list
->size
)
1677 extend_psymbol_list (list
, objfile
);
1679 *list
->next
++ = psym
;
1680 OBJSTAT (objfile
, n_psyms
++);
1683 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1686 add_psymbol_addr_to_list (name
, namelength
, namespace, class, list
, val
,
1690 namespace_enum
namespace;
1691 enum address_class
class;
1692 struct psymbol_allocation_list
*list
;
1694 enum language language
;
1695 struct objfile
*objfile
;
1697 register struct partial_symbol
*psym
;
1698 char *buf
= alloca (namelength
+ 1);
1699 struct partial_symbol psymbol
;
1701 /* Create local copy of the partial symbol */
1702 memcpy (buf
, name
, namelength
);
1703 buf
[namelength
] = '\0';
1704 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, &objfile
->psymbol_cache
);
1705 SYMBOL_VALUE_ADDRESS (&psymbol
) = val
;
1706 SYMBOL_SECTION (&psymbol
) = 0;
1707 SYMBOL_LANGUAGE (&psymbol
) = language
;
1708 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
1709 PSYMBOL_CLASS (&psymbol
) = class;
1710 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
1712 /* Stash the partial symbol away in the cache */
1713 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), &objfile
->psymbol_cache
);
1715 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1716 if (list
->next
>= list
->list
+ list
->size
)
1718 extend_psymbol_list (list
, objfile
);
1720 *list
->next
++ = psym
;
1721 OBJSTAT (objfile
, n_psyms
++);
1724 #endif /* !INLINE_ADD_PSYMBOL */
1726 /* Initialize storage for partial symbols. */
1729 init_psymbol_list (objfile
, total_symbols
)
1730 struct objfile
*objfile
;
1733 /* Free any previously allocated psymbol lists. */
1735 if (objfile
-> global_psymbols
.list
)
1737 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
1739 if (objfile
-> static_psymbols
.list
)
1741 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
1744 /* Current best guess is that approximately a twentieth
1745 of the total symbols (in a debugging file) are global or static
1748 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
1749 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
1750 objfile
-> global_psymbols
.next
=
1751 objfile
-> global_psymbols
.list
= (struct partial_symbol
**)
1752 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
1753 * sizeof (struct partial_symbol
*));
1754 objfile
-> static_psymbols
.next
=
1755 objfile
-> static_psymbols
.list
= (struct partial_symbol
**)
1756 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
1757 * sizeof (struct partial_symbol
*));
1761 _initialize_symfile ()
1763 struct cmd_list_element
*c
;
1765 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
1766 "Load symbol table from executable file FILE.\n\
1767 The `file' command can also load symbol tables, as well as setting the file\n\
1768 to execute.", &cmdlist
);
1769 c
->completer
= filename_completer
;
1771 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
1772 "Usage: add-symbol-file FILE ADDR\n\
1773 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
1774 ADDR is the starting address of the file's text.",
1776 c
->completer
= filename_completer
;
1778 c
= add_cmd ("add-shared-symbol-files", class_files
,
1779 add_shared_symbol_files_command
,
1780 "Load the symbols from shared objects in the dynamic linker's link map.",
1782 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
1785 c
= add_cmd ("load", class_files
, load_command
,
1786 "Dynamically load FILE into the running program, and record its symbols\n\
1787 for access from GDB.", &cmdlist
);
1788 c
->completer
= filename_completer
;
1791 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
1792 (char *)&symbol_reloading
,
1793 "Set dynamic symbol table reloading multiple times in one run.",