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"
55 /* Global variables owned by this file */
56 int readnow_symbol_files
; /* Read full symbols immediately */
58 struct complaint oldsyms_complaint
= {
59 "Replacing old symbols for `%s'", 0, 0
62 struct complaint empty_symtab_complaint
= {
63 "Empty symbol table found for `%s'", 0, 0
66 /* External variables and functions referenced. */
68 extern int info_verbose
;
70 /* Functions this file defines */
73 set_initial_language
PARAMS ((void));
76 load_command
PARAMS ((char *, int));
79 add_symbol_file_command
PARAMS ((char *, int));
82 add_shared_symbol_files_command
PARAMS ((char *, int));
85 cashier_psymtab
PARAMS ((struct partial_symtab
*));
88 compare_psymbols
PARAMS ((const void *, const void *));
91 compare_symbols
PARAMS ((const void *, const void *));
94 symfile_bfd_open
PARAMS ((char *));
97 find_sym_fns
PARAMS ((struct objfile
*));
99 /* List of all available sym_fns. On gdb startup, each object file reader
100 calls add_symtab_fns() to register information on each format it is
103 static struct sym_fns
*symtab_fns
= NULL
;
105 /* Flag for whether user will be reloading symbols multiple times.
106 Defaults to ON for VxWorks, otherwise OFF. */
108 #ifdef SYMBOL_RELOADING_DEFAULT
109 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
111 int symbol_reloading
= 0;
114 /* If true, then shared library symbols will be added automatically
115 when the inferior is created, new libraries are loaded, or when
116 attaching to the inferior. This is almost always what users
117 will want to have happen; but for very large programs, the startup
118 time will be excessive, and so if this is a problem, the user can
119 clear this flag and then add the shared library symbols as needed.
120 Note that there is a potential for confusion, since if the shared
121 library symbols are not loaded, commands like "info fun" will *not*
122 report all the functions that are actually present. */
124 int auto_solib_add
= 1;
127 /* Since this function is called from within qsort, in an ANSI environment
128 it must conform to the prototype for qsort, which specifies that the
129 comparison function takes two "void *" pointers. */
132 compare_symbols (s1p
, s2p
)
136 register struct symbol
**s1
, **s2
;
138 s1
= (struct symbol
**) s1p
;
139 s2
= (struct symbol
**) s2p
;
141 return (STRCMP (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
)));
148 compare_psymbols -- compare two partial symbols by name
152 Given pointers to pointers to two partial symbol table entries,
153 compare them by name and return -N, 0, or +N (ala strcmp).
154 Typically used by sorting routines like qsort().
158 Does direct compare of first two characters before punting
159 and passing to strcmp for longer compares. Note that the
160 original version had a bug whereby two null strings or two
161 identically named one character strings would return the
162 comparison of memory following the null byte.
167 compare_psymbols (s1p
, s2p
)
171 register char *st1
= SYMBOL_NAME (*(struct partial_symbol
**) s1p
);
172 register char *st2
= SYMBOL_NAME (*(struct partial_symbol
**) s2p
);
174 if ((st1
[0] - st2
[0]) || !st1
[0])
176 return (st1
[0] - st2
[0]);
178 else if ((st1
[1] - st2
[1]) || !st1
[1])
180 return (st1
[1] - st2
[1]);
184 return (STRCMP (st1
+ 2, st2
+ 2));
189 sort_pst_symbols (pst
)
190 struct partial_symtab
*pst
;
192 /* Sort the global list; don't sort the static list */
194 qsort (pst
-> objfile
-> global_psymbols
.list
+ pst
-> globals_offset
,
195 pst
-> n_global_syms
, sizeof (struct partial_symbol
*),
199 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
203 register struct block
*b
;
205 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
206 sizeof (struct symbol
*), compare_symbols
);
209 /* Call sort_symtab_syms to sort alphabetically
210 the symbols of each block of one symtab. */
214 register struct symtab
*s
;
216 register struct blockvector
*bv
;
219 register struct block
*b
;
223 bv
= BLOCKVECTOR (s
);
224 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
225 for (i
= 0; i
< nbl
; i
++)
227 b
= BLOCKVECTOR_BLOCK (bv
, i
);
228 if (BLOCK_SHOULD_SORT (b
))
233 /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
234 (and add a null character at the end in the copy).
235 Returns the address of the copy. */
238 obsavestring (ptr
, size
, obstackp
)
241 struct obstack
*obstackp
;
243 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
244 /* Open-coded memcpy--saves function call time.
245 These strings are usually short. */
247 register char *p1
= ptr
;
248 register char *p2
= p
;
249 char *end
= ptr
+ size
;
257 /* Concatenate strings S1, S2 and S3; return the new string.
258 Space is found in the symbol_obstack. */
261 obconcat (obstackp
, s1
, s2
, s3
)
262 struct obstack
*obstackp
;
263 const char *s1
, *s2
, *s3
;
265 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
266 register char *val
= (char *) obstack_alloc (obstackp
, len
);
273 /* True if we are nested inside psymtab_to_symtab. */
275 int currently_reading_symtab
= 0;
278 decrement_reading_symtab (dummy
)
281 currently_reading_symtab
--;
284 /* Get the symbol table that corresponds to a partial_symtab.
285 This is fast after the first time you do it. In fact, there
286 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
290 psymtab_to_symtab (pst
)
291 register struct partial_symtab
*pst
;
293 /* If it's been looked up before, return it. */
297 /* If it has not yet been read in, read it. */
300 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
301 currently_reading_symtab
++;
302 (*pst
->read_symtab
) (pst
);
303 do_cleanups (back_to
);
309 /* Initialize entry point information for this objfile. */
312 init_entry_point_info (objfile
)
313 struct objfile
*objfile
;
315 /* Save startup file's range of PC addresses to help blockframe.c
316 decide where the bottom of the stack is. */
318 if (bfd_get_file_flags (objfile
-> obfd
) & EXEC_P
)
320 /* Executable file -- record its entry point so we'll recognize
321 the startup file because it contains the entry point. */
322 objfile
-> ei
.entry_point
= bfd_get_start_address (objfile
-> obfd
);
326 /* Examination of non-executable.o files. Short-circuit this stuff. */
327 objfile
-> ei
.entry_point
= INVALID_ENTRY_POINT
;
329 objfile
-> ei
.entry_file_lowpc
= INVALID_ENTRY_LOWPC
;
330 objfile
-> ei
.entry_file_highpc
= INVALID_ENTRY_HIGHPC
;
331 objfile
-> ei
.entry_func_lowpc
= INVALID_ENTRY_LOWPC
;
332 objfile
-> ei
.entry_func_highpc
= INVALID_ENTRY_HIGHPC
;
333 objfile
-> ei
.main_func_lowpc
= INVALID_ENTRY_LOWPC
;
334 objfile
-> ei
.main_func_highpc
= INVALID_ENTRY_HIGHPC
;
337 /* Get current entry point address. */
340 entry_point_address()
342 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
345 /* Remember the lowest-addressed loadable section we've seen.
346 This function is called via bfd_map_over_sections.
348 In case of equal vmas, the section with the largest size becomes the
349 lowest-addressed loadable section.
351 If the vmas and sizes are equal, the last section is considered the
352 lowest-addressed loadable section. */
355 find_lowest_section (abfd
, sect
, obj
)
360 asection
**lowest
= (asection
**)obj
;
362 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
365 *lowest
= sect
; /* First loadable section */
366 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
367 *lowest
= sect
; /* A lower loadable section */
368 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
369 && (bfd_section_size (abfd
, (*lowest
))
370 <= bfd_section_size (abfd
, sect
)))
374 /* Process a symbol file, as either the main file or as a dynamically
377 NAME is the file name (which will be tilde-expanded and made
378 absolute herein) (but we don't free or modify NAME itself).
379 FROM_TTY says how verbose to be. MAINLINE specifies whether this
380 is the main symbol file, or whether it's an extra symbol file such
381 as dynamically loaded code. If !mainline, ADDR is the address
382 where the text segment was loaded. If VERBO, the caller has printed
383 a verbose message about the symbol reading (and complaints can be
384 more terse about it). */
387 syms_from_objfile (objfile
, addr
, mainline
, verbo
)
388 struct objfile
*objfile
;
393 struct section_offsets
*section_offsets
;
394 asection
*lowest_sect
;
395 struct cleanup
*old_chain
;
397 init_entry_point_info (objfile
);
398 find_sym_fns (objfile
);
400 /* Make sure that partially constructed symbol tables will be cleaned up
401 if an error occurs during symbol reading. */
402 old_chain
= make_cleanup (free_objfile
, objfile
);
406 /* We will modify the main symbol table, make sure that all its users
407 will be cleaned up if an error occurs during symbol reading. */
408 make_cleanup (clear_symtab_users
, 0);
410 /* Since no error yet, throw away the old symbol table. */
412 if (symfile_objfile
!= NULL
)
414 free_objfile (symfile_objfile
);
415 symfile_objfile
= NULL
;
418 /* Currently we keep symbols from the add-symbol-file command.
419 If the user wants to get rid of them, they should do "symbol-file"
420 without arguments first. Not sure this is the best behavior
423 (*objfile
-> sf
-> sym_new_init
) (objfile
);
426 /* Convert addr into an offset rather than an absolute address.
427 We find the lowest address of a loaded segment in the objfile,
428 and assume that <addr> is where that got loaded. Due to historical
429 precedent, we warn if that doesn't happen to be a text segment. */
433 addr
= 0; /* No offset from objfile addresses. */
437 lowest_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
438 if (lowest_sect
== NULL
)
439 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
442 if (lowest_sect
== NULL
)
443 warning ("no loadable sections found in added symbol-file %s",
445 else if ((bfd_get_section_flags (objfile
->obfd
, lowest_sect
) & SEC_CODE
)
447 /* FIXME-32x64--assumes bfd_vma fits in long. */
448 warning ("Lowest section in %s is %s at 0x%lx",
450 bfd_section_name (objfile
->obfd
, lowest_sect
),
451 (unsigned long) bfd_section_vma (objfile
->obfd
, lowest_sect
));
454 addr
-= bfd_section_vma (objfile
->obfd
, lowest_sect
);
457 /* Initialize symbol reading routines for this objfile, allow complaints to
458 appear for this new file, and record how verbose to be, then do the
459 initial symbol reading for this file. */
461 (*objfile
-> sf
-> sym_init
) (objfile
);
462 clear_complaints (1, verbo
);
464 section_offsets
= (*objfile
-> sf
-> sym_offsets
) (objfile
, addr
);
465 objfile
->section_offsets
= section_offsets
;
467 #ifndef IBM6000_TARGET
468 /* This is a SVR4/SunOS specific hack, I think. In any event, it
469 screws RS/6000. sym_offsets should be doing this sort of thing,
470 because it knows the mapping between bfd sections and
472 /* This is a hack. As far as I can tell, section offsets are not
473 target dependent. They are all set to addr with a couple of
474 exceptions. The exceptions are sysvr4 shared libraries, whose
475 offsets are kept in solib structures anyway and rs6000 xcoff
476 which handles shared libraries in a completely unique way.
478 Section offsets are built similarly, except that they are built
479 by adding addr in all cases because there is no clear mapping
480 from section_offsets into actual sections. Note that solib.c
481 has a different algorythm for finding section offsets.
483 These should probably all be collapsed into some target
484 independent form of shared library support. FIXME. */
488 struct obj_section
*s
;
490 for (s
= objfile
->sections
; s
< objfile
->sections_end
; ++s
)
492 s
->addr
-= s
->offset
;
494 s
->endaddr
-= s
->offset
;
499 #endif /* not IBM6000_TARGET */
501 (*objfile
-> sf
-> sym_read
) (objfile
, section_offsets
, mainline
);
503 if (!have_partial_symbols () && !have_full_symbols ())
506 printf_filtered ("(no debugging symbols found)...");
510 /* Don't allow char * to have a typename (else would get caddr_t).
511 Ditto void *. FIXME: Check whether this is now done by all the
512 symbol readers themselves (many of them now do), and if so remove
515 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
516 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
518 /* Mark the objfile has having had initial symbol read attempted. Note
519 that this does not mean we found any symbols... */
521 objfile
-> flags
|= OBJF_SYMS
;
523 /* Discard cleanups as symbol reading was successful. */
525 discard_cleanups (old_chain
);
527 /* Call this after reading in a new symbol table to give target dependant code
528 a crack at the new symbols. For instance, this could be used to update the
529 values of target-specific symbols GDB needs to keep track of (such as
530 _sigtramp, or whatever). */
532 TARGET_SYMFILE_POSTREAD (objfile
);
535 /* Perform required actions after either reading in the initial
536 symbols for a new objfile, or mapping in the symbols from a reusable
540 new_symfile_objfile (objfile
, mainline
, verbo
)
541 struct objfile
*objfile
;
546 /* If this is the main symbol file we have to clean up all users of the
547 old main symbol file. Otherwise it is sufficient to fixup all the
548 breakpoints that may have been redefined by this symbol file. */
551 /* OK, make it the "real" symbol file. */
552 symfile_objfile
= objfile
;
554 clear_symtab_users ();
558 breakpoint_re_set ();
561 /* We're done reading the symbol file; finish off complaints. */
562 clear_complaints (0, verbo
);
565 /* Process a symbol file, as either the main file or as a dynamically
568 NAME is the file name (which will be tilde-expanded and made
569 absolute herein) (but we don't free or modify NAME itself).
570 FROM_TTY says how verbose to be. MAINLINE specifies whether this
571 is the main symbol file, or whether it's an extra symbol file such
572 as dynamically loaded code. If !mainline, ADDR is the address
573 where the text segment was loaded.
575 Upon success, returns a pointer to the objfile that was added.
576 Upon failure, jumps back to command level (never returns). */
579 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
)
587 struct objfile
*objfile
;
588 struct partial_symtab
*psymtab
;
591 /* Open a bfd for the file, and give user a chance to burp if we'd be
592 interactively wiping out any existing symbols. */
594 abfd
= symfile_bfd_open (name
);
596 if ((have_full_symbols () || have_partial_symbols ())
599 && !query ("Load new symbol table from \"%s\"? ", name
))
600 error ("Not confirmed.");
602 objfile
= allocate_objfile (abfd
, mapped
);
604 /* If the objfile uses a mapped symbol file, and we have a psymtab for
605 it, then skip reading any symbols at this time. */
607 if ((objfile
-> flags
& OBJF_MAPPED
) && (objfile
-> flags
& OBJF_SYMS
))
609 /* We mapped in an existing symbol table file that already has had
610 initial symbol reading performed, so we can skip that part. Notify
611 the user that instead of reading the symbols, they have been mapped.
613 if (from_tty
|| info_verbose
)
615 printf_filtered ("Mapped symbols for %s...", name
);
617 gdb_flush (gdb_stdout
);
619 init_entry_point_info (objfile
);
620 find_sym_fns (objfile
);
624 /* We either created a new mapped symbol table, mapped an existing
625 symbol table file which has not had initial symbol reading
626 performed, or need to read an unmapped symbol table. */
627 if (from_tty
|| info_verbose
)
629 printf_filtered ("Reading symbols from %s...", name
);
631 gdb_flush (gdb_stdout
);
633 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
636 /* We now have at least a partial symbol table. Check to see if the
637 user requested that all symbols be read on initial access via either
638 the gdb startup command line or on a per symbol file basis. Expand
639 all partial symbol tables for this objfile if so. */
641 if (readnow
|| readnow_symbol_files
)
643 if (from_tty
|| info_verbose
)
645 printf_filtered ("expanding to full symbols...");
647 gdb_flush (gdb_stdout
);
650 for (psymtab
= objfile
-> psymtabs
;
652 psymtab
= psymtab
-> next
)
654 psymtab_to_symtab (psymtab
);
658 if (from_tty
|| info_verbose
)
660 printf_filtered ("done.\n");
661 gdb_flush (gdb_stdout
);
664 new_symfile_objfile (objfile
, mainline
, from_tty
);
669 /* This is the symbol-file command. Read the file, analyze its
670 symbols, and add a struct symtab to a symtab list. The syntax of
671 the command is rather bizarre--(1) buildargv implements various
672 quoting conventions which are undocumented and have little or
673 nothing in common with the way things are quoted (or not quoted)
674 elsewhere in GDB, (2) options are used, which are not generally
675 used in GDB (perhaps "set mapped on", "set readnow on" would be
676 better), (3) the order of options matters, which is contrary to GNU
677 conventions (because it is confusing and inconvenient). */
680 symbol_file_command (args
, from_tty
)
686 CORE_ADDR text_relocation
= 0; /* text_relocation */
687 struct cleanup
*cleanups
;
695 if ((have_full_symbols () || have_partial_symbols ())
697 && !query ("Discard symbol table from `%s'? ",
698 symfile_objfile
-> name
))
699 error ("Not confirmed.");
700 free_all_objfiles ();
701 symfile_objfile
= NULL
;
704 printf_unfiltered ("No symbol file now.\n");
709 if ((argv
= buildargv (args
)) == NULL
)
713 cleanups
= make_cleanup (freeargv
, (char *) argv
);
714 while (*argv
!= NULL
)
716 if (STREQ (*argv
, "-mapped"))
720 else if (STREQ (*argv
, "-readnow"))
724 else if (**argv
== '-')
726 error ("unknown option `%s'", *argv
);
734 /* this is for rombug remote only, to get the text relocation by
735 using link command */
736 p
= strrchr(name
, '/');
740 target_link(p
, &text_relocation
);
742 if (text_relocation
== (CORE_ADDR
)0)
744 else if (text_relocation
== (CORE_ADDR
)-1)
745 symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1, mapped
,
748 symbol_file_add (name
, from_tty
, (CORE_ADDR
)text_relocation
,
751 /* Getting new symbols may change our opinion about what is
753 reinit_frame_cache ();
755 set_initial_language ();
762 error ("no symbol file name was specified");
764 do_cleanups (cleanups
);
768 /* Set the initial language.
770 A better solution would be to record the language in the psymtab when reading
771 partial symbols, and then use it (if known) to set the language. This would
772 be a win for formats that encode the language in an easily discoverable place,
773 such as DWARF. For stabs, we can jump through hoops looking for specially
774 named symbols or try to intuit the language from the specific type of stabs
775 we find, but we can't do that until later when we read in full symbols.
779 set_initial_language ()
781 struct partial_symtab
*pst
;
782 enum language lang
= language_unknown
;
784 pst
= find_main_psymtab ();
787 if (pst
-> filename
!= NULL
)
789 lang
= deduce_language_from_filename (pst
-> filename
);
791 if (lang
== language_unknown
)
793 /* Make C the default language */
797 expected_language
= current_language
; /* Don't warn the user */
801 /* Open file specified by NAME and hand it off to BFD for preliminary
802 analysis. Result is a newly initialized bfd *, which includes a newly
803 malloc'd` copy of NAME (tilde-expanded and made absolute).
804 In case of trouble, error() is called. */
807 symfile_bfd_open (name
)
814 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
816 /* Look down path for it, allocate 2nd new malloc'd copy. */
817 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
820 make_cleanup (free
, name
);
821 perror_with_name (name
);
823 free (name
); /* Free 1st new malloc'd copy */
824 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
825 /* It'll be freed in free_objfile(). */
827 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
831 make_cleanup (free
, name
);
832 error ("\"%s\": can't open to read symbols: %s.", name
,
833 bfd_errmsg (bfd_get_error ()));
835 sym_bfd
->cacheable
= true;
837 if (!bfd_check_format (sym_bfd
, bfd_object
))
839 /* FIXME: should be checking for errors from bfd_close (for one thing,
840 on error it does not free all the storage associated with the
842 bfd_close (sym_bfd
); /* This also closes desc */
843 make_cleanup (free
, name
);
844 error ("\"%s\": can't read symbols: %s.", name
,
845 bfd_errmsg (bfd_get_error ()));
851 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
852 startup by the _initialize routine in each object file format reader,
853 to register information about each format the the reader is prepared
860 sf
->next
= symtab_fns
;
865 /* Initialize to read symbols from the symbol file sym_bfd. It either
866 returns or calls error(). The result is an initialized struct sym_fns
867 in the objfile structure, that contains cached information about the
871 find_sym_fns (objfile
)
872 struct objfile
*objfile
;
875 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
-> obfd
);
876 char *our_target
= bfd_get_target (objfile
-> obfd
);
878 /* Special kludge for RS/6000 and PowerMac. See xcoffread.c. */
879 if (STREQ (our_target
, "aixcoff-rs6000") ||
880 STREQ (our_target
, "xcoff-powermac"))
881 our_flavour
= (enum bfd_flavour
)-1;
883 /* Special kludge for apollo. See dstread.c. */
884 if (STREQN (our_target
, "apollo", 6))
885 our_flavour
= (enum bfd_flavour
)-2;
887 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
-> next
)
889 if (our_flavour
== sf
-> sym_flavour
)
895 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
896 bfd_get_target (objfile
-> obfd
));
899 /* This function runs the load command of our current target. */
902 load_command (arg
, from_tty
)
907 arg
= get_exec_file (1);
908 target_load (arg
, from_tty
);
911 /* This version of "load" should be usable for any target. Currently
912 it is just used for remote targets, not inftarg.c or core files,
913 on the theory that only in that case is it useful.
915 Avoiding xmodem and the like seems like a win (a) because we don't have
916 to worry about finding it, and (b) On VMS, fork() is very slow and so
917 we don't want to run a subprocess. On the other hand, I'm not sure how
918 performance compares. */
920 generic_load (filename
, from_tty
)
924 struct cleanup
*old_cleanups
;
927 time_t start_time
, end_time
; /* Start and end times of download */
928 unsigned long data_count
; /* Number of bytes transferred to memory */
930 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
931 if (loadfile_bfd
== NULL
)
933 perror_with_name (filename
);
936 /* FIXME: should be checking for errors from bfd_close (for one thing,
937 on error it does not free all the storage associated with the
939 old_cleanups
= make_cleanup (bfd_close
, loadfile_bfd
);
941 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
943 error ("\"%s\" is not an object file: %s", filename
,
944 bfd_errmsg (bfd_get_error ()));
947 start_time
= time (NULL
);
949 for (s
= loadfile_bfd
->sections
; s
; s
= s
->next
)
951 if (s
->flags
& SEC_LOAD
)
955 size
= bfd_get_section_size_before_reloc (s
);
959 struct cleanup
*old_chain
;
964 buffer
= xmalloc (size
);
965 old_chain
= make_cleanup (free
, buffer
);
967 vma
= bfd_get_section_vma (loadfile_bfd
, s
);
969 /* Is this really necessary? I guess it gives the user something
970 to look at during a long download. */
971 printf_filtered ("Loading section %s, size 0x%lx vma ",
972 bfd_get_section_name (loadfile_bfd
, s
),
973 (unsigned long) size
);
974 print_address_numeric (vma
, 1, gdb_stdout
);
975 printf_filtered ("\n");
977 bfd_get_section_contents (loadfile_bfd
, s
, buffer
, 0, size
);
979 target_write_memory (vma
, buffer
, size
);
981 do_cleanups (old_chain
);
986 end_time
= time (NULL
);
988 /* We were doing this in remote-mips.c, I suspect it is right
989 for other targets too. */
990 write_pc (loadfile_bfd
->start_address
);
992 /* FIXME: are we supposed to call symbol_file_add or not? According to
993 a comment from remote-mips.c (where a call to symbol_file_add was
994 commented out), making the call confuses GDB if more than one file is
995 loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
998 if (end_time
!= start_time
)
999 printf_filtered ("Transfer rate: %d bits/sec.\n",
1000 (data_count
* 8)/(end_time
- start_time
));
1002 do_cleanups (old_cleanups
);
1005 /* This function allows the addition of incrementally linked object files.
1006 It does not modify any state in the target, only in the debugger. */
1010 add_symbol_file_command (args
, from_tty
)
1015 CORE_ADDR text_addr
;
1024 error ("add-symbol-file takes a file name and an address");
1027 /* Make a copy of the string that we can safely write into. */
1029 args
= strdup (args
);
1030 make_cleanup (free
, args
);
1032 /* Pick off any -option args and the file name. */
1034 while ((*args
!= '\000') && (name
== NULL
))
1036 while (isspace (*args
)) {args
++;}
1038 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
1039 if (*args
!= '\000')
1047 else if (STREQ (arg
, "-mapped"))
1051 else if (STREQ (arg
, "-readnow"))
1057 error ("unknown option `%s'", arg
);
1061 /* After picking off any options and the file name, args should be
1062 left pointing at the remainder of the command line, which should
1063 be the address expression to evaluate. */
1067 error ("add-symbol-file takes a file name");
1069 name
= tilde_expand (name
);
1070 make_cleanup (free
, name
);
1072 if (*args
!= '\000')
1074 text_addr
= parse_and_eval_address (args
);
1078 target_link(name
, &text_addr
);
1079 if (text_addr
== (CORE_ADDR
)-1)
1080 error("Don't know how to get text start location for this file");
1083 /* FIXME-32x64: Assumes text_addr fits in a long. */
1084 if (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
1085 name
, local_hex_string ((unsigned long)text_addr
)))
1086 error ("Not confirmed.");
1088 symbol_file_add (name
, 0, text_addr
, 0, mapped
, readnow
);
1090 /* Getting new symbols may change our opinion about what is
1092 reinit_frame_cache ();
1096 add_shared_symbol_files_command (args
, from_tty
)
1100 #ifdef ADD_SHARED_SYMBOL_FILES
1101 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1103 error ("This command is not available in this configuration of GDB.");
1107 /* Re-read symbols if a symbol-file has changed. */
1111 struct objfile
*objfile
;
1114 struct stat new_statbuf
;
1117 /* With the addition of shared libraries, this should be modified,
1118 the load time should be saved in the partial symbol tables, since
1119 different tables may come from different source files. FIXME.
1120 This routine should then walk down each partial symbol table
1121 and see if the symbol table that it originates from has been changed */
1123 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
1124 if (objfile
->obfd
) {
1125 #ifdef IBM6000_TARGET
1126 /* If this object is from a shared library, then you should
1127 stat on the library name, not member name. */
1129 if (objfile
->obfd
->my_archive
)
1130 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1133 res
= stat (objfile
->name
, &new_statbuf
);
1135 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1136 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1140 new_modtime
= new_statbuf
.st_mtime
;
1141 if (new_modtime
!= objfile
->mtime
)
1143 struct cleanup
*old_cleanups
;
1144 struct section_offsets
*offsets
;
1146 int section_offsets_size
;
1147 char *obfd_filename
;
1149 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1152 /* There are various functions like symbol_file_add,
1153 symfile_bfd_open, syms_from_objfile, etc., which might
1154 appear to do what we want. But they have various other
1155 effects which we *don't* want. So we just do stuff
1156 ourselves. We don't worry about mapped files (for one thing,
1157 any mapped file will be out of date). */
1159 /* If we get an error, blow away this objfile (not sure if
1160 that is the correct response for things like shared
1162 old_cleanups
= make_cleanup (free_objfile
, objfile
);
1163 /* We need to do this whenever any symbols go away. */
1164 make_cleanup (clear_symtab_users
, 0);
1166 /* Clean up any state BFD has sitting around. We don't need
1167 to close the descriptor but BFD lacks a way of closing the
1168 BFD without closing the descriptor. */
1169 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1170 if (!bfd_close (objfile
->obfd
))
1171 error ("Can't close BFD for %s: %s", objfile
->name
,
1172 bfd_errmsg (bfd_get_error ()));
1173 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1174 if (objfile
->obfd
== NULL
)
1175 error ("Can't open %s to read symbols.", objfile
->name
);
1176 /* bfd_openr sets cacheable to true, which is what we want. */
1177 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1178 error ("Can't read symbols from %s: %s.", objfile
->name
,
1179 bfd_errmsg (bfd_get_error ()));
1181 /* Save the offsets, we will nuke them with the rest of the
1183 num_offsets
= objfile
->num_sections
;
1184 section_offsets_size
=
1185 sizeof (struct section_offsets
)
1186 + sizeof (objfile
->section_offsets
->offsets
) * num_offsets
;
1187 offsets
= (struct section_offsets
*) alloca (section_offsets_size
);
1188 memcpy (offsets
, objfile
->section_offsets
, section_offsets_size
);
1190 /* Nuke all the state that we will re-read. Much of the following
1191 code which sets things to NULL really is necessary to tell
1192 other parts of GDB that there is nothing currently there. */
1194 /* FIXME: Do we have to free a whole linked list, or is this
1196 if (objfile
->global_psymbols
.list
)
1197 mfree (objfile
->md
, objfile
->global_psymbols
.list
);
1198 memset (&objfile
-> global_psymbols
, 0,
1199 sizeof (objfile
-> global_psymbols
));
1200 if (objfile
->static_psymbols
.list
)
1201 mfree (objfile
->md
, objfile
->static_psymbols
.list
);
1202 memset (&objfile
-> static_psymbols
, 0,
1203 sizeof (objfile
-> static_psymbols
));
1205 /* Free the obstacks for non-reusable objfiles */
1206 obstack_free (&objfile
-> psymbol_cache
.cache
, 0);
1207 memset (&objfile
-> psymbol_cache
, 0,
1208 sizeof (objfile
-> psymbol_cache
));
1209 obstack_free (&objfile
-> psymbol_obstack
, 0);
1210 obstack_free (&objfile
-> symbol_obstack
, 0);
1211 obstack_free (&objfile
-> type_obstack
, 0);
1212 objfile
->sections
= NULL
;
1213 objfile
->symtabs
= NULL
;
1214 objfile
->psymtabs
= NULL
;
1215 objfile
->free_psymtabs
= NULL
;
1216 objfile
->msymbols
= NULL
;
1217 objfile
->minimal_symbol_count
= 0;
1218 objfile
->fundamental_types
= NULL
;
1219 if (objfile
-> sf
!= NULL
)
1221 (*objfile
-> sf
-> sym_finish
) (objfile
);
1224 /* We never make this a mapped file. */
1225 objfile
-> md
= NULL
;
1226 /* obstack_specify_allocation also initializes the obstack so
1228 obstack_specify_allocation (&objfile
-> psymbol_cache
.cache
, 0, 0,
1230 obstack_specify_allocation (&objfile
-> psymbol_obstack
, 0, 0,
1232 obstack_specify_allocation (&objfile
-> symbol_obstack
, 0, 0,
1234 obstack_specify_allocation (&objfile
-> type_obstack
, 0, 0,
1236 if (build_objfile_section_table (objfile
))
1238 error ("Can't find the file sections in `%s': %s",
1239 objfile
-> name
, bfd_errmsg (bfd_get_error ()));
1242 /* We use the same section offsets as from last time. I'm not
1243 sure whether that is always correct for shared libraries. */
1244 objfile
->section_offsets
= (struct section_offsets
*)
1245 obstack_alloc (&objfile
-> psymbol_obstack
, section_offsets_size
);
1246 memcpy (objfile
->section_offsets
, offsets
, section_offsets_size
);
1247 objfile
->num_sections
= num_offsets
;
1249 /* What the hell is sym_new_init for, anyway? The concept of
1250 distinguishing between the main file and additional files
1251 in this way seems rather dubious. */
1252 if (objfile
== symfile_objfile
)
1253 (*objfile
->sf
->sym_new_init
) (objfile
);
1255 (*objfile
->sf
->sym_init
) (objfile
);
1256 clear_complaints (1, 1);
1257 /* The "mainline" parameter is a hideous hack; I think leaving it
1258 zero is OK since dbxread.c also does what it needs to do if
1259 objfile->global_psymbols.size is 0. */
1260 (*objfile
->sf
->sym_read
) (objfile
, objfile
->section_offsets
, 0);
1261 if (!have_partial_symbols () && !have_full_symbols ())
1264 printf_filtered ("(no debugging symbols found)\n");
1267 objfile
-> flags
|= OBJF_SYMS
;
1269 /* We're done reading the symbol file; finish off complaints. */
1270 clear_complaints (0, 1);
1272 /* Getting new symbols may change our opinion about what is
1275 reinit_frame_cache ();
1277 /* Discard cleanups as symbol reading was successful. */
1278 discard_cleanups (old_cleanups
);
1280 /* If the mtime has changed between the time we set new_modtime
1281 and now, we *want* this to be out of date, so don't call stat
1283 objfile
->mtime
= new_modtime
;
1286 /* Call this after reading in a new symbol table to give target
1287 dependant code a crack at the new symbols. For instance, this
1288 could be used to update the values of target-specific symbols GDB
1289 needs to keep track of (such as _sigtramp, or whatever). */
1291 TARGET_SYMFILE_POSTREAD (objfile
);
1297 clear_symtab_users ();
1302 deduce_language_from_filename (filename
)
1309 else if (0 == (c
= strrchr (filename
, '.')))
1310 ; /* Get default. */
1311 else if (STREQ (c
, ".c"))
1313 else if (STREQ (c
, ".cc") || STREQ (c
, ".C") || STREQ (c
, ".cxx")
1314 || STREQ (c
, ".cpp") || STREQ (c
, ".cp") || STREQ (c
, ".c++"))
1315 return language_cplus
;
1316 else if (STREQ (c
, ".ch") || STREQ (c
, ".c186") || STREQ (c
, ".c286"))
1317 return language_chill
;
1318 else if (STREQ (c
, ".f") || STREQ (c
, ".F"))
1319 return language_fortran
;
1320 else if (STREQ (c
, ".mod"))
1322 else if (STREQ (c
, ".s") || STREQ (c
, ".S"))
1323 return language_asm
;
1325 return language_unknown
; /* default */
1330 Allocate and partly initialize a new symbol table. Return a pointer
1331 to it. error() if no space.
1333 Caller must set these fields:
1339 initialize any EXTRA_SYMTAB_INFO
1340 possibly free_named_symtabs (symtab->filename);
1344 allocate_symtab (filename
, objfile
)
1346 struct objfile
*objfile
;
1348 register struct symtab
*symtab
;
1350 symtab
= (struct symtab
*)
1351 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
1352 memset (symtab
, 0, sizeof (*symtab
));
1353 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
1354 &objfile
-> symbol_obstack
);
1355 symtab
-> fullname
= NULL
;
1356 symtab
-> language
= deduce_language_from_filename (filename
);
1358 /* Hook it to the objfile it comes from */
1360 symtab
-> objfile
= objfile
;
1361 symtab
-> next
= objfile
-> symtabs
;
1362 objfile
-> symtabs
= symtab
;
1364 #ifdef INIT_EXTRA_SYMTAB_INFO
1365 INIT_EXTRA_SYMTAB_INFO (symtab
);
1371 struct partial_symtab
*
1372 allocate_psymtab (filename
, objfile
)
1374 struct objfile
*objfile
;
1376 struct partial_symtab
*psymtab
;
1378 if (objfile
-> free_psymtabs
)
1380 psymtab
= objfile
-> free_psymtabs
;
1381 objfile
-> free_psymtabs
= psymtab
-> next
;
1384 psymtab
= (struct partial_symtab
*)
1385 obstack_alloc (&objfile
-> psymbol_obstack
,
1386 sizeof (struct partial_symtab
));
1388 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1389 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1390 &objfile
-> psymbol_obstack
);
1391 psymtab
-> symtab
= NULL
;
1393 /* Hook it to the objfile it comes from */
1395 psymtab
-> objfile
= objfile
;
1396 psymtab
-> next
= objfile
-> psymtabs
;
1397 objfile
-> psymtabs
= psymtab
;
1403 /* Reset all data structures in gdb which may contain references to symbol
1407 clear_symtab_users ()
1409 /* Someday, we should do better than this, by only blowing away
1410 the things that really need to be blown. */
1411 clear_value_history ();
1413 clear_internalvars ();
1414 breakpoint_re_set ();
1415 set_default_breakpoint (0, 0, 0, 0);
1416 current_source_symtab
= 0;
1417 current_source_line
= 0;
1418 clear_pc_function_cache ();
1421 /* clear_symtab_users_once:
1423 This function is run after symbol reading, or from a cleanup.
1424 If an old symbol table was obsoleted, the old symbol table
1425 has been blown away, but the other GDB data structures that may
1426 reference it have not yet been cleared or re-directed. (The old
1427 symtab was zapped, and the cleanup queued, in free_named_symtab()
1430 This function can be queued N times as a cleanup, or called
1431 directly; it will do all the work the first time, and then will be a
1432 no-op until the next time it is queued. This works by bumping a
1433 counter at queueing time. Much later when the cleanup is run, or at
1434 the end of symbol processing (in case the cleanup is discarded), if
1435 the queued count is greater than the "done-count", we do the work
1436 and set the done-count to the queued count. If the queued count is
1437 less than or equal to the done-count, we just ignore the call. This
1438 is needed because reading a single .o file will often replace many
1439 symtabs (one per .h file, for example), and we don't want to reset
1440 the breakpoints N times in the user's face.
1442 The reason we both queue a cleanup, and call it directly after symbol
1443 reading, is because the cleanup protects us in case of errors, but is
1444 discarded if symbol reading is successful. */
1447 /* FIXME: As free_named_symtabs is currently a big noop this function
1448 is no longer needed. */
1450 clear_symtab_users_once
PARAMS ((void));
1452 static int clear_symtab_users_queued
;
1453 static int clear_symtab_users_done
;
1456 clear_symtab_users_once ()
1458 /* Enforce once-per-`do_cleanups'-semantics */
1459 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1461 clear_symtab_users_done
= clear_symtab_users_queued
;
1463 clear_symtab_users ();
1467 /* Delete the specified psymtab, and any others that reference it. */
1470 cashier_psymtab (pst
)
1471 struct partial_symtab
*pst
;
1473 struct partial_symtab
*ps
, *pprev
= NULL
;
1476 /* Find its previous psymtab in the chain */
1477 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1484 /* Unhook it from the chain. */
1485 if (ps
== pst
->objfile
->psymtabs
)
1486 pst
->objfile
->psymtabs
= ps
->next
;
1488 pprev
->next
= ps
->next
;
1490 /* FIXME, we can't conveniently deallocate the entries in the
1491 partial_symbol lists (global_psymbols/static_psymbols) that
1492 this psymtab points to. These just take up space until all
1493 the psymtabs are reclaimed. Ditto the dependencies list and
1494 filename, which are all in the psymbol_obstack. */
1496 /* We need to cashier any psymtab that has this one as a dependency... */
1498 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1499 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1500 if (ps
->dependencies
[i
] == pst
) {
1501 cashier_psymtab (ps
);
1502 goto again
; /* Must restart, chain has been munged. */
1509 /* If a symtab or psymtab for filename NAME is found, free it along
1510 with any dependent breakpoints, displays, etc.
1511 Used when loading new versions of object modules with the "add-file"
1512 command. This is only called on the top-level symtab or psymtab's name;
1513 it is not called for subsidiary files such as .h files.
1515 Return value is 1 if we blew away the environment, 0 if not.
1516 FIXME. The return valu appears to never be used.
1518 FIXME. I think this is not the best way to do this. We should
1519 work on being gentler to the environment while still cleaning up
1520 all stray pointers into the freed symtab. */
1523 free_named_symtabs (name
)
1527 /* FIXME: With the new method of each objfile having it's own
1528 psymtab list, this function needs serious rethinking. In particular,
1529 why was it ever necessary to toss psymtabs with specific compilation
1530 unit filenames, as opposed to all psymtabs from a particular symbol
1532 Well, the answer is that some systems permit reloading of particular
1533 compilation units. We want to blow away any old info about these
1534 compilation units, regardless of which objfiles they arrived in. --gnu. */
1536 register struct symtab
*s
;
1537 register struct symtab
*prev
;
1538 register struct partial_symtab
*ps
;
1539 struct blockvector
*bv
;
1542 /* We only wack things if the symbol-reload switch is set. */
1543 if (!symbol_reloading
)
1546 /* Some symbol formats have trouble providing file names... */
1547 if (name
== 0 || *name
== '\0')
1550 /* Look for a psymtab with the specified name. */
1553 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1554 if (STREQ (name
, ps
->filename
)) {
1555 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1556 goto again2
; /* Must restart, chain has been munged */
1560 /* Look for a symtab with the specified name. */
1562 for (s
= symtab_list
; s
; s
= s
->next
)
1564 if (STREQ (name
, s
->filename
))
1571 if (s
== symtab_list
)
1572 symtab_list
= s
->next
;
1574 prev
->next
= s
->next
;
1576 /* For now, queue a delete for all breakpoints, displays, etc., whether
1577 or not they depend on the symtab being freed. This should be
1578 changed so that only those data structures affected are deleted. */
1580 /* But don't delete anything if the symtab is empty.
1581 This test is necessary due to a bug in "dbxread.c" that
1582 causes empty symtabs to be created for N_SO symbols that
1583 contain the pathname of the object file. (This problem
1584 has been fixed in GDB 3.9x). */
1586 bv
= BLOCKVECTOR (s
);
1587 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1588 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1589 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1591 complain (&oldsyms_complaint
, name
);
1593 clear_symtab_users_queued
++;
1594 make_cleanup (clear_symtab_users_once
, 0);
1597 complain (&empty_symtab_complaint
, name
);
1604 /* It is still possible that some breakpoints will be affected
1605 even though no symtab was found, since the file might have
1606 been compiled without debugging, and hence not be associated
1607 with a symtab. In order to handle this correctly, we would need
1608 to keep a list of text address ranges for undebuggable files.
1609 For now, we do nothing, since this is a fairly obscure case. */
1613 /* FIXME, what about the minimal symbol table? */
1620 /* Allocate and partially fill a partial symtab. It will be
1621 completely filled at the end of the symbol list.
1623 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1624 is the address relative to which its symbols are (incremental) or 0
1628 struct partial_symtab
*
1629 start_psymtab_common (objfile
, section_offsets
,
1630 filename
, textlow
, global_syms
, static_syms
)
1631 struct objfile
*objfile
;
1632 struct section_offsets
*section_offsets
;
1635 struct partial_symbol
**global_syms
;
1636 struct partial_symbol
**static_syms
;
1638 struct partial_symtab
*psymtab
;
1640 psymtab
= allocate_psymtab (filename
, objfile
);
1641 psymtab
-> section_offsets
= section_offsets
;
1642 psymtab
-> textlow
= textlow
;
1643 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
1644 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
1645 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
1649 /* Debugging versions of functions that are usually inline macros
1652 #if !INLINE_ADD_PSYMBOL
1654 /* Add a symbol with a long value to a psymtab.
1655 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
1658 add_psymbol_to_list (name
, namelength
, namespace, class, list
, val
, language
,
1662 namespace_enum
namespace;
1663 enum address_class
class;
1664 struct psymbol_allocation_list
*list
;
1666 enum language language
;
1667 struct objfile
*objfile
;
1669 register struct partial_symbol
*psym
;
1670 char *buf
= alloca (namelength
+ 1);
1671 struct partial_symbol psymbol
;
1673 /* Create local copy of the partial symbol */
1674 memcpy (buf
, name
, namelength
);
1675 buf
[namelength
] = '\0';
1676 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, &objfile
->psymbol_cache
);
1677 SYMBOL_VALUE (&psymbol
) = val
;
1678 SYMBOL_SECTION (&psymbol
) = 0;
1679 SYMBOL_LANGUAGE (&psymbol
) = language
;
1680 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
1681 PSYMBOL_CLASS (&psymbol
) = class;
1682 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
1684 /* Stash the partial symbol away in the cache */
1685 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), &objfile
->psymbol_cache
);
1687 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1688 if (list
->next
>= list
->list
+ list
->size
)
1690 extend_psymbol_list (list
, objfile
);
1692 *list
->next
++ = psym
;
1693 OBJSTAT (objfile
, n_psyms
++);
1696 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1699 add_psymbol_addr_to_list (name
, namelength
, namespace, class, list
, val
,
1703 namespace_enum
namespace;
1704 enum address_class
class;
1705 struct psymbol_allocation_list
*list
;
1707 enum language language
;
1708 struct objfile
*objfile
;
1710 register struct partial_symbol
*psym
;
1711 char *buf
= alloca (namelength
+ 1);
1712 struct partial_symbol psymbol
;
1714 /* Create local copy of the partial symbol */
1715 memcpy (buf
, name
, namelength
);
1716 buf
[namelength
] = '\0';
1717 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, &objfile
->psymbol_cache
);
1718 SYMBOL_VALUE_ADDRESS (&psymbol
) = val
;
1719 SYMBOL_SECTION (&psymbol
) = 0;
1720 SYMBOL_LANGUAGE (&psymbol
) = language
;
1721 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
1722 PSYMBOL_CLASS (&psymbol
) = class;
1723 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
1725 /* Stash the partial symbol away in the cache */
1726 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), &objfile
->psymbol_cache
);
1728 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1729 if (list
->next
>= list
->list
+ list
->size
)
1731 extend_psymbol_list (list
, objfile
);
1733 *list
->next
++ = psym
;
1734 OBJSTAT (objfile
, n_psyms
++);
1737 #endif /* !INLINE_ADD_PSYMBOL */
1739 /* Initialize storage for partial symbols. */
1742 init_psymbol_list (objfile
, total_symbols
)
1743 struct objfile
*objfile
;
1746 /* Free any previously allocated psymbol lists. */
1748 if (objfile
-> global_psymbols
.list
)
1750 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
1752 if (objfile
-> static_psymbols
.list
)
1754 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
1757 /* Current best guess is that approximately a twentieth
1758 of the total symbols (in a debugging file) are global or static
1761 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
1762 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
1763 objfile
-> global_psymbols
.next
=
1764 objfile
-> global_psymbols
.list
= (struct partial_symbol
**)
1765 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
1766 * sizeof (struct partial_symbol
*));
1767 objfile
-> static_psymbols
.next
=
1768 objfile
-> static_psymbols
.list
= (struct partial_symbol
**)
1769 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
1770 * sizeof (struct partial_symbol
*));
1774 _initialize_symfile ()
1776 struct cmd_list_element
*c
;
1778 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
1779 "Load symbol table from executable file FILE.\n\
1780 The `file' command can also load symbol tables, as well as setting the file\n\
1781 to execute.", &cmdlist
);
1782 c
->completer
= filename_completer
;
1784 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
1785 "Usage: add-symbol-file FILE ADDR\n\
1786 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
1787 ADDR is the starting address of the file's text.",
1789 c
->completer
= filename_completer
;
1791 c
= add_cmd ("add-shared-symbol-files", class_files
,
1792 add_shared_symbol_files_command
,
1793 "Load the symbols from shared objects in the dynamic linker's link map.",
1795 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
1798 c
= add_cmd ("load", class_files
, load_command
,
1799 "Dynamically load FILE into the running program, and record its symbols\n\
1800 for access from GDB.", &cmdlist
);
1801 c
->completer
= filename_completer
;
1804 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
1805 (char *)&symbol_reloading
,
1806 "Set dynamic symbol table reloading multiple times in one run.",