1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
6 Contributed by Cygnus Support, using pieces from other GDB modules.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
36 #include "breakpoint.h"
38 #include "complaints.h"
40 #include "inferior.h" /* for write_pc */
41 #include "filenames.h" /* for DOSish file names */
42 #include "gdb-stabs.h"
43 #include "gdb_obstack.h"
44 #include "completer.h"
46 #include <readline/readline.h>
47 #include "gdb_assert.h"
49 #include <sys/types.h>
51 #include "gdb_string.h"
62 /* Some HP-UX related globals to clear when a new "main"
63 symbol file is loaded. HP-specific. */
65 extern int hp_som_som_object_present;
66 extern int hp_cxx_exception_support_initialized;
67 #define RESET_HP_UX_GLOBALS() do {\
68 hp_som_som_object_present = 0; /* indicates HP-compiled code */ \
69 hp_cxx_exception_support_initialized = 0; /* must reinitialize exception stuff */ \
73 int (*ui_load_progress_hook) (const char *section, unsigned long num);
74 void (*show_load_progress) (const char *section,
75 unsigned long section_sent,
76 unsigned long section_size,
77 unsigned long total_sent,
78 unsigned long total_size);
79 void (*pre_add_symbol_hook) (char *);
80 void (*post_add_symbol_hook) (void);
81 void (*target_new_objfile_hook) (struct objfile *);
83 static void clear_symtab_users_cleanup (void *ignore);
85 /* Global variables owned by this file */
86 int readnow_symbol_files; /* Read full symbols immediately */
88 /* External variables and functions referenced. */
90 extern void report_transfer_performance (unsigned long, time_t, time_t);
92 /* Functions this file defines */
95 static int simple_read_overlay_region_table (void);
96 static void simple_free_overlay_region_table (void);
99 static void set_initial_language (void);
101 static void load_command (char *, int);
103 static void symbol_file_add_main_1 (char *args, int from_tty, int flags);
105 static void add_symbol_file_command (char *, int);
107 static void add_shared_symbol_files_command (char *, int);
109 static void reread_separate_symbols (struct objfile *objfile);
111 static void cashier_psymtab (struct partial_symtab *);
113 bfd *symfile_bfd_open (char *);
115 int get_section_index (struct objfile *, char *);
117 static void find_sym_fns (struct objfile *);
119 static void decrement_reading_symtab (void *);
121 static void overlay_invalidate_all (void);
123 static int overlay_is_mapped (struct obj_section *);
125 void list_overlays_command (char *, int);
127 void map_overlay_command (char *, int);
129 void unmap_overlay_command (char *, int);
131 static void overlay_auto_command (char *, int);
133 static void overlay_manual_command (char *, int);
135 static void overlay_off_command (char *, int);
137 static void overlay_load_command (char *, int);
139 static void overlay_command (char *, int);
141 static void simple_free_overlay_table (void);
143 static void read_target_long_array (CORE_ADDR, unsigned int *, int);
145 static int simple_read_overlay_table (void);
147 static int simple_overlay_update_1 (struct obj_section *);
149 static void add_filename_language (char *ext, enum language lang);
151 static void set_ext_lang_command (char *args, int from_tty);
153 static void info_ext_lang_command (char *args, int from_tty);
155 static char *find_separate_debug_file (struct objfile *objfile);
157 static void init_filename_language_table (void);
159 void _initialize_symfile (void);
161 /* List of all available sym_fns. On gdb startup, each object file reader
162 calls add_symtab_fns() to register information on each format it is
165 static struct sym_fns *symtab_fns = NULL;
167 /* Flag for whether user will be reloading symbols multiple times.
168 Defaults to ON for VxWorks, otherwise OFF. */
170 #ifdef SYMBOL_RELOADING_DEFAULT
171 int symbol_reloading = SYMBOL_RELOADING_DEFAULT;
173 int symbol_reloading = 0;
176 /* If non-zero, shared library symbols will be added automatically
177 when the inferior is created, new libraries are loaded, or when
178 attaching to the inferior. This is almost always what users will
179 want to have happen; but for very large programs, the startup time
180 will be excessive, and so if this is a problem, the user can clear
181 this flag and then add the shared library symbols as needed. Note
182 that there is a potential for confusion, since if the shared
183 library symbols are not loaded, commands like "info fun" will *not*
184 report all the functions that are actually present. */
186 int auto_solib_add = 1;
188 /* For systems that support it, a threshold size in megabytes. If
189 automatically adding a new library's symbol table to those already
190 known to the debugger would cause the total shared library symbol
191 size to exceed this threshhold, then the shlib's symbols are not
192 added. The threshold is ignored if the user explicitly asks for a
193 shlib to be added, such as when using the "sharedlibrary"
196 int auto_solib_limit;
199 /* Since this function is called from within qsort, in an ANSI environment
200 it must conform to the prototype for qsort, which specifies that the
201 comparison function takes two "void *" pointers. */
204 compare_symbols (const void *s1p, const void *s2p)
206 register struct symbol **s1, **s2;
208 s1 = (struct symbol **) s1p;
209 s2 = (struct symbol **) s2p;
210 return (strcmp (SYMBOL_SOURCE_NAME (*s1), SYMBOL_SOURCE_NAME (*s2)));
217 compare_psymbols -- compare two partial symbols by name
221 Given pointers to pointers to two partial symbol table entries,
222 compare them by name and return -N, 0, or +N (ala strcmp).
223 Typically used by sorting routines like qsort().
227 Does direct compare of first two characters before punting
228 and passing to strcmp for longer compares. Note that the
229 original version had a bug whereby two null strings or two
230 identically named one character strings would return the
231 comparison of memory following the null byte.
236 compare_psymbols (const void *s1p, const void *s2p)
238 register struct partial_symbol **s1, **s2;
239 register char *st1, *st2;
241 s1 = (struct partial_symbol **) s1p;
242 s2 = (struct partial_symbol **) s2p;
243 st1 = SYMBOL_SOURCE_NAME (*s1);
244 st2 = SYMBOL_SOURCE_NAME (*s2);
247 if ((st1[0] - st2[0]) || !st1[0])
249 return (st1[0] - st2[0]);
251 else if ((st1[1] - st2[1]) || !st1[1])
253 return (st1[1] - st2[1]);
257 return (strcmp (st1, st2));
262 sort_pst_symbols (struct partial_symtab *pst)
264 /* Sort the global list; don't sort the static list */
266 qsort (pst->objfile->global_psymbols.list + pst->globals_offset,
267 pst->n_global_syms, sizeof (struct partial_symbol *),
271 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
274 sort_block_syms (register struct block *b)
276 qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
277 sizeof (struct symbol *), compare_symbols);
280 /* Call sort_symtab_syms to sort alphabetically
281 the symbols of each block of one symtab. */
284 sort_symtab_syms (register struct symtab *s)
286 register struct blockvector *bv;
289 register struct block *b;
293 bv = BLOCKVECTOR (s);
294 nbl = BLOCKVECTOR_NBLOCKS (bv);
295 for (i = 0; i < nbl; i++)
297 b = BLOCKVECTOR_BLOCK (bv, i);
298 if (BLOCK_SHOULD_SORT (b))
303 /* Make a null terminated copy of the string at PTR with SIZE characters in
304 the obstack pointed to by OBSTACKP . Returns the address of the copy.
305 Note that the string at PTR does not have to be null terminated, I.E. it
306 may be part of a larger string and we are only saving a substring. */
309 obsavestring (const char *ptr, int size, struct obstack *obstackp)
311 register char *p = (char *) obstack_alloc (obstackp, size + 1);
312 /* Open-coded memcpy--saves function call time. These strings are usually
313 short. FIXME: Is this really still true with a compiler that can
316 register const char *p1 = ptr;
317 register char *p2 = p;
318 const char *end = ptr + size;
326 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
327 in the obstack pointed to by OBSTACKP. */
330 obconcat (struct obstack *obstackp, const char *s1, const char *s2,
333 register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
334 register char *val = (char *) obstack_alloc (obstackp, len);
341 /* True if we are nested inside psymtab_to_symtab. */
343 int currently_reading_symtab = 0;
346 decrement_reading_symtab (void *dummy)
348 currently_reading_symtab--;
351 /* Get the symbol table that corresponds to a partial_symtab.
352 This is fast after the first time you do it. In fact, there
353 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
357 psymtab_to_symtab (register struct partial_symtab *pst)
359 /* If it's been looked up before, return it. */
363 /* If it has not yet been read in, read it. */
366 struct cleanup *back_to = make_cleanup (decrement_reading_symtab, NULL);
367 currently_reading_symtab++;
368 (*pst->read_symtab) (pst);
369 do_cleanups (back_to);
375 /* Initialize entry point information for this objfile. */
378 init_entry_point_info (struct objfile *objfile)
380 /* Save startup file's range of PC addresses to help blockframe.c
381 decide where the bottom of the stack is. */
383 if (bfd_get_file_flags (objfile->obfd) & EXEC_P)
385 /* Executable file -- record its entry point so we'll recognize
386 the startup file because it contains the entry point. */
387 objfile->ei.entry_point = bfd_get_start_address (objfile->obfd);
391 /* Examination of non-executable.o files. Short-circuit this stuff. */
392 objfile->ei.entry_point = INVALID_ENTRY_POINT;
394 objfile->ei.entry_file_lowpc = INVALID_ENTRY_LOWPC;
395 objfile->ei.entry_file_highpc = INVALID_ENTRY_HIGHPC;
396 objfile->ei.entry_func_lowpc = INVALID_ENTRY_LOWPC;
397 objfile->ei.entry_func_highpc = INVALID_ENTRY_HIGHPC;
398 objfile->ei.main_func_lowpc = INVALID_ENTRY_LOWPC;
399 objfile->ei.main_func_highpc = INVALID_ENTRY_HIGHPC;
402 /* Get current entry point address. */
405 entry_point_address (void)
407 return symfile_objfile ? symfile_objfile->ei.entry_point : 0;
410 /* Remember the lowest-addressed loadable section we've seen.
411 This function is called via bfd_map_over_sections.
413 In case of equal vmas, the section with the largest size becomes the
414 lowest-addressed loadable section.
416 If the vmas and sizes are equal, the last section is considered the
417 lowest-addressed loadable section. */
420 find_lowest_section (bfd *abfd, asection *sect, void *obj)
422 asection **lowest = (asection **) obj;
424 if (0 == (bfd_get_section_flags (abfd, sect) & SEC_LOAD))
427 *lowest = sect; /* First loadable section */
428 else if (bfd_section_vma (abfd, *lowest) > bfd_section_vma (abfd, sect))
429 *lowest = sect; /* A lower loadable section */
430 else if (bfd_section_vma (abfd, *lowest) == bfd_section_vma (abfd, sect)
431 && (bfd_section_size (abfd, (*lowest))
432 <= bfd_section_size (abfd, sect)))
437 /* Build (allocate and populate) a section_addr_info struct from
438 an existing section table. */
440 extern struct section_addr_info *
441 build_section_addr_info_from_section_table (const struct section_table *start,
442 const struct section_table *end)
444 struct section_addr_info *sap;
445 const struct section_table *stp;
448 sap = xmalloc (sizeof (struct section_addr_info));
449 memset (sap, 0, sizeof (struct section_addr_info));
451 for (stp = start, oidx = 0; stp != end; stp++)
453 if (bfd_get_section_flags (stp->bfd,
454 stp->the_bfd_section) & (SEC_ALLOC | SEC_LOAD)
455 && oidx < MAX_SECTIONS)
457 sap->other[oidx].addr = stp->addr;
458 sap->other[oidx].name
459 = xstrdup (bfd_section_name (stp->bfd, stp->the_bfd_section));
460 sap->other[oidx].sectindex = stp->the_bfd_section->index;
469 /* Free all memory allocated by build_section_addr_info_from_section_table. */
472 free_section_addr_info (struct section_addr_info *sap)
476 for (idx = 0; idx < MAX_SECTIONS; idx++)
477 if (sap->other[idx].name)
478 xfree (sap->other[idx].name);
483 /* Initialize OBJFILE's sect_index_* members. */
485 init_objfile_sect_indices (struct objfile *objfile)
490 sect = bfd_get_section_by_name (objfile->obfd, ".text");
492 objfile->sect_index_text = sect->index;
494 sect = bfd_get_section_by_name (objfile->obfd, ".data");
496 objfile->sect_index_data = sect->index;
498 sect = bfd_get_section_by_name (objfile->obfd, ".bss");
500 objfile->sect_index_bss = sect->index;
502 sect = bfd_get_section_by_name (objfile->obfd, ".rodata");
504 objfile->sect_index_rodata = sect->index;
506 /* This is where things get really weird... We MUST have valid
507 indices for the various sect_index_* members or gdb will abort.
508 So if for example, there is no ".text" section, we have to
509 accomodate that. Except when explicitly adding symbol files at
510 some address, section_offsets contains nothing but zeros, so it
511 doesn't matter which slot in section_offsets the individual
512 sect_index_* members index into. So if they are all zero, it is
513 safe to just point all the currently uninitialized indices to the
516 for (i = 0; i < objfile->num_sections; i++)
518 if (ANOFFSET (objfile->section_offsets, i) != 0)
523 if (i == objfile->num_sections)
525 if (objfile->sect_index_text == -1)
526 objfile->sect_index_text = 0;
527 if (objfile->sect_index_data == -1)
528 objfile->sect_index_data = 0;
529 if (objfile->sect_index_bss == -1)
530 objfile->sect_index_bss = 0;
531 if (objfile->sect_index_rodata == -1)
532 objfile->sect_index_rodata = 0;
537 /* Parse the user's idea of an offset for dynamic linking, into our idea
538 of how to represent it for fast symbol reading. This is the default
539 version of the sym_fns.sym_offsets function for symbol readers that
540 don't need to do anything special. It allocates a section_offsets table
541 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
544 default_symfile_offsets (struct objfile *objfile,
545 struct section_addr_info *addrs)
549 objfile->num_sections = SECT_OFF_MAX;
550 objfile->section_offsets = (struct section_offsets *)
551 obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
552 memset (objfile->section_offsets, 0, SIZEOF_SECTION_OFFSETS);
554 /* Now calculate offsets for section that were specified by the
556 for (i = 0; i < MAX_SECTIONS && addrs->other[i].name; i++)
558 struct other_sections *osp ;
560 osp = &addrs->other[i] ;
564 /* Record all sections in offsets */
565 /* The section_offsets in the objfile are here filled in using
567 (objfile->section_offsets)->offsets[osp->sectindex] = osp->addr;
570 /* Remember the bfd indexes for the .text, .data, .bss and
572 init_objfile_sect_indices (objfile);
576 /* Process a symbol file, as either the main file or as a dynamically
579 OBJFILE is where the symbols are to be read from.
581 ADDRS is the list of section load addresses. If the user has given
582 an 'add-symbol-file' command, then this is the list of offsets and
583 addresses he or she provided as arguments to the command; or, if
584 we're handling a shared library, these are the actual addresses the
585 sections are loaded at, according to the inferior's dynamic linker
586 (as gleaned by GDB's shared library code). We convert each address
587 into an offset from the section VMA's as it appears in the object
588 file, and then call the file's sym_offsets function to convert this
589 into a format-specific offset table --- a `struct section_offsets'.
590 If ADDRS is non-zero, OFFSETS must be zero.
592 OFFSETS is a table of section offsets already in the right
593 format-specific representation. NUM_OFFSETS is the number of
594 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
595 assume this is the proper table the call to sym_offsets described
596 above would produce. Instead of calling sym_offsets, we just dump
597 it right into objfile->section_offsets. (When we're re-reading
598 symbols from an objfile, we don't have the original load address
599 list any more; all we have is the section offset table.) If
600 OFFSETS is non-zero, ADDRS must be zero.
602 MAINLINE is nonzero if this is the main symbol file, or zero if
603 it's an extra symbol file such as dynamically loaded code.
605 VERBO is nonzero if the caller has printed a verbose message about
606 the symbol reading (and complaints can be more terse about it). */
609 syms_from_objfile (struct objfile *objfile,
610 struct section_addr_info *addrs,
611 struct section_offsets *offsets,
616 asection *lower_sect;
618 CORE_ADDR lower_offset;
619 struct section_addr_info local_addr;
620 struct cleanup *old_chain;
623 gdb_assert (! (addrs && offsets));
625 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
626 list. We now establish the convention that an addr of zero means
627 no load address was specified. */
628 if (! addrs && ! offsets)
630 memset (&local_addr, 0, sizeof (local_addr));
634 /* Now either addrs or offsets is non-zero. */
636 init_entry_point_info (objfile);
637 find_sym_fns (objfile);
639 if (objfile->sf == NULL)
640 return; /* No symbols. */
642 /* Make sure that partially constructed symbol tables will be cleaned up
643 if an error occurs during symbol reading. */
644 old_chain = make_cleanup_free_objfile (objfile);
648 /* We will modify the main symbol table, make sure that all its users
649 will be cleaned up if an error occurs during symbol reading. */
650 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
652 /* Since no error yet, throw away the old symbol table. */
654 if (symfile_objfile != NULL)
656 free_objfile (symfile_objfile);
657 symfile_objfile = NULL;
660 /* Currently we keep symbols from the add-symbol-file command.
661 If the user wants to get rid of them, they should do "symbol-file"
662 without arguments first. Not sure this is the best behavior
665 (*objfile->sf->sym_new_init) (objfile);
668 /* Convert addr into an offset rather than an absolute address.
669 We find the lowest address of a loaded segment in the objfile,
670 and assume that <addr> is where that got loaded.
672 We no longer warn if the lowest section is not a text segment (as
673 happens for the PA64 port. */
676 /* Find lowest loadable section to be used as starting point for
677 continguous sections. FIXME!! won't work without call to find
678 .text first, but this assumes text is lowest section. */
679 lower_sect = bfd_get_section_by_name (objfile->obfd, ".text");
680 if (lower_sect == NULL)
681 bfd_map_over_sections (objfile->obfd, find_lowest_section,
683 if (lower_sect == NULL)
684 warning ("no loadable sections found in added symbol-file %s",
687 if ((bfd_get_section_flags (objfile->obfd, lower_sect) & SEC_CODE) == 0)
688 warning ("Lowest section in %s is %s at %s",
690 bfd_section_name (objfile->obfd, lower_sect),
691 paddr (bfd_section_vma (objfile->obfd, lower_sect)));
692 if (lower_sect != NULL)
693 lower_offset = bfd_section_vma (objfile->obfd, lower_sect);
697 /* Calculate offsets for the loadable sections.
698 FIXME! Sections must be in order of increasing loadable section
699 so that contiguous sections can use the lower-offset!!!
701 Adjust offsets if the segments are not contiguous.
702 If the section is contiguous, its offset should be set to
703 the offset of the highest loadable section lower than it
704 (the loadable section directly below it in memory).
705 this_offset = lower_offset = lower_addr - lower_orig_addr */
707 /* Calculate offsets for sections. */
709 for (i=0 ; i < MAX_SECTIONS && addrs->other[i].name; i++)
711 if (addrs->other[i].addr != 0)
713 sect = bfd_get_section_by_name (objfile->obfd,
714 addrs->other[i].name);
718 -= bfd_section_vma (objfile->obfd, sect);
719 lower_offset = addrs->other[i].addr;
720 /* This is the index used by BFD. */
721 addrs->other[i].sectindex = sect->index ;
725 warning ("section %s not found in %s",
726 addrs->other[i].name,
728 addrs->other[i].addr = 0;
732 addrs->other[i].addr = lower_offset;
736 /* Initialize symbol reading routines for this objfile, allow complaints to
737 appear for this new file, and record how verbose to be, then do the
738 initial symbol reading for this file. */
740 (*objfile->sf->sym_init) (objfile);
741 clear_complaints (&symfile_complaints, 1, verbo);
744 (*objfile->sf->sym_offsets) (objfile, addrs);
747 size_t size = SIZEOF_N_SECTION_OFFSETS (num_offsets);
749 /* Just copy in the offset table directly as given to us. */
750 objfile->num_sections = num_offsets;
751 objfile->section_offsets
752 = ((struct section_offsets *)
753 obstack_alloc (&objfile->psymbol_obstack, size));
754 memcpy (objfile->section_offsets, offsets, size);
756 init_objfile_sect_indices (objfile);
759 #ifndef IBM6000_TARGET
760 /* This is a SVR4/SunOS specific hack, I think. In any event, it
761 screws RS/6000. sym_offsets should be doing this sort of thing,
762 because it knows the mapping between bfd sections and
764 /* This is a hack. As far as I can tell, section offsets are not
765 target dependent. They are all set to addr with a couple of
766 exceptions. The exceptions are sysvr4 shared libraries, whose
767 offsets are kept in solib structures anyway and rs6000 xcoff
768 which handles shared libraries in a completely unique way.
770 Section offsets are built similarly, except that they are built
771 by adding addr in all cases because there is no clear mapping
772 from section_offsets into actual sections. Note that solib.c
773 has a different algorithm for finding section offsets.
775 These should probably all be collapsed into some target
776 independent form of shared library support. FIXME. */
780 struct obj_section *s;
782 /* Map section offsets in "addr" back to the object's
783 sections by comparing the section names with bfd's
784 section names. Then adjust the section address by
785 the offset. */ /* for gdb/13815 */
787 ALL_OBJFILE_OSECTIONS (objfile, s)
789 CORE_ADDR s_addr = 0;
793 !s_addr && i < MAX_SECTIONS && addrs->other[i].name;
795 if (strcmp (bfd_section_name (s->objfile->obfd,
797 addrs->other[i].name) == 0)
798 s_addr = addrs->other[i].addr; /* end added for gdb/13815 */
800 s->addr -= s->offset;
802 s->endaddr -= s->offset;
803 s->endaddr += s_addr;
807 #endif /* not IBM6000_TARGET */
809 (*objfile->sf->sym_read) (objfile, mainline);
811 /* Don't allow char * to have a typename (else would get caddr_t).
812 Ditto void *. FIXME: Check whether this is now done by all the
813 symbol readers themselves (many of them now do), and if so remove
816 TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
817 TYPE_NAME (lookup_pointer_type (builtin_type_void)) = 0;
819 /* Mark the objfile has having had initial symbol read attempted. Note
820 that this does not mean we found any symbols... */
822 objfile->flags |= OBJF_SYMS;
824 /* Discard cleanups as symbol reading was successful. */
826 discard_cleanups (old_chain);
828 /* Call this after reading in a new symbol table to give target
829 dependent code a crack at the new symbols. For instance, this
830 could be used to update the values of target-specific symbols GDB
831 needs to keep track of (such as _sigtramp, or whatever). */
833 TARGET_SYMFILE_POSTREAD (objfile);
836 /* Perform required actions after either reading in the initial
837 symbols for a new objfile, or mapping in the symbols from a reusable
841 new_symfile_objfile (struct objfile *objfile, int mainline, int verbo)
844 /* If this is the main symbol file we have to clean up all users of the
845 old main symbol file. Otherwise it is sufficient to fixup all the
846 breakpoints that may have been redefined by this symbol file. */
849 /* OK, make it the "real" symbol file. */
850 symfile_objfile = objfile;
852 clear_symtab_users ();
856 breakpoint_re_set ();
859 /* We're done reading the symbol file; finish off complaints. */
860 clear_complaints (&symfile_complaints, 0, verbo);
863 /* Process a symbol file, as either the main file or as a dynamically
866 NAME is the file name (which will be tilde-expanded and made
867 absolute herein) (but we don't free or modify NAME itself).
869 FROM_TTY says how verbose to be.
871 MAINLINE specifies whether this is the main symbol file, or whether
872 it's an extra symbol file such as dynamically loaded code.
874 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
875 syms_from_objfile, above. ADDRS is ignored when MAINLINE is
878 Upon success, returns a pointer to the objfile that was added.
879 Upon failure, jumps back to command level (never returns). */
880 static struct objfile *
881 symbol_file_add_with_addrs_or_offsets (char *name, int from_tty,
882 struct section_addr_info *addrs,
883 struct section_offsets *offsets,
885 int mainline, int flags)
887 struct objfile *objfile;
888 struct partial_symtab *psymtab;
891 struct section_addr_info orig_addrs;
896 /* Open a bfd for the file, and give user a chance to burp if we'd be
897 interactively wiping out any existing symbols. */
899 abfd = symfile_bfd_open (name);
901 if ((have_full_symbols () || have_partial_symbols ())
904 && !query ("Load new symbol table from \"%s\"? ", name))
905 error ("Not confirmed.");
907 objfile = allocate_objfile (abfd, flags);
909 /* If the objfile uses a mapped symbol file, and we have a psymtab for
910 it, then skip reading any symbols at this time. */
912 if ((objfile->flags & OBJF_MAPPED) && (objfile->flags & OBJF_SYMS))
914 /* We mapped in an existing symbol table file that already has had
915 initial symbol reading performed, so we can skip that part. Notify
916 the user that instead of reading the symbols, they have been mapped.
918 if (from_tty || info_verbose)
920 printf_filtered ("Mapped symbols for %s...", name);
922 gdb_flush (gdb_stdout);
924 init_entry_point_info (objfile);
925 find_sym_fns (objfile);
929 /* We either created a new mapped symbol table, mapped an existing
930 symbol table file which has not had initial symbol reading
931 performed, or need to read an unmapped symbol table. */
932 if (from_tty || info_verbose)
934 if (pre_add_symbol_hook)
935 pre_add_symbol_hook (name);
938 printf_filtered ("Reading symbols from %s...", name);
940 gdb_flush (gdb_stdout);
943 syms_from_objfile (objfile, addrs, offsets, num_offsets,
947 /* We now have at least a partial symbol table. Check to see if the
948 user requested that all symbols be read on initial access via either
949 the gdb startup command line or on a per symbol file basis. Expand
950 all partial symbol tables for this objfile if so. */
952 if ((flags & OBJF_READNOW) || readnow_symbol_files)
954 if (from_tty || info_verbose)
956 printf_filtered ("expanding to full symbols...");
958 gdb_flush (gdb_stdout);
961 for (psymtab = objfile->psymtabs;
963 psymtab = psymtab->next)
965 psymtab_to_symtab (psymtab);
969 debugfile = find_separate_debug_file (objfile);
974 objfile->separate_debug_objfile
975 = symbol_file_add (debugfile, from_tty, &orig_addrs, 0, flags);
979 objfile->separate_debug_objfile
980 = symbol_file_add (debugfile, from_tty, NULL, 0, flags);
982 objfile->separate_debug_objfile->separate_debug_objfile_backlink
985 /* Put the separate debug object before the normal one, this is so that
986 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
987 put_objfile_before (objfile->separate_debug_objfile, objfile);
992 if (!have_partial_symbols () && !have_full_symbols ())
995 printf_filtered ("(no debugging symbols found)...");
999 if (from_tty || info_verbose)
1001 if (post_add_symbol_hook)
1002 post_add_symbol_hook ();
1005 printf_filtered ("done.\n");
1009 /* We print some messages regardless of whether 'from_tty ||
1010 info_verbose' is true, so make sure they go out at the right
1012 gdb_flush (gdb_stdout);
1014 if (objfile->sf == NULL)
1015 return objfile; /* No symbols. */
1017 new_symfile_objfile (objfile, mainline, from_tty);
1019 if (target_new_objfile_hook)
1020 target_new_objfile_hook (objfile);
1026 /* Process a symbol file, as either the main file or as a dynamically
1027 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1030 symbol_file_add (char *name, int from_tty, struct section_addr_info *addrs,
1031 int mainline, int flags)
1033 return symbol_file_add_with_addrs_or_offsets (name, from_tty, addrs, 0, 0,
1038 /* Call symbol_file_add() with default values and update whatever is
1039 affected by the loading of a new main().
1040 Used when the file is supplied in the gdb command line
1041 and by some targets with special loading requirements.
1042 The auxiliary function, symbol_file_add_main_1(), has the flags
1043 argument for the switches that can only be specified in the symbol_file
1047 symbol_file_add_main (char *args, int from_tty)
1049 symbol_file_add_main_1 (args, from_tty, 0);
1053 symbol_file_add_main_1 (char *args, int from_tty, int flags)
1055 symbol_file_add (args, from_tty, NULL, 1, flags);
1058 RESET_HP_UX_GLOBALS ();
1061 /* Getting new symbols may change our opinion about
1062 what is frameless. */
1063 reinit_frame_cache ();
1065 set_initial_language ();
1069 symbol_file_clear (int from_tty)
1071 if ((have_full_symbols () || have_partial_symbols ())
1073 && !query ("Discard symbol table from `%s'? ",
1074 symfile_objfile->name))
1075 error ("Not confirmed.");
1076 free_all_objfiles ();
1078 /* solib descriptors may have handles to objfiles. Since their
1079 storage has just been released, we'd better wipe the solib
1080 descriptors as well.
1082 #if defined(SOLIB_RESTART)
1086 symfile_objfile = NULL;
1088 printf_unfiltered ("No symbol file now.\n");
1090 RESET_HP_UX_GLOBALS ();
1095 get_debug_link_info (struct objfile *objfile, unsigned long *crc32_out)
1098 bfd_size_type debuglink_size;
1099 unsigned long crc32;
1104 sect = bfd_get_section_by_name (objfile->obfd, ".gnu_debuglink");
1109 debuglink_size = bfd_section_size (objfile->obfd, sect);
1111 contents = xmalloc (debuglink_size);
1112 bfd_get_section_contents (objfile->obfd, sect, contents,
1113 (file_ptr)0, (bfd_size_type)debuglink_size);
1115 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1116 crc_offset = strlen (contents) + 1;
1117 crc_offset = (crc_offset + 3) & ~3;
1119 crc32 = bfd_get_32 (objfile->obfd, (bfd_byte *) (contents + crc_offset));
1126 separate_debug_file_exists (const char *name, unsigned long crc)
1128 unsigned long file_crc = 0;
1130 char buffer[8*1024];
1133 fd = open (name, O_RDONLY | O_BINARY);
1137 while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1138 file_crc = gnu_debuglink_crc32 (file_crc, buffer, count);
1142 return crc == file_crc;
1145 static char *debug_file_directory = NULL;
1147 #if ! defined (DEBUG_SUBDIRECTORY)
1148 #define DEBUG_SUBDIRECTORY ".debug"
1152 find_separate_debug_file (struct objfile *objfile)
1159 bfd_size_type debuglink_size;
1160 unsigned long crc32;
1163 basename = get_debug_link_info (objfile, &crc32);
1165 if (basename == NULL)
1168 dir = xstrdup (objfile->name);
1170 /* Strip off filename part */
1171 for (i = strlen(dir) - 1; i >= 0; i--)
1173 if (IS_DIR_SEPARATOR (dir[i]))
1178 debugfile = alloca (strlen (debug_file_directory) + 1
1180 + strlen (DEBUG_SUBDIRECTORY)
1185 /* First try in the same directory as the original file. */
1186 strcpy (debugfile, dir);
1187 strcat (debugfile, basename);
1189 if (separate_debug_file_exists (debugfile, crc32))
1193 return xstrdup (debugfile);
1196 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1197 strcpy (debugfile, dir);
1198 strcat (debugfile, DEBUG_SUBDIRECTORY);
1199 strcat (debugfile, "/");
1200 strcat (debugfile, basename);
1202 if (separate_debug_file_exists (debugfile, crc32))
1206 return xstrdup (debugfile);
1209 /* Then try in the global debugfile directory. */
1210 strcpy (debugfile, debug_file_directory);
1211 strcat (debugfile, "/");
1212 strcat (debugfile, dir);
1213 strcat (debugfile, "/");
1214 strcat (debugfile, basename);
1216 if (separate_debug_file_exists (debugfile, crc32))
1220 return xstrdup (debugfile);
1229 /* This is the symbol-file command. Read the file, analyze its
1230 symbols, and add a struct symtab to a symtab list. The syntax of
1231 the command is rather bizarre--(1) buildargv implements various
1232 quoting conventions which are undocumented and have little or
1233 nothing in common with the way things are quoted (or not quoted)
1234 elsewhere in GDB, (2) options are used, which are not generally
1235 used in GDB (perhaps "set mapped on", "set readnow on" would be
1236 better), (3) the order of options matters, which is contrary to GNU
1237 conventions (because it is confusing and inconvenient). */
1238 /* Note: ezannoni 2000-04-17. This function used to have support for
1239 rombug (see remote-os9k.c). It consisted of a call to target_link()
1240 (target.c) to get the address of the text segment from the target,
1241 and pass that to symbol_file_add(). This is no longer supported. */
1244 symbol_file_command (char *args, int from_tty)
1248 struct cleanup *cleanups;
1249 int flags = OBJF_USERLOADED;
1255 symbol_file_clear (from_tty);
1259 if ((argv = buildargv (args)) == NULL)
1263 cleanups = make_cleanup_freeargv (argv);
1264 while (*argv != NULL)
1266 if (STREQ (*argv, "-mapped"))
1267 flags |= OBJF_MAPPED;
1269 if (STREQ (*argv, "-readnow"))
1270 flags |= OBJF_READNOW;
1273 error ("unknown option `%s'", *argv);
1278 symbol_file_add_main_1 (name, from_tty, flags);
1285 error ("no symbol file name was specified");
1287 do_cleanups (cleanups);
1291 /* Set the initial language.
1293 A better solution would be to record the language in the psymtab when reading
1294 partial symbols, and then use it (if known) to set the language. This would
1295 be a win for formats that encode the language in an easily discoverable place,
1296 such as DWARF. For stabs, we can jump through hoops looking for specially
1297 named symbols or try to intuit the language from the specific type of stabs
1298 we find, but we can't do that until later when we read in full symbols.
1302 set_initial_language (void)
1304 struct partial_symtab *pst;
1305 enum language lang = language_unknown;
1307 pst = find_main_psymtab ();
1310 if (pst->filename != NULL)
1312 lang = deduce_language_from_filename (pst->filename);
1314 if (lang == language_unknown)
1316 /* Make C the default language */
1319 set_language (lang);
1320 expected_language = current_language; /* Don't warn the user */
1324 /* Open file specified by NAME and hand it off to BFD for preliminary
1325 analysis. Result is a newly initialized bfd *, which includes a newly
1326 malloc'd` copy of NAME (tilde-expanded and made absolute).
1327 In case of trouble, error() is called. */
1330 symfile_bfd_open (char *name)
1334 char *absolute_name;
1338 name = tilde_expand (name); /* Returns 1st new malloc'd copy */
1340 /* Look down path for it, allocate 2nd new malloc'd copy. */
1341 desc = openp (getenv ("PATH"), 1, name, O_RDONLY | O_BINARY, 0, &absolute_name);
1342 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1345 char *exename = alloca (strlen (name) + 5);
1346 strcat (strcpy (exename, name), ".exe");
1347 desc = openp (getenv ("PATH"), 1, exename, O_RDONLY | O_BINARY,
1353 make_cleanup (xfree, name);
1354 perror_with_name (name);
1356 xfree (name); /* Free 1st new malloc'd copy */
1357 name = absolute_name; /* Keep 2nd malloc'd copy in bfd */
1358 /* It'll be freed in free_objfile(). */
1360 sym_bfd = bfd_fdopenr (name, gnutarget, desc);
1364 make_cleanup (xfree, name);
1365 error ("\"%s\": can't open to read symbols: %s.", name,
1366 bfd_errmsg (bfd_get_error ()));
1368 sym_bfd->cacheable = 1;
1370 if (!bfd_check_format (sym_bfd, bfd_object))
1372 /* FIXME: should be checking for errors from bfd_close (for one thing,
1373 on error it does not free all the storage associated with the
1375 bfd_close (sym_bfd); /* This also closes desc */
1376 make_cleanup (xfree, name);
1377 error ("\"%s\": can't read symbols: %s.", name,
1378 bfd_errmsg (bfd_get_error ()));
1383 /* Return the section index for the given section name. Return -1 if
1384 the section was not found. */
1386 get_section_index (struct objfile *objfile, char *section_name)
1388 asection *sect = bfd_get_section_by_name (objfile->obfd, section_name);
1395 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
1396 startup by the _initialize routine in each object file format reader,
1397 to register information about each format the the reader is prepared
1401 add_symtab_fns (struct sym_fns *sf)
1403 sf->next = symtab_fns;
1408 /* Initialize to read symbols from the symbol file sym_bfd. It either
1409 returns or calls error(). The result is an initialized struct sym_fns
1410 in the objfile structure, that contains cached information about the
1414 find_sym_fns (struct objfile *objfile)
1417 enum bfd_flavour our_flavour = bfd_get_flavour (objfile->obfd);
1418 char *our_target = bfd_get_target (objfile->obfd);
1420 if (our_flavour == bfd_target_srec_flavour
1421 || our_flavour == bfd_target_ihex_flavour
1422 || our_flavour == bfd_target_tekhex_flavour)
1423 return; /* No symbols. */
1425 /* Special kludge for apollo. See dstread.c. */
1426 if (STREQN (our_target, "apollo", 6))
1427 our_flavour = (enum bfd_flavour) -2;
1429 for (sf = symtab_fns; sf != NULL; sf = sf->next)
1431 if (our_flavour == sf->sym_flavour)
1437 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
1438 bfd_get_target (objfile->obfd));
1441 /* This function runs the load command of our current target. */
1444 load_command (char *arg, int from_tty)
1447 arg = get_exec_file (1);
1448 target_load (arg, from_tty);
1450 /* After re-loading the executable, we don't really know which
1451 overlays are mapped any more. */
1452 overlay_cache_invalid = 1;
1455 /* This version of "load" should be usable for any target. Currently
1456 it is just used for remote targets, not inftarg.c or core files,
1457 on the theory that only in that case is it useful.
1459 Avoiding xmodem and the like seems like a win (a) because we don't have
1460 to worry about finding it, and (b) On VMS, fork() is very slow and so
1461 we don't want to run a subprocess. On the other hand, I'm not sure how
1462 performance compares. */
1464 static int download_write_size = 512;
1465 static int validate_download = 0;
1467 /* Callback service function for generic_load (bfd_map_over_sections). */
1470 add_section_size_callback (bfd *abfd, asection *asec, void *data)
1472 bfd_size_type *sum = data;
1474 *sum += bfd_get_section_size_before_reloc (asec);
1477 /* Opaque data for load_section_callback. */
1478 struct load_section_data {
1479 unsigned long load_offset;
1480 unsigned long write_count;
1481 unsigned long data_count;
1482 bfd_size_type total_size;
1485 /* Callback service function for generic_load (bfd_map_over_sections). */
1488 load_section_callback (bfd *abfd, asection *asec, void *data)
1490 struct load_section_data *args = data;
1492 if (bfd_get_section_flags (abfd, asec) & SEC_LOAD)
1494 bfd_size_type size = bfd_get_section_size_before_reloc (asec);
1498 struct cleanup *old_chain;
1499 CORE_ADDR lma = bfd_section_lma (abfd, asec) + args->load_offset;
1500 bfd_size_type block_size;
1502 const char *sect_name = bfd_get_section_name (abfd, asec);
1505 if (download_write_size > 0 && size > download_write_size)
1506 block_size = download_write_size;
1510 buffer = xmalloc (size);
1511 old_chain = make_cleanup (xfree, buffer);
1513 /* Is this really necessary? I guess it gives the user something
1514 to look at during a long download. */
1515 ui_out_message (uiout, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1516 sect_name, paddr_nz (size), paddr_nz (lma));
1518 bfd_get_section_contents (abfd, asec, buffer, 0, size);
1524 bfd_size_type this_transfer = size - sent;
1526 if (this_transfer >= block_size)
1527 this_transfer = block_size;
1528 len = target_write_memory_partial (lma, buffer,
1529 this_transfer, &err);
1532 if (validate_download)
1534 /* Broken memories and broken monitors manifest
1535 themselves here when bring new computers to
1536 life. This doubles already slow downloads. */
1537 /* NOTE: cagney/1999-10-18: A more efficient
1538 implementation might add a verify_memory()
1539 method to the target vector and then use
1540 that. remote.c could implement that method
1541 using the ``qCRC'' packet. */
1542 char *check = xmalloc (len);
1543 struct cleanup *verify_cleanups =
1544 make_cleanup (xfree, check);
1546 if (target_read_memory (lma, check, len) != 0)
1547 error ("Download verify read failed at 0x%s",
1549 if (memcmp (buffer, check, len) != 0)
1550 error ("Download verify compare failed at 0x%s",
1552 do_cleanups (verify_cleanups);
1554 args->data_count += len;
1557 args->write_count += 1;
1560 || (ui_load_progress_hook != NULL
1561 && ui_load_progress_hook (sect_name, sent)))
1562 error ("Canceled the download");
1564 if (show_load_progress != NULL)
1565 show_load_progress (sect_name, sent, size,
1566 args->data_count, args->total_size);
1568 while (sent < size);
1571 error ("Memory access error while loading section %s.", sect_name);
1573 do_cleanups (old_chain);
1579 generic_load (char *args, int from_tty)
1583 time_t start_time, end_time; /* Start and end times of download */
1585 struct cleanup *old_cleanups;
1587 struct load_section_data cbdata;
1590 cbdata.load_offset = 0; /* Offset to add to vma for each section. */
1591 cbdata.write_count = 0; /* Number of writes needed. */
1592 cbdata.data_count = 0; /* Number of bytes written to target memory. */
1593 cbdata.total_size = 0; /* Total size of all bfd sectors. */
1595 /* Parse the input argument - the user can specify a load offset as
1596 a second argument. */
1597 filename = xmalloc (strlen (args) + 1);
1598 old_cleanups = make_cleanup (xfree, filename);
1599 strcpy (filename, args);
1600 offptr = strchr (filename, ' ');
1605 cbdata.load_offset = strtoul (offptr, &endptr, 0);
1606 if (offptr == endptr)
1607 error ("Invalid download offset:%s\n", offptr);
1611 cbdata.load_offset = 0;
1613 /* Open the file for loading. */
1614 loadfile_bfd = bfd_openr (filename, gnutarget);
1615 if (loadfile_bfd == NULL)
1617 perror_with_name (filename);
1621 /* FIXME: should be checking for errors from bfd_close (for one thing,
1622 on error it does not free all the storage associated with the
1624 make_cleanup_bfd_close (loadfile_bfd);
1626 if (!bfd_check_format (loadfile_bfd, bfd_object))
1628 error ("\"%s\" is not an object file: %s", filename,
1629 bfd_errmsg (bfd_get_error ()));
1632 bfd_map_over_sections (loadfile_bfd, add_section_size_callback,
1633 (void *) &cbdata.total_size);
1635 start_time = time (NULL);
1637 bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata);
1639 end_time = time (NULL);
1641 entry = bfd_get_start_address (loadfile_bfd);
1642 ui_out_text (uiout, "Start address ");
1643 ui_out_field_fmt (uiout, "address", "0x%s", paddr_nz (entry));
1644 ui_out_text (uiout, ", load size ");
1645 ui_out_field_fmt (uiout, "load-size", "%lu", cbdata.data_count);
1646 ui_out_text (uiout, "\n");
1647 /* We were doing this in remote-mips.c, I suspect it is right
1648 for other targets too. */
1651 /* FIXME: are we supposed to call symbol_file_add or not? According to
1652 a comment from remote-mips.c (where a call to symbol_file_add was
1653 commented out), making the call confuses GDB if more than one file is
1654 loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
1657 print_transfer_performance (gdb_stdout, cbdata.data_count,
1658 cbdata.write_count, end_time - start_time);
1660 do_cleanups (old_cleanups);
1663 /* Report how fast the transfer went. */
1665 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1666 replaced by print_transfer_performance (with a very different
1667 function signature). */
1670 report_transfer_performance (unsigned long data_count, time_t start_time,
1673 print_transfer_performance (gdb_stdout, data_count,
1674 end_time - start_time, 0);
1678 print_transfer_performance (struct ui_file *stream,
1679 unsigned long data_count,
1680 unsigned long write_count,
1681 unsigned long time_count)
1683 ui_out_text (uiout, "Transfer rate: ");
1686 ui_out_field_fmt (uiout, "transfer-rate", "%lu",
1687 (data_count * 8) / time_count);
1688 ui_out_text (uiout, " bits/sec");
1692 ui_out_field_fmt (uiout, "transferred-bits", "%lu", (data_count * 8));
1693 ui_out_text (uiout, " bits in <1 sec");
1695 if (write_count > 0)
1697 ui_out_text (uiout, ", ");
1698 ui_out_field_fmt (uiout, "write-rate", "%lu", data_count / write_count);
1699 ui_out_text (uiout, " bytes/write");
1701 ui_out_text (uiout, ".\n");
1704 /* This function allows the addition of incrementally linked object files.
1705 It does not modify any state in the target, only in the debugger. */
1706 /* Note: ezannoni 2000-04-13 This function/command used to have a
1707 special case syntax for the rombug target (Rombug is the boot
1708 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1709 rombug case, the user doesn't need to supply a text address,
1710 instead a call to target_link() (in target.c) would supply the
1711 value to use. We are now discontinuing this type of ad hoc syntax. */
1715 add_symbol_file_command (char *args, int from_tty)
1717 char *filename = NULL;
1718 int flags = OBJF_USERLOADED;
1720 int expecting_option = 0;
1721 int section_index = 0;
1725 int expecting_sec_name = 0;
1726 int expecting_sec_addr = 0;
1732 } sect_opts[SECT_OFF_MAX];
1734 struct section_addr_info section_addrs;
1735 struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL);
1740 error ("add-symbol-file takes a file name and an address");
1742 /* Make a copy of the string that we can safely write into. */
1743 args = xstrdup (args);
1745 /* Ensure section_addrs is initialized */
1746 memset (§ion_addrs, 0, sizeof (section_addrs));
1748 while (*args != '\000')
1750 /* Any leading spaces? */
1751 while (isspace (*args))
1754 /* Point arg to the beginning of the argument. */
1757 /* Move args pointer over the argument. */
1758 while ((*args != '\000') && !isspace (*args))
1761 /* If there are more arguments, terminate arg and
1763 if (*args != '\000')
1766 /* Now process the argument. */
1769 /* The first argument is the file name. */
1770 filename = tilde_expand (arg);
1771 make_cleanup (xfree, filename);
1776 /* The second argument is always the text address at which
1777 to load the program. */
1778 sect_opts[section_index].name = ".text";
1779 sect_opts[section_index].value = arg;
1784 /* It's an option (starting with '-') or it's an argument
1789 if (strcmp (arg, "-mapped") == 0)
1790 flags |= OBJF_MAPPED;
1792 if (strcmp (arg, "-readnow") == 0)
1793 flags |= OBJF_READNOW;
1795 if (strcmp (arg, "-s") == 0)
1797 if (section_index >= SECT_OFF_MAX)
1798 error ("Too many sections specified.");
1799 expecting_sec_name = 1;
1800 expecting_sec_addr = 1;
1805 if (expecting_sec_name)
1807 sect_opts[section_index].name = arg;
1808 expecting_sec_name = 0;
1811 if (expecting_sec_addr)
1813 sect_opts[section_index].value = arg;
1814 expecting_sec_addr = 0;
1818 error ("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*");
1824 /* Print the prompt for the query below. And save the arguments into
1825 a sect_addr_info structure to be passed around to other
1826 functions. We have to split this up into separate print
1827 statements because local_hex_string returns a local static
1830 printf_filtered ("add symbol table from file \"%s\" at\n", filename);
1831 for (i = 0; i < section_index; i++)
1834 char *val = sect_opts[i].value;
1835 char *sec = sect_opts[i].name;
1837 val = sect_opts[i].value;
1838 if (val[0] == '0' && val[1] == 'x')
1839 addr = strtoul (val+2, NULL, 16);
1841 addr = strtoul (val, NULL, 10);
1843 /* Here we store the section offsets in the order they were
1844 entered on the command line. */
1845 section_addrs.other[sec_num].name = sec;
1846 section_addrs.other[sec_num].addr = addr;
1847 printf_filtered ("\t%s_addr = %s\n",
1849 local_hex_string ((unsigned long)addr));
1852 /* The object's sections are initialized when a
1853 call is made to build_objfile_section_table (objfile).
1854 This happens in reread_symbols.
1855 At this point, we don't know what file type this is,
1856 so we can't determine what section names are valid. */
1859 if (from_tty && (!query ("%s", "")))
1860 error ("Not confirmed.");
1862 symbol_file_add (filename, from_tty, §ion_addrs, 0, flags);
1864 /* Getting new symbols may change our opinion about what is
1866 reinit_frame_cache ();
1867 do_cleanups (my_cleanups);
1871 add_shared_symbol_files_command (char *args, int from_tty)
1873 #ifdef ADD_SHARED_SYMBOL_FILES
1874 ADD_SHARED_SYMBOL_FILES (args, from_tty);
1876 error ("This command is not available in this configuration of GDB.");
1880 /* Re-read symbols if a symbol-file has changed. */
1882 reread_symbols (void)
1884 struct objfile *objfile;
1887 struct stat new_statbuf;
1890 /* With the addition of shared libraries, this should be modified,
1891 the load time should be saved in the partial symbol tables, since
1892 different tables may come from different source files. FIXME.
1893 This routine should then walk down each partial symbol table
1894 and see if the symbol table that it originates from has been changed */
1896 for (objfile = object_files; objfile; objfile = objfile->next)
1900 #ifdef IBM6000_TARGET
1901 /* If this object is from a shared library, then you should
1902 stat on the library name, not member name. */
1904 if (objfile->obfd->my_archive)
1905 res = stat (objfile->obfd->my_archive->filename, &new_statbuf);
1908 res = stat (objfile->name, &new_statbuf);
1911 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1912 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1916 new_modtime = new_statbuf.st_mtime;
1917 if (new_modtime != objfile->mtime)
1919 struct cleanup *old_cleanups;
1920 struct section_offsets *offsets;
1922 char *obfd_filename;
1924 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1927 /* There are various functions like symbol_file_add,
1928 symfile_bfd_open, syms_from_objfile, etc., which might
1929 appear to do what we want. But they have various other
1930 effects which we *don't* want. So we just do stuff
1931 ourselves. We don't worry about mapped files (for one thing,
1932 any mapped file will be out of date). */
1934 /* If we get an error, blow away this objfile (not sure if
1935 that is the correct response for things like shared
1937 old_cleanups = make_cleanup_free_objfile (objfile);
1938 /* We need to do this whenever any symbols go away. */
1939 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
1941 /* Clean up any state BFD has sitting around. We don't need
1942 to close the descriptor but BFD lacks a way of closing the
1943 BFD without closing the descriptor. */
1944 obfd_filename = bfd_get_filename (objfile->obfd);
1945 if (!bfd_close (objfile->obfd))
1946 error ("Can't close BFD for %s: %s", objfile->name,
1947 bfd_errmsg (bfd_get_error ()));
1948 objfile->obfd = bfd_openr (obfd_filename, gnutarget);
1949 if (objfile->obfd == NULL)
1950 error ("Can't open %s to read symbols.", objfile->name);
1951 /* bfd_openr sets cacheable to true, which is what we want. */
1952 if (!bfd_check_format (objfile->obfd, bfd_object))
1953 error ("Can't read symbols from %s: %s.", objfile->name,
1954 bfd_errmsg (bfd_get_error ()));
1956 /* Save the offsets, we will nuke them with the rest of the
1958 num_offsets = objfile->num_sections;
1959 offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
1960 memcpy (offsets, objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
1962 /* Nuke all the state that we will re-read. Much of the following
1963 code which sets things to NULL really is necessary to tell
1964 other parts of GDB that there is nothing currently there. */
1966 /* FIXME: Do we have to free a whole linked list, or is this
1968 if (objfile->global_psymbols.list)
1969 xmfree (objfile->md, objfile->global_psymbols.list);
1970 memset (&objfile->global_psymbols, 0,
1971 sizeof (objfile->global_psymbols));
1972 if (objfile->static_psymbols.list)
1973 xmfree (objfile->md, objfile->static_psymbols.list);
1974 memset (&objfile->static_psymbols, 0,
1975 sizeof (objfile->static_psymbols));
1977 /* Free the obstacks for non-reusable objfiles */
1978 bcache_xfree (objfile->psymbol_cache);
1979 objfile->psymbol_cache = bcache_xmalloc ();
1980 bcache_xfree (objfile->macro_cache);
1981 objfile->macro_cache = bcache_xmalloc ();
1982 obstack_free (&objfile->psymbol_obstack, 0);
1983 obstack_free (&objfile->symbol_obstack, 0);
1984 obstack_free (&objfile->type_obstack, 0);
1985 objfile->sections = NULL;
1986 objfile->symtabs = NULL;
1987 objfile->psymtabs = NULL;
1988 objfile->free_psymtabs = NULL;
1989 objfile->msymbols = NULL;
1990 objfile->minimal_symbol_count = 0;
1991 memset (&objfile->msymbol_hash, 0,
1992 sizeof (objfile->msymbol_hash));
1993 memset (&objfile->msymbol_demangled_hash, 0,
1994 sizeof (objfile->msymbol_demangled_hash));
1995 objfile->fundamental_types = NULL;
1996 if (objfile->sf != NULL)
1998 (*objfile->sf->sym_finish) (objfile);
2001 /* We never make this a mapped file. */
2003 /* obstack_specify_allocation also initializes the obstack so
2005 objfile->psymbol_cache = bcache_xmalloc ();
2006 objfile->macro_cache = bcache_xmalloc ();
2007 obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0,
2009 obstack_specify_allocation (&objfile->symbol_obstack, 0, 0,
2011 obstack_specify_allocation (&objfile->type_obstack, 0, 0,
2013 if (build_objfile_section_table (objfile))
2015 error ("Can't find the file sections in `%s': %s",
2016 objfile->name, bfd_errmsg (bfd_get_error ()));
2019 /* We use the same section offsets as from last time. I'm not
2020 sure whether that is always correct for shared libraries. */
2021 objfile->section_offsets = (struct section_offsets *)
2022 obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
2023 memcpy (objfile->section_offsets, offsets, SIZEOF_SECTION_OFFSETS);
2024 objfile->num_sections = num_offsets;
2026 /* What the hell is sym_new_init for, anyway? The concept of
2027 distinguishing between the main file and additional files
2028 in this way seems rather dubious. */
2029 if (objfile == symfile_objfile)
2031 (*objfile->sf->sym_new_init) (objfile);
2033 RESET_HP_UX_GLOBALS ();
2037 (*objfile->sf->sym_init) (objfile);
2038 clear_complaints (&symfile_complaints, 1, 1);
2039 /* The "mainline" parameter is a hideous hack; I think leaving it
2040 zero is OK since dbxread.c also does what it needs to do if
2041 objfile->global_psymbols.size is 0. */
2042 (*objfile->sf->sym_read) (objfile, 0);
2043 if (!have_partial_symbols () && !have_full_symbols ())
2046 printf_filtered ("(no debugging symbols found)\n");
2049 objfile->flags |= OBJF_SYMS;
2051 /* We're done reading the symbol file; finish off complaints. */
2052 clear_complaints (&symfile_complaints, 0, 1);
2054 /* Getting new symbols may change our opinion about what is
2057 reinit_frame_cache ();
2059 /* Discard cleanups as symbol reading was successful. */
2060 discard_cleanups (old_cleanups);
2062 /* If the mtime has changed between the time we set new_modtime
2063 and now, we *want* this to be out of date, so don't call stat
2065 objfile->mtime = new_modtime;
2068 /* Call this after reading in a new symbol table to give target
2069 dependent code a crack at the new symbols. For instance, this
2070 could be used to update the values of target-specific symbols GDB
2071 needs to keep track of (such as _sigtramp, or whatever). */
2073 TARGET_SYMFILE_POSTREAD (objfile);
2075 reread_separate_symbols (objfile);
2081 clear_symtab_users ();
2085 /* Handle separate debug info for OBJFILE, which has just been
2087 - If we had separate debug info before, but now we don't, get rid
2088 of the separated objfile.
2089 - If we didn't have separated debug info before, but now we do,
2090 read in the new separated debug info file.
2091 - If the debug link points to a different file, toss the old one
2092 and read the new one.
2093 This function does *not* handle the case where objfile is still
2094 using the same separate debug info file, but that file's timestamp
2095 has changed. That case should be handled by the loop in
2096 reread_symbols already. */
2098 reread_separate_symbols (struct objfile *objfile)
2101 unsigned long crc32;
2103 /* Does the updated objfile's debug info live in a
2105 debug_file = find_separate_debug_file (objfile);
2107 if (objfile->separate_debug_objfile)
2109 /* There are two cases where we need to get rid of
2110 the old separated debug info objfile:
2111 - if the new primary objfile doesn't have
2112 separated debug info, or
2113 - if the new primary objfile has separate debug
2114 info, but it's under a different filename.
2116 If the old and new objfiles both have separate
2117 debug info, under the same filename, then we're
2118 okay --- if the separated file's contents have
2119 changed, we will have caught that when we
2120 visited it in this function's outermost
2123 || strcmp (debug_file, objfile->separate_debug_objfile->name) != 0)
2124 free_objfile (objfile->separate_debug_objfile);
2127 /* If the new objfile has separate debug info, and we
2128 haven't loaded it already, do so now. */
2130 && ! objfile->separate_debug_objfile)
2132 /* Use the same section offset table as objfile itself.
2133 Preserve the flags from objfile that make sense. */
2134 objfile->separate_debug_objfile
2135 = (symbol_file_add_with_addrs_or_offsets
2137 info_verbose, /* from_tty: Don't override the default. */
2138 0, /* No addr table. */
2139 objfile->section_offsets, objfile->num_sections,
2140 0, /* Not mainline. See comments about this above. */
2141 objfile->flags & (OBJF_MAPPED | OBJF_REORDERED
2142 | OBJF_SHARED | OBJF_READNOW
2143 | OBJF_USERLOADED)));
2144 objfile->separate_debug_objfile->separate_debug_objfile_backlink
2160 static filename_language *filename_language_table;
2161 static int fl_table_size, fl_table_next;
2164 add_filename_language (char *ext, enum language lang)
2166 if (fl_table_next >= fl_table_size)
2168 fl_table_size += 10;
2169 filename_language_table =
2170 xrealloc (filename_language_table,
2171 fl_table_size * sizeof (*filename_language_table));
2174 filename_language_table[fl_table_next].ext = xstrdup (ext);
2175 filename_language_table[fl_table_next].lang = lang;
2179 static char *ext_args;
2182 set_ext_lang_command (char *args, int from_tty)
2185 char *cp = ext_args;
2188 /* First arg is filename extension, starting with '.' */
2190 error ("'%s': Filename extension must begin with '.'", ext_args);
2192 /* Find end of first arg. */
2193 while (*cp && !isspace (*cp))
2197 error ("'%s': two arguments required -- filename extension and language",
2200 /* Null-terminate first arg */
2203 /* Find beginning of second arg, which should be a source language. */
2204 while (*cp && isspace (*cp))
2208 error ("'%s': two arguments required -- filename extension and language",
2211 /* Lookup the language from among those we know. */
2212 lang = language_enum (cp);
2214 /* Now lookup the filename extension: do we already know it? */
2215 for (i = 0; i < fl_table_next; i++)
2216 if (0 == strcmp (ext_args, filename_language_table[i].ext))
2219 if (i >= fl_table_next)
2221 /* new file extension */
2222 add_filename_language (ext_args, lang);
2226 /* redefining a previously known filename extension */
2229 /* query ("Really make files of type %s '%s'?", */
2230 /* ext_args, language_str (lang)); */
2232 xfree (filename_language_table[i].ext);
2233 filename_language_table[i].ext = xstrdup (ext_args);
2234 filename_language_table[i].lang = lang;
2239 info_ext_lang_command (char *args, int from_tty)
2243 printf_filtered ("Filename extensions and the languages they represent:");
2244 printf_filtered ("\n\n");
2245 for (i = 0; i < fl_table_next; i++)
2246 printf_filtered ("\t%s\t- %s\n",
2247 filename_language_table[i].ext,
2248 language_str (filename_language_table[i].lang));
2252 init_filename_language_table (void)
2254 if (fl_table_size == 0) /* protect against repetition */
2258 filename_language_table =
2259 xmalloc (fl_table_size * sizeof (*filename_language_table));
2260 add_filename_language (".c", language_c);
2261 add_filename_language (".C", language_cplus);
2262 add_filename_language (".cc", language_cplus);
2263 add_filename_language (".cp", language_cplus);
2264 add_filename_language (".cpp", language_cplus);
2265 add_filename_language (".cxx", language_cplus);
2266 add_filename_language (".c++", language_cplus);
2267 add_filename_language (".java", language_java);
2268 add_filename_language (".class", language_java);
2269 add_filename_language (".m", language_objc);
2270 add_filename_language (".f", language_fortran);
2271 add_filename_language (".F", language_fortran);
2272 add_filename_language (".s", language_asm);
2273 add_filename_language (".S", language_asm);
2274 add_filename_language (".pas", language_pascal);
2275 add_filename_language (".p", language_pascal);
2276 add_filename_language (".pp", language_pascal);
2281 deduce_language_from_filename (char *filename)
2286 if (filename != NULL)
2287 if ((cp = strrchr (filename, '.')) != NULL)
2288 for (i = 0; i < fl_table_next; i++)
2289 if (strcmp (cp, filename_language_table[i].ext) == 0)
2290 return filename_language_table[i].lang;
2292 return language_unknown;
2297 Allocate and partly initialize a new symbol table. Return a pointer
2298 to it. error() if no space.
2300 Caller must set these fields:
2306 possibly free_named_symtabs (symtab->filename);
2310 allocate_symtab (char *filename, struct objfile *objfile)
2312 register struct symtab *symtab;
2314 symtab = (struct symtab *)
2315 obstack_alloc (&objfile->symbol_obstack, sizeof (struct symtab));
2316 memset (symtab, 0, sizeof (*symtab));
2317 symtab->filename = obsavestring (filename, strlen (filename),
2318 &objfile->symbol_obstack);
2319 symtab->fullname = NULL;
2320 symtab->language = deduce_language_from_filename (filename);
2321 symtab->debugformat = obsavestring ("unknown", 7,
2322 &objfile->symbol_obstack);
2324 /* Hook it to the objfile it comes from */
2326 symtab->objfile = objfile;
2327 symtab->next = objfile->symtabs;
2328 objfile->symtabs = symtab;
2330 /* FIXME: This should go away. It is only defined for the Z8000,
2331 and the Z8000 definition of this macro doesn't have anything to
2332 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
2333 here for convenience. */
2334 #ifdef INIT_EXTRA_SYMTAB_INFO
2335 INIT_EXTRA_SYMTAB_INFO (symtab);
2341 struct partial_symtab *
2342 allocate_psymtab (char *filename, struct objfile *objfile)
2344 struct partial_symtab *psymtab;
2346 if (objfile->free_psymtabs)
2348 psymtab = objfile->free_psymtabs;
2349 objfile->free_psymtabs = psymtab->next;
2352 psymtab = (struct partial_symtab *)
2353 obstack_alloc (&objfile->psymbol_obstack,
2354 sizeof (struct partial_symtab));
2356 memset (psymtab, 0, sizeof (struct partial_symtab));
2357 psymtab->filename = obsavestring (filename, strlen (filename),
2358 &objfile->psymbol_obstack);
2359 psymtab->symtab = NULL;
2361 /* Prepend it to the psymtab list for the objfile it belongs to.
2362 Psymtabs are searched in most recent inserted -> least recent
2365 psymtab->objfile = objfile;
2366 psymtab->next = objfile->psymtabs;
2367 objfile->psymtabs = psymtab;
2370 struct partial_symtab **prev_pst;
2371 psymtab->objfile = objfile;
2372 psymtab->next = NULL;
2373 prev_pst = &(objfile->psymtabs);
2374 while ((*prev_pst) != NULL)
2375 prev_pst = &((*prev_pst)->next);
2376 (*prev_pst) = psymtab;
2384 discard_psymtab (struct partial_symtab *pst)
2386 struct partial_symtab **prev_pst;
2389 Empty psymtabs happen as a result of header files which don't
2390 have any symbols in them. There can be a lot of them. But this
2391 check is wrong, in that a psymtab with N_SLINE entries but
2392 nothing else is not empty, but we don't realize that. Fixing
2393 that without slowing things down might be tricky. */
2395 /* First, snip it out of the psymtab chain */
2397 prev_pst = &(pst->objfile->psymtabs);
2398 while ((*prev_pst) != pst)
2399 prev_pst = &((*prev_pst)->next);
2400 (*prev_pst) = pst->next;
2402 /* Next, put it on a free list for recycling */
2404 pst->next = pst->objfile->free_psymtabs;
2405 pst->objfile->free_psymtabs = pst;
2409 /* Reset all data structures in gdb which may contain references to symbol
2413 clear_symtab_users (void)
2415 /* Someday, we should do better than this, by only blowing away
2416 the things that really need to be blown. */
2417 clear_value_history ();
2419 clear_internalvars ();
2420 breakpoint_re_set ();
2421 set_default_breakpoint (0, 0, 0, 0);
2422 clear_current_source_symtab_and_line ();
2423 clear_pc_function_cache ();
2424 if (target_new_objfile_hook)
2425 target_new_objfile_hook (NULL);
2429 clear_symtab_users_cleanup (void *ignore)
2431 clear_symtab_users ();
2434 /* clear_symtab_users_once:
2436 This function is run after symbol reading, or from a cleanup.
2437 If an old symbol table was obsoleted, the old symbol table
2438 has been blown away, but the other GDB data structures that may
2439 reference it have not yet been cleared or re-directed. (The old
2440 symtab was zapped, and the cleanup queued, in free_named_symtab()
2443 This function can be queued N times as a cleanup, or called
2444 directly; it will do all the work the first time, and then will be a
2445 no-op until the next time it is queued. This works by bumping a
2446 counter at queueing time. Much later when the cleanup is run, or at
2447 the end of symbol processing (in case the cleanup is discarded), if
2448 the queued count is greater than the "done-count", we do the work
2449 and set the done-count to the queued count. If the queued count is
2450 less than or equal to the done-count, we just ignore the call. This
2451 is needed because reading a single .o file will often replace many
2452 symtabs (one per .h file, for example), and we don't want to reset
2453 the breakpoints N times in the user's face.
2455 The reason we both queue a cleanup, and call it directly after symbol
2456 reading, is because the cleanup protects us in case of errors, but is
2457 discarded if symbol reading is successful. */
2460 /* FIXME: As free_named_symtabs is currently a big noop this function
2461 is no longer needed. */
2462 static void clear_symtab_users_once (void);
2464 static int clear_symtab_users_queued;
2465 static int clear_symtab_users_done;
2468 clear_symtab_users_once (void)
2470 /* Enforce once-per-`do_cleanups'-semantics */
2471 if (clear_symtab_users_queued <= clear_symtab_users_done)
2473 clear_symtab_users_done = clear_symtab_users_queued;
2475 clear_symtab_users ();
2479 /* Delete the specified psymtab, and any others that reference it. */
2482 cashier_psymtab (struct partial_symtab *pst)
2484 struct partial_symtab *ps, *pprev = NULL;
2487 /* Find its previous psymtab in the chain */
2488 for (ps = pst->objfile->psymtabs; ps; ps = ps->next)
2497 /* Unhook it from the chain. */
2498 if (ps == pst->objfile->psymtabs)
2499 pst->objfile->psymtabs = ps->next;
2501 pprev->next = ps->next;
2503 /* FIXME, we can't conveniently deallocate the entries in the
2504 partial_symbol lists (global_psymbols/static_psymbols) that
2505 this psymtab points to. These just take up space until all
2506 the psymtabs are reclaimed. Ditto the dependencies list and
2507 filename, which are all in the psymbol_obstack. */
2509 /* We need to cashier any psymtab that has this one as a dependency... */
2511 for (ps = pst->objfile->psymtabs; ps; ps = ps->next)
2513 for (i = 0; i < ps->number_of_dependencies; i++)
2515 if (ps->dependencies[i] == pst)
2517 cashier_psymtab (ps);
2518 goto again; /* Must restart, chain has been munged. */
2525 /* If a symtab or psymtab for filename NAME is found, free it along
2526 with any dependent breakpoints, displays, etc.
2527 Used when loading new versions of object modules with the "add-file"
2528 command. This is only called on the top-level symtab or psymtab's name;
2529 it is not called for subsidiary files such as .h files.
2531 Return value is 1 if we blew away the environment, 0 if not.
2532 FIXME. The return value appears to never be used.
2534 FIXME. I think this is not the best way to do this. We should
2535 work on being gentler to the environment while still cleaning up
2536 all stray pointers into the freed symtab. */
2539 free_named_symtabs (char *name)
2542 /* FIXME: With the new method of each objfile having it's own
2543 psymtab list, this function needs serious rethinking. In particular,
2544 why was it ever necessary to toss psymtabs with specific compilation
2545 unit filenames, as opposed to all psymtabs from a particular symbol
2547 Well, the answer is that some systems permit reloading of particular
2548 compilation units. We want to blow away any old info about these
2549 compilation units, regardless of which objfiles they arrived in. --gnu. */
2551 register struct symtab *s;
2552 register struct symtab *prev;
2553 register struct partial_symtab *ps;
2554 struct blockvector *bv;
2557 /* We only wack things if the symbol-reload switch is set. */
2558 if (!symbol_reloading)
2561 /* Some symbol formats have trouble providing file names... */
2562 if (name == 0 || *name == '\0')
2565 /* Look for a psymtab with the specified name. */
2568 for (ps = partial_symtab_list; ps; ps = ps->next)
2570 if (STREQ (name, ps->filename))
2572 cashier_psymtab (ps); /* Blow it away...and its little dog, too. */
2573 goto again2; /* Must restart, chain has been munged */
2577 /* Look for a symtab with the specified name. */
2579 for (s = symtab_list; s; s = s->next)
2581 if (STREQ (name, s->filename))
2588 if (s == symtab_list)
2589 symtab_list = s->next;
2591 prev->next = s->next;
2593 /* For now, queue a delete for all breakpoints, displays, etc., whether
2594 or not they depend on the symtab being freed. This should be
2595 changed so that only those data structures affected are deleted. */
2597 /* But don't delete anything if the symtab is empty.
2598 This test is necessary due to a bug in "dbxread.c" that
2599 causes empty symtabs to be created for N_SO symbols that
2600 contain the pathname of the object file. (This problem
2601 has been fixed in GDB 3.9x). */
2603 bv = BLOCKVECTOR (s);
2604 if (BLOCKVECTOR_NBLOCKS (bv) > 2
2605 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
2606 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)))
2608 complaint (&symfile_complaints, "Replacing old symbols for `%s'",
2610 clear_symtab_users_queued++;
2611 make_cleanup (clear_symtab_users_once, 0);
2616 complaint (&symfile_complaints, "Empty symbol table found for `%s'",
2624 /* It is still possible that some breakpoints will be affected
2625 even though no symtab was found, since the file might have
2626 been compiled without debugging, and hence not be associated
2627 with a symtab. In order to handle this correctly, we would need
2628 to keep a list of text address ranges for undebuggable files.
2629 For now, we do nothing, since this is a fairly obscure case. */
2633 /* FIXME, what about the minimal symbol table? */
2640 /* Allocate and partially fill a partial symtab. It will be
2641 completely filled at the end of the symbol list.
2643 FILENAME is the name of the symbol-file we are reading from. */
2645 struct partial_symtab *
2646 start_psymtab_common (struct objfile *objfile,
2647 struct section_offsets *section_offsets, char *filename,
2648 CORE_ADDR textlow, struct partial_symbol **global_syms,
2649 struct partial_symbol **static_syms)
2651 struct partial_symtab *psymtab;
2653 psymtab = allocate_psymtab (filename, objfile);
2654 psymtab->section_offsets = section_offsets;
2655 psymtab->textlow = textlow;
2656 psymtab->texthigh = psymtab->textlow; /* default */
2657 psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
2658 psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
2662 /* Add a symbol with a long value to a psymtab.
2663 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
2666 add_psymbol_to_list (char *name, int namelength, namespace_enum namespace,
2667 enum address_class class,
2668 struct psymbol_allocation_list *list, long val, /* Value as a long */
2669 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
2670 enum language language, struct objfile *objfile)
2672 register struct partial_symbol *psym;
2673 char *buf = alloca (namelength + 1);
2674 /* psymbol is static so that there will be no uninitialized gaps in the
2675 structure which might contain random data, causing cache misses in
2677 static struct partial_symbol psymbol;
2679 /* Create local copy of the partial symbol */
2680 memcpy (buf, name, namelength);
2681 buf[namelength] = '\0';
2682 SYMBOL_NAME (&psymbol) = bcache (buf, namelength + 1, objfile->psymbol_cache);
2683 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2686 SYMBOL_VALUE (&psymbol) = val;
2690 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
2692 SYMBOL_SECTION (&psymbol) = 0;
2693 SYMBOL_LANGUAGE (&psymbol) = language;
2694 PSYMBOL_NAMESPACE (&psymbol) = namespace;
2695 PSYMBOL_CLASS (&psymbol) = class;
2696 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol, language);
2698 /* Stash the partial symbol away in the cache */
2699 psym = bcache (&psymbol, sizeof (struct partial_symbol), objfile->psymbol_cache);
2701 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2702 if (list->next >= list->list + list->size)
2704 extend_psymbol_list (list, objfile);
2706 *list->next++ = psym;
2707 OBJSTAT (objfile, n_psyms++);
2710 /* Add a symbol with a long value to a psymtab. This differs from
2711 * add_psymbol_to_list above in taking both a mangled and a demangled
2715 add_psymbol_with_dem_name_to_list (char *name, int namelength, char *dem_name,
2716 int dem_namelength, namespace_enum namespace,
2717 enum address_class class,
2718 struct psymbol_allocation_list *list, long val, /* Value as a long */
2719 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
2720 enum language language,
2721 struct objfile *objfile)
2723 register struct partial_symbol *psym;
2724 char *buf = alloca (namelength + 1);
2725 /* psymbol is static so that there will be no uninitialized gaps in the
2726 structure which might contain random data, causing cache misses in
2728 static struct partial_symbol psymbol;
2730 /* Create local copy of the partial symbol */
2732 memcpy (buf, name, namelength);
2733 buf[namelength] = '\0';
2734 SYMBOL_NAME (&psymbol) = bcache (buf, namelength + 1, objfile->psymbol_cache);
2736 buf = alloca (dem_namelength + 1);
2737 memcpy (buf, dem_name, dem_namelength);
2738 buf[dem_namelength] = '\0';
2743 case language_cplus:
2744 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol) =
2745 bcache (buf, dem_namelength + 1, objfile->psymbol_cache);
2747 /* FIXME What should be done for the default case? Ignoring for now. */
2750 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2753 SYMBOL_VALUE (&psymbol) = val;
2757 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
2759 SYMBOL_SECTION (&psymbol) = 0;
2760 SYMBOL_LANGUAGE (&psymbol) = language;
2761 PSYMBOL_NAMESPACE (&psymbol) = namespace;
2762 PSYMBOL_CLASS (&psymbol) = class;
2763 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol, language);
2765 /* Stash the partial symbol away in the cache */
2766 psym = bcache (&psymbol, sizeof (struct partial_symbol), objfile->psymbol_cache);
2768 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2769 if (list->next >= list->list + list->size)
2771 extend_psymbol_list (list, objfile);
2773 *list->next++ = psym;
2774 OBJSTAT (objfile, n_psyms++);
2777 /* Initialize storage for partial symbols. */
2780 init_psymbol_list (struct objfile *objfile, int total_symbols)
2782 /* Free any previously allocated psymbol lists. */
2784 if (objfile->global_psymbols.list)
2786 xmfree (objfile->md, objfile->global_psymbols.list);
2788 if (objfile->static_psymbols.list)
2790 xmfree (objfile->md, objfile->static_psymbols.list);
2793 /* Current best guess is that approximately a twentieth
2794 of the total symbols (in a debugging file) are global or static
2797 objfile->global_psymbols.size = total_symbols / 10;
2798 objfile->static_psymbols.size = total_symbols / 10;
2800 if (objfile->global_psymbols.size > 0)
2802 objfile->global_psymbols.next =
2803 objfile->global_psymbols.list = (struct partial_symbol **)
2804 xmmalloc (objfile->md, (objfile->global_psymbols.size
2805 * sizeof (struct partial_symbol *)));
2807 if (objfile->static_psymbols.size > 0)
2809 objfile->static_psymbols.next =
2810 objfile->static_psymbols.list = (struct partial_symbol **)
2811 xmmalloc (objfile->md, (objfile->static_psymbols.size
2812 * sizeof (struct partial_symbol *)));
2817 The following code implements an abstraction for debugging overlay sections.
2819 The target model is as follows:
2820 1) The gnu linker will permit multiple sections to be mapped into the
2821 same VMA, each with its own unique LMA (or load address).
2822 2) It is assumed that some runtime mechanism exists for mapping the
2823 sections, one by one, from the load address into the VMA address.
2824 3) This code provides a mechanism for gdb to keep track of which
2825 sections should be considered to be mapped from the VMA to the LMA.
2826 This information is used for symbol lookup, and memory read/write.
2827 For instance, if a section has been mapped then its contents
2828 should be read from the VMA, otherwise from the LMA.
2830 Two levels of debugger support for overlays are available. One is
2831 "manual", in which the debugger relies on the user to tell it which
2832 overlays are currently mapped. This level of support is
2833 implemented entirely in the core debugger, and the information about
2834 whether a section is mapped is kept in the objfile->obj_section table.
2836 The second level of support is "automatic", and is only available if
2837 the target-specific code provides functionality to read the target's
2838 overlay mapping table, and translate its contents for the debugger
2839 (by updating the mapped state information in the obj_section tables).
2841 The interface is as follows:
2843 overlay map <name> -- tell gdb to consider this section mapped
2844 overlay unmap <name> -- tell gdb to consider this section unmapped
2845 overlay list -- list the sections that GDB thinks are mapped
2846 overlay read-target -- get the target's state of what's mapped
2847 overlay off/manual/auto -- set overlay debugging state
2848 Functional interface:
2849 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2850 section, return that section.
2851 find_pc_overlay(pc): find any overlay section that contains
2852 the pc, either in its VMA or its LMA
2853 overlay_is_mapped(sect): true if overlay is marked as mapped
2854 section_is_overlay(sect): true if section's VMA != LMA
2855 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2856 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2857 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2858 overlay_mapped_address(...): map an address from section's LMA to VMA
2859 overlay_unmapped_address(...): map an address from section's VMA to LMA
2860 symbol_overlayed_address(...): Return a "current" address for symbol:
2861 either in VMA or LMA depending on whether
2862 the symbol's section is currently mapped
2865 /* Overlay debugging state: */
2867 enum overlay_debugging_state overlay_debugging = ovly_off;
2868 int overlay_cache_invalid = 0; /* True if need to refresh mapped state */
2870 /* Target vector for refreshing overlay mapped state */
2871 static void simple_overlay_update (struct obj_section *);
2872 void (*target_overlay_update) (struct obj_section *) = simple_overlay_update;
2874 /* Function: section_is_overlay (SECTION)
2875 Returns true if SECTION has VMA not equal to LMA, ie.
2876 SECTION is loaded at an address different from where it will "run". */
2879 section_is_overlay (asection *section)
2881 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2883 if (overlay_debugging)
2884 if (section && section->lma != 0 &&
2885 section->vma != section->lma)
2891 /* Function: overlay_invalidate_all (void)
2892 Invalidate the mapped state of all overlay sections (mark it as stale). */
2895 overlay_invalidate_all (void)
2897 struct objfile *objfile;
2898 struct obj_section *sect;
2900 ALL_OBJSECTIONS (objfile, sect)
2901 if (section_is_overlay (sect->the_bfd_section))
2902 sect->ovly_mapped = -1;
2905 /* Function: overlay_is_mapped (SECTION)
2906 Returns true if section is an overlay, and is currently mapped.
2907 Private: public access is thru function section_is_mapped.
2909 Access to the ovly_mapped flag is restricted to this function, so
2910 that we can do automatic update. If the global flag
2911 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2912 overlay_invalidate_all. If the mapped state of the particular
2913 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2916 overlay_is_mapped (struct obj_section *osect)
2918 if (osect == 0 || !section_is_overlay (osect->the_bfd_section))
2921 switch (overlay_debugging)
2925 return 0; /* overlay debugging off */
2926 case ovly_auto: /* overlay debugging automatic */
2927 /* Unles there is a target_overlay_update function,
2928 there's really nothing useful to do here (can't really go auto) */
2929 if (target_overlay_update)
2931 if (overlay_cache_invalid)
2933 overlay_invalidate_all ();
2934 overlay_cache_invalid = 0;
2936 if (osect->ovly_mapped == -1)
2937 (*target_overlay_update) (osect);
2939 /* fall thru to manual case */
2940 case ovly_on: /* overlay debugging manual */
2941 return osect->ovly_mapped == 1;
2945 /* Function: section_is_mapped
2946 Returns true if section is an overlay, and is currently mapped. */
2949 section_is_mapped (asection *section)
2951 struct objfile *objfile;
2952 struct obj_section *osect;
2954 if (overlay_debugging)
2955 if (section && section_is_overlay (section))
2956 ALL_OBJSECTIONS (objfile, osect)
2957 if (osect->the_bfd_section == section)
2958 return overlay_is_mapped (osect);
2963 /* Function: pc_in_unmapped_range
2964 If PC falls into the lma range of SECTION, return true, else false. */
2967 pc_in_unmapped_range (CORE_ADDR pc, asection *section)
2969 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2973 if (overlay_debugging)
2974 if (section && section_is_overlay (section))
2976 size = bfd_get_section_size_before_reloc (section);
2977 if (section->lma <= pc && pc < section->lma + size)
2983 /* Function: pc_in_mapped_range
2984 If PC falls into the vma range of SECTION, return true, else false. */
2987 pc_in_mapped_range (CORE_ADDR pc, asection *section)
2989 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2993 if (overlay_debugging)
2994 if (section && section_is_overlay (section))
2996 size = bfd_get_section_size_before_reloc (section);
2997 if (section->vma <= pc && pc < section->vma + size)
3004 /* Return true if the mapped ranges of sections A and B overlap, false
3007 sections_overlap (asection *a, asection *b)
3009 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3011 CORE_ADDR a_start = a->vma;
3012 CORE_ADDR a_end = a->vma + bfd_get_section_size_before_reloc (a);
3013 CORE_ADDR b_start = b->vma;
3014 CORE_ADDR b_end = b->vma + bfd_get_section_size_before_reloc (b);
3016 return (a_start < b_end && b_start < a_end);
3019 /* Function: overlay_unmapped_address (PC, SECTION)
3020 Returns the address corresponding to PC in the unmapped (load) range.
3021 May be the same as PC. */
3024 overlay_unmapped_address (CORE_ADDR pc, asection *section)
3026 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
3028 if (overlay_debugging)
3029 if (section && section_is_overlay (section) &&
3030 pc_in_mapped_range (pc, section))
3031 return pc + section->lma - section->vma;
3036 /* Function: overlay_mapped_address (PC, SECTION)
3037 Returns the address corresponding to PC in the mapped (runtime) range.
3038 May be the same as PC. */
3041 overlay_mapped_address (CORE_ADDR pc, asection *section)
3043 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3045 if (overlay_debugging)
3046 if (section && section_is_overlay (section) &&
3047 pc_in_unmapped_range (pc, section))
3048 return pc + section->vma - section->lma;
3054 /* Function: symbol_overlayed_address
3055 Return one of two addresses (relative to the VMA or to the LMA),
3056 depending on whether the section is mapped or not. */
3059 symbol_overlayed_address (CORE_ADDR address, asection *section)
3061 if (overlay_debugging)
3063 /* If the symbol has no section, just return its regular address. */
3066 /* If the symbol's section is not an overlay, just return its address */
3067 if (!section_is_overlay (section))
3069 /* If the symbol's section is mapped, just return its address */
3070 if (section_is_mapped (section))
3073 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3074 * then return its LOADED address rather than its vma address!!
3076 return overlay_unmapped_address (address, section);
3081 /* Function: find_pc_overlay (PC)
3082 Return the best-match overlay section for PC:
3083 If PC matches a mapped overlay section's VMA, return that section.
3084 Else if PC matches an unmapped section's VMA, return that section.
3085 Else if PC matches an unmapped section's LMA, return that section. */
3088 find_pc_overlay (CORE_ADDR pc)
3090 struct objfile *objfile;
3091 struct obj_section *osect, *best_match = NULL;
3093 if (overlay_debugging)
3094 ALL_OBJSECTIONS (objfile, osect)
3095 if (section_is_overlay (osect->the_bfd_section))
3097 if (pc_in_mapped_range (pc, osect->the_bfd_section))
3099 if (overlay_is_mapped (osect))
3100 return osect->the_bfd_section;
3104 else if (pc_in_unmapped_range (pc, osect->the_bfd_section))
3107 return best_match ? best_match->the_bfd_section : NULL;
3110 /* Function: find_pc_mapped_section (PC)
3111 If PC falls into the VMA address range of an overlay section that is
3112 currently marked as MAPPED, return that section. Else return NULL. */
3115 find_pc_mapped_section (CORE_ADDR pc)
3117 struct objfile *objfile;
3118 struct obj_section *osect;
3120 if (overlay_debugging)
3121 ALL_OBJSECTIONS (objfile, osect)
3122 if (pc_in_mapped_range (pc, osect->the_bfd_section) &&
3123 overlay_is_mapped (osect))
3124 return osect->the_bfd_section;
3129 /* Function: list_overlays_command
3130 Print a list of mapped sections and their PC ranges */
3133 list_overlays_command (char *args, int from_tty)
3136 struct objfile *objfile;
3137 struct obj_section *osect;
3139 if (overlay_debugging)
3140 ALL_OBJSECTIONS (objfile, osect)
3141 if (overlay_is_mapped (osect))
3147 vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section);
3148 lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section);
3149 size = bfd_get_section_size_before_reloc (osect->the_bfd_section);
3150 name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
3152 printf_filtered ("Section %s, loaded at ", name);
3153 print_address_numeric (lma, 1, gdb_stdout);
3154 puts_filtered (" - ");
3155 print_address_numeric (lma + size, 1, gdb_stdout);
3156 printf_filtered (", mapped at ");
3157 print_address_numeric (vma, 1, gdb_stdout);
3158 puts_filtered (" - ");
3159 print_address_numeric (vma + size, 1, gdb_stdout);
3160 puts_filtered ("\n");
3165 printf_filtered ("No sections are mapped.\n");
3168 /* Function: map_overlay_command
3169 Mark the named section as mapped (ie. residing at its VMA address). */
3172 map_overlay_command (char *args, int from_tty)
3174 struct objfile *objfile, *objfile2;
3175 struct obj_section *sec, *sec2;
3178 if (!overlay_debugging)
3180 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3181 the 'overlay manual' command.");
3183 if (args == 0 || *args == 0)
3184 error ("Argument required: name of an overlay section");
3186 /* First, find a section matching the user supplied argument */
3187 ALL_OBJSECTIONS (objfile, sec)
3188 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
3190 /* Now, check to see if the section is an overlay. */
3191 bfdsec = sec->the_bfd_section;
3192 if (!section_is_overlay (bfdsec))
3193 continue; /* not an overlay section */
3195 /* Mark the overlay as "mapped" */
3196 sec->ovly_mapped = 1;
3198 /* Next, make a pass and unmap any sections that are
3199 overlapped by this new section: */
3200 ALL_OBJSECTIONS (objfile2, sec2)
3201 if (sec2->ovly_mapped
3203 && sec->the_bfd_section != sec2->the_bfd_section
3204 && sections_overlap (sec->the_bfd_section,
3205 sec2->the_bfd_section))
3208 printf_filtered ("Note: section %s unmapped by overlap\n",
3209 bfd_section_name (objfile->obfd,
3210 sec2->the_bfd_section));
3211 sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2 */
3215 error ("No overlay section called %s", args);
3218 /* Function: unmap_overlay_command
3219 Mark the overlay section as unmapped
3220 (ie. resident in its LMA address range, rather than the VMA range). */
3223 unmap_overlay_command (char *args, int from_tty)
3225 struct objfile *objfile;
3226 struct obj_section *sec;
3228 if (!overlay_debugging)
3230 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3231 the 'overlay manual' command.");
3233 if (args == 0 || *args == 0)
3234 error ("Argument required: name of an overlay section");
3236 /* First, find a section matching the user supplied argument */
3237 ALL_OBJSECTIONS (objfile, sec)
3238 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
3240 if (!sec->ovly_mapped)
3241 error ("Section %s is not mapped", args);
3242 sec->ovly_mapped = 0;
3245 error ("No overlay section called %s", args);
3248 /* Function: overlay_auto_command
3249 A utility command to turn on overlay debugging.
3250 Possibly this should be done via a set/show command. */
3253 overlay_auto_command (char *args, int from_tty)
3255 overlay_debugging = ovly_auto;
3256 enable_overlay_breakpoints ();
3258 printf_filtered ("Automatic overlay debugging enabled.");
3261 /* Function: overlay_manual_command
3262 A utility command to turn on overlay debugging.
3263 Possibly this should be done via a set/show command. */
3266 overlay_manual_command (char *args, int from_tty)
3268 overlay_debugging = ovly_on;
3269 disable_overlay_breakpoints ();
3271 printf_filtered ("Overlay debugging enabled.");
3274 /* Function: overlay_off_command
3275 A utility command to turn on overlay debugging.
3276 Possibly this should be done via a set/show command. */
3279 overlay_off_command (char *args, int from_tty)
3281 overlay_debugging = ovly_off;
3282 disable_overlay_breakpoints ();
3284 printf_filtered ("Overlay debugging disabled.");
3288 overlay_load_command (char *args, int from_tty)
3290 if (target_overlay_update)
3291 (*target_overlay_update) (NULL);
3293 error ("This target does not know how to read its overlay state.");
3296 /* Function: overlay_command
3297 A place-holder for a mis-typed command */
3299 /* Command list chain containing all defined "overlay" subcommands. */
3300 struct cmd_list_element *overlaylist;
3303 overlay_command (char *args, int from_tty)
3306 ("\"overlay\" must be followed by the name of an overlay command.\n");
3307 help_list (overlaylist, "overlay ", -1, gdb_stdout);
3311 /* Target Overlays for the "Simplest" overlay manager:
3313 This is GDB's default target overlay layer. It works with the
3314 minimal overlay manager supplied as an example by Cygnus. The
3315 entry point is via a function pointer "target_overlay_update",
3316 so targets that use a different runtime overlay manager can
3317 substitute their own overlay_update function and take over the
3320 The overlay_update function pokes around in the target's data structures
3321 to see what overlays are mapped, and updates GDB's overlay mapping with
3324 In this simple implementation, the target data structures are as follows:
3325 unsigned _novlys; /# number of overlay sections #/
3326 unsigned _ovly_table[_novlys][4] = {
3327 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3328 {..., ..., ..., ...},
3330 unsigned _novly_regions; /# number of overlay regions #/
3331 unsigned _ovly_region_table[_novly_regions][3] = {
3332 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3335 These functions will attempt to update GDB's mappedness state in the
3336 symbol section table, based on the target's mappedness state.
3338 To do this, we keep a cached copy of the target's _ovly_table, and
3339 attempt to detect when the cached copy is invalidated. The main
3340 entry point is "simple_overlay_update(SECT), which looks up SECT in
3341 the cached table and re-reads only the entry for that section from
3342 the target (whenever possible).
3345 /* Cached, dynamically allocated copies of the target data structures: */
3346 static unsigned (*cache_ovly_table)[4] = 0;
3348 static unsigned (*cache_ovly_region_table)[3] = 0;
3350 static unsigned cache_novlys = 0;
3352 static unsigned cache_novly_regions = 0;
3354 static CORE_ADDR cache_ovly_table_base = 0;
3356 static CORE_ADDR cache_ovly_region_table_base = 0;
3360 VMA, SIZE, LMA, MAPPED
3362 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
3364 /* Throw away the cached copy of _ovly_table */
3366 simple_free_overlay_table (void)
3368 if (cache_ovly_table)
3369 xfree (cache_ovly_table);
3371 cache_ovly_table = NULL;
3372 cache_ovly_table_base = 0;
3376 /* Throw away the cached copy of _ovly_region_table */
3378 simple_free_overlay_region_table (void)
3380 if (cache_ovly_region_table)
3381 xfree (cache_ovly_region_table);
3382 cache_novly_regions = 0;
3383 cache_ovly_region_table = NULL;
3384 cache_ovly_region_table_base = 0;
3388 /* Read an array of ints from the target into a local buffer.
3389 Convert to host order. int LEN is number of ints */
3391 read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr, int len)
3393 /* FIXME (alloca): Not safe if array is very large. */
3394 char *buf = alloca (len * TARGET_LONG_BYTES);
3397 read_memory (memaddr, buf, len * TARGET_LONG_BYTES);
3398 for (i = 0; i < len; i++)
3399 myaddr[i] = extract_unsigned_integer (TARGET_LONG_BYTES * i + buf,
3403 /* Find and grab a copy of the target _ovly_table
3404 (and _novlys, which is needed for the table's size) */
3406 simple_read_overlay_table (void)
3408 struct minimal_symbol *novlys_msym, *ovly_table_msym;
3410 simple_free_overlay_table ();
3411 novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL);
3414 error ("Error reading inferior's overlay table: "
3415 "couldn't find `_novlys' variable\n"
3416 "in inferior. Use `overlay manual' mode.");
3420 ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, NULL);
3421 if (! ovly_table_msym)
3423 error ("Error reading inferior's overlay table: couldn't find "
3424 "`_ovly_table' array\n"
3425 "in inferior. Use `overlay manual' mode.");
3429 cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym), 4);
3431 = (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
3432 cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym);
3433 read_target_long_array (cache_ovly_table_base,
3434 (int *) cache_ovly_table,
3437 return 1; /* SUCCESS */
3441 /* Find and grab a copy of the target _ovly_region_table
3442 (and _novly_regions, which is needed for the table's size) */
3444 simple_read_overlay_region_table (void)
3446 struct minimal_symbol *msym;
3448 simple_free_overlay_region_table ();
3449 msym = lookup_minimal_symbol ("_novly_regions", NULL, NULL);
3451 cache_novly_regions = read_memory_integer (SYMBOL_VALUE_ADDRESS (msym), 4);
3453 return 0; /* failure */
3454 cache_ovly_region_table = (void *) xmalloc (cache_novly_regions * 12);
3455 if (cache_ovly_region_table != NULL)
3457 msym = lookup_minimal_symbol ("_ovly_region_table", NULL, NULL);
3460 cache_ovly_region_table_base = SYMBOL_VALUE_ADDRESS (msym);
3461 read_target_long_array (cache_ovly_region_table_base,
3462 (int *) cache_ovly_region_table,
3463 cache_novly_regions * 3);
3466 return 0; /* failure */
3469 return 0; /* failure */
3470 return 1; /* SUCCESS */
3474 /* Function: simple_overlay_update_1
3475 A helper function for simple_overlay_update. Assuming a cached copy
3476 of _ovly_table exists, look through it to find an entry whose vma,
3477 lma and size match those of OSECT. Re-read the entry and make sure
3478 it still matches OSECT (else the table may no longer be valid).
3479 Set OSECT's mapped state to match the entry. Return: 1 for
3480 success, 0 for failure. */
3483 simple_overlay_update_1 (struct obj_section *osect)
3486 bfd *obfd = osect->objfile->obfd;
3487 asection *bsect = osect->the_bfd_section;
3489 size = bfd_get_section_size_before_reloc (osect->the_bfd_section);
3490 for (i = 0; i < cache_novlys; i++)
3491 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3492 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3493 /* && cache_ovly_table[i][SIZE] == size */ )
3495 read_target_long_array (cache_ovly_table_base + i * TARGET_LONG_BYTES,
3496 (int *) cache_ovly_table[i], 4);
3497 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3498 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3499 /* && cache_ovly_table[i][SIZE] == size */ )
3501 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3504 else /* Warning! Warning! Target's ovly table has changed! */
3510 /* Function: simple_overlay_update
3511 If OSECT is NULL, then update all sections' mapped state
3512 (after re-reading the entire target _ovly_table).
3513 If OSECT is non-NULL, then try to find a matching entry in the
3514 cached ovly_table and update only OSECT's mapped state.
3515 If a cached entry can't be found or the cache isn't valid, then
3516 re-read the entire cache, and go ahead and update all sections. */
3519 simple_overlay_update (struct obj_section *osect)
3521 struct objfile *objfile;
3523 /* Were we given an osect to look up? NULL means do all of them. */
3525 /* Have we got a cached copy of the target's overlay table? */
3526 if (cache_ovly_table != NULL)
3527 /* Does its cached location match what's currently in the symtab? */
3528 if (cache_ovly_table_base ==
3529 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL, NULL)))
3530 /* Then go ahead and try to look up this single section in the cache */
3531 if (simple_overlay_update_1 (osect))
3532 /* Found it! We're done. */
3535 /* Cached table no good: need to read the entire table anew.
3536 Or else we want all the sections, in which case it's actually
3537 more efficient to read the whole table in one block anyway. */
3539 if (! simple_read_overlay_table ())
3542 /* Now may as well update all sections, even if only one was requested. */
3543 ALL_OBJSECTIONS (objfile, osect)
3544 if (section_is_overlay (osect->the_bfd_section))
3547 bfd *obfd = osect->objfile->obfd;
3548 asection *bsect = osect->the_bfd_section;
3550 size = bfd_get_section_size_before_reloc (osect->the_bfd_section);
3551 for (i = 0; i < cache_novlys; i++)
3552 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
3553 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
3554 /* && cache_ovly_table[i][SIZE] == size */ )
3555 { /* obj_section matches i'th entry in ovly_table */
3556 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3557 break; /* finished with inner for loop: break out */
3564 _initialize_symfile (void)
3566 struct cmd_list_element *c;
3568 c = add_cmd ("symbol-file", class_files, symbol_file_command,
3569 "Load symbol table from executable file FILE.\n\
3570 The `file' command can also load symbol tables, as well as setting the file\n\
3571 to execute.", &cmdlist);
3572 set_cmd_completer (c, filename_completer);
3574 c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command,
3575 "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3576 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
3577 ADDR is the starting address of the file's text.\n\
3578 The optional arguments are section-name section-address pairs and\n\
3579 should be specified if the data and bss segments are not contiguous\n\
3580 with the text. SECT is a section name to be loaded at SECT_ADDR.",
3582 set_cmd_completer (c, filename_completer);
3584 c = add_cmd ("add-shared-symbol-files", class_files,
3585 add_shared_symbol_files_command,
3586 "Load the symbols from shared objects in the dynamic linker's link map.",
3588 c = add_alias_cmd ("assf", "add-shared-symbol-files", class_files, 1,
3591 c = add_cmd ("load", class_files, load_command,
3592 "Dynamically load FILE into the running program, and record its symbols\n\
3593 for access from GDB.", &cmdlist);
3594 set_cmd_completer (c, filename_completer);
3597 (add_set_cmd ("symbol-reloading", class_support, var_boolean,
3598 (char *) &symbol_reloading,
3599 "Set dynamic symbol table reloading multiple times in one run.",
3603 add_prefix_cmd ("overlay", class_support, overlay_command,
3604 "Commands for debugging overlays.", &overlaylist,
3605 "overlay ", 0, &cmdlist);
3607 add_com_alias ("ovly", "overlay", class_alias, 1);
3608 add_com_alias ("ov", "overlay", class_alias, 1);
3610 add_cmd ("map-overlay", class_support, map_overlay_command,
3611 "Assert that an overlay section is mapped.", &overlaylist);
3613 add_cmd ("unmap-overlay", class_support, unmap_overlay_command,
3614 "Assert that an overlay section is unmapped.", &overlaylist);
3616 add_cmd ("list-overlays", class_support, list_overlays_command,
3617 "List mappings of overlay sections.", &overlaylist);
3619 add_cmd ("manual", class_support, overlay_manual_command,
3620 "Enable overlay debugging.", &overlaylist);
3621 add_cmd ("off", class_support, overlay_off_command,
3622 "Disable overlay debugging.", &overlaylist);
3623 add_cmd ("auto", class_support, overlay_auto_command,
3624 "Enable automatic overlay debugging.", &overlaylist);
3625 add_cmd ("load-target", class_support, overlay_load_command,
3626 "Read the overlay mapping state from the target.", &overlaylist);
3628 /* Filename extension to source language lookup table: */
3629 init_filename_language_table ();
3630 c = add_set_cmd ("extension-language", class_files, var_string_noescape,
3632 "Set mapping between filename extension and source language.\n\
3633 Usage: set extension-language .foo bar",
3635 set_cmd_cfunc (c, set_ext_lang_command);
3637 add_info ("extensions", info_ext_lang_command,
3638 "All filename extensions associated with a source language.");
3641 (add_set_cmd ("download-write-size", class_obscure,
3642 var_integer, (char *) &download_write_size,
3643 "Set the write size used when downloading a program.\n"
3644 "Only used when downloading a program onto a remote\n"
3645 "target. Specify zero, or a negative value, to disable\n"
3646 "blocked writes. The actual size of each transfer is also\n"
3647 "limited by the size of the target packet and the memory\n"
3652 debug_file_directory = xstrdup (DEBUGDIR);
3654 ("debug-file-directory", class_support, var_string,
3655 (char *) &debug_file_directory,
3656 "Set the directory where separate debug symbols are searched for.\n"
3657 "Separate debug symbols are first searched for in the same\n"
3658 "directory as the binary, then in the `" DEBUG_SUBDIRECTORY
3660 "and lastly at the path of the directory of the binary with\n"
3661 "the global debug-file directory prepended\n",
3663 add_show_from_set (c, &showlist);
3664 set_cmd_completer (c, filename_completer);