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. */
37 #include "breakpoint.h"
39 #include "complaints.h"
41 #include "inferior.h" /* for write_pc */
42 #include "filenames.h" /* for DOSish file names */
43 #include "gdb-stabs.h"
44 #include "gdb_obstack.h"
45 #include "completer.h"
48 #include <readline/readline.h>
49 #include "gdb_assert.h"
52 #include <sys/types.h>
54 #include "gdb_string.h"
65 /* Some HP-UX related globals to clear when a new "main"
66 symbol file is loaded. HP-specific. */
68 extern int hp_som_som_object_present
;
69 extern int hp_cxx_exception_support_initialized
;
70 #define RESET_HP_UX_GLOBALS() do {\
71 hp_som_som_object_present = 0; /* indicates HP-compiled code */ \
72 hp_cxx_exception_support_initialized = 0; /* must reinitialize exception stuff */ \
76 int (*ui_load_progress_hook
) (const char *section
, unsigned long num
);
77 void (*show_load_progress
) (const char *section
,
78 unsigned long section_sent
,
79 unsigned long section_size
,
80 unsigned long total_sent
,
81 unsigned long total_size
);
82 void (*pre_add_symbol_hook
) (char *);
83 void (*post_add_symbol_hook
) (void);
84 void (*target_new_objfile_hook
) (struct objfile
*);
86 static void clear_symtab_users_cleanup (void *ignore
);
88 /* Global variables owned by this file */
89 int readnow_symbol_files
; /* Read full symbols immediately */
91 /* External variables and functions referenced. */
93 extern void report_transfer_performance (unsigned long, time_t, time_t);
95 /* Functions this file defines */
98 static int simple_read_overlay_region_table (void);
99 static void simple_free_overlay_region_table (void);
102 static void set_initial_language (void);
104 static void load_command (char *, int);
106 static void symbol_file_add_main_1 (char *args
, int from_tty
, int flags
);
108 static void add_symbol_file_command (char *, int);
110 static void add_shared_symbol_files_command (char *, int);
112 static void reread_separate_symbols (struct objfile
*objfile
);
114 static void cashier_psymtab (struct partial_symtab
*);
116 bfd
*symfile_bfd_open (char *);
118 int get_section_index (struct objfile
*, char *);
120 static void find_sym_fns (struct objfile
*);
122 static void decrement_reading_symtab (void *);
124 static void overlay_invalidate_all (void);
126 static int overlay_is_mapped (struct obj_section
*);
128 void list_overlays_command (char *, int);
130 void map_overlay_command (char *, int);
132 void unmap_overlay_command (char *, int);
134 static void overlay_auto_command (char *, int);
136 static void overlay_manual_command (char *, int);
138 static void overlay_off_command (char *, int);
140 static void overlay_load_command (char *, int);
142 static void overlay_command (char *, int);
144 static void simple_free_overlay_table (void);
146 static void read_target_long_array (CORE_ADDR
, unsigned int *, int);
148 static int simple_read_overlay_table (void);
150 static int simple_overlay_update_1 (struct obj_section
*);
152 static void add_filename_language (char *ext
, enum language lang
);
154 static void set_ext_lang_command (char *args
, int from_tty
);
156 static void info_ext_lang_command (char *args
, int from_tty
);
158 static char *find_separate_debug_file (struct objfile
*objfile
);
160 static void init_filename_language_table (void);
162 void _initialize_symfile (void);
164 /* List of all available sym_fns. On gdb startup, each object file reader
165 calls add_symtab_fns() to register information on each format it is
168 static struct sym_fns
*symtab_fns
= NULL
;
170 /* Flag for whether user will be reloading symbols multiple times.
171 Defaults to ON for VxWorks, otherwise OFF. */
173 #ifdef SYMBOL_RELOADING_DEFAULT
174 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
176 int symbol_reloading
= 0;
179 /* If non-zero, shared library symbols will be added automatically
180 when the inferior is created, new libraries are loaded, or when
181 attaching to the inferior. This is almost always what users will
182 want to have happen; but for very large programs, the startup time
183 will be excessive, and so if this is a problem, the user can clear
184 this flag and then add the shared library symbols as needed. Note
185 that there is a potential for confusion, since if the shared
186 library symbols are not loaded, commands like "info fun" will *not*
187 report all the functions that are actually present. */
189 int auto_solib_add
= 1;
191 /* For systems that support it, a threshold size in megabytes. If
192 automatically adding a new library's symbol table to those already
193 known to the debugger would cause the total shared library symbol
194 size to exceed this threshhold, then the shlib's symbols are not
195 added. The threshold is ignored if the user explicitly asks for a
196 shlib to be added, such as when using the "sharedlibrary"
199 int auto_solib_limit
;
202 /* Since this function is called from within qsort, in an ANSI environment
203 it must conform to the prototype for qsort, which specifies that the
204 comparison function takes two "void *" pointers. */
207 compare_symbols (const void *s1p
, const void *s2p
)
209 register struct symbol
**s1
, **s2
;
211 s1
= (struct symbol
**) s1p
;
212 s2
= (struct symbol
**) s2p
;
213 return (strcmp (SYMBOL_NATURAL_NAME (*s1
), SYMBOL_NATURAL_NAME (*s2
)));
216 /* This compares two partial symbols by names, using strcmp_iw_ordered
217 for the comparison. */
220 compare_psymbols (const void *s1p
, const void *s2p
)
222 struct partial_symbol
*const *s1
= s1p
;
223 struct partial_symbol
*const *s2
= s2p
;
225 return strcmp_iw_ordered (SYMBOL_NATURAL_NAME (*s1
),
226 SYMBOL_NATURAL_NAME (*s2
));
230 sort_pst_symbols (struct partial_symtab
*pst
)
232 /* Sort the global list; don't sort the static list */
234 qsort (pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
,
235 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
239 /* Make a null terminated copy of the string at PTR with SIZE characters in
240 the obstack pointed to by OBSTACKP . Returns the address of the copy.
241 Note that the string at PTR does not have to be null terminated, I.E. it
242 may be part of a larger string and we are only saving a substring. */
245 obsavestring (const char *ptr
, int size
, struct obstack
*obstackp
)
247 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
248 /* Open-coded memcpy--saves function call time. These strings are usually
249 short. FIXME: Is this really still true with a compiler that can
252 register const char *p1
= ptr
;
253 register char *p2
= p
;
254 const char *end
= ptr
+ size
;
262 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
263 in the obstack pointed to by OBSTACKP. */
266 obconcat (struct obstack
*obstackp
, const char *s1
, const char *s2
,
269 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
270 register char *val
= (char *) obstack_alloc (obstackp
, len
);
277 /* True if we are nested inside psymtab_to_symtab. */
279 int currently_reading_symtab
= 0;
282 decrement_reading_symtab (void *dummy
)
284 currently_reading_symtab
--;
287 /* Get the symbol table that corresponds to a partial_symtab.
288 This is fast after the first time you do it. In fact, there
289 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
293 psymtab_to_symtab (register struct partial_symtab
*pst
)
295 /* If it's been looked up before, return it. */
299 /* If it has not yet been read in, read it. */
302 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
303 currently_reading_symtab
++;
304 (*pst
->read_symtab
) (pst
);
305 do_cleanups (back_to
);
311 /* Initialize entry point information for this objfile. */
314 init_entry_point_info (struct objfile
*objfile
)
316 /* Save startup file's range of PC addresses to help blockframe.c
317 decide where the bottom of the stack is. */
319 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
321 /* Executable file -- record its entry point so we'll recognize
322 the startup file because it contains the entry point. */
323 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
327 /* Examination of non-executable.o files. Short-circuit this stuff. */
328 objfile
->ei
.entry_point
= INVALID_ENTRY_POINT
;
330 objfile
->ei
.entry_file_lowpc
= INVALID_ENTRY_LOWPC
;
331 objfile
->ei
.entry_file_highpc
= INVALID_ENTRY_HIGHPC
;
332 objfile
->ei
.entry_func_lowpc
= INVALID_ENTRY_LOWPC
;
333 objfile
->ei
.entry_func_highpc
= INVALID_ENTRY_HIGHPC
;
334 objfile
->ei
.main_func_lowpc
= INVALID_ENTRY_LOWPC
;
335 objfile
->ei
.main_func_highpc
= INVALID_ENTRY_HIGHPC
;
338 /* Get current entry point address. */
341 entry_point_address (void)
343 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
346 /* Remember the lowest-addressed loadable section we've seen.
347 This function is called via bfd_map_over_sections.
349 In case of equal vmas, the section with the largest size becomes the
350 lowest-addressed loadable section.
352 If the vmas and sizes are equal, the last section is considered the
353 lowest-addressed loadable section. */
356 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
358 asection
**lowest
= (asection
**) obj
;
360 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
363 *lowest
= sect
; /* First loadable section */
364 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
365 *lowest
= sect
; /* A lower loadable section */
366 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
367 && (bfd_section_size (abfd
, (*lowest
))
368 <= bfd_section_size (abfd
, sect
)))
372 /* Create a new section_addr_info, with room for NUM_SECTIONS. */
374 struct section_addr_info
*
375 alloc_section_addr_info (size_t num_sections
)
377 struct section_addr_info
*sap
;
380 size
= (sizeof (struct section_addr_info
)
381 + sizeof (struct other_sections
) * (num_sections
- 1));
382 sap
= (struct section_addr_info
*) xmalloc (size
);
383 memset (sap
, 0, size
);
384 sap
->num_sections
= num_sections
;
389 /* Build (allocate and populate) a section_addr_info struct from
390 an existing section table. */
392 extern struct section_addr_info
*
393 build_section_addr_info_from_section_table (const struct section_table
*start
,
394 const struct section_table
*end
)
396 struct section_addr_info
*sap
;
397 const struct section_table
*stp
;
400 sap
= alloc_section_addr_info (end
- start
);
402 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
404 if (bfd_get_section_flags (stp
->bfd
,
405 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
406 && oidx
< end
- start
)
408 sap
->other
[oidx
].addr
= stp
->addr
;
409 sap
->other
[oidx
].name
410 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
411 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
420 /* Free all memory allocated by build_section_addr_info_from_section_table. */
423 free_section_addr_info (struct section_addr_info
*sap
)
427 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
428 if (sap
->other
[idx
].name
)
429 xfree (sap
->other
[idx
].name
);
434 /* Initialize OBJFILE's sect_index_* members. */
436 init_objfile_sect_indices (struct objfile
*objfile
)
441 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
443 objfile
->sect_index_text
= sect
->index
;
445 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
447 objfile
->sect_index_data
= sect
->index
;
449 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
451 objfile
->sect_index_bss
= sect
->index
;
453 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
455 objfile
->sect_index_rodata
= sect
->index
;
457 /* This is where things get really weird... We MUST have valid
458 indices for the various sect_index_* members or gdb will abort.
459 So if for example, there is no ".text" section, we have to
460 accomodate that. Except when explicitly adding symbol files at
461 some address, section_offsets contains nothing but zeros, so it
462 doesn't matter which slot in section_offsets the individual
463 sect_index_* members index into. So if they are all zero, it is
464 safe to just point all the currently uninitialized indices to the
467 for (i
= 0; i
< objfile
->num_sections
; i
++)
469 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
474 if (i
== objfile
->num_sections
)
476 if (objfile
->sect_index_text
== -1)
477 objfile
->sect_index_text
= 0;
478 if (objfile
->sect_index_data
== -1)
479 objfile
->sect_index_data
= 0;
480 if (objfile
->sect_index_bss
== -1)
481 objfile
->sect_index_bss
= 0;
482 if (objfile
->sect_index_rodata
== -1)
483 objfile
->sect_index_rodata
= 0;
488 /* Parse the user's idea of an offset for dynamic linking, into our idea
489 of how to represent it for fast symbol reading. This is the default
490 version of the sym_fns.sym_offsets function for symbol readers that
491 don't need to do anything special. It allocates a section_offsets table
492 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
495 default_symfile_offsets (struct objfile
*objfile
,
496 struct section_addr_info
*addrs
)
500 objfile
->num_sections
= bfd_count_sections (objfile
->obfd
);
501 objfile
->section_offsets
= (struct section_offsets
*)
502 obstack_alloc (&objfile
->psymbol_obstack
,
503 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
504 memset (objfile
->section_offsets
, 0,
505 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
507 /* Now calculate offsets for section that were specified by the
509 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
511 struct other_sections
*osp
;
513 osp
= &addrs
->other
[i
] ;
517 /* Record all sections in offsets */
518 /* The section_offsets in the objfile are here filled in using
520 (objfile
->section_offsets
)->offsets
[osp
->sectindex
] = osp
->addr
;
523 /* Remember the bfd indexes for the .text, .data, .bss and
525 init_objfile_sect_indices (objfile
);
529 /* Process a symbol file, as either the main file or as a dynamically
532 OBJFILE is where the symbols are to be read from.
534 ADDRS is the list of section load addresses. If the user has given
535 an 'add-symbol-file' command, then this is the list of offsets and
536 addresses he or she provided as arguments to the command; or, if
537 we're handling a shared library, these are the actual addresses the
538 sections are loaded at, according to the inferior's dynamic linker
539 (as gleaned by GDB's shared library code). We convert each address
540 into an offset from the section VMA's as it appears in the object
541 file, and then call the file's sym_offsets function to convert this
542 into a format-specific offset table --- a `struct section_offsets'.
543 If ADDRS is non-zero, OFFSETS must be zero.
545 OFFSETS is a table of section offsets already in the right
546 format-specific representation. NUM_OFFSETS is the number of
547 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
548 assume this is the proper table the call to sym_offsets described
549 above would produce. Instead of calling sym_offsets, we just dump
550 it right into objfile->section_offsets. (When we're re-reading
551 symbols from an objfile, we don't have the original load address
552 list any more; all we have is the section offset table.) If
553 OFFSETS is non-zero, ADDRS must be zero.
555 MAINLINE is nonzero if this is the main symbol file, or zero if
556 it's an extra symbol file such as dynamically loaded code.
558 VERBO is nonzero if the caller has printed a verbose message about
559 the symbol reading (and complaints can be more terse about it). */
562 syms_from_objfile (struct objfile
*objfile
,
563 struct section_addr_info
*addrs
,
564 struct section_offsets
*offsets
,
569 struct section_addr_info
*local_addr
= NULL
;
570 struct cleanup
*old_chain
;
572 gdb_assert (! (addrs
&& offsets
));
574 init_entry_point_info (objfile
);
575 find_sym_fns (objfile
);
577 if (objfile
->sf
== NULL
)
578 return; /* No symbols. */
580 /* Make sure that partially constructed symbol tables will be cleaned up
581 if an error occurs during symbol reading. */
582 old_chain
= make_cleanup_free_objfile (objfile
);
584 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
585 list. We now establish the convention that an addr of zero means
586 no load address was specified. */
587 if (! addrs
&& ! offsets
)
590 = alloc_section_addr_info (bfd_count_sections (objfile
->obfd
));
591 make_cleanup (xfree
, local_addr
);
595 /* Now either addrs or offsets is non-zero. */
599 /* We will modify the main symbol table, make sure that all its users
600 will be cleaned up if an error occurs during symbol reading. */
601 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
603 /* Since no error yet, throw away the old symbol table. */
605 if (symfile_objfile
!= NULL
)
607 free_objfile (symfile_objfile
);
608 symfile_objfile
= NULL
;
611 /* Currently we keep symbols from the add-symbol-file command.
612 If the user wants to get rid of them, they should do "symbol-file"
613 without arguments first. Not sure this is the best behavior
616 (*objfile
->sf
->sym_new_init
) (objfile
);
619 /* Convert addr into an offset rather than an absolute address.
620 We find the lowest address of a loaded segment in the objfile,
621 and assume that <addr> is where that got loaded.
623 We no longer warn if the lowest section is not a text segment (as
624 happens for the PA64 port. */
625 if (!mainline
&& addrs
&& addrs
->other
[0].name
)
627 asection
*lower_sect
;
629 CORE_ADDR lower_offset
;
632 /* Find lowest loadable section to be used as starting point for
633 continguous sections. FIXME!! won't work without call to find
634 .text first, but this assumes text is lowest section. */
635 lower_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
636 if (lower_sect
== NULL
)
637 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
639 if (lower_sect
== NULL
)
640 warning ("no loadable sections found in added symbol-file %s",
643 if ((bfd_get_section_flags (objfile
->obfd
, lower_sect
) & SEC_CODE
) == 0)
644 warning ("Lowest section in %s is %s at %s",
646 bfd_section_name (objfile
->obfd
, lower_sect
),
647 paddr (bfd_section_vma (objfile
->obfd
, lower_sect
)));
648 if (lower_sect
!= NULL
)
649 lower_offset
= bfd_section_vma (objfile
->obfd
, lower_sect
);
653 /* Calculate offsets for the loadable sections.
654 FIXME! Sections must be in order of increasing loadable section
655 so that contiguous sections can use the lower-offset!!!
657 Adjust offsets if the segments are not contiguous.
658 If the section is contiguous, its offset should be set to
659 the offset of the highest loadable section lower than it
660 (the loadable section directly below it in memory).
661 this_offset = lower_offset = lower_addr - lower_orig_addr */
663 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
665 if (addrs
->other
[i
].addr
!= 0)
667 sect
= bfd_get_section_by_name (objfile
->obfd
,
668 addrs
->other
[i
].name
);
672 -= bfd_section_vma (objfile
->obfd
, sect
);
673 lower_offset
= addrs
->other
[i
].addr
;
674 /* This is the index used by BFD. */
675 addrs
->other
[i
].sectindex
= sect
->index
;
679 warning ("section %s not found in %s",
680 addrs
->other
[i
].name
,
682 addrs
->other
[i
].addr
= 0;
686 addrs
->other
[i
].addr
= lower_offset
;
690 /* Initialize symbol reading routines for this objfile, allow complaints to
691 appear for this new file, and record how verbose to be, then do the
692 initial symbol reading for this file. */
694 (*objfile
->sf
->sym_init
) (objfile
);
695 clear_complaints (&symfile_complaints
, 1, verbo
);
698 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
701 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
703 /* Just copy in the offset table directly as given to us. */
704 objfile
->num_sections
= num_offsets
;
705 objfile
->section_offsets
706 = ((struct section_offsets
*)
707 obstack_alloc (&objfile
->psymbol_obstack
, size
));
708 memcpy (objfile
->section_offsets
, offsets
, size
);
710 init_objfile_sect_indices (objfile
);
713 #ifndef IBM6000_TARGET
714 /* This is a SVR4/SunOS specific hack, I think. In any event, it
715 screws RS/6000. sym_offsets should be doing this sort of thing,
716 because it knows the mapping between bfd sections and
718 /* This is a hack. As far as I can tell, section offsets are not
719 target dependent. They are all set to addr with a couple of
720 exceptions. The exceptions are sysvr4 shared libraries, whose
721 offsets are kept in solib structures anyway and rs6000 xcoff
722 which handles shared libraries in a completely unique way.
724 Section offsets are built similarly, except that they are built
725 by adding addr in all cases because there is no clear mapping
726 from section_offsets into actual sections. Note that solib.c
727 has a different algorithm for finding section offsets.
729 These should probably all be collapsed into some target
730 independent form of shared library support. FIXME. */
734 struct obj_section
*s
;
736 /* Map section offsets in "addr" back to the object's
737 sections by comparing the section names with bfd's
738 section names. Then adjust the section address by
739 the offset. */ /* for gdb/13815 */
741 ALL_OBJFILE_OSECTIONS (objfile
, s
)
743 CORE_ADDR s_addr
= 0;
747 !s_addr
&& i
< addrs
->num_sections
&& addrs
->other
[i
].name
;
749 if (strcmp (bfd_section_name (s
->objfile
->obfd
,
751 addrs
->other
[i
].name
) == 0)
752 s_addr
= addrs
->other
[i
].addr
; /* end added for gdb/13815 */
754 s
->addr
-= s
->offset
;
756 s
->endaddr
-= s
->offset
;
757 s
->endaddr
+= s_addr
;
761 #endif /* not IBM6000_TARGET */
763 (*objfile
->sf
->sym_read
) (objfile
, mainline
);
765 /* Don't allow char * to have a typename (else would get caddr_t).
766 Ditto void *. FIXME: Check whether this is now done by all the
767 symbol readers themselves (many of them now do), and if so remove
770 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
771 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
773 /* Mark the objfile has having had initial symbol read attempted. Note
774 that this does not mean we found any symbols... */
776 objfile
->flags
|= OBJF_SYMS
;
778 /* Discard cleanups as symbol reading was successful. */
780 discard_cleanups (old_chain
);
783 /* Perform required actions after either reading in the initial
784 symbols for a new objfile, or mapping in the symbols from a reusable
788 new_symfile_objfile (struct objfile
*objfile
, int mainline
, int verbo
)
791 /* If this is the main symbol file we have to clean up all users of the
792 old main symbol file. Otherwise it is sufficient to fixup all the
793 breakpoints that may have been redefined by this symbol file. */
796 /* OK, make it the "real" symbol file. */
797 symfile_objfile
= objfile
;
799 clear_symtab_users ();
803 breakpoint_re_set ();
806 /* We're done reading the symbol file; finish off complaints. */
807 clear_complaints (&symfile_complaints
, 0, verbo
);
810 /* Process a symbol file, as either the main file or as a dynamically
813 NAME is the file name (which will be tilde-expanded and made
814 absolute herein) (but we don't free or modify NAME itself).
816 FROM_TTY says how verbose to be.
818 MAINLINE specifies whether this is the main symbol file, or whether
819 it's an extra symbol file such as dynamically loaded code.
821 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
822 syms_from_objfile, above. ADDRS is ignored when MAINLINE is
825 Upon success, returns a pointer to the objfile that was added.
826 Upon failure, jumps back to command level (never returns). */
827 static struct objfile
*
828 symbol_file_add_with_addrs_or_offsets (char *name
, int from_tty
,
829 struct section_addr_info
*addrs
,
830 struct section_offsets
*offsets
,
832 int mainline
, int flags
)
834 struct objfile
*objfile
;
835 struct partial_symtab
*psymtab
;
838 struct section_addr_info
*orig_addrs
;
839 struct cleanup
*my_cleanups
;
841 /* Open a bfd for the file, and give user a chance to burp if we'd be
842 interactively wiping out any existing symbols. */
844 abfd
= symfile_bfd_open (name
);
846 if ((have_full_symbols () || have_partial_symbols ())
849 && !query ("Load new symbol table from \"%s\"? ", name
))
850 error ("Not confirmed.");
852 objfile
= allocate_objfile (abfd
, flags
);
854 orig_addrs
= alloc_section_addr_info (bfd_count_sections (abfd
));
855 my_cleanups
= make_cleanup (xfree
, orig_addrs
);
857 *orig_addrs
= *addrs
;
859 /* If the objfile uses a mapped symbol file, and we have a psymtab for
860 it, then skip reading any symbols at this time. */
862 if ((objfile
->flags
& OBJF_MAPPED
) && (objfile
->flags
& OBJF_SYMS
))
864 /* We mapped in an existing symbol table file that already has had
865 initial symbol reading performed, so we can skip that part. Notify
866 the user that instead of reading the symbols, they have been mapped.
868 if (from_tty
|| info_verbose
)
870 printf_filtered ("Mapped symbols for %s...", name
);
872 gdb_flush (gdb_stdout
);
874 init_entry_point_info (objfile
);
875 find_sym_fns (objfile
);
879 /* We either created a new mapped symbol table, mapped an existing
880 symbol table file which has not had initial symbol reading
881 performed, or need to read an unmapped symbol table. */
882 if (from_tty
|| info_verbose
)
884 if (pre_add_symbol_hook
)
885 pre_add_symbol_hook (name
);
888 printf_filtered ("Reading symbols from %s...", name
);
890 gdb_flush (gdb_stdout
);
893 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
897 /* We now have at least a partial symbol table. Check to see if the
898 user requested that all symbols be read on initial access via either
899 the gdb startup command line or on a per symbol file basis. Expand
900 all partial symbol tables for this objfile if so. */
902 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
904 if (from_tty
|| info_verbose
)
906 printf_filtered ("expanding to full symbols...");
908 gdb_flush (gdb_stdout
);
911 for (psymtab
= objfile
->psymtabs
;
913 psymtab
= psymtab
->next
)
915 psymtab_to_symtab (psymtab
);
919 debugfile
= find_separate_debug_file (objfile
);
924 objfile
->separate_debug_objfile
925 = symbol_file_add (debugfile
, from_tty
, orig_addrs
, 0, flags
);
929 objfile
->separate_debug_objfile
930 = symbol_file_add (debugfile
, from_tty
, NULL
, 0, flags
);
932 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
935 /* Put the separate debug object before the normal one, this is so that
936 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
937 put_objfile_before (objfile
->separate_debug_objfile
, objfile
);
942 if (!have_partial_symbols () && !have_full_symbols ())
945 printf_filtered ("(no debugging symbols found)...");
949 if (from_tty
|| info_verbose
)
951 if (post_add_symbol_hook
)
952 post_add_symbol_hook ();
955 printf_filtered ("done.\n");
959 /* We print some messages regardless of whether 'from_tty ||
960 info_verbose' is true, so make sure they go out at the right
962 gdb_flush (gdb_stdout
);
964 do_cleanups (my_cleanups
);
966 if (objfile
->sf
== NULL
)
967 return objfile
; /* No symbols. */
969 new_symfile_objfile (objfile
, mainline
, from_tty
);
971 if (target_new_objfile_hook
)
972 target_new_objfile_hook (objfile
);
978 /* Process a symbol file, as either the main file or as a dynamically
979 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
982 symbol_file_add (char *name
, int from_tty
, struct section_addr_info
*addrs
,
983 int mainline
, int flags
)
985 return symbol_file_add_with_addrs_or_offsets (name
, from_tty
, addrs
, 0, 0,
990 /* Call symbol_file_add() with default values and update whatever is
991 affected by the loading of a new main().
992 Used when the file is supplied in the gdb command line
993 and by some targets with special loading requirements.
994 The auxiliary function, symbol_file_add_main_1(), has the flags
995 argument for the switches that can only be specified in the symbol_file
999 symbol_file_add_main (char *args
, int from_tty
)
1001 symbol_file_add_main_1 (args
, from_tty
, 0);
1005 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1007 symbol_file_add (args
, from_tty
, NULL
, 1, flags
);
1010 RESET_HP_UX_GLOBALS ();
1013 /* Getting new symbols may change our opinion about
1014 what is frameless. */
1015 reinit_frame_cache ();
1017 set_initial_language ();
1021 symbol_file_clear (int from_tty
)
1023 if ((have_full_symbols () || have_partial_symbols ())
1025 && !query ("Discard symbol table from `%s'? ",
1026 symfile_objfile
->name
))
1027 error ("Not confirmed.");
1028 free_all_objfiles ();
1030 /* solib descriptors may have handles to objfiles. Since their
1031 storage has just been released, we'd better wipe the solib
1032 descriptors as well.
1034 #if defined(SOLIB_RESTART)
1038 symfile_objfile
= NULL
;
1040 printf_unfiltered ("No symbol file now.\n");
1042 RESET_HP_UX_GLOBALS ();
1047 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1050 bfd_size_type debuglink_size
;
1051 unsigned long crc32
;
1056 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1061 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1063 contents
= xmalloc (debuglink_size
);
1064 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1065 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1067 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1068 crc_offset
= strlen (contents
) + 1;
1069 crc_offset
= (crc_offset
+ 3) & ~3;
1071 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1078 separate_debug_file_exists (const char *name
, unsigned long crc
)
1080 unsigned long file_crc
= 0;
1082 char buffer
[8*1024];
1085 fd
= open (name
, O_RDONLY
| O_BINARY
);
1089 while ((count
= read (fd
, buffer
, sizeof (buffer
))) > 0)
1090 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1094 return crc
== file_crc
;
1097 static char *debug_file_directory
= NULL
;
1099 #if ! defined (DEBUG_SUBDIRECTORY)
1100 #define DEBUG_SUBDIRECTORY ".debug"
1104 find_separate_debug_file (struct objfile
*objfile
)
1111 bfd_size_type debuglink_size
;
1112 unsigned long crc32
;
1115 basename
= get_debug_link_info (objfile
, &crc32
);
1117 if (basename
== NULL
)
1120 dir
= xstrdup (objfile
->name
);
1122 /* Strip off the final filename part, leaving the directory name,
1123 followed by a slash. Objfile names should always be absolute and
1124 tilde-expanded, so there should always be a slash in there
1126 for (i
= strlen(dir
) - 1; i
>= 0; i
--)
1128 if (IS_DIR_SEPARATOR (dir
[i
]))
1131 gdb_assert (i
>= 0 && IS_DIR_SEPARATOR (dir
[i
]));
1134 debugfile
= alloca (strlen (debug_file_directory
) + 1
1136 + strlen (DEBUG_SUBDIRECTORY
)
1141 /* First try in the same directory as the original file. */
1142 strcpy (debugfile
, dir
);
1143 strcat (debugfile
, basename
);
1145 if (separate_debug_file_exists (debugfile
, crc32
))
1149 return xstrdup (debugfile
);
1152 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1153 strcpy (debugfile
, dir
);
1154 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1155 strcat (debugfile
, "/");
1156 strcat (debugfile
, basename
);
1158 if (separate_debug_file_exists (debugfile
, crc32
))
1162 return xstrdup (debugfile
);
1165 /* Then try in the global debugfile directory. */
1166 strcpy (debugfile
, debug_file_directory
);
1167 strcat (debugfile
, "/");
1168 strcat (debugfile
, dir
);
1169 strcat (debugfile
, basename
);
1171 if (separate_debug_file_exists (debugfile
, crc32
))
1175 return xstrdup (debugfile
);
1184 /* This is the symbol-file command. Read the file, analyze its
1185 symbols, and add a struct symtab to a symtab list. The syntax of
1186 the command is rather bizarre--(1) buildargv implements various
1187 quoting conventions which are undocumented and have little or
1188 nothing in common with the way things are quoted (or not quoted)
1189 elsewhere in GDB, (2) options are used, which are not generally
1190 used in GDB (perhaps "set mapped on", "set readnow on" would be
1191 better), (3) the order of options matters, which is contrary to GNU
1192 conventions (because it is confusing and inconvenient). */
1193 /* Note: ezannoni 2000-04-17. This function used to have support for
1194 rombug (see remote-os9k.c). It consisted of a call to target_link()
1195 (target.c) to get the address of the text segment from the target,
1196 and pass that to symbol_file_add(). This is no longer supported. */
1199 symbol_file_command (char *args
, int from_tty
)
1203 struct cleanup
*cleanups
;
1204 int flags
= OBJF_USERLOADED
;
1210 symbol_file_clear (from_tty
);
1214 if ((argv
= buildargv (args
)) == NULL
)
1218 cleanups
= make_cleanup_freeargv (argv
);
1219 while (*argv
!= NULL
)
1221 if (STREQ (*argv
, "-mapped"))
1222 flags
|= OBJF_MAPPED
;
1224 if (STREQ (*argv
, "-readnow"))
1225 flags
|= OBJF_READNOW
;
1228 error ("unknown option `%s'", *argv
);
1233 symbol_file_add_main_1 (name
, from_tty
, flags
);
1240 error ("no symbol file name was specified");
1242 do_cleanups (cleanups
);
1246 /* Set the initial language.
1248 A better solution would be to record the language in the psymtab when reading
1249 partial symbols, and then use it (if known) to set the language. This would
1250 be a win for formats that encode the language in an easily discoverable place,
1251 such as DWARF. For stabs, we can jump through hoops looking for specially
1252 named symbols or try to intuit the language from the specific type of stabs
1253 we find, but we can't do that until later when we read in full symbols.
1257 set_initial_language (void)
1259 struct partial_symtab
*pst
;
1260 enum language lang
= language_unknown
;
1262 pst
= find_main_psymtab ();
1265 if (pst
->filename
!= NULL
)
1267 lang
= deduce_language_from_filename (pst
->filename
);
1269 if (lang
== language_unknown
)
1271 /* Make C the default language */
1274 set_language (lang
);
1275 expected_language
= current_language
; /* Don't warn the user */
1279 /* Open file specified by NAME and hand it off to BFD for preliminary
1280 analysis. Result is a newly initialized bfd *, which includes a newly
1281 malloc'd` copy of NAME (tilde-expanded and made absolute).
1282 In case of trouble, error() is called. */
1285 symfile_bfd_open (char *name
)
1289 char *absolute_name
;
1293 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
1295 /* Look down path for it, allocate 2nd new malloc'd copy. */
1296 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1297 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1300 char *exename
= alloca (strlen (name
) + 5);
1301 strcat (strcpy (exename
, name
), ".exe");
1302 desc
= openp (getenv ("PATH"), 1, exename
, O_RDONLY
| O_BINARY
,
1308 make_cleanup (xfree
, name
);
1309 perror_with_name (name
);
1311 xfree (name
); /* Free 1st new malloc'd copy */
1312 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
1313 /* It'll be freed in free_objfile(). */
1315 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
1319 make_cleanup (xfree
, name
);
1320 error ("\"%s\": can't open to read symbols: %s.", name
,
1321 bfd_errmsg (bfd_get_error ()));
1323 sym_bfd
->cacheable
= 1;
1325 if (!bfd_check_format (sym_bfd
, bfd_object
))
1327 /* FIXME: should be checking for errors from bfd_close (for one thing,
1328 on error it does not free all the storage associated with the
1330 bfd_close (sym_bfd
); /* This also closes desc */
1331 make_cleanup (xfree
, name
);
1332 error ("\"%s\": can't read symbols: %s.", name
,
1333 bfd_errmsg (bfd_get_error ()));
1338 /* Return the section index for the given section name. Return -1 if
1339 the section was not found. */
1341 get_section_index (struct objfile
*objfile
, char *section_name
)
1343 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1350 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
1351 startup by the _initialize routine in each object file format reader,
1352 to register information about each format the the reader is prepared
1356 add_symtab_fns (struct sym_fns
*sf
)
1358 sf
->next
= symtab_fns
;
1363 /* Initialize to read symbols from the symbol file sym_bfd. It either
1364 returns or calls error(). The result is an initialized struct sym_fns
1365 in the objfile structure, that contains cached information about the
1369 find_sym_fns (struct objfile
*objfile
)
1372 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
->obfd
);
1373 char *our_target
= bfd_get_target (objfile
->obfd
);
1375 if (our_flavour
== bfd_target_srec_flavour
1376 || our_flavour
== bfd_target_ihex_flavour
1377 || our_flavour
== bfd_target_tekhex_flavour
)
1378 return; /* No symbols. */
1380 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1382 if (our_flavour
== sf
->sym_flavour
)
1388 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
1389 bfd_get_target (objfile
->obfd
));
1392 /* This function runs the load command of our current target. */
1395 load_command (char *arg
, int from_tty
)
1398 arg
= get_exec_file (1);
1399 target_load (arg
, from_tty
);
1401 /* After re-loading the executable, we don't really know which
1402 overlays are mapped any more. */
1403 overlay_cache_invalid
= 1;
1406 /* This version of "load" should be usable for any target. Currently
1407 it is just used for remote targets, not inftarg.c or core files,
1408 on the theory that only in that case is it useful.
1410 Avoiding xmodem and the like seems like a win (a) because we don't have
1411 to worry about finding it, and (b) On VMS, fork() is very slow and so
1412 we don't want to run a subprocess. On the other hand, I'm not sure how
1413 performance compares. */
1415 static int download_write_size
= 512;
1416 static int validate_download
= 0;
1418 /* Callback service function for generic_load (bfd_map_over_sections). */
1421 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1423 bfd_size_type
*sum
= data
;
1425 *sum
+= bfd_get_section_size_before_reloc (asec
);
1428 /* Opaque data for load_section_callback. */
1429 struct load_section_data
{
1430 unsigned long load_offset
;
1431 unsigned long write_count
;
1432 unsigned long data_count
;
1433 bfd_size_type total_size
;
1436 /* Callback service function for generic_load (bfd_map_over_sections). */
1439 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1441 struct load_section_data
*args
= data
;
1443 if (bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
)
1445 bfd_size_type size
= bfd_get_section_size_before_reloc (asec
);
1449 struct cleanup
*old_chain
;
1450 CORE_ADDR lma
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1451 bfd_size_type block_size
;
1453 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1456 if (download_write_size
> 0 && size
> download_write_size
)
1457 block_size
= download_write_size
;
1461 buffer
= xmalloc (size
);
1462 old_chain
= make_cleanup (xfree
, buffer
);
1464 /* Is this really necessary? I guess it gives the user something
1465 to look at during a long download. */
1466 ui_out_message (uiout
, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1467 sect_name
, paddr_nz (size
), paddr_nz (lma
));
1469 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1475 bfd_size_type this_transfer
= size
- sent
;
1477 if (this_transfer
>= block_size
)
1478 this_transfer
= block_size
;
1479 len
= target_write_memory_partial (lma
, buffer
,
1480 this_transfer
, &err
);
1483 if (validate_download
)
1485 /* Broken memories and broken monitors manifest
1486 themselves here when bring new computers to
1487 life. This doubles already slow downloads. */
1488 /* NOTE: cagney/1999-10-18: A more efficient
1489 implementation might add a verify_memory()
1490 method to the target vector and then use
1491 that. remote.c could implement that method
1492 using the ``qCRC'' packet. */
1493 char *check
= xmalloc (len
);
1494 struct cleanup
*verify_cleanups
=
1495 make_cleanup (xfree
, check
);
1497 if (target_read_memory (lma
, check
, len
) != 0)
1498 error ("Download verify read failed at 0x%s",
1500 if (memcmp (buffer
, check
, len
) != 0)
1501 error ("Download verify compare failed at 0x%s",
1503 do_cleanups (verify_cleanups
);
1505 args
->data_count
+= len
;
1508 args
->write_count
+= 1;
1511 || (ui_load_progress_hook
!= NULL
1512 && ui_load_progress_hook (sect_name
, sent
)))
1513 error ("Canceled the download");
1515 if (show_load_progress
!= NULL
)
1516 show_load_progress (sect_name
, sent
, size
,
1517 args
->data_count
, args
->total_size
);
1519 while (sent
< size
);
1522 error ("Memory access error while loading section %s.", sect_name
);
1524 do_cleanups (old_chain
);
1530 generic_load (char *args
, int from_tty
)
1534 time_t start_time
, end_time
; /* Start and end times of download */
1536 struct cleanup
*old_cleanups
;
1538 struct load_section_data cbdata
;
1541 cbdata
.load_offset
= 0; /* Offset to add to vma for each section. */
1542 cbdata
.write_count
= 0; /* Number of writes needed. */
1543 cbdata
.data_count
= 0; /* Number of bytes written to target memory. */
1544 cbdata
.total_size
= 0; /* Total size of all bfd sectors. */
1546 /* Parse the input argument - the user can specify a load offset as
1547 a second argument. */
1548 filename
= xmalloc (strlen (args
) + 1);
1549 old_cleanups
= make_cleanup (xfree
, filename
);
1550 strcpy (filename
, args
);
1551 offptr
= strchr (filename
, ' ');
1556 cbdata
.load_offset
= strtoul (offptr
, &endptr
, 0);
1557 if (offptr
== endptr
)
1558 error ("Invalid download offset:%s\n", offptr
);
1562 cbdata
.load_offset
= 0;
1564 /* Open the file for loading. */
1565 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1566 if (loadfile_bfd
== NULL
)
1568 perror_with_name (filename
);
1572 /* FIXME: should be checking for errors from bfd_close (for one thing,
1573 on error it does not free all the storage associated with the
1575 make_cleanup_bfd_close (loadfile_bfd
);
1577 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1579 error ("\"%s\" is not an object file: %s", filename
,
1580 bfd_errmsg (bfd_get_error ()));
1583 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1584 (void *) &cbdata
.total_size
);
1586 start_time
= time (NULL
);
1588 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1590 end_time
= time (NULL
);
1592 entry
= bfd_get_start_address (loadfile_bfd
);
1593 ui_out_text (uiout
, "Start address ");
1594 ui_out_field_fmt (uiout
, "address", "0x%s", paddr_nz (entry
));
1595 ui_out_text (uiout
, ", load size ");
1596 ui_out_field_fmt (uiout
, "load-size", "%lu", cbdata
.data_count
);
1597 ui_out_text (uiout
, "\n");
1598 /* We were doing this in remote-mips.c, I suspect it is right
1599 for other targets too. */
1602 /* FIXME: are we supposed to call symbol_file_add or not? According
1603 to a comment from remote-mips.c (where a call to symbol_file_add
1604 was commented out), making the call confuses GDB if more than one
1605 file is loaded in. Some targets do (e.g., remote-vx.c) but
1606 others don't (or didn't - perhaphs they have all been deleted). */
1608 print_transfer_performance (gdb_stdout
, cbdata
.data_count
,
1609 cbdata
.write_count
, end_time
- start_time
);
1611 do_cleanups (old_cleanups
);
1614 /* Report how fast the transfer went. */
1616 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1617 replaced by print_transfer_performance (with a very different
1618 function signature). */
1621 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1624 print_transfer_performance (gdb_stdout
, data_count
,
1625 end_time
- start_time
, 0);
1629 print_transfer_performance (struct ui_file
*stream
,
1630 unsigned long data_count
,
1631 unsigned long write_count
,
1632 unsigned long time_count
)
1634 ui_out_text (uiout
, "Transfer rate: ");
1637 ui_out_field_fmt (uiout
, "transfer-rate", "%lu",
1638 (data_count
* 8) / time_count
);
1639 ui_out_text (uiout
, " bits/sec");
1643 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
1644 ui_out_text (uiout
, " bits in <1 sec");
1646 if (write_count
> 0)
1648 ui_out_text (uiout
, ", ");
1649 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
1650 ui_out_text (uiout
, " bytes/write");
1652 ui_out_text (uiout
, ".\n");
1655 /* This function allows the addition of incrementally linked object files.
1656 It does not modify any state in the target, only in the debugger. */
1657 /* Note: ezannoni 2000-04-13 This function/command used to have a
1658 special case syntax for the rombug target (Rombug is the boot
1659 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1660 rombug case, the user doesn't need to supply a text address,
1661 instead a call to target_link() (in target.c) would supply the
1662 value to use. We are now discontinuing this type of ad hoc syntax. */
1666 add_symbol_file_command (char *args
, int from_tty
)
1668 char *filename
= NULL
;
1669 int flags
= OBJF_USERLOADED
;
1671 int expecting_option
= 0;
1672 int section_index
= 0;
1676 int expecting_sec_name
= 0;
1677 int expecting_sec_addr
= 0;
1685 struct section_addr_info
*section_addrs
;
1686 struct sect_opt
*sect_opts
= NULL
;
1687 size_t num_sect_opts
= 0;
1688 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
1691 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
1692 * sizeof (struct sect_opt
));
1697 error ("add-symbol-file takes a file name and an address");
1699 /* Make a copy of the string that we can safely write into. */
1700 args
= xstrdup (args
);
1702 while (*args
!= '\000')
1704 /* Any leading spaces? */
1705 while (isspace (*args
))
1708 /* Point arg to the beginning of the argument. */
1711 /* Move args pointer over the argument. */
1712 while ((*args
!= '\000') && !isspace (*args
))
1715 /* If there are more arguments, terminate arg and
1717 if (*args
!= '\000')
1720 /* Now process the argument. */
1723 /* The first argument is the file name. */
1724 filename
= tilde_expand (arg
);
1725 make_cleanup (xfree
, filename
);
1730 /* The second argument is always the text address at which
1731 to load the program. */
1732 sect_opts
[section_index
].name
= ".text";
1733 sect_opts
[section_index
].value
= arg
;
1734 if (++section_index
> num_sect_opts
)
1737 sect_opts
= ((struct sect_opt
*)
1738 xrealloc (sect_opts
,
1740 * sizeof (struct sect_opt
)));
1745 /* It's an option (starting with '-') or it's an argument
1750 if (strcmp (arg
, "-mapped") == 0)
1751 flags
|= OBJF_MAPPED
;
1753 if (strcmp (arg
, "-readnow") == 0)
1754 flags
|= OBJF_READNOW
;
1756 if (strcmp (arg
, "-s") == 0)
1758 expecting_sec_name
= 1;
1759 expecting_sec_addr
= 1;
1764 if (expecting_sec_name
)
1766 sect_opts
[section_index
].name
= arg
;
1767 expecting_sec_name
= 0;
1770 if (expecting_sec_addr
)
1772 sect_opts
[section_index
].value
= arg
;
1773 expecting_sec_addr
= 0;
1774 if (++section_index
> num_sect_opts
)
1777 sect_opts
= ((struct sect_opt
*)
1778 xrealloc (sect_opts
,
1780 * sizeof (struct sect_opt
)));
1784 error ("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*");
1790 /* Print the prompt for the query below. And save the arguments into
1791 a sect_addr_info structure to be passed around to other
1792 functions. We have to split this up into separate print
1793 statements because local_hex_string returns a local static
1796 printf_filtered ("add symbol table from file \"%s\" at\n", filename
);
1797 section_addrs
= alloc_section_addr_info (section_index
);
1798 make_cleanup (xfree
, section_addrs
);
1799 for (i
= 0; i
< section_index
; i
++)
1802 char *val
= sect_opts
[i
].value
;
1803 char *sec
= sect_opts
[i
].name
;
1805 addr
= parse_and_eval_address (val
);
1807 /* Here we store the section offsets in the order they were
1808 entered on the command line. */
1809 section_addrs
->other
[sec_num
].name
= sec
;
1810 section_addrs
->other
[sec_num
].addr
= addr
;
1811 printf_filtered ("\t%s_addr = %s\n",
1813 local_hex_string ((unsigned long)addr
));
1816 /* The object's sections are initialized when a
1817 call is made to build_objfile_section_table (objfile).
1818 This happens in reread_symbols.
1819 At this point, we don't know what file type this is,
1820 so we can't determine what section names are valid. */
1823 if (from_tty
&& (!query ("%s", "")))
1824 error ("Not confirmed.");
1826 symbol_file_add (filename
, from_tty
, section_addrs
, 0, flags
);
1828 /* Getting new symbols may change our opinion about what is
1830 reinit_frame_cache ();
1831 do_cleanups (my_cleanups
);
1835 add_shared_symbol_files_command (char *args
, int from_tty
)
1837 #ifdef ADD_SHARED_SYMBOL_FILES
1838 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1840 error ("This command is not available in this configuration of GDB.");
1844 /* Re-read symbols if a symbol-file has changed. */
1846 reread_symbols (void)
1848 struct objfile
*objfile
;
1851 struct stat new_statbuf
;
1854 /* With the addition of shared libraries, this should be modified,
1855 the load time should be saved in the partial symbol tables, since
1856 different tables may come from different source files. FIXME.
1857 This routine should then walk down each partial symbol table
1858 and see if the symbol table that it originates from has been changed */
1860 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
1864 #ifdef IBM6000_TARGET
1865 /* If this object is from a shared library, then you should
1866 stat on the library name, not member name. */
1868 if (objfile
->obfd
->my_archive
)
1869 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1872 res
= stat (objfile
->name
, &new_statbuf
);
1875 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1876 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1880 new_modtime
= new_statbuf
.st_mtime
;
1881 if (new_modtime
!= objfile
->mtime
)
1883 struct cleanup
*old_cleanups
;
1884 struct section_offsets
*offsets
;
1886 char *obfd_filename
;
1888 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1891 /* There are various functions like symbol_file_add,
1892 symfile_bfd_open, syms_from_objfile, etc., which might
1893 appear to do what we want. But they have various other
1894 effects which we *don't* want. So we just do stuff
1895 ourselves. We don't worry about mapped files (for one thing,
1896 any mapped file will be out of date). */
1898 /* If we get an error, blow away this objfile (not sure if
1899 that is the correct response for things like shared
1901 old_cleanups
= make_cleanup_free_objfile (objfile
);
1902 /* We need to do this whenever any symbols go away. */
1903 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1905 /* Clean up any state BFD has sitting around. We don't need
1906 to close the descriptor but BFD lacks a way of closing the
1907 BFD without closing the descriptor. */
1908 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1909 if (!bfd_close (objfile
->obfd
))
1910 error ("Can't close BFD for %s: %s", objfile
->name
,
1911 bfd_errmsg (bfd_get_error ()));
1912 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1913 if (objfile
->obfd
== NULL
)
1914 error ("Can't open %s to read symbols.", objfile
->name
);
1915 /* bfd_openr sets cacheable to true, which is what we want. */
1916 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1917 error ("Can't read symbols from %s: %s.", objfile
->name
,
1918 bfd_errmsg (bfd_get_error ()));
1920 /* Save the offsets, we will nuke them with the rest of the
1922 num_offsets
= objfile
->num_sections
;
1923 offsets
= ((struct section_offsets
*)
1924 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
1925 memcpy (offsets
, objfile
->section_offsets
,
1926 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
1928 /* Nuke all the state that we will re-read. Much of the following
1929 code which sets things to NULL really is necessary to tell
1930 other parts of GDB that there is nothing currently there. */
1932 /* FIXME: Do we have to free a whole linked list, or is this
1934 if (objfile
->global_psymbols
.list
)
1935 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
1936 memset (&objfile
->global_psymbols
, 0,
1937 sizeof (objfile
->global_psymbols
));
1938 if (objfile
->static_psymbols
.list
)
1939 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
1940 memset (&objfile
->static_psymbols
, 0,
1941 sizeof (objfile
->static_psymbols
));
1943 /* Free the obstacks for non-reusable objfiles */
1944 bcache_xfree (objfile
->psymbol_cache
);
1945 objfile
->psymbol_cache
= bcache_xmalloc ();
1946 bcache_xfree (objfile
->macro_cache
);
1947 objfile
->macro_cache
= bcache_xmalloc ();
1948 if (objfile
->demangled_names_hash
!= NULL
)
1950 htab_delete (objfile
->demangled_names_hash
);
1951 objfile
->demangled_names_hash
= NULL
;
1953 obstack_free (&objfile
->psymbol_obstack
, 0);
1954 obstack_free (&objfile
->symbol_obstack
, 0);
1955 obstack_free (&objfile
->type_obstack
, 0);
1956 objfile
->sections
= NULL
;
1957 objfile
->symtabs
= NULL
;
1958 objfile
->psymtabs
= NULL
;
1959 objfile
->free_psymtabs
= NULL
;
1960 objfile
->msymbols
= NULL
;
1961 objfile
->sym_private
= NULL
;
1962 objfile
->minimal_symbol_count
= 0;
1963 memset (&objfile
->msymbol_hash
, 0,
1964 sizeof (objfile
->msymbol_hash
));
1965 memset (&objfile
->msymbol_demangled_hash
, 0,
1966 sizeof (objfile
->msymbol_demangled_hash
));
1967 objfile
->fundamental_types
= NULL
;
1968 if (objfile
->sf
!= NULL
)
1970 (*objfile
->sf
->sym_finish
) (objfile
);
1973 /* We never make this a mapped file. */
1975 /* obstack_specify_allocation also initializes the obstack so
1977 objfile
->psymbol_cache
= bcache_xmalloc ();
1978 objfile
->macro_cache
= bcache_xmalloc ();
1979 obstack_specify_allocation (&objfile
->psymbol_obstack
, 0, 0,
1981 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0,
1983 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0,
1985 if (build_objfile_section_table (objfile
))
1987 error ("Can't find the file sections in `%s': %s",
1988 objfile
->name
, bfd_errmsg (bfd_get_error ()));
1990 terminate_minimal_symbol_table (objfile
);
1992 /* We use the same section offsets as from last time. I'm not
1993 sure whether that is always correct for shared libraries. */
1994 objfile
->section_offsets
= (struct section_offsets
*)
1995 obstack_alloc (&objfile
->psymbol_obstack
,
1996 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
1997 memcpy (objfile
->section_offsets
, offsets
,
1998 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
1999 objfile
->num_sections
= num_offsets
;
2001 /* What the hell is sym_new_init for, anyway? The concept of
2002 distinguishing between the main file and additional files
2003 in this way seems rather dubious. */
2004 if (objfile
== symfile_objfile
)
2006 (*objfile
->sf
->sym_new_init
) (objfile
);
2008 RESET_HP_UX_GLOBALS ();
2012 (*objfile
->sf
->sym_init
) (objfile
);
2013 clear_complaints (&symfile_complaints
, 1, 1);
2014 /* The "mainline" parameter is a hideous hack; I think leaving it
2015 zero is OK since dbxread.c also does what it needs to do if
2016 objfile->global_psymbols.size is 0. */
2017 (*objfile
->sf
->sym_read
) (objfile
, 0);
2018 if (!have_partial_symbols () && !have_full_symbols ())
2021 printf_filtered ("(no debugging symbols found)\n");
2024 objfile
->flags
|= OBJF_SYMS
;
2026 /* We're done reading the symbol file; finish off complaints. */
2027 clear_complaints (&symfile_complaints
, 0, 1);
2029 /* Getting new symbols may change our opinion about what is
2032 reinit_frame_cache ();
2034 /* Discard cleanups as symbol reading was successful. */
2035 discard_cleanups (old_cleanups
);
2037 /* If the mtime has changed between the time we set new_modtime
2038 and now, we *want* this to be out of date, so don't call stat
2040 objfile
->mtime
= new_modtime
;
2042 reread_separate_symbols (objfile
);
2048 clear_symtab_users ();
2052 /* Handle separate debug info for OBJFILE, which has just been
2054 - If we had separate debug info before, but now we don't, get rid
2055 of the separated objfile.
2056 - If we didn't have separated debug info before, but now we do,
2057 read in the new separated debug info file.
2058 - If the debug link points to a different file, toss the old one
2059 and read the new one.
2060 This function does *not* handle the case where objfile is still
2061 using the same separate debug info file, but that file's timestamp
2062 has changed. That case should be handled by the loop in
2063 reread_symbols already. */
2065 reread_separate_symbols (struct objfile
*objfile
)
2068 unsigned long crc32
;
2070 /* Does the updated objfile's debug info live in a
2072 debug_file
= find_separate_debug_file (objfile
);
2074 if (objfile
->separate_debug_objfile
)
2076 /* There are two cases where we need to get rid of
2077 the old separated debug info objfile:
2078 - if the new primary objfile doesn't have
2079 separated debug info, or
2080 - if the new primary objfile has separate debug
2081 info, but it's under a different filename.
2083 If the old and new objfiles both have separate
2084 debug info, under the same filename, then we're
2085 okay --- if the separated file's contents have
2086 changed, we will have caught that when we
2087 visited it in this function's outermost
2090 || strcmp (debug_file
, objfile
->separate_debug_objfile
->name
) != 0)
2091 free_objfile (objfile
->separate_debug_objfile
);
2094 /* If the new objfile has separate debug info, and we
2095 haven't loaded it already, do so now. */
2097 && ! objfile
->separate_debug_objfile
)
2099 /* Use the same section offset table as objfile itself.
2100 Preserve the flags from objfile that make sense. */
2101 objfile
->separate_debug_objfile
2102 = (symbol_file_add_with_addrs_or_offsets
2104 info_verbose
, /* from_tty: Don't override the default. */
2105 0, /* No addr table. */
2106 objfile
->section_offsets
, objfile
->num_sections
,
2107 0, /* Not mainline. See comments about this above. */
2108 objfile
->flags
& (OBJF_MAPPED
| OBJF_REORDERED
2109 | OBJF_SHARED
| OBJF_READNOW
2110 | OBJF_USERLOADED
)));
2111 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
2127 static filename_language
*filename_language_table
;
2128 static int fl_table_size
, fl_table_next
;
2131 add_filename_language (char *ext
, enum language lang
)
2133 if (fl_table_next
>= fl_table_size
)
2135 fl_table_size
+= 10;
2136 filename_language_table
=
2137 xrealloc (filename_language_table
,
2138 fl_table_size
* sizeof (*filename_language_table
));
2141 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2142 filename_language_table
[fl_table_next
].lang
= lang
;
2146 static char *ext_args
;
2149 set_ext_lang_command (char *args
, int from_tty
)
2152 char *cp
= ext_args
;
2155 /* First arg is filename extension, starting with '.' */
2157 error ("'%s': Filename extension must begin with '.'", ext_args
);
2159 /* Find end of first arg. */
2160 while (*cp
&& !isspace (*cp
))
2164 error ("'%s': two arguments required -- filename extension and language",
2167 /* Null-terminate first arg */
2170 /* Find beginning of second arg, which should be a source language. */
2171 while (*cp
&& isspace (*cp
))
2175 error ("'%s': two arguments required -- filename extension and language",
2178 /* Lookup the language from among those we know. */
2179 lang
= language_enum (cp
);
2181 /* Now lookup the filename extension: do we already know it? */
2182 for (i
= 0; i
< fl_table_next
; i
++)
2183 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2186 if (i
>= fl_table_next
)
2188 /* new file extension */
2189 add_filename_language (ext_args
, lang
);
2193 /* redefining a previously known filename extension */
2196 /* query ("Really make files of type %s '%s'?", */
2197 /* ext_args, language_str (lang)); */
2199 xfree (filename_language_table
[i
].ext
);
2200 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2201 filename_language_table
[i
].lang
= lang
;
2206 info_ext_lang_command (char *args
, int from_tty
)
2210 printf_filtered ("Filename extensions and the languages they represent:");
2211 printf_filtered ("\n\n");
2212 for (i
= 0; i
< fl_table_next
; i
++)
2213 printf_filtered ("\t%s\t- %s\n",
2214 filename_language_table
[i
].ext
,
2215 language_str (filename_language_table
[i
].lang
));
2219 init_filename_language_table (void)
2221 if (fl_table_size
== 0) /* protect against repetition */
2225 filename_language_table
=
2226 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2227 add_filename_language (".c", language_c
);
2228 add_filename_language (".C", language_cplus
);
2229 add_filename_language (".cc", language_cplus
);
2230 add_filename_language (".cp", language_cplus
);
2231 add_filename_language (".cpp", language_cplus
);
2232 add_filename_language (".cxx", language_cplus
);
2233 add_filename_language (".c++", language_cplus
);
2234 add_filename_language (".java", language_java
);
2235 add_filename_language (".class", language_java
);
2236 add_filename_language (".m", language_objc
);
2237 add_filename_language (".f", language_fortran
);
2238 add_filename_language (".F", language_fortran
);
2239 add_filename_language (".s", language_asm
);
2240 add_filename_language (".S", language_asm
);
2241 add_filename_language (".pas", language_pascal
);
2242 add_filename_language (".p", language_pascal
);
2243 add_filename_language (".pp", language_pascal
);
2248 deduce_language_from_filename (char *filename
)
2253 if (filename
!= NULL
)
2254 if ((cp
= strrchr (filename
, '.')) != NULL
)
2255 for (i
= 0; i
< fl_table_next
; i
++)
2256 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2257 return filename_language_table
[i
].lang
;
2259 return language_unknown
;
2264 Allocate and partly initialize a new symbol table. Return a pointer
2265 to it. error() if no space.
2267 Caller must set these fields:
2273 possibly free_named_symtabs (symtab->filename);
2277 allocate_symtab (char *filename
, struct objfile
*objfile
)
2279 register struct symtab
*symtab
;
2281 symtab
= (struct symtab
*)
2282 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct symtab
));
2283 memset (symtab
, 0, sizeof (*symtab
));
2284 symtab
->filename
= obsavestring (filename
, strlen (filename
),
2285 &objfile
->symbol_obstack
);
2286 symtab
->fullname
= NULL
;
2287 symtab
->language
= deduce_language_from_filename (filename
);
2288 symtab
->debugformat
= obsavestring ("unknown", 7,
2289 &objfile
->symbol_obstack
);
2291 /* Hook it to the objfile it comes from */
2293 symtab
->objfile
= objfile
;
2294 symtab
->next
= objfile
->symtabs
;
2295 objfile
->symtabs
= symtab
;
2297 /* FIXME: This should go away. It is only defined for the Z8000,
2298 and the Z8000 definition of this macro doesn't have anything to
2299 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
2300 here for convenience. */
2301 #ifdef INIT_EXTRA_SYMTAB_INFO
2302 INIT_EXTRA_SYMTAB_INFO (symtab
);
2308 struct partial_symtab
*
2309 allocate_psymtab (char *filename
, struct objfile
*objfile
)
2311 struct partial_symtab
*psymtab
;
2313 if (objfile
->free_psymtabs
)
2315 psymtab
= objfile
->free_psymtabs
;
2316 objfile
->free_psymtabs
= psymtab
->next
;
2319 psymtab
= (struct partial_symtab
*)
2320 obstack_alloc (&objfile
->psymbol_obstack
,
2321 sizeof (struct partial_symtab
));
2323 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2324 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
2325 &objfile
->psymbol_obstack
);
2326 psymtab
->symtab
= NULL
;
2328 /* Prepend it to the psymtab list for the objfile it belongs to.
2329 Psymtabs are searched in most recent inserted -> least recent
2332 psymtab
->objfile
= objfile
;
2333 psymtab
->next
= objfile
->psymtabs
;
2334 objfile
->psymtabs
= psymtab
;
2337 struct partial_symtab
**prev_pst
;
2338 psymtab
->objfile
= objfile
;
2339 psymtab
->next
= NULL
;
2340 prev_pst
= &(objfile
->psymtabs
);
2341 while ((*prev_pst
) != NULL
)
2342 prev_pst
= &((*prev_pst
)->next
);
2343 (*prev_pst
) = psymtab
;
2351 discard_psymtab (struct partial_symtab
*pst
)
2353 struct partial_symtab
**prev_pst
;
2356 Empty psymtabs happen as a result of header files which don't
2357 have any symbols in them. There can be a lot of them. But this
2358 check is wrong, in that a psymtab with N_SLINE entries but
2359 nothing else is not empty, but we don't realize that. Fixing
2360 that without slowing things down might be tricky. */
2362 /* First, snip it out of the psymtab chain */
2364 prev_pst
= &(pst
->objfile
->psymtabs
);
2365 while ((*prev_pst
) != pst
)
2366 prev_pst
= &((*prev_pst
)->next
);
2367 (*prev_pst
) = pst
->next
;
2369 /* Next, put it on a free list for recycling */
2371 pst
->next
= pst
->objfile
->free_psymtabs
;
2372 pst
->objfile
->free_psymtabs
= pst
;
2376 /* Reset all data structures in gdb which may contain references to symbol
2380 clear_symtab_users (void)
2382 /* Someday, we should do better than this, by only blowing away
2383 the things that really need to be blown. */
2384 clear_value_history ();
2386 clear_internalvars ();
2387 breakpoint_re_set ();
2388 set_default_breakpoint (0, 0, 0, 0);
2389 clear_current_source_symtab_and_line ();
2390 clear_pc_function_cache ();
2391 if (target_new_objfile_hook
)
2392 target_new_objfile_hook (NULL
);
2396 clear_symtab_users_cleanup (void *ignore
)
2398 clear_symtab_users ();
2401 /* clear_symtab_users_once:
2403 This function is run after symbol reading, or from a cleanup.
2404 If an old symbol table was obsoleted, the old symbol table
2405 has been blown away, but the other GDB data structures that may
2406 reference it have not yet been cleared or re-directed. (The old
2407 symtab was zapped, and the cleanup queued, in free_named_symtab()
2410 This function can be queued N times as a cleanup, or called
2411 directly; it will do all the work the first time, and then will be a
2412 no-op until the next time it is queued. This works by bumping a
2413 counter at queueing time. Much later when the cleanup is run, or at
2414 the end of symbol processing (in case the cleanup is discarded), if
2415 the queued count is greater than the "done-count", we do the work
2416 and set the done-count to the queued count. If the queued count is
2417 less than or equal to the done-count, we just ignore the call. This
2418 is needed because reading a single .o file will often replace many
2419 symtabs (one per .h file, for example), and we don't want to reset
2420 the breakpoints N times in the user's face.
2422 The reason we both queue a cleanup, and call it directly after symbol
2423 reading, is because the cleanup protects us in case of errors, but is
2424 discarded if symbol reading is successful. */
2427 /* FIXME: As free_named_symtabs is currently a big noop this function
2428 is no longer needed. */
2429 static void clear_symtab_users_once (void);
2431 static int clear_symtab_users_queued
;
2432 static int clear_symtab_users_done
;
2435 clear_symtab_users_once (void)
2437 /* Enforce once-per-`do_cleanups'-semantics */
2438 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2440 clear_symtab_users_done
= clear_symtab_users_queued
;
2442 clear_symtab_users ();
2446 /* Delete the specified psymtab, and any others that reference it. */
2449 cashier_psymtab (struct partial_symtab
*pst
)
2451 struct partial_symtab
*ps
, *pprev
= NULL
;
2454 /* Find its previous psymtab in the chain */
2455 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2464 /* Unhook it from the chain. */
2465 if (ps
== pst
->objfile
->psymtabs
)
2466 pst
->objfile
->psymtabs
= ps
->next
;
2468 pprev
->next
= ps
->next
;
2470 /* FIXME, we can't conveniently deallocate the entries in the
2471 partial_symbol lists (global_psymbols/static_psymbols) that
2472 this psymtab points to. These just take up space until all
2473 the psymtabs are reclaimed. Ditto the dependencies list and
2474 filename, which are all in the psymbol_obstack. */
2476 /* We need to cashier any psymtab that has this one as a dependency... */
2478 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2480 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2482 if (ps
->dependencies
[i
] == pst
)
2484 cashier_psymtab (ps
);
2485 goto again
; /* Must restart, chain has been munged. */
2492 /* If a symtab or psymtab for filename NAME is found, free it along
2493 with any dependent breakpoints, displays, etc.
2494 Used when loading new versions of object modules with the "add-file"
2495 command. This is only called on the top-level symtab or psymtab's name;
2496 it is not called for subsidiary files such as .h files.
2498 Return value is 1 if we blew away the environment, 0 if not.
2499 FIXME. The return value appears to never be used.
2501 FIXME. I think this is not the best way to do this. We should
2502 work on being gentler to the environment while still cleaning up
2503 all stray pointers into the freed symtab. */
2506 free_named_symtabs (char *name
)
2509 /* FIXME: With the new method of each objfile having it's own
2510 psymtab list, this function needs serious rethinking. In particular,
2511 why was it ever necessary to toss psymtabs with specific compilation
2512 unit filenames, as opposed to all psymtabs from a particular symbol
2514 Well, the answer is that some systems permit reloading of particular
2515 compilation units. We want to blow away any old info about these
2516 compilation units, regardless of which objfiles they arrived in. --gnu. */
2518 register struct symtab
*s
;
2519 register struct symtab
*prev
;
2520 register struct partial_symtab
*ps
;
2521 struct blockvector
*bv
;
2524 /* We only wack things if the symbol-reload switch is set. */
2525 if (!symbol_reloading
)
2528 /* Some symbol formats have trouble providing file names... */
2529 if (name
== 0 || *name
== '\0')
2532 /* Look for a psymtab with the specified name. */
2535 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2537 if (STREQ (name
, ps
->filename
))
2539 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2540 goto again2
; /* Must restart, chain has been munged */
2544 /* Look for a symtab with the specified name. */
2546 for (s
= symtab_list
; s
; s
= s
->next
)
2548 if (STREQ (name
, s
->filename
))
2555 if (s
== symtab_list
)
2556 symtab_list
= s
->next
;
2558 prev
->next
= s
->next
;
2560 /* For now, queue a delete for all breakpoints, displays, etc., whether
2561 or not they depend on the symtab being freed. This should be
2562 changed so that only those data structures affected are deleted. */
2564 /* But don't delete anything if the symtab is empty.
2565 This test is necessary due to a bug in "dbxread.c" that
2566 causes empty symtabs to be created for N_SO symbols that
2567 contain the pathname of the object file. (This problem
2568 has been fixed in GDB 3.9x). */
2570 bv
= BLOCKVECTOR (s
);
2571 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2572 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2573 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2575 complaint (&symfile_complaints
, "Replacing old symbols for `%s'",
2577 clear_symtab_users_queued
++;
2578 make_cleanup (clear_symtab_users_once
, 0);
2583 complaint (&symfile_complaints
, "Empty symbol table found for `%s'",
2591 /* It is still possible that some breakpoints will be affected
2592 even though no symtab was found, since the file might have
2593 been compiled without debugging, and hence not be associated
2594 with a symtab. In order to handle this correctly, we would need
2595 to keep a list of text address ranges for undebuggable files.
2596 For now, we do nothing, since this is a fairly obscure case. */
2600 /* FIXME, what about the minimal symbol table? */
2607 /* Allocate and partially fill a partial symtab. It will be
2608 completely filled at the end of the symbol list.
2610 FILENAME is the name of the symbol-file we are reading from. */
2612 struct partial_symtab
*
2613 start_psymtab_common (struct objfile
*objfile
,
2614 struct section_offsets
*section_offsets
, char *filename
,
2615 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2616 struct partial_symbol
**static_syms
)
2618 struct partial_symtab
*psymtab
;
2620 psymtab
= allocate_psymtab (filename
, objfile
);
2621 psymtab
->section_offsets
= section_offsets
;
2622 psymtab
->textlow
= textlow
;
2623 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2624 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2625 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2629 /* Add a symbol with a long value to a psymtab.
2630 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
2633 add_psymbol_to_list (char *name
, int namelength
, domain_enum domain
,
2634 enum address_class
class,
2635 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2636 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2637 enum language language
, struct objfile
*objfile
)
2639 register struct partial_symbol
*psym
;
2640 char *buf
= alloca (namelength
+ 1);
2641 /* psymbol is static so that there will be no uninitialized gaps in the
2642 structure which might contain random data, causing cache misses in
2644 static struct partial_symbol psymbol
;
2646 /* Create local copy of the partial symbol */
2647 memcpy (buf
, name
, namelength
);
2648 buf
[namelength
] = '\0';
2649 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2652 SYMBOL_VALUE (&psymbol
) = val
;
2656 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2658 SYMBOL_SECTION (&psymbol
) = 0;
2659 SYMBOL_LANGUAGE (&psymbol
) = language
;
2660 PSYMBOL_DOMAIN (&psymbol
) = domain
;
2661 PSYMBOL_CLASS (&psymbol
) = class;
2663 SYMBOL_SET_NAMES (&psymbol
, buf
, namelength
, objfile
);
2665 /* Stash the partial symbol away in the cache */
2666 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), objfile
->psymbol_cache
);
2668 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2669 if (list
->next
>= list
->list
+ list
->size
)
2671 extend_psymbol_list (list
, objfile
);
2673 *list
->next
++ = psym
;
2674 OBJSTAT (objfile
, n_psyms
++);
2677 /* Add a symbol with a long value to a psymtab. This differs from
2678 * add_psymbol_to_list above in taking both a mangled and a demangled
2682 add_psymbol_with_dem_name_to_list (char *name
, int namelength
, char *dem_name
,
2683 int dem_namelength
, domain_enum domain
,
2684 enum address_class
class,
2685 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2686 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2687 enum language language
,
2688 struct objfile
*objfile
)
2690 register struct partial_symbol
*psym
;
2691 char *buf
= alloca (namelength
+ 1);
2692 /* psymbol is static so that there will be no uninitialized gaps in the
2693 structure which might contain random data, causing cache misses in
2695 static struct partial_symbol psymbol
;
2697 /* Create local copy of the partial symbol */
2699 memcpy (buf
, name
, namelength
);
2700 buf
[namelength
] = '\0';
2701 DEPRECATED_SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, objfile
->psymbol_cache
);
2703 buf
= alloca (dem_namelength
+ 1);
2704 memcpy (buf
, dem_name
, dem_namelength
);
2705 buf
[dem_namelength
] = '\0';
2710 case language_cplus
:
2711 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol
) =
2712 bcache (buf
, dem_namelength
+ 1, objfile
->psymbol_cache
);
2714 /* FIXME What should be done for the default case? Ignoring for now. */
2717 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2720 SYMBOL_VALUE (&psymbol
) = val
;
2724 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2726 SYMBOL_SECTION (&psymbol
) = 0;
2727 SYMBOL_LANGUAGE (&psymbol
) = language
;
2728 PSYMBOL_DOMAIN (&psymbol
) = domain
;
2729 PSYMBOL_CLASS (&psymbol
) = class;
2730 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2732 /* Stash the partial symbol away in the cache */
2733 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), objfile
->psymbol_cache
);
2735 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2736 if (list
->next
>= list
->list
+ list
->size
)
2738 extend_psymbol_list (list
, objfile
);
2740 *list
->next
++ = psym
;
2741 OBJSTAT (objfile
, n_psyms
++);
2744 /* Initialize storage for partial symbols. */
2747 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
2749 /* Free any previously allocated psymbol lists. */
2751 if (objfile
->global_psymbols
.list
)
2753 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
2755 if (objfile
->static_psymbols
.list
)
2757 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
2760 /* Current best guess is that approximately a twentieth
2761 of the total symbols (in a debugging file) are global or static
2764 objfile
->global_psymbols
.size
= total_symbols
/ 10;
2765 objfile
->static_psymbols
.size
= total_symbols
/ 10;
2767 if (objfile
->global_psymbols
.size
> 0)
2769 objfile
->global_psymbols
.next
=
2770 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
2771 xmmalloc (objfile
->md
, (objfile
->global_psymbols
.size
2772 * sizeof (struct partial_symbol
*)));
2774 if (objfile
->static_psymbols
.size
> 0)
2776 objfile
->static_psymbols
.next
=
2777 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
2778 xmmalloc (objfile
->md
, (objfile
->static_psymbols
.size
2779 * sizeof (struct partial_symbol
*)));
2784 The following code implements an abstraction for debugging overlay sections.
2786 The target model is as follows:
2787 1) The gnu linker will permit multiple sections to be mapped into the
2788 same VMA, each with its own unique LMA (or load address).
2789 2) It is assumed that some runtime mechanism exists for mapping the
2790 sections, one by one, from the load address into the VMA address.
2791 3) This code provides a mechanism for gdb to keep track of which
2792 sections should be considered to be mapped from the VMA to the LMA.
2793 This information is used for symbol lookup, and memory read/write.
2794 For instance, if a section has been mapped then its contents
2795 should be read from the VMA, otherwise from the LMA.
2797 Two levels of debugger support for overlays are available. One is
2798 "manual", in which the debugger relies on the user to tell it which
2799 overlays are currently mapped. This level of support is
2800 implemented entirely in the core debugger, and the information about
2801 whether a section is mapped is kept in the objfile->obj_section table.
2803 The second level of support is "automatic", and is only available if
2804 the target-specific code provides functionality to read the target's
2805 overlay mapping table, and translate its contents for the debugger
2806 (by updating the mapped state information in the obj_section tables).
2808 The interface is as follows:
2810 overlay map <name> -- tell gdb to consider this section mapped
2811 overlay unmap <name> -- tell gdb to consider this section unmapped
2812 overlay list -- list the sections that GDB thinks are mapped
2813 overlay read-target -- get the target's state of what's mapped
2814 overlay off/manual/auto -- set overlay debugging state
2815 Functional interface:
2816 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2817 section, return that section.
2818 find_pc_overlay(pc): find any overlay section that contains
2819 the pc, either in its VMA or its LMA
2820 overlay_is_mapped(sect): true if overlay is marked as mapped
2821 section_is_overlay(sect): true if section's VMA != LMA
2822 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2823 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2824 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2825 overlay_mapped_address(...): map an address from section's LMA to VMA
2826 overlay_unmapped_address(...): map an address from section's VMA to LMA
2827 symbol_overlayed_address(...): Return a "current" address for symbol:
2828 either in VMA or LMA depending on whether
2829 the symbol's section is currently mapped
2832 /* Overlay debugging state: */
2834 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2835 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
2837 /* Target vector for refreshing overlay mapped state */
2838 static void simple_overlay_update (struct obj_section
*);
2839 void (*target_overlay_update
) (struct obj_section
*) = simple_overlay_update
;
2841 /* Function: section_is_overlay (SECTION)
2842 Returns true if SECTION has VMA not equal to LMA, ie.
2843 SECTION is loaded at an address different from where it will "run". */
2846 section_is_overlay (asection
*section
)
2848 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2850 if (overlay_debugging
)
2851 if (section
&& section
->lma
!= 0 &&
2852 section
->vma
!= section
->lma
)
2858 /* Function: overlay_invalidate_all (void)
2859 Invalidate the mapped state of all overlay sections (mark it as stale). */
2862 overlay_invalidate_all (void)
2864 struct objfile
*objfile
;
2865 struct obj_section
*sect
;
2867 ALL_OBJSECTIONS (objfile
, sect
)
2868 if (section_is_overlay (sect
->the_bfd_section
))
2869 sect
->ovly_mapped
= -1;
2872 /* Function: overlay_is_mapped (SECTION)
2873 Returns true if section is an overlay, and is currently mapped.
2874 Private: public access is thru function section_is_mapped.
2876 Access to the ovly_mapped flag is restricted to this function, so
2877 that we can do automatic update. If the global flag
2878 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2879 overlay_invalidate_all. If the mapped state of the particular
2880 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2883 overlay_is_mapped (struct obj_section
*osect
)
2885 if (osect
== 0 || !section_is_overlay (osect
->the_bfd_section
))
2888 switch (overlay_debugging
)
2892 return 0; /* overlay debugging off */
2893 case ovly_auto
: /* overlay debugging automatic */
2894 /* Unles there is a target_overlay_update function,
2895 there's really nothing useful to do here (can't really go auto) */
2896 if (target_overlay_update
)
2898 if (overlay_cache_invalid
)
2900 overlay_invalidate_all ();
2901 overlay_cache_invalid
= 0;
2903 if (osect
->ovly_mapped
== -1)
2904 (*target_overlay_update
) (osect
);
2906 /* fall thru to manual case */
2907 case ovly_on
: /* overlay debugging manual */
2908 return osect
->ovly_mapped
== 1;
2912 /* Function: section_is_mapped
2913 Returns true if section is an overlay, and is currently mapped. */
2916 section_is_mapped (asection
*section
)
2918 struct objfile
*objfile
;
2919 struct obj_section
*osect
;
2921 if (overlay_debugging
)
2922 if (section
&& section_is_overlay (section
))
2923 ALL_OBJSECTIONS (objfile
, osect
)
2924 if (osect
->the_bfd_section
== section
)
2925 return overlay_is_mapped (osect
);
2930 /* Function: pc_in_unmapped_range
2931 If PC falls into the lma range of SECTION, return true, else false. */
2934 pc_in_unmapped_range (CORE_ADDR pc
, asection
*section
)
2936 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2940 if (overlay_debugging
)
2941 if (section
&& section_is_overlay (section
))
2943 size
= bfd_get_section_size_before_reloc (section
);
2944 if (section
->lma
<= pc
&& pc
< section
->lma
+ size
)
2950 /* Function: pc_in_mapped_range
2951 If PC falls into the vma range of SECTION, return true, else false. */
2954 pc_in_mapped_range (CORE_ADDR pc
, asection
*section
)
2956 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2960 if (overlay_debugging
)
2961 if (section
&& section_is_overlay (section
))
2963 size
= bfd_get_section_size_before_reloc (section
);
2964 if (section
->vma
<= pc
&& pc
< section
->vma
+ size
)
2971 /* Return true if the mapped ranges of sections A and B overlap, false
2974 sections_overlap (asection
*a
, asection
*b
)
2976 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2978 CORE_ADDR a_start
= a
->vma
;
2979 CORE_ADDR a_end
= a
->vma
+ bfd_get_section_size_before_reloc (a
);
2980 CORE_ADDR b_start
= b
->vma
;
2981 CORE_ADDR b_end
= b
->vma
+ bfd_get_section_size_before_reloc (b
);
2983 return (a_start
< b_end
&& b_start
< a_end
);
2986 /* Function: overlay_unmapped_address (PC, SECTION)
2987 Returns the address corresponding to PC in the unmapped (load) range.
2988 May be the same as PC. */
2991 overlay_unmapped_address (CORE_ADDR pc
, asection
*section
)
2993 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2995 if (overlay_debugging
)
2996 if (section
&& section_is_overlay (section
) &&
2997 pc_in_mapped_range (pc
, section
))
2998 return pc
+ section
->lma
- section
->vma
;
3003 /* Function: overlay_mapped_address (PC, SECTION)
3004 Returns the address corresponding to PC in the mapped (runtime) range.
3005 May be the same as PC. */
3008 overlay_mapped_address (CORE_ADDR pc
, asection
*section
)
3010 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3012 if (overlay_debugging
)
3013 if (section
&& section_is_overlay (section
) &&
3014 pc_in_unmapped_range (pc
, section
))
3015 return pc
+ section
->vma
- section
->lma
;
3021 /* Function: symbol_overlayed_address
3022 Return one of two addresses (relative to the VMA or to the LMA),
3023 depending on whether the section is mapped or not. */
3026 symbol_overlayed_address (CORE_ADDR address
, asection
*section
)
3028 if (overlay_debugging
)
3030 /* If the symbol has no section, just return its regular address. */
3033 /* If the symbol's section is not an overlay, just return its address */
3034 if (!section_is_overlay (section
))
3036 /* If the symbol's section is mapped, just return its address */
3037 if (section_is_mapped (section
))
3040 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3041 * then return its LOADED address rather than its vma address!!
3043 return overlay_unmapped_address (address
, section
);
3048 /* Function: find_pc_overlay (PC)
3049 Return the best-match overlay section for PC:
3050 If PC matches a mapped overlay section's VMA, return that section.
3051 Else if PC matches an unmapped section's VMA, return that section.
3052 Else if PC matches an unmapped section's LMA, return that section. */
3055 find_pc_overlay (CORE_ADDR pc
)
3057 struct objfile
*objfile
;
3058 struct obj_section
*osect
, *best_match
= NULL
;
3060 if (overlay_debugging
)
3061 ALL_OBJSECTIONS (objfile
, osect
)
3062 if (section_is_overlay (osect
->the_bfd_section
))
3064 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
))
3066 if (overlay_is_mapped (osect
))
3067 return osect
->the_bfd_section
;
3071 else if (pc_in_unmapped_range (pc
, osect
->the_bfd_section
))
3074 return best_match
? best_match
->the_bfd_section
: NULL
;
3077 /* Function: find_pc_mapped_section (PC)
3078 If PC falls into the VMA address range of an overlay section that is
3079 currently marked as MAPPED, return that section. Else return NULL. */
3082 find_pc_mapped_section (CORE_ADDR pc
)
3084 struct objfile
*objfile
;
3085 struct obj_section
*osect
;
3087 if (overlay_debugging
)
3088 ALL_OBJSECTIONS (objfile
, osect
)
3089 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
) &&
3090 overlay_is_mapped (osect
))
3091 return osect
->the_bfd_section
;
3096 /* Function: list_overlays_command
3097 Print a list of mapped sections and their PC ranges */
3100 list_overlays_command (char *args
, int from_tty
)
3103 struct objfile
*objfile
;
3104 struct obj_section
*osect
;
3106 if (overlay_debugging
)
3107 ALL_OBJSECTIONS (objfile
, osect
)
3108 if (overlay_is_mapped (osect
))
3114 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3115 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3116 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3117 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3119 printf_filtered ("Section %s, loaded at ", name
);
3120 print_address_numeric (lma
, 1, gdb_stdout
);
3121 puts_filtered (" - ");
3122 print_address_numeric (lma
+ size
, 1, gdb_stdout
);
3123 printf_filtered (", mapped at ");
3124 print_address_numeric (vma
, 1, gdb_stdout
);
3125 puts_filtered (" - ");
3126 print_address_numeric (vma
+ size
, 1, gdb_stdout
);
3127 puts_filtered ("\n");
3132 printf_filtered ("No sections are mapped.\n");
3135 /* Function: map_overlay_command
3136 Mark the named section as mapped (ie. residing at its VMA address). */
3139 map_overlay_command (char *args
, int from_tty
)
3141 struct objfile
*objfile
, *objfile2
;
3142 struct obj_section
*sec
, *sec2
;
3145 if (!overlay_debugging
)
3147 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3148 the 'overlay manual' command.");
3150 if (args
== 0 || *args
== 0)
3151 error ("Argument required: name of an overlay section");
3153 /* First, find a section matching the user supplied argument */
3154 ALL_OBJSECTIONS (objfile
, sec
)
3155 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3157 /* Now, check to see if the section is an overlay. */
3158 bfdsec
= sec
->the_bfd_section
;
3159 if (!section_is_overlay (bfdsec
))
3160 continue; /* not an overlay section */
3162 /* Mark the overlay as "mapped" */
3163 sec
->ovly_mapped
= 1;
3165 /* Next, make a pass and unmap any sections that are
3166 overlapped by this new section: */
3167 ALL_OBJSECTIONS (objfile2
, sec2
)
3168 if (sec2
->ovly_mapped
3170 && sec
->the_bfd_section
!= sec2
->the_bfd_section
3171 && sections_overlap (sec
->the_bfd_section
,
3172 sec2
->the_bfd_section
))
3175 printf_filtered ("Note: section %s unmapped by overlap\n",
3176 bfd_section_name (objfile
->obfd
,
3177 sec2
->the_bfd_section
));
3178 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3182 error ("No overlay section called %s", args
);
3185 /* Function: unmap_overlay_command
3186 Mark the overlay section as unmapped
3187 (ie. resident in its LMA address range, rather than the VMA range). */
3190 unmap_overlay_command (char *args
, int from_tty
)
3192 struct objfile
*objfile
;
3193 struct obj_section
*sec
;
3195 if (!overlay_debugging
)
3197 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3198 the 'overlay manual' command.");
3200 if (args
== 0 || *args
== 0)
3201 error ("Argument required: name of an overlay section");
3203 /* First, find a section matching the user supplied argument */
3204 ALL_OBJSECTIONS (objfile
, sec
)
3205 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3207 if (!sec
->ovly_mapped
)
3208 error ("Section %s is not mapped", args
);
3209 sec
->ovly_mapped
= 0;
3212 error ("No overlay section called %s", args
);
3215 /* Function: overlay_auto_command
3216 A utility command to turn on overlay debugging.
3217 Possibly this should be done via a set/show command. */
3220 overlay_auto_command (char *args
, int from_tty
)
3222 overlay_debugging
= ovly_auto
;
3223 enable_overlay_breakpoints ();
3225 printf_filtered ("Automatic overlay debugging enabled.");
3228 /* Function: overlay_manual_command
3229 A utility command to turn on overlay debugging.
3230 Possibly this should be done via a set/show command. */
3233 overlay_manual_command (char *args
, int from_tty
)
3235 overlay_debugging
= ovly_on
;
3236 disable_overlay_breakpoints ();
3238 printf_filtered ("Overlay debugging enabled.");
3241 /* Function: overlay_off_command
3242 A utility command to turn on overlay debugging.
3243 Possibly this should be done via a set/show command. */
3246 overlay_off_command (char *args
, int from_tty
)
3248 overlay_debugging
= ovly_off
;
3249 disable_overlay_breakpoints ();
3251 printf_filtered ("Overlay debugging disabled.");
3255 overlay_load_command (char *args
, int from_tty
)
3257 if (target_overlay_update
)
3258 (*target_overlay_update
) (NULL
);
3260 error ("This target does not know how to read its overlay state.");
3263 /* Function: overlay_command
3264 A place-holder for a mis-typed command */
3266 /* Command list chain containing all defined "overlay" subcommands. */
3267 struct cmd_list_element
*overlaylist
;
3270 overlay_command (char *args
, int from_tty
)
3273 ("\"overlay\" must be followed by the name of an overlay command.\n");
3274 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3278 /* Target Overlays for the "Simplest" overlay manager:
3280 This is GDB's default target overlay layer. It works with the
3281 minimal overlay manager supplied as an example by Cygnus. The
3282 entry point is via a function pointer "target_overlay_update",
3283 so targets that use a different runtime overlay manager can
3284 substitute their own overlay_update function and take over the
3287 The overlay_update function pokes around in the target's data structures
3288 to see what overlays are mapped, and updates GDB's overlay mapping with
3291 In this simple implementation, the target data structures are as follows:
3292 unsigned _novlys; /# number of overlay sections #/
3293 unsigned _ovly_table[_novlys][4] = {
3294 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3295 {..., ..., ..., ...},
3297 unsigned _novly_regions; /# number of overlay regions #/
3298 unsigned _ovly_region_table[_novly_regions][3] = {
3299 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3302 These functions will attempt to update GDB's mappedness state in the
3303 symbol section table, based on the target's mappedness state.
3305 To do this, we keep a cached copy of the target's _ovly_table, and
3306 attempt to detect when the cached copy is invalidated. The main
3307 entry point is "simple_overlay_update(SECT), which looks up SECT in
3308 the cached table and re-reads only the entry for that section from
3309 the target (whenever possible).
3312 /* Cached, dynamically allocated copies of the target data structures: */
3313 static unsigned (*cache_ovly_table
)[4] = 0;
3315 static unsigned (*cache_ovly_region_table
)[3] = 0;
3317 static unsigned cache_novlys
= 0;
3319 static unsigned cache_novly_regions
= 0;
3321 static CORE_ADDR cache_ovly_table_base
= 0;
3323 static CORE_ADDR cache_ovly_region_table_base
= 0;
3327 VMA
, SIZE
, LMA
, MAPPED
3329 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
3331 /* Throw away the cached copy of _ovly_table */
3333 simple_free_overlay_table (void)
3335 if (cache_ovly_table
)
3336 xfree (cache_ovly_table
);
3338 cache_ovly_table
= NULL
;
3339 cache_ovly_table_base
= 0;
3343 /* Throw away the cached copy of _ovly_region_table */
3345 simple_free_overlay_region_table (void)
3347 if (cache_ovly_region_table
)
3348 xfree (cache_ovly_region_table
);
3349 cache_novly_regions
= 0;
3350 cache_ovly_region_table
= NULL
;
3351 cache_ovly_region_table_base
= 0;
3355 /* Read an array of ints from the target into a local buffer.
3356 Convert to host order. int LEN is number of ints */
3358 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
, int len
)
3360 /* FIXME (alloca): Not safe if array is very large. */
3361 char *buf
= alloca (len
* TARGET_LONG_BYTES
);
3364 read_memory (memaddr
, buf
, len
* TARGET_LONG_BYTES
);
3365 for (i
= 0; i
< len
; i
++)
3366 myaddr
[i
] = extract_unsigned_integer (TARGET_LONG_BYTES
* i
+ buf
,
3370 /* Find and grab a copy of the target _ovly_table
3371 (and _novlys, which is needed for the table's size) */
3373 simple_read_overlay_table (void)
3375 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3377 simple_free_overlay_table ();
3378 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3381 error ("Error reading inferior's overlay table: "
3382 "couldn't find `_novlys' variable\n"
3383 "in inferior. Use `overlay manual' mode.");
3387 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3388 if (! ovly_table_msym
)
3390 error ("Error reading inferior's overlay table: couldn't find "
3391 "`_ovly_table' array\n"
3392 "in inferior. Use `overlay manual' mode.");
3396 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
), 4);
3398 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3399 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3400 read_target_long_array (cache_ovly_table_base
,
3401 (int *) cache_ovly_table
,
3404 return 1; /* SUCCESS */
3408 /* Find and grab a copy of the target _ovly_region_table
3409 (and _novly_regions, which is needed for the table's size) */
3411 simple_read_overlay_region_table (void)
3413 struct minimal_symbol
*msym
;
3415 simple_free_overlay_region_table ();
3416 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3418 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
3420 return 0; /* failure */
3421 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3422 if (cache_ovly_region_table
!= NULL
)
3424 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3427 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3428 read_target_long_array (cache_ovly_region_table_base
,
3429 (int *) cache_ovly_region_table
,
3430 cache_novly_regions
* 3);
3433 return 0; /* failure */
3436 return 0; /* failure */
3437 return 1; /* SUCCESS */
3441 /* Function: simple_overlay_update_1
3442 A helper function for simple_overlay_update. Assuming a cached copy
3443 of _ovly_table exists, look through it to find an entry whose vma,
3444 lma and size match those of OSECT. Re-read the entry and make sure
3445 it still matches OSECT (else the table may no longer be valid).
3446 Set OSECT's mapped state to match the entry. Return: 1 for
3447 success, 0 for failure. */
3450 simple_overlay_update_1 (struct obj_section
*osect
)
3453 bfd
*obfd
= osect
->objfile
->obfd
;
3454 asection
*bsect
= osect
->the_bfd_section
;
3456 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3457 for (i
= 0; i
< cache_novlys
; i
++)
3458 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3459 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3460 /* && cache_ovly_table[i][SIZE] == size */ )
3462 read_target_long_array (cache_ovly_table_base
+ i
* TARGET_LONG_BYTES
,
3463 (int *) cache_ovly_table
[i
], 4);
3464 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3465 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3466 /* && cache_ovly_table[i][SIZE] == size */ )
3468 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3471 else /* Warning! Warning! Target's ovly table has changed! */
3477 /* Function: simple_overlay_update
3478 If OSECT is NULL, then update all sections' mapped state
3479 (after re-reading the entire target _ovly_table).
3480 If OSECT is non-NULL, then try to find a matching entry in the
3481 cached ovly_table and update only OSECT's mapped state.
3482 If a cached entry can't be found or the cache isn't valid, then
3483 re-read the entire cache, and go ahead and update all sections. */
3486 simple_overlay_update (struct obj_section
*osect
)
3488 struct objfile
*objfile
;
3490 /* Were we given an osect to look up? NULL means do all of them. */
3492 /* Have we got a cached copy of the target's overlay table? */
3493 if (cache_ovly_table
!= NULL
)
3494 /* Does its cached location match what's currently in the symtab? */
3495 if (cache_ovly_table_base
==
3496 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3497 /* Then go ahead and try to look up this single section in the cache */
3498 if (simple_overlay_update_1 (osect
))
3499 /* Found it! We're done. */
3502 /* Cached table no good: need to read the entire table anew.
3503 Or else we want all the sections, in which case it's actually
3504 more efficient to read the whole table in one block anyway. */
3506 if (! simple_read_overlay_table ())
3509 /* Now may as well update all sections, even if only one was requested. */
3510 ALL_OBJSECTIONS (objfile
, osect
)
3511 if (section_is_overlay (osect
->the_bfd_section
))
3514 bfd
*obfd
= osect
->objfile
->obfd
;
3515 asection
*bsect
= osect
->the_bfd_section
;
3517 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3518 for (i
= 0; i
< cache_novlys
; i
++)
3519 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3520 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3521 /* && cache_ovly_table[i][SIZE] == size */ )
3522 { /* obj_section matches i'th entry in ovly_table */
3523 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3524 break; /* finished with inner for loop: break out */
3529 /* Set the output sections and output offsets for section SECTP in
3530 ABFD. The relocation code in BFD will read these offsets, so we
3531 need to be sure they're initialized. We map each section to itself,
3532 with no offset; this means that SECTP->vma will be honored. */
3535 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3537 sectp
->output_section
= sectp
;
3538 sectp
->output_offset
= 0;
3541 /* Relocate the contents of a debug section SECTP in ABFD. The
3542 contents are stored in BUF if it is non-NULL, or returned in a
3543 malloc'd buffer otherwise.
3545 For some platforms and debug info formats, shared libraries contain
3546 relocations against the debug sections (particularly for DWARF-2;
3547 one affected platform is PowerPC GNU/Linux, although it depends on
3548 the version of the linker in use). Also, ELF object files naturally
3549 have unresolved relocations for their debug sections. We need to apply
3550 the relocations in order to get the locations of symbols correct. */
3553 symfile_relocate_debug_section (bfd
*abfd
, asection
*sectp
, bfd_byte
*buf
)
3555 /* We're only interested in debugging sections with relocation
3557 if ((sectp
->flags
& SEC_RELOC
) == 0)
3559 if ((sectp
->flags
& SEC_DEBUGGING
) == 0)
3562 /* We will handle section offsets properly elsewhere, so relocate as if
3563 all sections begin at 0. */
3564 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3566 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3570 _initialize_symfile (void)
3572 struct cmd_list_element
*c
;
3574 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
3575 "Load symbol table from executable file FILE.\n\
3576 The `file' command can also load symbol tables, as well as setting the file\n\
3577 to execute.", &cmdlist
);
3578 set_cmd_completer (c
, filename_completer
);
3580 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
3581 "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3582 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
3583 ADDR is the starting address of the file's text.\n\
3584 The optional arguments are section-name section-address pairs and\n\
3585 should be specified if the data and bss segments are not contiguous\n\
3586 with the text. SECT is a section name to be loaded at SECT_ADDR.",
3588 set_cmd_completer (c
, filename_completer
);
3590 c
= add_cmd ("add-shared-symbol-files", class_files
,
3591 add_shared_symbol_files_command
,
3592 "Load the symbols from shared objects in the dynamic linker's link map.",
3594 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
3597 c
= add_cmd ("load", class_files
, load_command
,
3598 "Dynamically load FILE into the running program, and record its symbols\n\
3599 for access from GDB.", &cmdlist
);
3600 set_cmd_completer (c
, filename_completer
);
3603 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
3604 (char *) &symbol_reloading
,
3605 "Set dynamic symbol table reloading multiple times in one run.",
3609 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3610 "Commands for debugging overlays.", &overlaylist
,
3611 "overlay ", 0, &cmdlist
);
3613 add_com_alias ("ovly", "overlay", class_alias
, 1);
3614 add_com_alias ("ov", "overlay", class_alias
, 1);
3616 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3617 "Assert that an overlay section is mapped.", &overlaylist
);
3619 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3620 "Assert that an overlay section is unmapped.", &overlaylist
);
3622 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3623 "List mappings of overlay sections.", &overlaylist
);
3625 add_cmd ("manual", class_support
, overlay_manual_command
,
3626 "Enable overlay debugging.", &overlaylist
);
3627 add_cmd ("off", class_support
, overlay_off_command
,
3628 "Disable overlay debugging.", &overlaylist
);
3629 add_cmd ("auto", class_support
, overlay_auto_command
,
3630 "Enable automatic overlay debugging.", &overlaylist
);
3631 add_cmd ("load-target", class_support
, overlay_load_command
,
3632 "Read the overlay mapping state from the target.", &overlaylist
);
3634 /* Filename extension to source language lookup table: */
3635 init_filename_language_table ();
3636 c
= add_set_cmd ("extension-language", class_files
, var_string_noescape
,
3638 "Set mapping between filename extension and source language.\n\
3639 Usage: set extension-language .foo bar",
3641 set_cmd_cfunc (c
, set_ext_lang_command
);
3643 add_info ("extensions", info_ext_lang_command
,
3644 "All filename extensions associated with a source language.");
3647 (add_set_cmd ("download-write-size", class_obscure
,
3648 var_integer
, (char *) &download_write_size
,
3649 "Set the write size used when downloading a program.\n"
3650 "Only used when downloading a program onto a remote\n"
3651 "target. Specify zero, or a negative value, to disable\n"
3652 "blocked writes. The actual size of each transfer is also\n"
3653 "limited by the size of the target packet and the memory\n"
3658 debug_file_directory
= xstrdup (DEBUGDIR
);
3660 ("debug-file-directory", class_support
, var_string
,
3661 (char *) &debug_file_directory
,
3662 "Set the directory where separate debug symbols are searched for.\n"
3663 "Separate debug symbols are first searched for in the same\n"
3664 "directory as the binary, then in the `" DEBUG_SUBDIRECTORY
3666 "and lastly at the path of the directory of the binary with\n"
3667 "the global debug-file directory prepended\n",
3669 add_show_from_set (c
, &showlist
);
3670 set_cmd_completer (c
, filename_completer
);