1 /* Generic symbol file reading for the GNU debugger, GDB.
2 Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
3 Contributed by Cygnus Support, using pieces from other GDB modules.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
31 #include "breakpoint.h"
33 #include "complaints.h"
35 #include "inferior.h" /* for write_pc */
40 #include <sys/types.h>
42 #include "gdb_string.h"
53 /* Global variables owned by this file */
54 int readnow_symbol_files
; /* Read full symbols immediately */
56 struct complaint oldsyms_complaint
= {
57 "Replacing old symbols for `%s'", 0, 0
60 struct complaint empty_symtab_complaint
= {
61 "Empty symbol table found for `%s'", 0, 0
64 /* External variables and functions referenced. */
66 extern int info_verbose
;
68 /* Functions this file defines */
71 set_initial_language
PARAMS ((void));
74 load_command
PARAMS ((char *, int));
77 add_symbol_file_command
PARAMS ((char *, int));
80 add_shared_symbol_files_command
PARAMS ((char *, int));
83 cashier_psymtab
PARAMS ((struct partial_symtab
*));
86 compare_psymbols
PARAMS ((const void *, const void *));
89 compare_symbols
PARAMS ((const void *, const void *));
92 symfile_bfd_open
PARAMS ((char *));
95 find_sym_fns
PARAMS ((struct objfile
*));
97 /* List of all available sym_fns. On gdb startup, each object file reader
98 calls add_symtab_fns() to register information on each format it is
101 static struct sym_fns
*symtab_fns
= NULL
;
103 /* Structures with which to manage partial symbol allocation. */
105 struct psymbol_allocation_list global_psymbols
= {0}, static_psymbols
= {0};
107 /* Flag for whether user will be reloading symbols multiple times.
108 Defaults to ON for VxWorks, otherwise OFF. */
110 #ifdef SYMBOL_RELOADING_DEFAULT
111 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
113 int symbol_reloading
= 0;
117 /* Since this function is called from within qsort, in an ANSI environment
118 it must conform to the prototype for qsort, which specifies that the
119 comparison function takes two "void *" pointers. */
122 compare_symbols (s1p
, s2p
)
126 register struct symbol
**s1
, **s2
;
128 s1
= (struct symbol
**) s1p
;
129 s2
= (struct symbol
**) s2p
;
131 return (STRCMP (SYMBOL_NAME (*s1
), SYMBOL_NAME (*s2
)));
138 compare_psymbols -- compare two partial symbols by name
142 Given pointer to two partial symbol table entries, compare
143 them by name and return -N, 0, or +N (ala strcmp). Typically
144 used by sorting routines like qsort().
148 Does direct compare of first two characters before punting
149 and passing to strcmp for longer compares. Note that the
150 original version had a bug whereby two null strings or two
151 identically named one character strings would return the
152 comparison of memory following the null byte.
157 compare_psymbols (s1p
, s2p
)
161 register char *st1
= SYMBOL_NAME ((struct partial_symbol
*) s1p
);
162 register char *st2
= SYMBOL_NAME ((struct partial_symbol
*) s2p
);
164 if ((st1
[0] - st2
[0]) || !st1
[0])
166 return (st1
[0] - st2
[0]);
168 else if ((st1
[1] - st2
[1]) || !st1
[1])
170 return (st1
[1] - st2
[1]);
174 return (STRCMP (st1
+ 2, st2
+ 2));
179 sort_pst_symbols (pst
)
180 struct partial_symtab
*pst
;
182 /* Sort the global list; don't sort the static list */
184 qsort (pst
-> objfile
-> global_psymbols
.list
+ pst
-> globals_offset
,
185 pst
-> n_global_syms
, sizeof (struct partial_symbol
),
189 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
193 register struct block
*b
;
195 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
196 sizeof (struct symbol
*), compare_symbols
);
199 /* Call sort_symtab_syms to sort alphabetically
200 the symbols of each block of one symtab. */
204 register struct symtab
*s
;
206 register struct blockvector
*bv
;
209 register struct block
*b
;
213 bv
= BLOCKVECTOR (s
);
214 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
215 for (i
= 0; i
< nbl
; i
++)
217 b
= BLOCKVECTOR_BLOCK (bv
, i
);
218 if (BLOCK_SHOULD_SORT (b
))
223 /* Make a copy of the string at PTR with SIZE characters in the symbol obstack
224 (and add a null character at the end in the copy).
225 Returns the address of the copy. */
228 obsavestring (ptr
, size
, obstackp
)
231 struct obstack
*obstackp
;
233 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
234 /* Open-coded memcpy--saves function call time.
235 These strings are usually short. */
237 register char *p1
= ptr
;
238 register char *p2
= p
;
239 char *end
= ptr
+ size
;
247 /* Concatenate strings S1, S2 and S3; return the new string.
248 Space is found in the symbol_obstack. */
251 obconcat (obstackp
, s1
, s2
, s3
)
252 struct obstack
*obstackp
;
253 const char *s1
, *s2
, *s3
;
255 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
256 register char *val
= (char *) obstack_alloc (obstackp
, len
);
263 /* Get the symbol table that corresponds to a partial_symtab.
264 This is fast after the first time you do it. In fact, there
265 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
269 psymtab_to_symtab (pst
)
270 register struct partial_symtab
*pst
;
272 /* If it's been looked up before, return it. */
276 /* If it has not yet been read in, read it. */
279 (*pst
->read_symtab
) (pst
);
285 /* Initialize entry point information for this objfile. */
288 init_entry_point_info (objfile
)
289 struct objfile
*objfile
;
291 /* Save startup file's range of PC addresses to help blockframe.c
292 decide where the bottom of the stack is. */
294 if (bfd_get_file_flags (objfile
-> obfd
) & EXEC_P
)
296 /* Executable file -- record its entry point so we'll recognize
297 the startup file because it contains the entry point. */
298 objfile
-> ei
.entry_point
= bfd_get_start_address (objfile
-> obfd
);
302 /* Examination of non-executable.o files. Short-circuit this stuff. */
303 objfile
-> ei
.entry_point
= INVALID_ENTRY_POINT
;
304 objfile
-> ei
.entry_file_lowpc
= INVALID_ENTRY_LOWPC
;
305 objfile
-> ei
.entry_file_highpc
= INVALID_ENTRY_HIGHPC
;
309 /* Get current entry point address. */
312 entry_point_address()
314 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
317 /* Remember the lowest-addressed loadable section we've seen.
318 This function is called via bfd_map_over_sections.
320 In case of equal vmas, the section with the largest size becomes the
321 lowest-addressed loadable section.
323 If the vmas and sizes are equal, the last section is considered the
324 lowest-addressed loadable section. */
327 find_lowest_section (abfd
, sect
, obj
)
332 asection
**lowest
= (asection
**)obj
;
334 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
337 *lowest
= sect
; /* First loadable section */
338 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
339 *lowest
= sect
; /* A lower loadable section */
340 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
341 && (bfd_section_size (abfd
, (*lowest
))
342 <= bfd_section_size (abfd
, sect
)))
346 /* Process a symbol file, as either the main file or as a dynamically
349 NAME is the file name (which will be tilde-expanded and made
350 absolute herein) (but we don't free or modify NAME itself).
351 FROM_TTY says how verbose to be. MAINLINE specifies whether this
352 is the main symbol file, or whether it's an extra symbol file such
353 as dynamically loaded code. If !mainline, ADDR is the address
354 where the text segment was loaded. If VERBO, the caller has printed
355 a verbose message about the symbol reading (and complaints can be
356 more terse about it). */
359 syms_from_objfile (objfile
, addr
, mainline
, verbo
)
360 struct objfile
*objfile
;
365 struct section_offsets
*section_offsets
;
366 asection
*lowest_sect
;
367 struct cleanup
*old_chain
;
369 init_entry_point_info (objfile
);
370 find_sym_fns (objfile
);
372 /* Make sure that partially constructed symbol tables will be cleaned up
373 if an error occurs during symbol reading. */
374 old_chain
= make_cleanup (free_objfile
, objfile
);
378 /* We will modify the main symbol table, make sure that all its users
379 will be cleaned up if an error occurs during symbol reading. */
380 make_cleanup (clear_symtab_users
, 0);
382 /* Since no error yet, throw away the old symbol table. */
384 if (symfile_objfile
!= NULL
)
386 free_objfile (symfile_objfile
);
387 symfile_objfile
= NULL
;
390 /* Currently we keep symbols from the add-symbol-file command.
391 If the user wants to get rid of them, they should do "symbol-file"
392 without arguments first. Not sure this is the best behavior
395 (*objfile
-> sf
-> sym_new_init
) (objfile
);
398 /* Convert addr into an offset rather than an absolute address.
399 We find the lowest address of a loaded segment in the objfile,
400 and assume that <addr> is where that got loaded. Due to historical
401 precedent, we warn if that doesn't happen to be a text segment. */
405 addr
= 0; /* No offset from objfile addresses. */
409 lowest_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
410 if (lowest_sect
== NULL
)
411 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
414 if (lowest_sect
== NULL
)
415 warning ("no loadable sections found in added symbol-file %s",
417 else if ((bfd_get_section_flags (objfile
->obfd
, lowest_sect
) & SEC_CODE
)
419 /* FIXME-32x64--assumes bfd_vma fits in long. */
420 warning ("Lowest section in %s is %s at 0x%lx",
422 bfd_section_name (objfile
->obfd
, lowest_sect
),
423 (unsigned long) bfd_section_vma (objfile
->obfd
, lowest_sect
));
426 addr
-= bfd_section_vma (objfile
->obfd
, lowest_sect
);
429 /* Initialize symbol reading routines for this objfile, allow complaints to
430 appear for this new file, and record how verbose to be, then do the
431 initial symbol reading for this file. */
433 (*objfile
-> sf
-> sym_init
) (objfile
);
434 clear_complaints (1, verbo
);
436 section_offsets
= (*objfile
-> sf
-> sym_offsets
) (objfile
, addr
);
437 objfile
->section_offsets
= section_offsets
;
439 #ifndef IBM6000_TARGET
440 /* This is a SVR4/SunOS specific hack, I think. In any event, it
441 screws RS/6000. sym_offsets should be doing this sort of thing,
442 because it knows the mapping between bfd sections and
444 /* This is a hack. As far as I can tell, section offsets are not
445 target dependent. They are all set to addr with a couple of
446 exceptions. The exceptions are sysvr4 shared libraries, whose
447 offsets are kept in solib structures anyway and rs6000 xcoff
448 which handles shared libraries in a completely unique way.
450 Section offsets are built similarly, except that they are built
451 by adding addr in all cases because there is no clear mapping
452 from section_offsets into actual sections. Note that solib.c
453 has a different algorythm for finding section offsets.
455 These should probably all be collapsed into some target
456 independent form of shared library support. FIXME. */
460 struct obj_section
*s
;
462 for (s
= objfile
->sections
; s
< objfile
->sections_end
; ++s
)
464 s
->addr
-= s
->offset
;
466 s
->endaddr
-= s
->offset
;
471 #endif /* not IBM6000_TARGET */
473 (*objfile
-> sf
-> sym_read
) (objfile
, section_offsets
, mainline
);
475 if (!have_partial_symbols () && !have_full_symbols ())
478 printf_filtered ("(no debugging symbols found)...");
482 /* Don't allow char * to have a typename (else would get caddr_t).
483 Ditto void *. FIXME: Check whether this is now done by all the
484 symbol readers themselves (many of them now do), and if so remove
487 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
488 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
490 /* Mark the objfile has having had initial symbol read attempted. Note
491 that this does not mean we found any symbols... */
493 objfile
-> flags
|= OBJF_SYMS
;
495 /* Discard cleanups as symbol reading was successful. */
497 discard_cleanups (old_chain
);
500 /* Perform required actions after either reading in the initial
501 symbols for a new objfile, or mapping in the symbols from a reusable
505 new_symfile_objfile (objfile
, mainline
, verbo
)
506 struct objfile
*objfile
;
511 /* If this is the main symbol file we have to clean up all users of the
512 old main symbol file. Otherwise it is sufficient to fixup all the
513 breakpoints that may have been redefined by this symbol file. */
516 /* OK, make it the "real" symbol file. */
517 symfile_objfile
= objfile
;
519 clear_symtab_users ();
523 breakpoint_re_set ();
526 /* We're done reading the symbol file; finish off complaints. */
527 clear_complaints (0, verbo
);
530 /* Process a symbol file, as either the main file or as a dynamically
533 NAME is the file name (which will be tilde-expanded and made
534 absolute herein) (but we don't free or modify NAME itself).
535 FROM_TTY says how verbose to be. MAINLINE specifies whether this
536 is the main symbol file, or whether it's an extra symbol file such
537 as dynamically loaded code. If !mainline, ADDR is the address
538 where the text segment was loaded.
540 Upon success, returns a pointer to the objfile that was added.
541 Upon failure, jumps back to command level (never returns). */
544 symbol_file_add (name
, from_tty
, addr
, mainline
, mapped
, readnow
)
552 struct objfile
*objfile
;
553 struct partial_symtab
*psymtab
;
556 /* Open a bfd for the file, and give user a chance to burp if we'd be
557 interactively wiping out any existing symbols. */
559 abfd
= symfile_bfd_open (name
);
561 if ((have_full_symbols () || have_partial_symbols ())
564 && !query ("Load new symbol table from \"%s\"? ", name
))
565 error ("Not confirmed.");
567 objfile
= allocate_objfile (abfd
, mapped
);
569 /* If the objfile uses a mapped symbol file, and we have a psymtab for
570 it, then skip reading any symbols at this time. */
572 if ((objfile
-> flags
& OBJF_MAPPED
) && (objfile
-> flags
& OBJF_SYMS
))
574 /* We mapped in an existing symbol table file that already has had
575 initial symbol reading performed, so we can skip that part. Notify
576 the user that instead of reading the symbols, they have been mapped.
578 if (from_tty
|| info_verbose
)
580 printf_filtered ("Mapped symbols for %s...", name
);
582 gdb_flush (gdb_stdout
);
584 init_entry_point_info (objfile
);
585 find_sym_fns (objfile
);
589 /* We either created a new mapped symbol table, mapped an existing
590 symbol table file which has not had initial symbol reading
591 performed, or need to read an unmapped symbol table. */
592 if (from_tty
|| info_verbose
)
594 printf_filtered ("Reading symbols from %s...", name
);
596 gdb_flush (gdb_stdout
);
598 syms_from_objfile (objfile
, addr
, mainline
, from_tty
);
601 /* We now have at least a partial symbol table. Check to see if the
602 user requested that all symbols be read on initial access via either
603 the gdb startup command line or on a per symbol file basis. Expand
604 all partial symbol tables for this objfile if so. */
606 if (readnow
|| readnow_symbol_files
)
608 if (from_tty
|| info_verbose
)
610 printf_filtered ("expanding to full symbols...");
612 gdb_flush (gdb_stdout
);
615 for (psymtab
= objfile
-> psymtabs
;
617 psymtab
= psymtab
-> next
)
619 psymtab_to_symtab (psymtab
);
623 if (from_tty
|| info_verbose
)
625 printf_filtered ("done.\n");
626 gdb_flush (gdb_stdout
);
629 new_symfile_objfile (objfile
, mainline
, from_tty
);
634 /* This is the symbol-file command. Read the file, analyze its
635 symbols, and add a struct symtab to a symtab list. The syntax of
636 the command is rather bizarre--(1) buildargv implements various
637 quoting conventions which are undocumented and have little or
638 nothing in common with the way things are quoted (or not quoted)
639 elsewhere in GDB, (2) options are used, which are not generally
640 used in GDB (perhaps "set mapped on", "set readnow on" would be
641 better), (3) the order of options matters, which is contrary to GNU
642 conventions (because it is confusing and inconvenient). */
645 symbol_file_command (args
, from_tty
)
651 CORE_ADDR text_relocation
= 0; /* text_relocation */
652 struct cleanup
*cleanups
;
660 if ((have_full_symbols () || have_partial_symbols ())
662 && !query ("Discard symbol table from `%s'? ",
663 symfile_objfile
-> name
))
664 error ("Not confirmed.");
665 free_all_objfiles ();
666 symfile_objfile
= NULL
;
669 printf_unfiltered ("No symbol file now.\n");
674 if ((argv
= buildargv (args
)) == NULL
)
678 cleanups
= make_cleanup (freeargv
, (char *) argv
);
679 while (*argv
!= NULL
)
681 if (STREQ (*argv
, "-mapped"))
685 else if (STREQ (*argv
, "-readnow"))
689 else if (**argv
== '-')
691 error ("unknown option `%s'", *argv
);
699 /* this is for rombug remote only, to get the text relocation by
700 using link command */
701 p
= strrchr(name
, '/');
705 target_link(p
, &text_relocation
);
707 if (text_relocation
== (CORE_ADDR
)0)
709 else if (text_relocation
== (CORE_ADDR
)-1)
710 symbol_file_add (name
, from_tty
, (CORE_ADDR
)0, 1, mapped
,
713 symbol_file_add (name
, from_tty
, (CORE_ADDR
)text_relocation
,
716 /* Getting new symbols may change our opinion about what is
718 reinit_frame_cache ();
720 set_initial_language ();
727 error ("no symbol file name was specified");
729 do_cleanups (cleanups
);
733 /* Set the initial language.
735 A better solution would be to record the language in the psymtab when reading
736 partial symbols, and then use it (if known) to set the language. This would
737 be a win for formats that encode the language in an easily discoverable place,
738 such as DWARF. For stabs, we can jump through hoops looking for specially
739 named symbols or try to intuit the language from the specific type of stabs
740 we find, but we can't do that until later when we read in full symbols.
744 set_initial_language ()
746 struct partial_symtab
*pst
;
747 enum language lang
= language_unknown
;
749 pst
= find_main_psymtab ();
752 if (pst
-> filename
!= NULL
)
754 lang
= deduce_language_from_filename (pst
-> filename
);
756 if (lang
== language_unknown
)
758 /* Make C the default language */
762 expected_language
= current_language
; /* Don't warn the user */
766 /* Open file specified by NAME and hand it off to BFD for preliminary
767 analysis. Result is a newly initialized bfd *, which includes a newly
768 malloc'd` copy of NAME (tilde-expanded and made absolute).
769 In case of trouble, error() is called. */
772 symfile_bfd_open (name
)
779 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
781 /* Look down path for it, allocate 2nd new malloc'd copy. */
782 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
785 make_cleanup (free
, name
);
786 perror_with_name (name
);
788 free (name
); /* Free 1st new malloc'd copy */
789 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
790 /* It'll be freed in free_objfile(). */
792 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
796 make_cleanup (free
, name
);
797 error ("\"%s\": can't open to read symbols: %s.", name
,
798 bfd_errmsg (bfd_get_error ()));
800 sym_bfd
->cacheable
= true;
802 if (!bfd_check_format (sym_bfd
, bfd_object
))
804 /* FIXME: should be checking for errors from bfd_close (for one thing,
805 on error it does not free all the storage associated with the
807 bfd_close (sym_bfd
); /* This also closes desc */
808 make_cleanup (free
, name
);
809 error ("\"%s\": can't read symbols: %s.", name
,
810 bfd_errmsg (bfd_get_error ()));
816 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
817 startup by the _initialize routine in each object file format reader,
818 to register information about each format the the reader is prepared
825 sf
->next
= symtab_fns
;
830 /* Initialize to read symbols from the symbol file sym_bfd. It either
831 returns or calls error(). The result is an initialized struct sym_fns
832 in the objfile structure, that contains cached information about the
836 find_sym_fns (objfile
)
837 struct objfile
*objfile
;
840 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
-> obfd
);
841 char *our_target
= bfd_get_target (objfile
-> obfd
);
843 /* Special kludge for RS/6000. See xcoffread.c. */
844 if (STREQ (our_target
, "aixcoff-rs6000"))
845 our_flavour
= (enum bfd_flavour
)-1;
847 /* Special kludge for apollo. See dstread.c. */
848 if (STREQN (our_target
, "apollo", 6))
849 our_flavour
= (enum bfd_flavour
)-2;
851 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
-> next
)
853 if (our_flavour
== sf
-> sym_flavour
)
859 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
860 bfd_get_target (objfile
-> obfd
));
863 /* This function runs the load command of our current target. */
866 load_command (arg
, from_tty
)
871 arg
= get_exec_file (1);
872 target_load (arg
, from_tty
);
875 /* This version of "load" should be usable for any target. Currently
876 it is just used for remote targets, not inftarg.c or core files,
877 on the theory that only in that case is it useful.
879 Avoiding xmodem and the like seems like a win (a) because we don't have
880 to worry about finding it, and (b) On VMS, fork() is very slow and so
881 we don't want to run a subprocess. On the other hand, I'm not sure how
882 performance compares. */
884 generic_load (filename
, from_tty
)
888 struct cleanup
*old_cleanups
;
892 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
893 if (loadfile_bfd
== NULL
)
895 perror_with_name (filename
);
898 /* FIXME: should be checking for errors from bfd_close (for one thing,
899 on error it does not free all the storage associated with the
901 old_cleanups
= make_cleanup (bfd_close
, loadfile_bfd
);
903 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
905 error ("\"%s\" is not an object file: %s", filename
,
906 bfd_errmsg (bfd_get_error ()));
909 for (s
= loadfile_bfd
->sections
; s
; s
= s
->next
)
911 if (s
->flags
& SEC_LOAD
)
915 size
= bfd_get_section_size_before_reloc (s
);
919 struct cleanup
*old_chain
;
922 buffer
= xmalloc (size
);
923 old_chain
= make_cleanup (free
, buffer
);
925 vma
= bfd_get_section_vma (loadfile_bfd
, s
);
927 /* Is this really necessary? I guess it gives the user something
928 to look at during a long download. */
929 printf_filtered ("Loading section %s, size 0x%lx vma ",
930 bfd_get_section_name (loadfile_bfd
, s
),
931 (unsigned long) size
);
932 print_address_numeric (vma
, 1, gdb_stdout
);
933 printf_filtered ("\n");
935 bfd_get_section_contents (loadfile_bfd
, s
, buffer
, 0, size
);
937 target_write_memory (vma
, buffer
, size
);
939 do_cleanups (old_chain
);
944 /* We were doing this in remote-mips.c, I suspect it is right
945 for other targets too. */
946 write_pc (loadfile_bfd
->start_address
);
948 /* FIXME: are we supposed to call symbol_file_add or not? According to
949 a comment from remote-mips.c (where a call to symbol_file_add was
950 commented out), making the call confuses GDB if more than one file is
951 loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
954 do_cleanups (old_cleanups
);
957 /* This function allows the addition of incrementally linked object files.
958 It does not modify any state in the target, only in the debugger. */
962 add_symbol_file_command (args
, from_tty
)
976 error ("add-symbol-file takes a file name and an address");
979 /* Make a copy of the string that we can safely write into. */
981 args
= strdup (args
);
982 make_cleanup (free
, args
);
984 /* Pick off any -option args and the file name. */
986 while ((*args
!= '\000') && (name
== NULL
))
988 while (isspace (*args
)) {args
++;}
990 while ((*args
!= '\000') && !isspace (*args
)) {args
++;}
999 else if (STREQ (arg
, "-mapped"))
1003 else if (STREQ (arg
, "-readnow"))
1009 error ("unknown option `%s'", arg
);
1013 /* After picking off any options and the file name, args should be
1014 left pointing at the remainder of the command line, which should
1015 be the address expression to evaluate. */
1019 error ("add-symbol-file takes a file name");
1021 name
= tilde_expand (name
);
1022 make_cleanup (free
, name
);
1024 if (*args
!= '\000')
1026 text_addr
= parse_and_eval_address (args
);
1030 target_link(name
, &text_addr
);
1031 if (text_addr
== (CORE_ADDR
)-1)
1032 error("Don't know how to get text start location for this file");
1035 /* FIXME-32x64: Assumes text_addr fits in a long. */
1036 if (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
1037 name
, local_hex_string ((unsigned long)text_addr
)))
1038 error ("Not confirmed.");
1040 symbol_file_add (name
, 0, text_addr
, 0, mapped
, readnow
);
1042 /* Getting new symbols may change our opinion about what is
1044 reinit_frame_cache ();
1048 add_shared_symbol_files_command (args
, from_tty
)
1052 #ifdef ADD_SHARED_SYMBOL_FILES
1053 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1055 error ("This command is not available in this configuration of GDB.");
1059 /* Re-read symbols if a symbol-file has changed. */
1063 struct objfile
*objfile
;
1066 struct stat new_statbuf
;
1069 /* With the addition of shared libraries, this should be modified,
1070 the load time should be saved in the partial symbol tables, since
1071 different tables may come from different source files. FIXME.
1072 This routine should then walk down each partial symbol table
1073 and see if the symbol table that it originates from has been changed */
1075 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
) {
1076 if (objfile
->obfd
) {
1077 #ifdef IBM6000_TARGET
1078 /* If this object is from a shared library, then you should
1079 stat on the library name, not member name. */
1081 if (objfile
->obfd
->my_archive
)
1082 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1085 res
= stat (objfile
->name
, &new_statbuf
);
1087 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1088 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1092 new_modtime
= new_statbuf
.st_mtime
;
1093 if (new_modtime
!= objfile
->mtime
)
1095 struct cleanup
*old_cleanups
;
1096 struct section_offsets
*offsets
;
1098 int section_offsets_size
;
1099 char *obfd_filename
;
1101 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1104 /* There are various functions like symbol_file_add,
1105 symfile_bfd_open, syms_from_objfile, etc., which might
1106 appear to do what we want. But they have various other
1107 effects which we *don't* want. So we just do stuff
1108 ourselves. We don't worry about mapped files (for one thing,
1109 any mapped file will be out of date). */
1111 /* If we get an error, blow away this objfile (not sure if
1112 that is the correct response for things like shared
1114 old_cleanups
= make_cleanup (free_objfile
, objfile
);
1115 /* We need to do this whenever any symbols go away. */
1116 make_cleanup (clear_symtab_users
, 0);
1118 /* Clean up any state BFD has sitting around. We don't need
1119 to close the descriptor but BFD lacks a way of closing the
1120 BFD without closing the descriptor. */
1121 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1122 if (!bfd_close (objfile
->obfd
))
1123 error ("Can't close BFD for %s: %s", objfile
->name
,
1124 bfd_errmsg (bfd_get_error ()));
1125 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1126 if (objfile
->obfd
== NULL
)
1127 error ("Can't open %s to read symbols.", objfile
->name
);
1128 /* bfd_openr sets cacheable to true, which is what we want. */
1129 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1130 error ("Can't read symbols from %s: %s.", objfile
->name
,
1131 bfd_errmsg (bfd_get_error ()));
1133 /* Save the offsets, we will nuke them with the rest of the
1135 num_offsets
= objfile
->num_sections
;
1136 section_offsets_size
=
1137 sizeof (struct section_offsets
)
1138 + sizeof (objfile
->section_offsets
->offsets
) * num_offsets
;
1139 offsets
= (struct section_offsets
*) alloca (section_offsets_size
);
1140 memcpy (offsets
, objfile
->section_offsets
, section_offsets_size
);
1142 /* Nuke all the state that we will re-read. Much of the following
1143 code which sets things to NULL really is necessary to tell
1144 other parts of GDB that there is nothing currently there. */
1146 /* FIXME: Do we have to free a whole linked list, or is this
1148 if (objfile
->global_psymbols
.list
)
1149 mfree (objfile
->md
, objfile
->global_psymbols
.list
);
1150 objfile
->global_psymbols
.list
= NULL
;
1151 objfile
->global_psymbols
.next
= NULL
;
1152 objfile
->global_psymbols
.size
= 0;
1153 if (objfile
->static_psymbols
.list
)
1154 mfree (objfile
->md
, objfile
->static_psymbols
.list
);
1155 objfile
->static_psymbols
.list
= NULL
;
1156 objfile
->static_psymbols
.next
= NULL
;
1157 objfile
->static_psymbols
.size
= 0;
1159 /* Free the obstacks for non-reusable objfiles */
1160 obstack_free (&objfile
-> psymbol_obstack
, 0);
1161 obstack_free (&objfile
-> symbol_obstack
, 0);
1162 obstack_free (&objfile
-> type_obstack
, 0);
1163 objfile
->sections
= NULL
;
1164 objfile
->symtabs
= NULL
;
1165 objfile
->psymtabs
= NULL
;
1166 objfile
->free_psymtabs
= NULL
;
1167 objfile
->msymbols
= NULL
;
1168 objfile
->minimal_symbol_count
= 0;
1169 objfile
->fundamental_types
= NULL
;
1170 if (objfile
-> sf
!= NULL
)
1172 (*objfile
-> sf
-> sym_finish
) (objfile
);
1175 /* We never make this a mapped file. */
1176 objfile
-> md
= NULL
;
1177 /* obstack_specify_allocation also initializes the obstack so
1179 obstack_specify_allocation (&objfile
-> psymbol_obstack
, 0, 0,
1181 obstack_specify_allocation (&objfile
-> symbol_obstack
, 0, 0,
1183 obstack_specify_allocation (&objfile
-> type_obstack
, 0, 0,
1185 if (build_objfile_section_table (objfile
))
1187 error ("Can't find the file sections in `%s': %s",
1188 objfile
-> name
, bfd_errmsg (bfd_get_error ()));
1191 /* We use the same section offsets as from last time. I'm not
1192 sure whether that is always correct for shared libraries. */
1193 objfile
->section_offsets
= (struct section_offsets
*)
1194 obstack_alloc (&objfile
-> psymbol_obstack
, section_offsets_size
);
1195 memcpy (objfile
->section_offsets
, offsets
, section_offsets_size
);
1196 objfile
->num_sections
= num_offsets
;
1198 /* What the hell is sym_new_init for, anyway? The concept of
1199 distinguishing between the main file and additional files
1200 in this way seems rather dubious. */
1201 if (objfile
== symfile_objfile
)
1202 (*objfile
->sf
->sym_new_init
) (objfile
);
1204 (*objfile
->sf
->sym_init
) (objfile
);
1205 clear_complaints (1, 1);
1206 /* The "mainline" parameter is a hideous hack; I think leaving it
1207 zero is OK since dbxread.c also does what it needs to do if
1208 objfile->global_psymbols.size is 0. */
1209 (*objfile
->sf
->sym_read
) (objfile
, objfile
->section_offsets
, 0);
1210 if (!have_partial_symbols () && !have_full_symbols ())
1213 printf_filtered ("(no debugging symbols found)\n");
1216 objfile
-> flags
|= OBJF_SYMS
;
1218 /* We're done reading the symbol file; finish off complaints. */
1219 clear_complaints (0, 1);
1221 /* Getting new symbols may change our opinion about what is
1224 reinit_frame_cache ();
1226 /* Discard cleanups as symbol reading was successful. */
1227 discard_cleanups (old_cleanups
);
1229 /* If the mtime has changed between the time we set new_modtime
1230 and now, we *want* this to be out of date, so don't call stat
1232 objfile
->mtime
= new_modtime
;
1239 clear_symtab_users ();
1244 deduce_language_from_filename (filename
)
1251 else if (0 == (c
= strrchr (filename
, '.')))
1252 ; /* Get default. */
1253 else if (STREQ (c
, ".c"))
1255 else if (STREQ (c
, ".cc") || STREQ (c
, ".C") || STREQ (c
, ".cxx")
1256 || STREQ (c
, ".cpp") || STREQ (c
, ".cp") || STREQ (c
, ".c++"))
1257 return language_cplus
;
1258 else if (STREQ (c
, ".ch") || STREQ (c
, ".c186") || STREQ (c
, ".c286"))
1259 return language_chill
;
1260 else if (STREQ (c
, ".f") || STREQ (c
, ".F"))
1261 return language_fortran
;
1262 else if (STREQ (c
, ".mod"))
1264 else if (STREQ (c
, ".s") || STREQ (c
, ".S"))
1265 return language_asm
;
1267 return language_unknown
; /* default */
1272 Allocate and partly initialize a new symbol table. Return a pointer
1273 to it. error() if no space.
1275 Caller must set these fields:
1281 initialize any EXTRA_SYMTAB_INFO
1282 possibly free_named_symtabs (symtab->filename);
1286 allocate_symtab (filename
, objfile
)
1288 struct objfile
*objfile
;
1290 register struct symtab
*symtab
;
1292 symtab
= (struct symtab
*)
1293 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symtab
));
1294 memset (symtab
, 0, sizeof (*symtab
));
1295 symtab
-> filename
= obsavestring (filename
, strlen (filename
),
1296 &objfile
-> symbol_obstack
);
1297 symtab
-> fullname
= NULL
;
1298 symtab
-> language
= deduce_language_from_filename (filename
);
1300 /* Hook it to the objfile it comes from */
1302 symtab
-> objfile
= objfile
;
1303 symtab
-> next
= objfile
-> symtabs
;
1304 objfile
-> symtabs
= symtab
;
1306 #ifdef INIT_EXTRA_SYMTAB_INFO
1307 INIT_EXTRA_SYMTAB_INFO (symtab
);
1313 struct partial_symtab
*
1314 allocate_psymtab (filename
, objfile
)
1316 struct objfile
*objfile
;
1318 struct partial_symtab
*psymtab
;
1320 if (objfile
-> free_psymtabs
)
1322 psymtab
= objfile
-> free_psymtabs
;
1323 objfile
-> free_psymtabs
= psymtab
-> next
;
1326 psymtab
= (struct partial_symtab
*)
1327 obstack_alloc (&objfile
-> psymbol_obstack
,
1328 sizeof (struct partial_symtab
));
1330 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1331 psymtab
-> filename
= obsavestring (filename
, strlen (filename
),
1332 &objfile
-> psymbol_obstack
);
1333 psymtab
-> symtab
= NULL
;
1335 /* Hook it to the objfile it comes from */
1337 psymtab
-> objfile
= objfile
;
1338 psymtab
-> next
= objfile
-> psymtabs
;
1339 objfile
-> psymtabs
= psymtab
;
1345 /* Reset all data structures in gdb which may contain references to symbol
1349 clear_symtab_users ()
1351 /* Someday, we should do better than this, by only blowing away
1352 the things that really need to be blown. */
1353 clear_value_history ();
1355 clear_internalvars ();
1356 breakpoint_re_set ();
1357 set_default_breakpoint (0, 0, 0, 0);
1358 current_source_symtab
= 0;
1359 current_source_line
= 0;
1360 clear_pc_function_cache ();
1363 /* clear_symtab_users_once:
1365 This function is run after symbol reading, or from a cleanup.
1366 If an old symbol table was obsoleted, the old symbol table
1367 has been blown away, but the other GDB data structures that may
1368 reference it have not yet been cleared or re-directed. (The old
1369 symtab was zapped, and the cleanup queued, in free_named_symtab()
1372 This function can be queued N times as a cleanup, or called
1373 directly; it will do all the work the first time, and then will be a
1374 no-op until the next time it is queued. This works by bumping a
1375 counter at queueing time. Much later when the cleanup is run, or at
1376 the end of symbol processing (in case the cleanup is discarded), if
1377 the queued count is greater than the "done-count", we do the work
1378 and set the done-count to the queued count. If the queued count is
1379 less than or equal to the done-count, we just ignore the call. This
1380 is needed because reading a single .o file will often replace many
1381 symtabs (one per .h file, for example), and we don't want to reset
1382 the breakpoints N times in the user's face.
1384 The reason we both queue a cleanup, and call it directly after symbol
1385 reading, is because the cleanup protects us in case of errors, but is
1386 discarded if symbol reading is successful. */
1389 /* FIXME: As free_named_symtabs is currently a big noop this function
1390 is no longer needed. */
1392 clear_symtab_users_once
PARAMS ((void));
1394 static int clear_symtab_users_queued
;
1395 static int clear_symtab_users_done
;
1398 clear_symtab_users_once ()
1400 /* Enforce once-per-`do_cleanups'-semantics */
1401 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
1403 clear_symtab_users_done
= clear_symtab_users_queued
;
1405 clear_symtab_users ();
1409 /* Delete the specified psymtab, and any others that reference it. */
1412 cashier_psymtab (pst
)
1413 struct partial_symtab
*pst
;
1415 struct partial_symtab
*ps
, *pprev
= NULL
;
1418 /* Find its previous psymtab in the chain */
1419 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1426 /* Unhook it from the chain. */
1427 if (ps
== pst
->objfile
->psymtabs
)
1428 pst
->objfile
->psymtabs
= ps
->next
;
1430 pprev
->next
= ps
->next
;
1432 /* FIXME, we can't conveniently deallocate the entries in the
1433 partial_symbol lists (global_psymbols/static_psymbols) that
1434 this psymtab points to. These just take up space until all
1435 the psymtabs are reclaimed. Ditto the dependencies list and
1436 filename, which are all in the psymbol_obstack. */
1438 /* We need to cashier any psymtab that has this one as a dependency... */
1440 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
) {
1441 for (i
= 0; i
< ps
->number_of_dependencies
; i
++) {
1442 if (ps
->dependencies
[i
] == pst
) {
1443 cashier_psymtab (ps
);
1444 goto again
; /* Must restart, chain has been munged. */
1451 /* If a symtab or psymtab for filename NAME is found, free it along
1452 with any dependent breakpoints, displays, etc.
1453 Used when loading new versions of object modules with the "add-file"
1454 command. This is only called on the top-level symtab or psymtab's name;
1455 it is not called for subsidiary files such as .h files.
1457 Return value is 1 if we blew away the environment, 0 if not.
1458 FIXME. The return valu appears to never be used.
1460 FIXME. I think this is not the best way to do this. We should
1461 work on being gentler to the environment while still cleaning up
1462 all stray pointers into the freed symtab. */
1465 free_named_symtabs (name
)
1469 /* FIXME: With the new method of each objfile having it's own
1470 psymtab list, this function needs serious rethinking. In particular,
1471 why was it ever necessary to toss psymtabs with specific compilation
1472 unit filenames, as opposed to all psymtabs from a particular symbol
1474 Well, the answer is that some systems permit reloading of particular
1475 compilation units. We want to blow away any old info about these
1476 compilation units, regardless of which objfiles they arrived in. --gnu. */
1478 register struct symtab
*s
;
1479 register struct symtab
*prev
;
1480 register struct partial_symtab
*ps
;
1481 struct blockvector
*bv
;
1484 /* We only wack things if the symbol-reload switch is set. */
1485 if (!symbol_reloading
)
1488 /* Some symbol formats have trouble providing file names... */
1489 if (name
== 0 || *name
== '\0')
1492 /* Look for a psymtab with the specified name. */
1495 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
) {
1496 if (STREQ (name
, ps
->filename
)) {
1497 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
1498 goto again2
; /* Must restart, chain has been munged */
1502 /* Look for a symtab with the specified name. */
1504 for (s
= symtab_list
; s
; s
= s
->next
)
1506 if (STREQ (name
, s
->filename
))
1513 if (s
== symtab_list
)
1514 symtab_list
= s
->next
;
1516 prev
->next
= s
->next
;
1518 /* For now, queue a delete for all breakpoints, displays, etc., whether
1519 or not they depend on the symtab being freed. This should be
1520 changed so that only those data structures affected are deleted. */
1522 /* But don't delete anything if the symtab is empty.
1523 This test is necessary due to a bug in "dbxread.c" that
1524 causes empty symtabs to be created for N_SO symbols that
1525 contain the pathname of the object file. (This problem
1526 has been fixed in GDB 3.9x). */
1528 bv
= BLOCKVECTOR (s
);
1529 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
1530 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
1531 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
1533 complain (&oldsyms_complaint
, name
);
1535 clear_symtab_users_queued
++;
1536 make_cleanup (clear_symtab_users_once
, 0);
1539 complain (&empty_symtab_complaint
, name
);
1546 /* It is still possible that some breakpoints will be affected
1547 even though no symtab was found, since the file might have
1548 been compiled without debugging, and hence not be associated
1549 with a symtab. In order to handle this correctly, we would need
1550 to keep a list of text address ranges for undebuggable files.
1551 For now, we do nothing, since this is a fairly obscure case. */
1555 /* FIXME, what about the minimal symbol table? */
1562 /* Allocate and partially fill a partial symtab. It will be
1563 completely filled at the end of the symbol list.
1565 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1566 is the address relative to which its symbols are (incremental) or 0
1570 struct partial_symtab
*
1571 start_psymtab_common (objfile
, section_offsets
,
1572 filename
, textlow
, global_syms
, static_syms
)
1573 struct objfile
*objfile
;
1574 struct section_offsets
*section_offsets
;
1577 struct partial_symbol
*global_syms
;
1578 struct partial_symbol
*static_syms
;
1580 struct partial_symtab
*psymtab
;
1582 psymtab
= allocate_psymtab (filename
, objfile
);
1583 psymtab
-> section_offsets
= section_offsets
;
1584 psymtab
-> textlow
= textlow
;
1585 psymtab
-> texthigh
= psymtab
-> textlow
; /* default */
1586 psymtab
-> globals_offset
= global_syms
- objfile
-> global_psymbols
.list
;
1587 psymtab
-> statics_offset
= static_syms
- objfile
-> static_psymbols
.list
;
1591 /* Debugging versions of functions that are usually inline macros
1594 #if !INLINE_ADD_PSYMBOL
1596 /* Add a symbol with a long value to a psymtab.
1597 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
1600 add_psymbol_to_list (name
, namelength
, namespace, class, list
, val
, language
,
1604 enum namespace namespace;
1605 enum address_class
class;
1606 struct psymbol_allocation_list
*list
;
1608 enum language language
;
1609 struct objfile
*objfile
;
1611 register struct partial_symbol
*psym
;
1612 register char *demangled_name
;
1614 if (list
->next
>= list
->list
+ list
->size
)
1616 extend_psymbol_list (list
,objfile
);
1618 psym
= list
->next
++;
1620 SYMBOL_NAME (psym
) =
1621 (char *) obstack_alloc (&objfile
->psymbol_obstack
, namelength
+ 1);
1622 memcpy (SYMBOL_NAME (psym
), name
, namelength
);
1623 SYMBOL_NAME (psym
)[namelength
] = '\0';
1624 SYMBOL_VALUE (psym
) = val
;
1625 SYMBOL_LANGUAGE (psym
) = language
;
1626 PSYMBOL_NAMESPACE (psym
) = namespace;
1627 PSYMBOL_CLASS (psym
) = class;
1628 SYMBOL_INIT_LANGUAGE_SPECIFIC (psym
, language
);
1631 /* Add a symbol with a CORE_ADDR value to a psymtab. */
1634 add_psymbol_addr_to_list (name
, namelength
, namespace, class, list
, val
,
1638 enum namespace namespace;
1639 enum address_class
class;
1640 struct psymbol_allocation_list
*list
;
1642 enum language language
;
1643 struct objfile
*objfile
;
1645 register struct partial_symbol
*psym
;
1646 register char *demangled_name
;
1648 if (list
->next
>= list
->list
+ list
->size
)
1650 extend_psymbol_list (list
,objfile
);
1652 psym
= list
->next
++;
1654 SYMBOL_NAME (psym
) =
1655 (char *) obstack_alloc (&objfile
->psymbol_obstack
, namelength
+ 1);
1656 memcpy (SYMBOL_NAME (psym
), name
, namelength
);
1657 SYMBOL_NAME (psym
)[namelength
] = '\0';
1658 SYMBOL_VALUE_ADDRESS (psym
) = val
;
1659 SYMBOL_LANGUAGE (psym
) = language
;
1660 PSYMBOL_NAMESPACE (psym
) = namespace;
1661 PSYMBOL_CLASS (psym
) = class;
1662 SYMBOL_INIT_LANGUAGE_SPECIFIC (psym
, language
);
1665 #endif /* !INLINE_ADD_PSYMBOL */
1667 /* Initialize storage for partial symbols. */
1670 init_psymbol_list (objfile
, total_symbols
)
1671 struct objfile
*objfile
;
1674 /* Free any previously allocated psymbol lists. */
1676 if (objfile
-> global_psymbols
.list
)
1678 mfree (objfile
-> md
, (PTR
)objfile
-> global_psymbols
.list
);
1680 if (objfile
-> static_psymbols
.list
)
1682 mfree (objfile
-> md
, (PTR
)objfile
-> static_psymbols
.list
);
1685 /* Current best guess is that approximately a twentieth
1686 of the total symbols (in a debugging file) are global or static
1689 objfile
-> global_psymbols
.size
= total_symbols
/ 10;
1690 objfile
-> static_psymbols
.size
= total_symbols
/ 10;
1691 objfile
-> global_psymbols
.next
=
1692 objfile
-> global_psymbols
.list
= (struct partial_symbol
*)
1693 xmmalloc (objfile
-> md
, objfile
-> global_psymbols
.size
1694 * sizeof (struct partial_symbol
));
1695 objfile
-> static_psymbols
.next
=
1696 objfile
-> static_psymbols
.list
= (struct partial_symbol
*)
1697 xmmalloc (objfile
-> md
, objfile
-> static_psymbols
.size
1698 * sizeof (struct partial_symbol
));
1702 _initialize_symfile ()
1704 struct cmd_list_element
*c
;
1706 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
1707 "Load symbol table from executable file FILE.\n\
1708 The `file' command can also load symbol tables, as well as setting the file\n\
1709 to execute.", &cmdlist
);
1710 c
->completer
= filename_completer
;
1712 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
1713 "Usage: add-symbol-file FILE ADDR\n\
1714 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
1715 ADDR is the starting address of the file's text.",
1717 c
->completer
= filename_completer
;
1719 c
= add_cmd ("add-shared-symbol-files", class_files
,
1720 add_shared_symbol_files_command
,
1721 "Load the symbols from shared objects in the dynamic linker's link map.",
1723 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
1726 c
= add_cmd ("load", class_files
, load_command
,
1727 "Dynamically load FILE into the running program, and record its symbols\n\
1728 for access from GDB.", &cmdlist
);
1729 c
->completer
= filename_completer
;
1732 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
1733 (char *)&symbol_reloading
,
1734 "Set dynamic symbol table reloading multiple times in one run.",