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"
47 #include <readline/readline.h>
48 #include "gdb_assert.h"
50 #include <sys/types.h>
52 #include "gdb_string.h"
63 /* Some HP-UX related globals to clear when a new "main"
64 symbol file is loaded. HP-specific. */
66 extern int hp_som_som_object_present
;
67 extern int hp_cxx_exception_support_initialized
;
68 #define RESET_HP_UX_GLOBALS() do {\
69 hp_som_som_object_present = 0; /* indicates HP-compiled code */ \
70 hp_cxx_exception_support_initialized = 0; /* must reinitialize exception stuff */ \
74 int (*ui_load_progress_hook
) (const char *section
, unsigned long num
);
75 void (*show_load_progress
) (const char *section
,
76 unsigned long section_sent
,
77 unsigned long section_size
,
78 unsigned long total_sent
,
79 unsigned long total_size
);
80 void (*pre_add_symbol_hook
) (char *);
81 void (*post_add_symbol_hook
) (void);
82 void (*target_new_objfile_hook
) (struct objfile
*);
84 static void clear_symtab_users_cleanup (void *ignore
);
86 /* Global variables owned by this file */
87 int readnow_symbol_files
; /* Read full symbols immediately */
89 /* External variables and functions referenced. */
91 extern void report_transfer_performance (unsigned long, time_t, time_t);
93 /* Functions this file defines */
96 static int simple_read_overlay_region_table (void);
97 static void simple_free_overlay_region_table (void);
100 static void set_initial_language (void);
102 static void load_command (char *, int);
104 static void symbol_file_add_main_1 (char *args
, int from_tty
, int flags
);
106 static void add_symbol_file_command (char *, int);
108 static void add_shared_symbol_files_command (char *, int);
110 static void reread_separate_symbols (struct objfile
*objfile
);
112 static void cashier_psymtab (struct partial_symtab
*);
114 bfd
*symfile_bfd_open (char *);
116 int get_section_index (struct objfile
*, char *);
118 static void find_sym_fns (struct objfile
*);
120 static void decrement_reading_symtab (void *);
122 static void overlay_invalidate_all (void);
124 static int overlay_is_mapped (struct obj_section
*);
126 void list_overlays_command (char *, int);
128 void map_overlay_command (char *, int);
130 void unmap_overlay_command (char *, int);
132 static void overlay_auto_command (char *, int);
134 static void overlay_manual_command (char *, int);
136 static void overlay_off_command (char *, int);
138 static void overlay_load_command (char *, int);
140 static void overlay_command (char *, int);
142 static void simple_free_overlay_table (void);
144 static void read_target_long_array (CORE_ADDR
, unsigned int *, int);
146 static int simple_read_overlay_table (void);
148 static int simple_overlay_update_1 (struct obj_section
*);
150 static void add_filename_language (char *ext
, enum language lang
);
152 static void set_ext_lang_command (char *args
, int from_tty
);
154 static void info_ext_lang_command (char *args
, int from_tty
);
156 static char *find_separate_debug_file (struct objfile
*objfile
);
158 static void init_filename_language_table (void);
160 void _initialize_symfile (void);
162 /* List of all available sym_fns. On gdb startup, each object file reader
163 calls add_symtab_fns() to register information on each format it is
166 static struct sym_fns
*symtab_fns
= NULL
;
168 /* Flag for whether user will be reloading symbols multiple times.
169 Defaults to ON for VxWorks, otherwise OFF. */
171 #ifdef SYMBOL_RELOADING_DEFAULT
172 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
174 int symbol_reloading
= 0;
177 /* If non-zero, shared library symbols will be added automatically
178 when the inferior is created, new libraries are loaded, or when
179 attaching to the inferior. This is almost always what users will
180 want to have happen; but for very large programs, the startup time
181 will be excessive, and so if this is a problem, the user can clear
182 this flag and then add the shared library symbols as needed. Note
183 that there is a potential for confusion, since if the shared
184 library symbols are not loaded, commands like "info fun" will *not*
185 report all the functions that are actually present. */
187 int auto_solib_add
= 1;
189 /* For systems that support it, a threshold size in megabytes. If
190 automatically adding a new library's symbol table to those already
191 known to the debugger would cause the total shared library symbol
192 size to exceed this threshhold, then the shlib's symbols are not
193 added. The threshold is ignored if the user explicitly asks for a
194 shlib to be added, such as when using the "sharedlibrary"
197 int auto_solib_limit
;
200 /* Since this function is called from within qsort, in an ANSI environment
201 it must conform to the prototype for qsort, which specifies that the
202 comparison function takes two "void *" pointers. */
205 compare_symbols (const void *s1p
, const void *s2p
)
207 register struct symbol
**s1
, **s2
;
209 s1
= (struct symbol
**) s1p
;
210 s2
= (struct symbol
**) s2p
;
211 return (strcmp (SYMBOL_SOURCE_NAME (*s1
), SYMBOL_SOURCE_NAME (*s2
)));
218 compare_psymbols -- compare two partial symbols by name
222 Given pointers to pointers to two partial symbol table entries,
223 compare them by name and return -N, 0, or +N (ala strcmp).
224 Typically used by sorting routines like qsort().
228 Does direct compare of first two characters before punting
229 and passing to strcmp for longer compares. Note that the
230 original version had a bug whereby two null strings or two
231 identically named one character strings would return the
232 comparison of memory following the null byte.
237 compare_psymbols (const void *s1p
, const void *s2p
)
239 register struct partial_symbol
**s1
, **s2
;
240 register char *st1
, *st2
;
242 s1
= (struct partial_symbol
**) s1p
;
243 s2
= (struct partial_symbol
**) s2p
;
244 st1
= SYMBOL_SOURCE_NAME (*s1
);
245 st2
= SYMBOL_SOURCE_NAME (*s2
);
248 if ((st1
[0] - st2
[0]) || !st1
[0])
250 return (st1
[0] - st2
[0]);
252 else if ((st1
[1] - st2
[1]) || !st1
[1])
254 return (st1
[1] - st2
[1]);
258 return (strcmp (st1
, st2
));
263 sort_pst_symbols (struct partial_symtab
*pst
)
265 /* Sort the global list; don't sort the static list */
267 qsort (pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
,
268 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
272 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
275 sort_block_syms (register struct block
*b
)
277 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
278 sizeof (struct symbol
*), compare_symbols
);
281 /* Call sort_symtab_syms to sort alphabetically
282 the symbols of each block of one symtab. */
285 sort_symtab_syms (register struct symtab
*s
)
287 register struct blockvector
*bv
;
290 register struct block
*b
;
294 bv
= BLOCKVECTOR (s
);
295 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
296 for (i
= 0; i
< nbl
; i
++)
298 b
= BLOCKVECTOR_BLOCK (bv
, i
);
299 if (BLOCK_SHOULD_SORT (b
))
304 /* Make a null terminated copy of the string at PTR with SIZE characters in
305 the obstack pointed to by OBSTACKP . Returns the address of the copy.
306 Note that the string at PTR does not have to be null terminated, I.E. it
307 may be part of a larger string and we are only saving a substring. */
310 obsavestring (const char *ptr
, int size
, struct obstack
*obstackp
)
312 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
313 /* Open-coded memcpy--saves function call time. These strings are usually
314 short. FIXME: Is this really still true with a compiler that can
317 register const char *p1
= ptr
;
318 register char *p2
= p
;
319 const char *end
= ptr
+ size
;
327 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
328 in the obstack pointed to by OBSTACKP. */
331 obconcat (struct obstack
*obstackp
, const char *s1
, const char *s2
,
334 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
335 register char *val
= (char *) obstack_alloc (obstackp
, len
);
342 /* True if we are nested inside psymtab_to_symtab. */
344 int currently_reading_symtab
= 0;
347 decrement_reading_symtab (void *dummy
)
349 currently_reading_symtab
--;
352 /* Get the symbol table that corresponds to a partial_symtab.
353 This is fast after the first time you do it. In fact, there
354 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
358 psymtab_to_symtab (register struct partial_symtab
*pst
)
360 /* If it's been looked up before, return it. */
364 /* If it has not yet been read in, read it. */
367 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
368 currently_reading_symtab
++;
369 (*pst
->read_symtab
) (pst
);
370 do_cleanups (back_to
);
376 /* Initialize entry point information for this objfile. */
379 init_entry_point_info (struct objfile
*objfile
)
381 /* Save startup file's range of PC addresses to help blockframe.c
382 decide where the bottom of the stack is. */
384 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
386 /* Executable file -- record its entry point so we'll recognize
387 the startup file because it contains the entry point. */
388 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
392 /* Examination of non-executable.o files. Short-circuit this stuff. */
393 objfile
->ei
.entry_point
= INVALID_ENTRY_POINT
;
395 objfile
->ei
.entry_file_lowpc
= INVALID_ENTRY_LOWPC
;
396 objfile
->ei
.entry_file_highpc
= INVALID_ENTRY_HIGHPC
;
397 objfile
->ei
.entry_func_lowpc
= INVALID_ENTRY_LOWPC
;
398 objfile
->ei
.entry_func_highpc
= INVALID_ENTRY_HIGHPC
;
399 objfile
->ei
.main_func_lowpc
= INVALID_ENTRY_LOWPC
;
400 objfile
->ei
.main_func_highpc
= INVALID_ENTRY_HIGHPC
;
403 /* Get current entry point address. */
406 entry_point_address (void)
408 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
411 /* Remember the lowest-addressed loadable section we've seen.
412 This function is called via bfd_map_over_sections.
414 In case of equal vmas, the section with the largest size becomes the
415 lowest-addressed loadable section.
417 If the vmas and sizes are equal, the last section is considered the
418 lowest-addressed loadable section. */
421 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
423 asection
**lowest
= (asection
**) obj
;
425 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
428 *lowest
= sect
; /* First loadable section */
429 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
430 *lowest
= sect
; /* A lower loadable section */
431 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
432 && (bfd_section_size (abfd
, (*lowest
))
433 <= bfd_section_size (abfd
, sect
)))
438 /* Build (allocate and populate) a section_addr_info struct from
439 an existing section table. */
441 extern struct section_addr_info
*
442 build_section_addr_info_from_section_table (const struct section_table
*start
,
443 const struct section_table
*end
)
445 struct section_addr_info
*sap
;
446 const struct section_table
*stp
;
449 sap
= xmalloc (sizeof (struct section_addr_info
));
450 memset (sap
, 0, sizeof (struct section_addr_info
));
452 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
454 if (bfd_get_section_flags (stp
->bfd
,
455 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
456 && oidx
< MAX_SECTIONS
)
458 sap
->other
[oidx
].addr
= stp
->addr
;
459 sap
->other
[oidx
].name
460 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
461 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
470 /* Free all memory allocated by build_section_addr_info_from_section_table. */
473 free_section_addr_info (struct section_addr_info
*sap
)
477 for (idx
= 0; idx
< MAX_SECTIONS
; idx
++)
478 if (sap
->other
[idx
].name
)
479 xfree (sap
->other
[idx
].name
);
484 /* Initialize OBJFILE's sect_index_* members. */
486 init_objfile_sect_indices (struct objfile
*objfile
)
491 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
493 objfile
->sect_index_text
= sect
->index
;
495 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
497 objfile
->sect_index_data
= sect
->index
;
499 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
501 objfile
->sect_index_bss
= sect
->index
;
503 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
505 objfile
->sect_index_rodata
= sect
->index
;
507 /* This is where things get really weird... We MUST have valid
508 indices for the various sect_index_* members or gdb will abort.
509 So if for example, there is no ".text" section, we have to
510 accomodate that. Except when explicitly adding symbol files at
511 some address, section_offsets contains nothing but zeros, so it
512 doesn't matter which slot in section_offsets the individual
513 sect_index_* members index into. So if they are all zero, it is
514 safe to just point all the currently uninitialized indices to the
517 for (i
= 0; i
< objfile
->num_sections
; i
++)
519 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
524 if (i
== objfile
->num_sections
)
526 if (objfile
->sect_index_text
== -1)
527 objfile
->sect_index_text
= 0;
528 if (objfile
->sect_index_data
== -1)
529 objfile
->sect_index_data
= 0;
530 if (objfile
->sect_index_bss
== -1)
531 objfile
->sect_index_bss
= 0;
532 if (objfile
->sect_index_rodata
== -1)
533 objfile
->sect_index_rodata
= 0;
538 /* Parse the user's idea of an offset for dynamic linking, into our idea
539 of how to represent it for fast symbol reading. This is the default
540 version of the sym_fns.sym_offsets function for symbol readers that
541 don't need to do anything special. It allocates a section_offsets table
542 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
545 default_symfile_offsets (struct objfile
*objfile
,
546 struct section_addr_info
*addrs
)
550 objfile
->num_sections
= SECT_OFF_MAX
;
551 objfile
->section_offsets
= (struct section_offsets
*)
552 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
553 memset (objfile
->section_offsets
, 0, SIZEOF_SECTION_OFFSETS
);
555 /* Now calculate offsets for section that were specified by the
557 for (i
= 0; i
< MAX_SECTIONS
&& addrs
->other
[i
].name
; i
++)
559 struct other_sections
*osp
;
561 osp
= &addrs
->other
[i
] ;
565 /* Record all sections in offsets */
566 /* The section_offsets in the objfile are here filled in using
568 (objfile
->section_offsets
)->offsets
[osp
->sectindex
] = osp
->addr
;
571 /* Remember the bfd indexes for the .text, .data, .bss and
573 init_objfile_sect_indices (objfile
);
577 /* Process a symbol file, as either the main file or as a dynamically
580 OBJFILE is where the symbols are to be read from.
582 ADDRS is the list of section load addresses. If the user has given
583 an 'add-symbol-file' command, then this is the list of offsets and
584 addresses he or she provided as arguments to the command; or, if
585 we're handling a shared library, these are the actual addresses the
586 sections are loaded at, according to the inferior's dynamic linker
587 (as gleaned by GDB's shared library code). We convert each address
588 into an offset from the section VMA's as it appears in the object
589 file, and then call the file's sym_offsets function to convert this
590 into a format-specific offset table --- a `struct section_offsets'.
591 If ADDRS is non-zero, OFFSETS must be zero.
593 OFFSETS is a table of section offsets already in the right
594 format-specific representation. NUM_OFFSETS is the number of
595 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
596 assume this is the proper table the call to sym_offsets described
597 above would produce. Instead of calling sym_offsets, we just dump
598 it right into objfile->section_offsets. (When we're re-reading
599 symbols from an objfile, we don't have the original load address
600 list any more; all we have is the section offset table.) If
601 OFFSETS is non-zero, ADDRS must be zero.
603 MAINLINE is nonzero if this is the main symbol file, or zero if
604 it's an extra symbol file such as dynamically loaded code.
606 VERBO is nonzero if the caller has printed a verbose message about
607 the symbol reading (and complaints can be more terse about it). */
610 syms_from_objfile (struct objfile
*objfile
,
611 struct section_addr_info
*addrs
,
612 struct section_offsets
*offsets
,
617 asection
*lower_sect
;
619 CORE_ADDR lower_offset
;
620 struct section_addr_info local_addr
;
621 struct cleanup
*old_chain
;
624 gdb_assert (! (addrs
&& offsets
));
626 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
627 list. We now establish the convention that an addr of zero means
628 no load address was specified. */
629 if (! addrs
&& ! offsets
)
631 memset (&local_addr
, 0, sizeof (local_addr
));
635 /* Now either addrs or offsets is non-zero. */
637 init_entry_point_info (objfile
);
638 find_sym_fns (objfile
);
640 if (objfile
->sf
== NULL
)
641 return; /* No symbols. */
643 /* Make sure that partially constructed symbol tables will be cleaned up
644 if an error occurs during symbol reading. */
645 old_chain
= make_cleanup_free_objfile (objfile
);
649 /* We will modify the main symbol table, make sure that all its users
650 will be cleaned up if an error occurs during symbol reading. */
651 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
653 /* Since no error yet, throw away the old symbol table. */
655 if (symfile_objfile
!= NULL
)
657 free_objfile (symfile_objfile
);
658 symfile_objfile
= NULL
;
661 /* Currently we keep symbols from the add-symbol-file command.
662 If the user wants to get rid of them, they should do "symbol-file"
663 without arguments first. Not sure this is the best behavior
666 (*objfile
->sf
->sym_new_init
) (objfile
);
669 /* Convert addr into an offset rather than an absolute address.
670 We find the lowest address of a loaded segment in the objfile,
671 and assume that <addr> is where that got loaded.
673 We no longer warn if the lowest section is not a text segment (as
674 happens for the PA64 port. */
677 /* Find lowest loadable section to be used as starting point for
678 continguous sections. FIXME!! won't work without call to find
679 .text first, but this assumes text is lowest section. */
680 lower_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
681 if (lower_sect
== NULL
)
682 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
684 if (lower_sect
== NULL
)
685 warning ("no loadable sections found in added symbol-file %s",
688 if ((bfd_get_section_flags (objfile
->obfd
, lower_sect
) & SEC_CODE
) == 0)
689 warning ("Lowest section in %s is %s at %s",
691 bfd_section_name (objfile
->obfd
, lower_sect
),
692 paddr (bfd_section_vma (objfile
->obfd
, lower_sect
)));
693 if (lower_sect
!= NULL
)
694 lower_offset
= bfd_section_vma (objfile
->obfd
, lower_sect
);
698 /* Calculate offsets for the loadable sections.
699 FIXME! Sections must be in order of increasing loadable section
700 so that contiguous sections can use the lower-offset!!!
702 Adjust offsets if the segments are not contiguous.
703 If the section is contiguous, its offset should be set to
704 the offset of the highest loadable section lower than it
705 (the loadable section directly below it in memory).
706 this_offset = lower_offset = lower_addr - lower_orig_addr */
708 /* Calculate offsets for sections. */
710 for (i
=0 ; i
< MAX_SECTIONS
&& addrs
->other
[i
].name
; i
++)
712 if (addrs
->other
[i
].addr
!= 0)
714 sect
= bfd_get_section_by_name (objfile
->obfd
,
715 addrs
->other
[i
].name
);
719 -= bfd_section_vma (objfile
->obfd
, sect
);
720 lower_offset
= addrs
->other
[i
].addr
;
721 /* This is the index used by BFD. */
722 addrs
->other
[i
].sectindex
= sect
->index
;
726 warning ("section %s not found in %s",
727 addrs
->other
[i
].name
,
729 addrs
->other
[i
].addr
= 0;
733 addrs
->other
[i
].addr
= lower_offset
;
737 /* Initialize symbol reading routines for this objfile, allow complaints to
738 appear for this new file, and record how verbose to be, then do the
739 initial symbol reading for this file. */
741 (*objfile
->sf
->sym_init
) (objfile
);
742 clear_complaints (&symfile_complaints
, 1, verbo
);
745 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
748 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
750 /* Just copy in the offset table directly as given to us. */
751 objfile
->num_sections
= num_offsets
;
752 objfile
->section_offsets
753 = ((struct section_offsets
*)
754 obstack_alloc (&objfile
->psymbol_obstack
, size
));
755 memcpy (objfile
->section_offsets
, offsets
, size
);
757 init_objfile_sect_indices (objfile
);
760 #ifndef IBM6000_TARGET
761 /* This is a SVR4/SunOS specific hack, I think. In any event, it
762 screws RS/6000. sym_offsets should be doing this sort of thing,
763 because it knows the mapping between bfd sections and
765 /* This is a hack. As far as I can tell, section offsets are not
766 target dependent. They are all set to addr with a couple of
767 exceptions. The exceptions are sysvr4 shared libraries, whose
768 offsets are kept in solib structures anyway and rs6000 xcoff
769 which handles shared libraries in a completely unique way.
771 Section offsets are built similarly, except that they are built
772 by adding addr in all cases because there is no clear mapping
773 from section_offsets into actual sections. Note that solib.c
774 has a different algorithm for finding section offsets.
776 These should probably all be collapsed into some target
777 independent form of shared library support. FIXME. */
781 struct obj_section
*s
;
783 /* Map section offsets in "addr" back to the object's
784 sections by comparing the section names with bfd's
785 section names. Then adjust the section address by
786 the offset. */ /* for gdb/13815 */
788 ALL_OBJFILE_OSECTIONS (objfile
, s
)
790 CORE_ADDR s_addr
= 0;
794 !s_addr
&& i
< MAX_SECTIONS
&& addrs
->other
[i
].name
;
796 if (strcmp (bfd_section_name (s
->objfile
->obfd
,
798 addrs
->other
[i
].name
) == 0)
799 s_addr
= addrs
->other
[i
].addr
; /* end added for gdb/13815 */
801 s
->addr
-= s
->offset
;
803 s
->endaddr
-= s
->offset
;
804 s
->endaddr
+= s_addr
;
808 #endif /* not IBM6000_TARGET */
810 (*objfile
->sf
->sym_read
) (objfile
, mainline
);
812 /* Don't allow char * to have a typename (else would get caddr_t).
813 Ditto void *. FIXME: Check whether this is now done by all the
814 symbol readers themselves (many of them now do), and if so remove
817 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
818 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
820 /* Mark the objfile has having had initial symbol read attempted. Note
821 that this does not mean we found any symbols... */
823 objfile
->flags
|= OBJF_SYMS
;
825 /* Discard cleanups as symbol reading was successful. */
827 discard_cleanups (old_chain
);
829 /* Call this after reading in a new symbol table to give target
830 dependent code a crack at the new symbols. For instance, this
831 could be used to update the values of target-specific symbols GDB
832 needs to keep track of (such as _sigtramp, or whatever). */
834 TARGET_SYMFILE_POSTREAD (objfile
);
837 /* Perform required actions after either reading in the initial
838 symbols for a new objfile, or mapping in the symbols from a reusable
842 new_symfile_objfile (struct objfile
*objfile
, int mainline
, int verbo
)
845 /* If this is the main symbol file we have to clean up all users of the
846 old main symbol file. Otherwise it is sufficient to fixup all the
847 breakpoints that may have been redefined by this symbol file. */
850 /* OK, make it the "real" symbol file. */
851 symfile_objfile
= objfile
;
853 clear_symtab_users ();
857 breakpoint_re_set ();
860 /* We're done reading the symbol file; finish off complaints. */
861 clear_complaints (&symfile_complaints
, 0, verbo
);
864 /* Process a symbol file, as either the main file or as a dynamically
867 NAME is the file name (which will be tilde-expanded and made
868 absolute herein) (but we don't free or modify NAME itself).
870 FROM_TTY says how verbose to be.
872 MAINLINE specifies whether this is the main symbol file, or whether
873 it's an extra symbol file such as dynamically loaded code.
875 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
876 syms_from_objfile, above. ADDRS is ignored when MAINLINE is
879 Upon success, returns a pointer to the objfile that was added.
880 Upon failure, jumps back to command level (never returns). */
881 static struct objfile
*
882 symbol_file_add_with_addrs_or_offsets (char *name
, int from_tty
,
883 struct section_addr_info
*addrs
,
884 struct section_offsets
*offsets
,
886 int mainline
, int flags
)
888 struct objfile
*objfile
;
889 struct partial_symtab
*psymtab
;
892 struct section_addr_info orig_addrs
;
897 /* Open a bfd for the file, and give user a chance to burp if we'd be
898 interactively wiping out any existing symbols. */
900 abfd
= symfile_bfd_open (name
);
902 if ((have_full_symbols () || have_partial_symbols ())
905 && !query ("Load new symbol table from \"%s\"? ", name
))
906 error ("Not confirmed.");
908 objfile
= allocate_objfile (abfd
, flags
);
910 /* If the objfile uses a mapped symbol file, and we have a psymtab for
911 it, then skip reading any symbols at this time. */
913 if ((objfile
->flags
& OBJF_MAPPED
) && (objfile
->flags
& OBJF_SYMS
))
915 /* We mapped in an existing symbol table file that already has had
916 initial symbol reading performed, so we can skip that part. Notify
917 the user that instead of reading the symbols, they have been mapped.
919 if (from_tty
|| info_verbose
)
921 printf_filtered ("Mapped symbols for %s...", name
);
923 gdb_flush (gdb_stdout
);
925 init_entry_point_info (objfile
);
926 find_sym_fns (objfile
);
930 /* We either created a new mapped symbol table, mapped an existing
931 symbol table file which has not had initial symbol reading
932 performed, or need to read an unmapped symbol table. */
933 if (from_tty
|| info_verbose
)
935 if (pre_add_symbol_hook
)
936 pre_add_symbol_hook (name
);
939 printf_filtered ("Reading symbols from %s...", name
);
941 gdb_flush (gdb_stdout
);
944 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
948 /* We now have at least a partial symbol table. Check to see if the
949 user requested that all symbols be read on initial access via either
950 the gdb startup command line or on a per symbol file basis. Expand
951 all partial symbol tables for this objfile if so. */
953 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
955 if (from_tty
|| info_verbose
)
957 printf_filtered ("expanding to full symbols...");
959 gdb_flush (gdb_stdout
);
962 for (psymtab
= objfile
->psymtabs
;
964 psymtab
= psymtab
->next
)
966 psymtab_to_symtab (psymtab
);
970 debugfile
= find_separate_debug_file (objfile
);
975 objfile
->separate_debug_objfile
976 = symbol_file_add (debugfile
, from_tty
, &orig_addrs
, 0, flags
);
980 objfile
->separate_debug_objfile
981 = symbol_file_add (debugfile
, from_tty
, NULL
, 0, flags
);
983 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
986 /* Put the separate debug object before the normal one, this is so that
987 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
988 put_objfile_before (objfile
->separate_debug_objfile
, objfile
);
993 if (!have_partial_symbols () && !have_full_symbols ())
996 printf_filtered ("(no debugging symbols found)...");
1000 if (from_tty
|| info_verbose
)
1002 if (post_add_symbol_hook
)
1003 post_add_symbol_hook ();
1006 printf_filtered ("done.\n");
1010 /* We print some messages regardless of whether 'from_tty ||
1011 info_verbose' is true, so make sure they go out at the right
1013 gdb_flush (gdb_stdout
);
1015 if (objfile
->sf
== NULL
)
1016 return objfile
; /* No symbols. */
1018 new_symfile_objfile (objfile
, mainline
, from_tty
);
1020 if (target_new_objfile_hook
)
1021 target_new_objfile_hook (objfile
);
1027 /* Process a symbol file, as either the main file or as a dynamically
1028 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1031 symbol_file_add (char *name
, int from_tty
, struct section_addr_info
*addrs
,
1032 int mainline
, int flags
)
1034 return symbol_file_add_with_addrs_or_offsets (name
, from_tty
, addrs
, 0, 0,
1039 /* Call symbol_file_add() with default values and update whatever is
1040 affected by the loading of a new main().
1041 Used when the file is supplied in the gdb command line
1042 and by some targets with special loading requirements.
1043 The auxiliary function, symbol_file_add_main_1(), has the flags
1044 argument for the switches that can only be specified in the symbol_file
1048 symbol_file_add_main (char *args
, int from_tty
)
1050 symbol_file_add_main_1 (args
, from_tty
, 0);
1054 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1056 symbol_file_add (args
, from_tty
, NULL
, 1, flags
);
1059 RESET_HP_UX_GLOBALS ();
1062 /* Getting new symbols may change our opinion about
1063 what is frameless. */
1064 reinit_frame_cache ();
1066 set_initial_language ();
1070 symbol_file_clear (int from_tty
)
1072 if ((have_full_symbols () || have_partial_symbols ())
1074 && !query ("Discard symbol table from `%s'? ",
1075 symfile_objfile
->name
))
1076 error ("Not confirmed.");
1077 free_all_objfiles ();
1079 /* solib descriptors may have handles to objfiles. Since their
1080 storage has just been released, we'd better wipe the solib
1081 descriptors as well.
1083 #if defined(SOLIB_RESTART)
1087 symfile_objfile
= NULL
;
1089 printf_unfiltered ("No symbol file now.\n");
1091 RESET_HP_UX_GLOBALS ();
1096 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1099 bfd_size_type debuglink_size
;
1100 unsigned long crc32
;
1105 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1110 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1112 contents
= xmalloc (debuglink_size
);
1113 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1114 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1116 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1117 crc_offset
= strlen (contents
) + 1;
1118 crc_offset
= (crc_offset
+ 3) & ~3;
1120 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1127 separate_debug_file_exists (const char *name
, unsigned long crc
)
1129 unsigned long file_crc
= 0;
1131 char buffer
[8*1024];
1134 fd
= open (name
, O_RDONLY
| O_BINARY
);
1138 while ((count
= read (fd
, buffer
, sizeof (buffer
))) > 0)
1139 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1143 return crc
== file_crc
;
1146 static char *debug_file_directory
= NULL
;
1148 #if ! defined (DEBUG_SUBDIRECTORY)
1149 #define DEBUG_SUBDIRECTORY ".debug"
1153 find_separate_debug_file (struct objfile
*objfile
)
1160 bfd_size_type debuglink_size
;
1161 unsigned long crc32
;
1164 basename
= get_debug_link_info (objfile
, &crc32
);
1166 if (basename
== NULL
)
1169 dir
= xstrdup (objfile
->name
);
1171 /* Strip off the final filename part, leaving the directory name,
1172 followed by a slash. Objfile names should always be absolute and
1173 tilde-expanded, so there should always be a slash in there
1175 for (i
= strlen(dir
) - 1; i
>= 0; i
--)
1177 if (IS_DIR_SEPARATOR (dir
[i
]))
1180 gdb_assert (i
>= 0 && IS_DIR_SEPARATOR (dir
[i
]));
1183 debugfile
= alloca (strlen (debug_file_directory
) + 1
1185 + strlen (DEBUG_SUBDIRECTORY
)
1190 /* First try in the same directory as the original file. */
1191 strcpy (debugfile
, dir
);
1192 strcat (debugfile
, basename
);
1194 if (separate_debug_file_exists (debugfile
, crc32
))
1198 return xstrdup (debugfile
);
1201 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1202 strcpy (debugfile
, dir
);
1203 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1204 strcat (debugfile
, "/");
1205 strcat (debugfile
, basename
);
1207 if (separate_debug_file_exists (debugfile
, crc32
))
1211 return xstrdup (debugfile
);
1214 /* Then try in the global debugfile directory. */
1215 strcpy (debugfile
, debug_file_directory
);
1216 strcat (debugfile
, "/");
1217 strcat (debugfile
, dir
);
1218 strcat (debugfile
, basename
);
1220 if (separate_debug_file_exists (debugfile
, crc32
))
1224 return xstrdup (debugfile
);
1233 /* This is the symbol-file command. Read the file, analyze its
1234 symbols, and add a struct symtab to a symtab list. The syntax of
1235 the command is rather bizarre--(1) buildargv implements various
1236 quoting conventions which are undocumented and have little or
1237 nothing in common with the way things are quoted (or not quoted)
1238 elsewhere in GDB, (2) options are used, which are not generally
1239 used in GDB (perhaps "set mapped on", "set readnow on" would be
1240 better), (3) the order of options matters, which is contrary to GNU
1241 conventions (because it is confusing and inconvenient). */
1242 /* Note: ezannoni 2000-04-17. This function used to have support for
1243 rombug (see remote-os9k.c). It consisted of a call to target_link()
1244 (target.c) to get the address of the text segment from the target,
1245 and pass that to symbol_file_add(). This is no longer supported. */
1248 symbol_file_command (char *args
, int from_tty
)
1252 struct cleanup
*cleanups
;
1253 int flags
= OBJF_USERLOADED
;
1259 symbol_file_clear (from_tty
);
1263 if ((argv
= buildargv (args
)) == NULL
)
1267 cleanups
= make_cleanup_freeargv (argv
);
1268 while (*argv
!= NULL
)
1270 if (STREQ (*argv
, "-mapped"))
1271 flags
|= OBJF_MAPPED
;
1273 if (STREQ (*argv
, "-readnow"))
1274 flags
|= OBJF_READNOW
;
1277 error ("unknown option `%s'", *argv
);
1282 symbol_file_add_main_1 (name
, from_tty
, flags
);
1289 error ("no symbol file name was specified");
1291 do_cleanups (cleanups
);
1295 /* Set the initial language.
1297 A better solution would be to record the language in the psymtab when reading
1298 partial symbols, and then use it (if known) to set the language. This would
1299 be a win for formats that encode the language in an easily discoverable place,
1300 such as DWARF. For stabs, we can jump through hoops looking for specially
1301 named symbols or try to intuit the language from the specific type of stabs
1302 we find, but we can't do that until later when we read in full symbols.
1306 set_initial_language (void)
1308 struct partial_symtab
*pst
;
1309 enum language lang
= language_unknown
;
1311 pst
= find_main_psymtab ();
1314 if (pst
->filename
!= NULL
)
1316 lang
= deduce_language_from_filename (pst
->filename
);
1318 if (lang
== language_unknown
)
1320 /* Make C the default language */
1323 set_language (lang
);
1324 expected_language
= current_language
; /* Don't warn the user */
1328 /* Open file specified by NAME and hand it off to BFD for preliminary
1329 analysis. Result is a newly initialized bfd *, which includes a newly
1330 malloc'd` copy of NAME (tilde-expanded and made absolute).
1331 In case of trouble, error() is called. */
1334 symfile_bfd_open (char *name
)
1338 char *absolute_name
;
1342 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
1344 /* Look down path for it, allocate 2nd new malloc'd copy. */
1345 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1346 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1349 char *exename
= alloca (strlen (name
) + 5);
1350 strcat (strcpy (exename
, name
), ".exe");
1351 desc
= openp (getenv ("PATH"), 1, exename
, O_RDONLY
| O_BINARY
,
1357 make_cleanup (xfree
, name
);
1358 perror_with_name (name
);
1360 xfree (name
); /* Free 1st new malloc'd copy */
1361 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
1362 /* It'll be freed in free_objfile(). */
1364 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
1368 make_cleanup (xfree
, name
);
1369 error ("\"%s\": can't open to read symbols: %s.", name
,
1370 bfd_errmsg (bfd_get_error ()));
1372 sym_bfd
->cacheable
= 1;
1374 if (!bfd_check_format (sym_bfd
, bfd_object
))
1376 /* FIXME: should be checking for errors from bfd_close (for one thing,
1377 on error it does not free all the storage associated with the
1379 bfd_close (sym_bfd
); /* This also closes desc */
1380 make_cleanup (xfree
, name
);
1381 error ("\"%s\": can't read symbols: %s.", name
,
1382 bfd_errmsg (bfd_get_error ()));
1387 /* Return the section index for the given section name. Return -1 if
1388 the section was not found. */
1390 get_section_index (struct objfile
*objfile
, char *section_name
)
1392 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1399 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
1400 startup by the _initialize routine in each object file format reader,
1401 to register information about each format the the reader is prepared
1405 add_symtab_fns (struct sym_fns
*sf
)
1407 sf
->next
= symtab_fns
;
1412 /* Initialize to read symbols from the symbol file sym_bfd. It either
1413 returns or calls error(). The result is an initialized struct sym_fns
1414 in the objfile structure, that contains cached information about the
1418 find_sym_fns (struct objfile
*objfile
)
1421 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
->obfd
);
1422 char *our_target
= bfd_get_target (objfile
->obfd
);
1424 if (our_flavour
== bfd_target_srec_flavour
1425 || our_flavour
== bfd_target_ihex_flavour
1426 || our_flavour
== bfd_target_tekhex_flavour
)
1427 return; /* No symbols. */
1429 /* Special kludge for apollo. See dstread.c. */
1430 if (STREQN (our_target
, "apollo", 6))
1431 our_flavour
= (enum bfd_flavour
) -2;
1433 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1435 if (our_flavour
== sf
->sym_flavour
)
1441 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
1442 bfd_get_target (objfile
->obfd
));
1445 /* This function runs the load command of our current target. */
1448 load_command (char *arg
, int from_tty
)
1451 arg
= get_exec_file (1);
1452 target_load (arg
, from_tty
);
1454 /* After re-loading the executable, we don't really know which
1455 overlays are mapped any more. */
1456 overlay_cache_invalid
= 1;
1459 /* This version of "load" should be usable for any target. Currently
1460 it is just used for remote targets, not inftarg.c or core files,
1461 on the theory that only in that case is it useful.
1463 Avoiding xmodem and the like seems like a win (a) because we don't have
1464 to worry about finding it, and (b) On VMS, fork() is very slow and so
1465 we don't want to run a subprocess. On the other hand, I'm not sure how
1466 performance compares. */
1468 static int download_write_size
= 512;
1469 static int validate_download
= 0;
1471 /* Callback service function for generic_load (bfd_map_over_sections). */
1474 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1476 bfd_size_type
*sum
= data
;
1478 *sum
+= bfd_get_section_size_before_reloc (asec
);
1481 /* Opaque data for load_section_callback. */
1482 struct load_section_data
{
1483 unsigned long load_offset
;
1484 unsigned long write_count
;
1485 unsigned long data_count
;
1486 bfd_size_type total_size
;
1489 /* Callback service function for generic_load (bfd_map_over_sections). */
1492 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1494 struct load_section_data
*args
= data
;
1496 if (bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
)
1498 bfd_size_type size
= bfd_get_section_size_before_reloc (asec
);
1502 struct cleanup
*old_chain
;
1503 CORE_ADDR lma
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1504 bfd_size_type block_size
;
1506 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1509 if (download_write_size
> 0 && size
> download_write_size
)
1510 block_size
= download_write_size
;
1514 buffer
= xmalloc (size
);
1515 old_chain
= make_cleanup (xfree
, buffer
);
1517 /* Is this really necessary? I guess it gives the user something
1518 to look at during a long download. */
1519 ui_out_message (uiout
, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1520 sect_name
, paddr_nz (size
), paddr_nz (lma
));
1522 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1528 bfd_size_type this_transfer
= size
- sent
;
1530 if (this_transfer
>= block_size
)
1531 this_transfer
= block_size
;
1532 len
= target_write_memory_partial (lma
, buffer
,
1533 this_transfer
, &err
);
1536 if (validate_download
)
1538 /* Broken memories and broken monitors manifest
1539 themselves here when bring new computers to
1540 life. This doubles already slow downloads. */
1541 /* NOTE: cagney/1999-10-18: A more efficient
1542 implementation might add a verify_memory()
1543 method to the target vector and then use
1544 that. remote.c could implement that method
1545 using the ``qCRC'' packet. */
1546 char *check
= xmalloc (len
);
1547 struct cleanup
*verify_cleanups
=
1548 make_cleanup (xfree
, check
);
1550 if (target_read_memory (lma
, check
, len
) != 0)
1551 error ("Download verify read failed at 0x%s",
1553 if (memcmp (buffer
, check
, len
) != 0)
1554 error ("Download verify compare failed at 0x%s",
1556 do_cleanups (verify_cleanups
);
1558 args
->data_count
+= len
;
1561 args
->write_count
+= 1;
1564 || (ui_load_progress_hook
!= NULL
1565 && ui_load_progress_hook (sect_name
, sent
)))
1566 error ("Canceled the download");
1568 if (show_load_progress
!= NULL
)
1569 show_load_progress (sect_name
, sent
, size
,
1570 args
->data_count
, args
->total_size
);
1572 while (sent
< size
);
1575 error ("Memory access error while loading section %s.", sect_name
);
1577 do_cleanups (old_chain
);
1583 generic_load (char *args
, int from_tty
)
1587 time_t start_time
, end_time
; /* Start and end times of download */
1589 struct cleanup
*old_cleanups
;
1591 struct load_section_data cbdata
;
1594 cbdata
.load_offset
= 0; /* Offset to add to vma for each section. */
1595 cbdata
.write_count
= 0; /* Number of writes needed. */
1596 cbdata
.data_count
= 0; /* Number of bytes written to target memory. */
1597 cbdata
.total_size
= 0; /* Total size of all bfd sectors. */
1599 /* Parse the input argument - the user can specify a load offset as
1600 a second argument. */
1601 filename
= xmalloc (strlen (args
) + 1);
1602 old_cleanups
= make_cleanup (xfree
, filename
);
1603 strcpy (filename
, args
);
1604 offptr
= strchr (filename
, ' ');
1609 cbdata
.load_offset
= strtoul (offptr
, &endptr
, 0);
1610 if (offptr
== endptr
)
1611 error ("Invalid download offset:%s\n", offptr
);
1615 cbdata
.load_offset
= 0;
1617 /* Open the file for loading. */
1618 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1619 if (loadfile_bfd
== NULL
)
1621 perror_with_name (filename
);
1625 /* FIXME: should be checking for errors from bfd_close (for one thing,
1626 on error it does not free all the storage associated with the
1628 make_cleanup_bfd_close (loadfile_bfd
);
1630 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1632 error ("\"%s\" is not an object file: %s", filename
,
1633 bfd_errmsg (bfd_get_error ()));
1636 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1637 (void *) &cbdata
.total_size
);
1639 start_time
= time (NULL
);
1641 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1643 end_time
= time (NULL
);
1645 entry
= bfd_get_start_address (loadfile_bfd
);
1646 ui_out_text (uiout
, "Start address ");
1647 ui_out_field_fmt (uiout
, "address", "0x%s", paddr_nz (entry
));
1648 ui_out_text (uiout
, ", load size ");
1649 ui_out_field_fmt (uiout
, "load-size", "%lu", cbdata
.data_count
);
1650 ui_out_text (uiout
, "\n");
1651 /* We were doing this in remote-mips.c, I suspect it is right
1652 for other targets too. */
1655 /* FIXME: are we supposed to call symbol_file_add or not? According
1656 to a comment from remote-mips.c (where a call to symbol_file_add
1657 was commented out), making the call confuses GDB if more than one
1658 file is loaded in. Some targets do (e.g., remote-vx.c) but
1659 others don't (or didn't - perhaphs they have all been deleted). */
1661 print_transfer_performance (gdb_stdout
, cbdata
.data_count
,
1662 cbdata
.write_count
, end_time
- start_time
);
1664 do_cleanups (old_cleanups
);
1667 /* Report how fast the transfer went. */
1669 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1670 replaced by print_transfer_performance (with a very different
1671 function signature). */
1674 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1677 print_transfer_performance (gdb_stdout
, data_count
,
1678 end_time
- start_time
, 0);
1682 print_transfer_performance (struct ui_file
*stream
,
1683 unsigned long data_count
,
1684 unsigned long write_count
,
1685 unsigned long time_count
)
1687 ui_out_text (uiout
, "Transfer rate: ");
1690 ui_out_field_fmt (uiout
, "transfer-rate", "%lu",
1691 (data_count
* 8) / time_count
);
1692 ui_out_text (uiout
, " bits/sec");
1696 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
1697 ui_out_text (uiout
, " bits in <1 sec");
1699 if (write_count
> 0)
1701 ui_out_text (uiout
, ", ");
1702 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
1703 ui_out_text (uiout
, " bytes/write");
1705 ui_out_text (uiout
, ".\n");
1708 /* This function allows the addition of incrementally linked object files.
1709 It does not modify any state in the target, only in the debugger. */
1710 /* Note: ezannoni 2000-04-13 This function/command used to have a
1711 special case syntax for the rombug target (Rombug is the boot
1712 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1713 rombug case, the user doesn't need to supply a text address,
1714 instead a call to target_link() (in target.c) would supply the
1715 value to use. We are now discontinuing this type of ad hoc syntax. */
1719 add_symbol_file_command (char *args
, int from_tty
)
1721 char *filename
= NULL
;
1722 int flags
= OBJF_USERLOADED
;
1724 int expecting_option
= 0;
1725 int section_index
= 0;
1729 int expecting_sec_name
= 0;
1730 int expecting_sec_addr
= 0;
1736 } sect_opts
[SECT_OFF_MAX
];
1738 struct section_addr_info section_addrs
;
1739 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
1744 error ("add-symbol-file takes a file name and an address");
1746 /* Make a copy of the string that we can safely write into. */
1747 args
= xstrdup (args
);
1749 /* Ensure section_addrs is initialized */
1750 memset (§ion_addrs
, 0, sizeof (section_addrs
));
1752 while (*args
!= '\000')
1754 /* Any leading spaces? */
1755 while (isspace (*args
))
1758 /* Point arg to the beginning of the argument. */
1761 /* Move args pointer over the argument. */
1762 while ((*args
!= '\000') && !isspace (*args
))
1765 /* If there are more arguments, terminate arg and
1767 if (*args
!= '\000')
1770 /* Now process the argument. */
1773 /* The first argument is the file name. */
1774 filename
= tilde_expand (arg
);
1775 make_cleanup (xfree
, filename
);
1780 /* The second argument is always the text address at which
1781 to load the program. */
1782 sect_opts
[section_index
].name
= ".text";
1783 sect_opts
[section_index
].value
= arg
;
1788 /* It's an option (starting with '-') or it's an argument
1793 if (strcmp (arg
, "-mapped") == 0)
1794 flags
|= OBJF_MAPPED
;
1796 if (strcmp (arg
, "-readnow") == 0)
1797 flags
|= OBJF_READNOW
;
1799 if (strcmp (arg
, "-s") == 0)
1801 if (section_index
>= SECT_OFF_MAX
)
1802 error ("Too many sections specified.");
1803 expecting_sec_name
= 1;
1804 expecting_sec_addr
= 1;
1809 if (expecting_sec_name
)
1811 sect_opts
[section_index
].name
= arg
;
1812 expecting_sec_name
= 0;
1815 if (expecting_sec_addr
)
1817 sect_opts
[section_index
].value
= arg
;
1818 expecting_sec_addr
= 0;
1822 error ("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*");
1828 /* Print the prompt for the query below. And save the arguments into
1829 a sect_addr_info structure to be passed around to other
1830 functions. We have to split this up into separate print
1831 statements because local_hex_string returns a local static
1834 printf_filtered ("add symbol table from file \"%s\" at\n", filename
);
1835 for (i
= 0; i
< section_index
; i
++)
1838 char *val
= sect_opts
[i
].value
;
1839 char *sec
= sect_opts
[i
].name
;
1841 val
= sect_opts
[i
].value
;
1842 if (val
[0] == '0' && val
[1] == 'x')
1843 addr
= strtoul (val
+2, NULL
, 16);
1845 addr
= strtoul (val
, NULL
, 10);
1847 /* Here we store the section offsets in the order they were
1848 entered on the command line. */
1849 section_addrs
.other
[sec_num
].name
= sec
;
1850 section_addrs
.other
[sec_num
].addr
= addr
;
1851 printf_filtered ("\t%s_addr = %s\n",
1853 local_hex_string ((unsigned long)addr
));
1856 /* The object's sections are initialized when a
1857 call is made to build_objfile_section_table (objfile).
1858 This happens in reread_symbols.
1859 At this point, we don't know what file type this is,
1860 so we can't determine what section names are valid. */
1863 if (from_tty
&& (!query ("%s", "")))
1864 error ("Not confirmed.");
1866 symbol_file_add (filename
, from_tty
, §ion_addrs
, 0, flags
);
1868 /* Getting new symbols may change our opinion about what is
1870 reinit_frame_cache ();
1871 do_cleanups (my_cleanups
);
1875 add_shared_symbol_files_command (char *args
, int from_tty
)
1877 #ifdef ADD_SHARED_SYMBOL_FILES
1878 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1880 error ("This command is not available in this configuration of GDB.");
1884 /* Re-read symbols if a symbol-file has changed. */
1886 reread_symbols (void)
1888 struct objfile
*objfile
;
1891 struct stat new_statbuf
;
1894 /* With the addition of shared libraries, this should be modified,
1895 the load time should be saved in the partial symbol tables, since
1896 different tables may come from different source files. FIXME.
1897 This routine should then walk down each partial symbol table
1898 and see if the symbol table that it originates from has been changed */
1900 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
1904 #ifdef IBM6000_TARGET
1905 /* If this object is from a shared library, then you should
1906 stat on the library name, not member name. */
1908 if (objfile
->obfd
->my_archive
)
1909 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1912 res
= stat (objfile
->name
, &new_statbuf
);
1915 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1916 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1920 new_modtime
= new_statbuf
.st_mtime
;
1921 if (new_modtime
!= objfile
->mtime
)
1923 struct cleanup
*old_cleanups
;
1924 struct section_offsets
*offsets
;
1926 char *obfd_filename
;
1928 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1931 /* There are various functions like symbol_file_add,
1932 symfile_bfd_open, syms_from_objfile, etc., which might
1933 appear to do what we want. But they have various other
1934 effects which we *don't* want. So we just do stuff
1935 ourselves. We don't worry about mapped files (for one thing,
1936 any mapped file will be out of date). */
1938 /* If we get an error, blow away this objfile (not sure if
1939 that is the correct response for things like shared
1941 old_cleanups
= make_cleanup_free_objfile (objfile
);
1942 /* We need to do this whenever any symbols go away. */
1943 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1945 /* Clean up any state BFD has sitting around. We don't need
1946 to close the descriptor but BFD lacks a way of closing the
1947 BFD without closing the descriptor. */
1948 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1949 if (!bfd_close (objfile
->obfd
))
1950 error ("Can't close BFD for %s: %s", objfile
->name
,
1951 bfd_errmsg (bfd_get_error ()));
1952 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1953 if (objfile
->obfd
== NULL
)
1954 error ("Can't open %s to read symbols.", objfile
->name
);
1955 /* bfd_openr sets cacheable to true, which is what we want. */
1956 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1957 error ("Can't read symbols from %s: %s.", objfile
->name
,
1958 bfd_errmsg (bfd_get_error ()));
1960 /* Save the offsets, we will nuke them with the rest of the
1962 num_offsets
= objfile
->num_sections
;
1963 offsets
= (struct section_offsets
*) alloca (SIZEOF_SECTION_OFFSETS
);
1964 memcpy (offsets
, objfile
->section_offsets
, SIZEOF_SECTION_OFFSETS
);
1966 /* Nuke all the state that we will re-read. Much of the following
1967 code which sets things to NULL really is necessary to tell
1968 other parts of GDB that there is nothing currently there. */
1970 /* FIXME: Do we have to free a whole linked list, or is this
1972 if (objfile
->global_psymbols
.list
)
1973 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
1974 memset (&objfile
->global_psymbols
, 0,
1975 sizeof (objfile
->global_psymbols
));
1976 if (objfile
->static_psymbols
.list
)
1977 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
1978 memset (&objfile
->static_psymbols
, 0,
1979 sizeof (objfile
->static_psymbols
));
1981 /* Free the obstacks for non-reusable objfiles */
1982 bcache_xfree (objfile
->psymbol_cache
);
1983 objfile
->psymbol_cache
= bcache_xmalloc ();
1984 bcache_xfree (objfile
->macro_cache
);
1985 objfile
->macro_cache
= bcache_xmalloc ();
1986 obstack_free (&objfile
->psymbol_obstack
, 0);
1987 obstack_free (&objfile
->symbol_obstack
, 0);
1988 obstack_free (&objfile
->type_obstack
, 0);
1989 objfile
->sections
= NULL
;
1990 objfile
->symtabs
= NULL
;
1991 objfile
->psymtabs
= NULL
;
1992 objfile
->free_psymtabs
= NULL
;
1993 objfile
->msymbols
= NULL
;
1994 objfile
->minimal_symbol_count
= 0;
1995 memset (&objfile
->msymbol_hash
, 0,
1996 sizeof (objfile
->msymbol_hash
));
1997 memset (&objfile
->msymbol_demangled_hash
, 0,
1998 sizeof (objfile
->msymbol_demangled_hash
));
1999 objfile
->fundamental_types
= NULL
;
2000 if (objfile
->sf
!= NULL
)
2002 (*objfile
->sf
->sym_finish
) (objfile
);
2005 /* We never make this a mapped file. */
2007 /* obstack_specify_allocation also initializes the obstack so
2009 objfile
->psymbol_cache
= bcache_xmalloc ();
2010 objfile
->macro_cache
= bcache_xmalloc ();
2011 obstack_specify_allocation (&objfile
->psymbol_obstack
, 0, 0,
2013 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0,
2015 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0,
2017 if (build_objfile_section_table (objfile
))
2019 error ("Can't find the file sections in `%s': %s",
2020 objfile
->name
, bfd_errmsg (bfd_get_error ()));
2022 terminate_minimal_symbol_table (objfile
);
2024 /* We use the same section offsets as from last time. I'm not
2025 sure whether that is always correct for shared libraries. */
2026 objfile
->section_offsets
= (struct section_offsets
*)
2027 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
2028 memcpy (objfile
->section_offsets
, offsets
, SIZEOF_SECTION_OFFSETS
);
2029 objfile
->num_sections
= num_offsets
;
2031 /* What the hell is sym_new_init for, anyway? The concept of
2032 distinguishing between the main file and additional files
2033 in this way seems rather dubious. */
2034 if (objfile
== symfile_objfile
)
2036 (*objfile
->sf
->sym_new_init
) (objfile
);
2038 RESET_HP_UX_GLOBALS ();
2042 (*objfile
->sf
->sym_init
) (objfile
);
2043 clear_complaints (&symfile_complaints
, 1, 1);
2044 /* The "mainline" parameter is a hideous hack; I think leaving it
2045 zero is OK since dbxread.c also does what it needs to do if
2046 objfile->global_psymbols.size is 0. */
2047 (*objfile
->sf
->sym_read
) (objfile
, 0);
2048 if (!have_partial_symbols () && !have_full_symbols ())
2051 printf_filtered ("(no debugging symbols found)\n");
2054 objfile
->flags
|= OBJF_SYMS
;
2056 /* We're done reading the symbol file; finish off complaints. */
2057 clear_complaints (&symfile_complaints
, 0, 1);
2059 /* Getting new symbols may change our opinion about what is
2062 reinit_frame_cache ();
2064 /* Discard cleanups as symbol reading was successful. */
2065 discard_cleanups (old_cleanups
);
2067 /* If the mtime has changed between the time we set new_modtime
2068 and now, we *want* this to be out of date, so don't call stat
2070 objfile
->mtime
= new_modtime
;
2073 /* Call this after reading in a new symbol table to give target
2074 dependent code a crack at the new symbols. For instance, this
2075 could be used to update the values of target-specific symbols GDB
2076 needs to keep track of (such as _sigtramp, or whatever). */
2078 TARGET_SYMFILE_POSTREAD (objfile
);
2080 reread_separate_symbols (objfile
);
2086 clear_symtab_users ();
2090 /* Handle separate debug info for OBJFILE, which has just been
2092 - If we had separate debug info before, but now we don't, get rid
2093 of the separated objfile.
2094 - If we didn't have separated debug info before, but now we do,
2095 read in the new separated debug info file.
2096 - If the debug link points to a different file, toss the old one
2097 and read the new one.
2098 This function does *not* handle the case where objfile is still
2099 using the same separate debug info file, but that file's timestamp
2100 has changed. That case should be handled by the loop in
2101 reread_symbols already. */
2103 reread_separate_symbols (struct objfile
*objfile
)
2106 unsigned long crc32
;
2108 /* Does the updated objfile's debug info live in a
2110 debug_file
= find_separate_debug_file (objfile
);
2112 if (objfile
->separate_debug_objfile
)
2114 /* There are two cases where we need to get rid of
2115 the old separated debug info objfile:
2116 - if the new primary objfile doesn't have
2117 separated debug info, or
2118 - if the new primary objfile has separate debug
2119 info, but it's under a different filename.
2121 If the old and new objfiles both have separate
2122 debug info, under the same filename, then we're
2123 okay --- if the separated file's contents have
2124 changed, we will have caught that when we
2125 visited it in this function's outermost
2128 || strcmp (debug_file
, objfile
->separate_debug_objfile
->name
) != 0)
2129 free_objfile (objfile
->separate_debug_objfile
);
2132 /* If the new objfile has separate debug info, and we
2133 haven't loaded it already, do so now. */
2135 && ! objfile
->separate_debug_objfile
)
2137 /* Use the same section offset table as objfile itself.
2138 Preserve the flags from objfile that make sense. */
2139 objfile
->separate_debug_objfile
2140 = (symbol_file_add_with_addrs_or_offsets
2142 info_verbose
, /* from_tty: Don't override the default. */
2143 0, /* No addr table. */
2144 objfile
->section_offsets
, objfile
->num_sections
,
2145 0, /* Not mainline. See comments about this above. */
2146 objfile
->flags
& (OBJF_MAPPED
| OBJF_REORDERED
2147 | OBJF_SHARED
| OBJF_READNOW
2148 | OBJF_USERLOADED
)));
2149 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
2165 static filename_language
*filename_language_table
;
2166 static int fl_table_size
, fl_table_next
;
2169 add_filename_language (char *ext
, enum language lang
)
2171 if (fl_table_next
>= fl_table_size
)
2173 fl_table_size
+= 10;
2174 filename_language_table
=
2175 xrealloc (filename_language_table
,
2176 fl_table_size
* sizeof (*filename_language_table
));
2179 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2180 filename_language_table
[fl_table_next
].lang
= lang
;
2184 static char *ext_args
;
2187 set_ext_lang_command (char *args
, int from_tty
)
2190 char *cp
= ext_args
;
2193 /* First arg is filename extension, starting with '.' */
2195 error ("'%s': Filename extension must begin with '.'", ext_args
);
2197 /* Find end of first arg. */
2198 while (*cp
&& !isspace (*cp
))
2202 error ("'%s': two arguments required -- filename extension and language",
2205 /* Null-terminate first arg */
2208 /* Find beginning of second arg, which should be a source language. */
2209 while (*cp
&& isspace (*cp
))
2213 error ("'%s': two arguments required -- filename extension and language",
2216 /* Lookup the language from among those we know. */
2217 lang
= language_enum (cp
);
2219 /* Now lookup the filename extension: do we already know it? */
2220 for (i
= 0; i
< fl_table_next
; i
++)
2221 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2224 if (i
>= fl_table_next
)
2226 /* new file extension */
2227 add_filename_language (ext_args
, lang
);
2231 /* redefining a previously known filename extension */
2234 /* query ("Really make files of type %s '%s'?", */
2235 /* ext_args, language_str (lang)); */
2237 xfree (filename_language_table
[i
].ext
);
2238 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2239 filename_language_table
[i
].lang
= lang
;
2244 info_ext_lang_command (char *args
, int from_tty
)
2248 printf_filtered ("Filename extensions and the languages they represent:");
2249 printf_filtered ("\n\n");
2250 for (i
= 0; i
< fl_table_next
; i
++)
2251 printf_filtered ("\t%s\t- %s\n",
2252 filename_language_table
[i
].ext
,
2253 language_str (filename_language_table
[i
].lang
));
2257 init_filename_language_table (void)
2259 if (fl_table_size
== 0) /* protect against repetition */
2263 filename_language_table
=
2264 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2265 add_filename_language (".c", language_c
);
2266 add_filename_language (".C", language_cplus
);
2267 add_filename_language (".cc", language_cplus
);
2268 add_filename_language (".cp", language_cplus
);
2269 add_filename_language (".cpp", language_cplus
);
2270 add_filename_language (".cxx", language_cplus
);
2271 add_filename_language (".c++", language_cplus
);
2272 add_filename_language (".java", language_java
);
2273 add_filename_language (".class", language_java
);
2274 add_filename_language (".m", language_objc
);
2275 add_filename_language (".f", language_fortran
);
2276 add_filename_language (".F", language_fortran
);
2277 add_filename_language (".s", language_asm
);
2278 add_filename_language (".S", language_asm
);
2279 add_filename_language (".pas", language_pascal
);
2280 add_filename_language (".p", language_pascal
);
2281 add_filename_language (".pp", language_pascal
);
2286 deduce_language_from_filename (char *filename
)
2291 if (filename
!= NULL
)
2292 if ((cp
= strrchr (filename
, '.')) != NULL
)
2293 for (i
= 0; i
< fl_table_next
; i
++)
2294 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2295 return filename_language_table
[i
].lang
;
2297 return language_unknown
;
2302 Allocate and partly initialize a new symbol table. Return a pointer
2303 to it. error() if no space.
2305 Caller must set these fields:
2311 possibly free_named_symtabs (symtab->filename);
2315 allocate_symtab (char *filename
, struct objfile
*objfile
)
2317 register struct symtab
*symtab
;
2319 symtab
= (struct symtab
*)
2320 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct symtab
));
2321 memset (symtab
, 0, sizeof (*symtab
));
2322 symtab
->filename
= obsavestring (filename
, strlen (filename
),
2323 &objfile
->symbol_obstack
);
2324 symtab
->fullname
= NULL
;
2325 symtab
->language
= deduce_language_from_filename (filename
);
2326 symtab
->debugformat
= obsavestring ("unknown", 7,
2327 &objfile
->symbol_obstack
);
2329 /* Hook it to the objfile it comes from */
2331 symtab
->objfile
= objfile
;
2332 symtab
->next
= objfile
->symtabs
;
2333 objfile
->symtabs
= symtab
;
2335 /* FIXME: This should go away. It is only defined for the Z8000,
2336 and the Z8000 definition of this macro doesn't have anything to
2337 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
2338 here for convenience. */
2339 #ifdef INIT_EXTRA_SYMTAB_INFO
2340 INIT_EXTRA_SYMTAB_INFO (symtab
);
2346 struct partial_symtab
*
2347 allocate_psymtab (char *filename
, struct objfile
*objfile
)
2349 struct partial_symtab
*psymtab
;
2351 if (objfile
->free_psymtabs
)
2353 psymtab
= objfile
->free_psymtabs
;
2354 objfile
->free_psymtabs
= psymtab
->next
;
2357 psymtab
= (struct partial_symtab
*)
2358 obstack_alloc (&objfile
->psymbol_obstack
,
2359 sizeof (struct partial_symtab
));
2361 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2362 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
2363 &objfile
->psymbol_obstack
);
2364 psymtab
->symtab
= NULL
;
2366 /* Prepend it to the psymtab list for the objfile it belongs to.
2367 Psymtabs are searched in most recent inserted -> least recent
2370 psymtab
->objfile
= objfile
;
2371 psymtab
->next
= objfile
->psymtabs
;
2372 objfile
->psymtabs
= psymtab
;
2375 struct partial_symtab
**prev_pst
;
2376 psymtab
->objfile
= objfile
;
2377 psymtab
->next
= NULL
;
2378 prev_pst
= &(objfile
->psymtabs
);
2379 while ((*prev_pst
) != NULL
)
2380 prev_pst
= &((*prev_pst
)->next
);
2381 (*prev_pst
) = psymtab
;
2389 discard_psymtab (struct partial_symtab
*pst
)
2391 struct partial_symtab
**prev_pst
;
2394 Empty psymtabs happen as a result of header files which don't
2395 have any symbols in them. There can be a lot of them. But this
2396 check is wrong, in that a psymtab with N_SLINE entries but
2397 nothing else is not empty, but we don't realize that. Fixing
2398 that without slowing things down might be tricky. */
2400 /* First, snip it out of the psymtab chain */
2402 prev_pst
= &(pst
->objfile
->psymtabs
);
2403 while ((*prev_pst
) != pst
)
2404 prev_pst
= &((*prev_pst
)->next
);
2405 (*prev_pst
) = pst
->next
;
2407 /* Next, put it on a free list for recycling */
2409 pst
->next
= pst
->objfile
->free_psymtabs
;
2410 pst
->objfile
->free_psymtabs
= pst
;
2414 /* Reset all data structures in gdb which may contain references to symbol
2418 clear_symtab_users (void)
2420 /* Someday, we should do better than this, by only blowing away
2421 the things that really need to be blown. */
2422 clear_value_history ();
2424 clear_internalvars ();
2425 breakpoint_re_set ();
2426 set_default_breakpoint (0, 0, 0, 0);
2427 clear_current_source_symtab_and_line ();
2428 clear_pc_function_cache ();
2429 if (target_new_objfile_hook
)
2430 target_new_objfile_hook (NULL
);
2434 clear_symtab_users_cleanup (void *ignore
)
2436 clear_symtab_users ();
2439 /* clear_symtab_users_once:
2441 This function is run after symbol reading, or from a cleanup.
2442 If an old symbol table was obsoleted, the old symbol table
2443 has been blown away, but the other GDB data structures that may
2444 reference it have not yet been cleared or re-directed. (The old
2445 symtab was zapped, and the cleanup queued, in free_named_symtab()
2448 This function can be queued N times as a cleanup, or called
2449 directly; it will do all the work the first time, and then will be a
2450 no-op until the next time it is queued. This works by bumping a
2451 counter at queueing time. Much later when the cleanup is run, or at
2452 the end of symbol processing (in case the cleanup is discarded), if
2453 the queued count is greater than the "done-count", we do the work
2454 and set the done-count to the queued count. If the queued count is
2455 less than or equal to the done-count, we just ignore the call. This
2456 is needed because reading a single .o file will often replace many
2457 symtabs (one per .h file, for example), and we don't want to reset
2458 the breakpoints N times in the user's face.
2460 The reason we both queue a cleanup, and call it directly after symbol
2461 reading, is because the cleanup protects us in case of errors, but is
2462 discarded if symbol reading is successful. */
2465 /* FIXME: As free_named_symtabs is currently a big noop this function
2466 is no longer needed. */
2467 static void clear_symtab_users_once (void);
2469 static int clear_symtab_users_queued
;
2470 static int clear_symtab_users_done
;
2473 clear_symtab_users_once (void)
2475 /* Enforce once-per-`do_cleanups'-semantics */
2476 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2478 clear_symtab_users_done
= clear_symtab_users_queued
;
2480 clear_symtab_users ();
2484 /* Delete the specified psymtab, and any others that reference it. */
2487 cashier_psymtab (struct partial_symtab
*pst
)
2489 struct partial_symtab
*ps
, *pprev
= NULL
;
2492 /* Find its previous psymtab in the chain */
2493 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2502 /* Unhook it from the chain. */
2503 if (ps
== pst
->objfile
->psymtabs
)
2504 pst
->objfile
->psymtabs
= ps
->next
;
2506 pprev
->next
= ps
->next
;
2508 /* FIXME, we can't conveniently deallocate the entries in the
2509 partial_symbol lists (global_psymbols/static_psymbols) that
2510 this psymtab points to. These just take up space until all
2511 the psymtabs are reclaimed. Ditto the dependencies list and
2512 filename, which are all in the psymbol_obstack. */
2514 /* We need to cashier any psymtab that has this one as a dependency... */
2516 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2518 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2520 if (ps
->dependencies
[i
] == pst
)
2522 cashier_psymtab (ps
);
2523 goto again
; /* Must restart, chain has been munged. */
2530 /* If a symtab or psymtab for filename NAME is found, free it along
2531 with any dependent breakpoints, displays, etc.
2532 Used when loading new versions of object modules with the "add-file"
2533 command. This is only called on the top-level symtab or psymtab's name;
2534 it is not called for subsidiary files such as .h files.
2536 Return value is 1 if we blew away the environment, 0 if not.
2537 FIXME. The return value appears to never be used.
2539 FIXME. I think this is not the best way to do this. We should
2540 work on being gentler to the environment while still cleaning up
2541 all stray pointers into the freed symtab. */
2544 free_named_symtabs (char *name
)
2547 /* FIXME: With the new method of each objfile having it's own
2548 psymtab list, this function needs serious rethinking. In particular,
2549 why was it ever necessary to toss psymtabs with specific compilation
2550 unit filenames, as opposed to all psymtabs from a particular symbol
2552 Well, the answer is that some systems permit reloading of particular
2553 compilation units. We want to blow away any old info about these
2554 compilation units, regardless of which objfiles they arrived in. --gnu. */
2556 register struct symtab
*s
;
2557 register struct symtab
*prev
;
2558 register struct partial_symtab
*ps
;
2559 struct blockvector
*bv
;
2562 /* We only wack things if the symbol-reload switch is set. */
2563 if (!symbol_reloading
)
2566 /* Some symbol formats have trouble providing file names... */
2567 if (name
== 0 || *name
== '\0')
2570 /* Look for a psymtab with the specified name. */
2573 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2575 if (STREQ (name
, ps
->filename
))
2577 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2578 goto again2
; /* Must restart, chain has been munged */
2582 /* Look for a symtab with the specified name. */
2584 for (s
= symtab_list
; s
; s
= s
->next
)
2586 if (STREQ (name
, s
->filename
))
2593 if (s
== symtab_list
)
2594 symtab_list
= s
->next
;
2596 prev
->next
= s
->next
;
2598 /* For now, queue a delete for all breakpoints, displays, etc., whether
2599 or not they depend on the symtab being freed. This should be
2600 changed so that only those data structures affected are deleted. */
2602 /* But don't delete anything if the symtab is empty.
2603 This test is necessary due to a bug in "dbxread.c" that
2604 causes empty symtabs to be created for N_SO symbols that
2605 contain the pathname of the object file. (This problem
2606 has been fixed in GDB 3.9x). */
2608 bv
= BLOCKVECTOR (s
);
2609 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2610 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2611 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2613 complaint (&symfile_complaints
, "Replacing old symbols for `%s'",
2615 clear_symtab_users_queued
++;
2616 make_cleanup (clear_symtab_users_once
, 0);
2621 complaint (&symfile_complaints
, "Empty symbol table found for `%s'",
2629 /* It is still possible that some breakpoints will be affected
2630 even though no symtab was found, since the file might have
2631 been compiled without debugging, and hence not be associated
2632 with a symtab. In order to handle this correctly, we would need
2633 to keep a list of text address ranges for undebuggable files.
2634 For now, we do nothing, since this is a fairly obscure case. */
2638 /* FIXME, what about the minimal symbol table? */
2645 /* Allocate and partially fill a partial symtab. It will be
2646 completely filled at the end of the symbol list.
2648 FILENAME is the name of the symbol-file we are reading from. */
2650 struct partial_symtab
*
2651 start_psymtab_common (struct objfile
*objfile
,
2652 struct section_offsets
*section_offsets
, char *filename
,
2653 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2654 struct partial_symbol
**static_syms
)
2656 struct partial_symtab
*psymtab
;
2658 psymtab
= allocate_psymtab (filename
, objfile
);
2659 psymtab
->section_offsets
= section_offsets
;
2660 psymtab
->textlow
= textlow
;
2661 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2662 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2663 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2667 /* Add a symbol with a long value to a psymtab.
2668 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
2671 add_psymbol_to_list (char *name
, int namelength
, namespace_enum
namespace,
2672 enum address_class
class,
2673 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2674 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2675 enum language language
, struct objfile
*objfile
)
2677 register struct partial_symbol
*psym
;
2678 char *buf
= alloca (namelength
+ 1);
2679 /* psymbol is static so that there will be no uninitialized gaps in the
2680 structure which might contain random data, causing cache misses in
2682 static struct partial_symbol psymbol
;
2684 /* Create local copy of the partial symbol */
2685 memcpy (buf
, name
, namelength
);
2686 buf
[namelength
] = '\0';
2687 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, objfile
->psymbol_cache
);
2688 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2691 SYMBOL_VALUE (&psymbol
) = val
;
2695 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2697 SYMBOL_SECTION (&psymbol
) = 0;
2698 SYMBOL_LANGUAGE (&psymbol
) = language
;
2699 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2700 PSYMBOL_CLASS (&psymbol
) = class;
2701 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2703 /* Stash the partial symbol away in the cache */
2704 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), objfile
->psymbol_cache
);
2706 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2707 if (list
->next
>= list
->list
+ list
->size
)
2709 extend_psymbol_list (list
, objfile
);
2711 *list
->next
++ = psym
;
2712 OBJSTAT (objfile
, n_psyms
++);
2715 /* Add a symbol with a long value to a psymtab. This differs from
2716 * add_psymbol_to_list above in taking both a mangled and a demangled
2720 add_psymbol_with_dem_name_to_list (char *name
, int namelength
, char *dem_name
,
2721 int dem_namelength
, namespace_enum
namespace,
2722 enum address_class
class,
2723 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2724 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2725 enum language language
,
2726 struct objfile
*objfile
)
2728 register struct partial_symbol
*psym
;
2729 char *buf
= alloca (namelength
+ 1);
2730 /* psymbol is static so that there will be no uninitialized gaps in the
2731 structure which might contain random data, causing cache misses in
2733 static struct partial_symbol psymbol
;
2735 /* Create local copy of the partial symbol */
2737 memcpy (buf
, name
, namelength
);
2738 buf
[namelength
] = '\0';
2739 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, objfile
->psymbol_cache
);
2741 buf
= alloca (dem_namelength
+ 1);
2742 memcpy (buf
, dem_name
, dem_namelength
);
2743 buf
[dem_namelength
] = '\0';
2748 case language_cplus
:
2749 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol
) =
2750 bcache (buf
, dem_namelength
+ 1, objfile
->psymbol_cache
);
2752 /* FIXME What should be done for the default case? Ignoring for now. */
2755 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2758 SYMBOL_VALUE (&psymbol
) = val
;
2762 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2764 SYMBOL_SECTION (&psymbol
) = 0;
2765 SYMBOL_LANGUAGE (&psymbol
) = language
;
2766 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2767 PSYMBOL_CLASS (&psymbol
) = class;
2768 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2770 /* Stash the partial symbol away in the cache */
2771 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), objfile
->psymbol_cache
);
2773 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2774 if (list
->next
>= list
->list
+ list
->size
)
2776 extend_psymbol_list (list
, objfile
);
2778 *list
->next
++ = psym
;
2779 OBJSTAT (objfile
, n_psyms
++);
2782 /* Initialize storage for partial symbols. */
2785 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
2787 /* Free any previously allocated psymbol lists. */
2789 if (objfile
->global_psymbols
.list
)
2791 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
2793 if (objfile
->static_psymbols
.list
)
2795 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
2798 /* Current best guess is that approximately a twentieth
2799 of the total symbols (in a debugging file) are global or static
2802 objfile
->global_psymbols
.size
= total_symbols
/ 10;
2803 objfile
->static_psymbols
.size
= total_symbols
/ 10;
2805 if (objfile
->global_psymbols
.size
> 0)
2807 objfile
->global_psymbols
.next
=
2808 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
2809 xmmalloc (objfile
->md
, (objfile
->global_psymbols
.size
2810 * sizeof (struct partial_symbol
*)));
2812 if (objfile
->static_psymbols
.size
> 0)
2814 objfile
->static_psymbols
.next
=
2815 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
2816 xmmalloc (objfile
->md
, (objfile
->static_psymbols
.size
2817 * sizeof (struct partial_symbol
*)));
2822 The following code implements an abstraction for debugging overlay sections.
2824 The target model is as follows:
2825 1) The gnu linker will permit multiple sections to be mapped into the
2826 same VMA, each with its own unique LMA (or load address).
2827 2) It is assumed that some runtime mechanism exists for mapping the
2828 sections, one by one, from the load address into the VMA address.
2829 3) This code provides a mechanism for gdb to keep track of which
2830 sections should be considered to be mapped from the VMA to the LMA.
2831 This information is used for symbol lookup, and memory read/write.
2832 For instance, if a section has been mapped then its contents
2833 should be read from the VMA, otherwise from the LMA.
2835 Two levels of debugger support for overlays are available. One is
2836 "manual", in which the debugger relies on the user to tell it which
2837 overlays are currently mapped. This level of support is
2838 implemented entirely in the core debugger, and the information about
2839 whether a section is mapped is kept in the objfile->obj_section table.
2841 The second level of support is "automatic", and is only available if
2842 the target-specific code provides functionality to read the target's
2843 overlay mapping table, and translate its contents for the debugger
2844 (by updating the mapped state information in the obj_section tables).
2846 The interface is as follows:
2848 overlay map <name> -- tell gdb to consider this section mapped
2849 overlay unmap <name> -- tell gdb to consider this section unmapped
2850 overlay list -- list the sections that GDB thinks are mapped
2851 overlay read-target -- get the target's state of what's mapped
2852 overlay off/manual/auto -- set overlay debugging state
2853 Functional interface:
2854 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2855 section, return that section.
2856 find_pc_overlay(pc): find any overlay section that contains
2857 the pc, either in its VMA or its LMA
2858 overlay_is_mapped(sect): true if overlay is marked as mapped
2859 section_is_overlay(sect): true if section's VMA != LMA
2860 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2861 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2862 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2863 overlay_mapped_address(...): map an address from section's LMA to VMA
2864 overlay_unmapped_address(...): map an address from section's VMA to LMA
2865 symbol_overlayed_address(...): Return a "current" address for symbol:
2866 either in VMA or LMA depending on whether
2867 the symbol's section is currently mapped
2870 /* Overlay debugging state: */
2872 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2873 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
2875 /* Target vector for refreshing overlay mapped state */
2876 static void simple_overlay_update (struct obj_section
*);
2877 void (*target_overlay_update
) (struct obj_section
*) = simple_overlay_update
;
2879 /* Function: section_is_overlay (SECTION)
2880 Returns true if SECTION has VMA not equal to LMA, ie.
2881 SECTION is loaded at an address different from where it will "run". */
2884 section_is_overlay (asection
*section
)
2886 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2888 if (overlay_debugging
)
2889 if (section
&& section
->lma
!= 0 &&
2890 section
->vma
!= section
->lma
)
2896 /* Function: overlay_invalidate_all (void)
2897 Invalidate the mapped state of all overlay sections (mark it as stale). */
2900 overlay_invalidate_all (void)
2902 struct objfile
*objfile
;
2903 struct obj_section
*sect
;
2905 ALL_OBJSECTIONS (objfile
, sect
)
2906 if (section_is_overlay (sect
->the_bfd_section
))
2907 sect
->ovly_mapped
= -1;
2910 /* Function: overlay_is_mapped (SECTION)
2911 Returns true if section is an overlay, and is currently mapped.
2912 Private: public access is thru function section_is_mapped.
2914 Access to the ovly_mapped flag is restricted to this function, so
2915 that we can do automatic update. If the global flag
2916 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2917 overlay_invalidate_all. If the mapped state of the particular
2918 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2921 overlay_is_mapped (struct obj_section
*osect
)
2923 if (osect
== 0 || !section_is_overlay (osect
->the_bfd_section
))
2926 switch (overlay_debugging
)
2930 return 0; /* overlay debugging off */
2931 case ovly_auto
: /* overlay debugging automatic */
2932 /* Unles there is a target_overlay_update function,
2933 there's really nothing useful to do here (can't really go auto) */
2934 if (target_overlay_update
)
2936 if (overlay_cache_invalid
)
2938 overlay_invalidate_all ();
2939 overlay_cache_invalid
= 0;
2941 if (osect
->ovly_mapped
== -1)
2942 (*target_overlay_update
) (osect
);
2944 /* fall thru to manual case */
2945 case ovly_on
: /* overlay debugging manual */
2946 return osect
->ovly_mapped
== 1;
2950 /* Function: section_is_mapped
2951 Returns true if section is an overlay, and is currently mapped. */
2954 section_is_mapped (asection
*section
)
2956 struct objfile
*objfile
;
2957 struct obj_section
*osect
;
2959 if (overlay_debugging
)
2960 if (section
&& section_is_overlay (section
))
2961 ALL_OBJSECTIONS (objfile
, osect
)
2962 if (osect
->the_bfd_section
== section
)
2963 return overlay_is_mapped (osect
);
2968 /* Function: pc_in_unmapped_range
2969 If PC falls into the lma range of SECTION, return true, else false. */
2972 pc_in_unmapped_range (CORE_ADDR pc
, asection
*section
)
2974 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2978 if (overlay_debugging
)
2979 if (section
&& section_is_overlay (section
))
2981 size
= bfd_get_section_size_before_reloc (section
);
2982 if (section
->lma
<= pc
&& pc
< section
->lma
+ size
)
2988 /* Function: pc_in_mapped_range
2989 If PC falls into the vma range of SECTION, return true, else false. */
2992 pc_in_mapped_range (CORE_ADDR pc
, asection
*section
)
2994 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2998 if (overlay_debugging
)
2999 if (section
&& section_is_overlay (section
))
3001 size
= bfd_get_section_size_before_reloc (section
);
3002 if (section
->vma
<= pc
&& pc
< section
->vma
+ size
)
3009 /* Return true if the mapped ranges of sections A and B overlap, false
3012 sections_overlap (asection
*a
, asection
*b
)
3014 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3016 CORE_ADDR a_start
= a
->vma
;
3017 CORE_ADDR a_end
= a
->vma
+ bfd_get_section_size_before_reloc (a
);
3018 CORE_ADDR b_start
= b
->vma
;
3019 CORE_ADDR b_end
= b
->vma
+ bfd_get_section_size_before_reloc (b
);
3021 return (a_start
< b_end
&& b_start
< a_end
);
3024 /* Function: overlay_unmapped_address (PC, SECTION)
3025 Returns the address corresponding to PC in the unmapped (load) range.
3026 May be the same as PC. */
3029 overlay_unmapped_address (CORE_ADDR pc
, asection
*section
)
3031 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
3033 if (overlay_debugging
)
3034 if (section
&& section_is_overlay (section
) &&
3035 pc_in_mapped_range (pc
, section
))
3036 return pc
+ section
->lma
- section
->vma
;
3041 /* Function: overlay_mapped_address (PC, SECTION)
3042 Returns the address corresponding to PC in the mapped (runtime) range.
3043 May be the same as PC. */
3046 overlay_mapped_address (CORE_ADDR pc
, asection
*section
)
3048 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3050 if (overlay_debugging
)
3051 if (section
&& section_is_overlay (section
) &&
3052 pc_in_unmapped_range (pc
, section
))
3053 return pc
+ section
->vma
- section
->lma
;
3059 /* Function: symbol_overlayed_address
3060 Return one of two addresses (relative to the VMA or to the LMA),
3061 depending on whether the section is mapped or not. */
3064 symbol_overlayed_address (CORE_ADDR address
, asection
*section
)
3066 if (overlay_debugging
)
3068 /* If the symbol has no section, just return its regular address. */
3071 /* If the symbol's section is not an overlay, just return its address */
3072 if (!section_is_overlay (section
))
3074 /* If the symbol's section is mapped, just return its address */
3075 if (section_is_mapped (section
))
3078 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3079 * then return its LOADED address rather than its vma address!!
3081 return overlay_unmapped_address (address
, section
);
3086 /* Function: find_pc_overlay (PC)
3087 Return the best-match overlay section for PC:
3088 If PC matches a mapped overlay section's VMA, return that section.
3089 Else if PC matches an unmapped section's VMA, return that section.
3090 Else if PC matches an unmapped section's LMA, return that section. */
3093 find_pc_overlay (CORE_ADDR pc
)
3095 struct objfile
*objfile
;
3096 struct obj_section
*osect
, *best_match
= NULL
;
3098 if (overlay_debugging
)
3099 ALL_OBJSECTIONS (objfile
, osect
)
3100 if (section_is_overlay (osect
->the_bfd_section
))
3102 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
))
3104 if (overlay_is_mapped (osect
))
3105 return osect
->the_bfd_section
;
3109 else if (pc_in_unmapped_range (pc
, osect
->the_bfd_section
))
3112 return best_match
? best_match
->the_bfd_section
: NULL
;
3115 /* Function: find_pc_mapped_section (PC)
3116 If PC falls into the VMA address range of an overlay section that is
3117 currently marked as MAPPED, return that section. Else return NULL. */
3120 find_pc_mapped_section (CORE_ADDR pc
)
3122 struct objfile
*objfile
;
3123 struct obj_section
*osect
;
3125 if (overlay_debugging
)
3126 ALL_OBJSECTIONS (objfile
, osect
)
3127 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
) &&
3128 overlay_is_mapped (osect
))
3129 return osect
->the_bfd_section
;
3134 /* Function: list_overlays_command
3135 Print a list of mapped sections and their PC ranges */
3138 list_overlays_command (char *args
, int from_tty
)
3141 struct objfile
*objfile
;
3142 struct obj_section
*osect
;
3144 if (overlay_debugging
)
3145 ALL_OBJSECTIONS (objfile
, osect
)
3146 if (overlay_is_mapped (osect
))
3152 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3153 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3154 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3155 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3157 printf_filtered ("Section %s, loaded at ", name
);
3158 print_address_numeric (lma
, 1, gdb_stdout
);
3159 puts_filtered (" - ");
3160 print_address_numeric (lma
+ size
, 1, gdb_stdout
);
3161 printf_filtered (", mapped at ");
3162 print_address_numeric (vma
, 1, gdb_stdout
);
3163 puts_filtered (" - ");
3164 print_address_numeric (vma
+ size
, 1, gdb_stdout
);
3165 puts_filtered ("\n");
3170 printf_filtered ("No sections are mapped.\n");
3173 /* Function: map_overlay_command
3174 Mark the named section as mapped (ie. residing at its VMA address). */
3177 map_overlay_command (char *args
, int from_tty
)
3179 struct objfile
*objfile
, *objfile2
;
3180 struct obj_section
*sec
, *sec2
;
3183 if (!overlay_debugging
)
3185 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3186 the 'overlay manual' command.");
3188 if (args
== 0 || *args
== 0)
3189 error ("Argument required: name of an overlay section");
3191 /* First, find a section matching the user supplied argument */
3192 ALL_OBJSECTIONS (objfile
, sec
)
3193 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3195 /* Now, check to see if the section is an overlay. */
3196 bfdsec
= sec
->the_bfd_section
;
3197 if (!section_is_overlay (bfdsec
))
3198 continue; /* not an overlay section */
3200 /* Mark the overlay as "mapped" */
3201 sec
->ovly_mapped
= 1;
3203 /* Next, make a pass and unmap any sections that are
3204 overlapped by this new section: */
3205 ALL_OBJSECTIONS (objfile2
, sec2
)
3206 if (sec2
->ovly_mapped
3208 && sec
->the_bfd_section
!= sec2
->the_bfd_section
3209 && sections_overlap (sec
->the_bfd_section
,
3210 sec2
->the_bfd_section
))
3213 printf_filtered ("Note: section %s unmapped by overlap\n",
3214 bfd_section_name (objfile
->obfd
,
3215 sec2
->the_bfd_section
));
3216 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3220 error ("No overlay section called %s", args
);
3223 /* Function: unmap_overlay_command
3224 Mark the overlay section as unmapped
3225 (ie. resident in its LMA address range, rather than the VMA range). */
3228 unmap_overlay_command (char *args
, int from_tty
)
3230 struct objfile
*objfile
;
3231 struct obj_section
*sec
;
3233 if (!overlay_debugging
)
3235 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3236 the 'overlay manual' command.");
3238 if (args
== 0 || *args
== 0)
3239 error ("Argument required: name of an overlay section");
3241 /* First, find a section matching the user supplied argument */
3242 ALL_OBJSECTIONS (objfile
, sec
)
3243 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3245 if (!sec
->ovly_mapped
)
3246 error ("Section %s is not mapped", args
);
3247 sec
->ovly_mapped
= 0;
3250 error ("No overlay section called %s", args
);
3253 /* Function: overlay_auto_command
3254 A utility command to turn on overlay debugging.
3255 Possibly this should be done via a set/show command. */
3258 overlay_auto_command (char *args
, int from_tty
)
3260 overlay_debugging
= ovly_auto
;
3261 enable_overlay_breakpoints ();
3263 printf_filtered ("Automatic overlay debugging enabled.");
3266 /* Function: overlay_manual_command
3267 A utility command to turn on overlay debugging.
3268 Possibly this should be done via a set/show command. */
3271 overlay_manual_command (char *args
, int from_tty
)
3273 overlay_debugging
= ovly_on
;
3274 disable_overlay_breakpoints ();
3276 printf_filtered ("Overlay debugging enabled.");
3279 /* Function: overlay_off_command
3280 A utility command to turn on overlay debugging.
3281 Possibly this should be done via a set/show command. */
3284 overlay_off_command (char *args
, int from_tty
)
3286 overlay_debugging
= ovly_off
;
3287 disable_overlay_breakpoints ();
3289 printf_filtered ("Overlay debugging disabled.");
3293 overlay_load_command (char *args
, int from_tty
)
3295 if (target_overlay_update
)
3296 (*target_overlay_update
) (NULL
);
3298 error ("This target does not know how to read its overlay state.");
3301 /* Function: overlay_command
3302 A place-holder for a mis-typed command */
3304 /* Command list chain containing all defined "overlay" subcommands. */
3305 struct cmd_list_element
*overlaylist
;
3308 overlay_command (char *args
, int from_tty
)
3311 ("\"overlay\" must be followed by the name of an overlay command.\n");
3312 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3316 /* Target Overlays for the "Simplest" overlay manager:
3318 This is GDB's default target overlay layer. It works with the
3319 minimal overlay manager supplied as an example by Cygnus. The
3320 entry point is via a function pointer "target_overlay_update",
3321 so targets that use a different runtime overlay manager can
3322 substitute their own overlay_update function and take over the
3325 The overlay_update function pokes around in the target's data structures
3326 to see what overlays are mapped, and updates GDB's overlay mapping with
3329 In this simple implementation, the target data structures are as follows:
3330 unsigned _novlys; /# number of overlay sections #/
3331 unsigned _ovly_table[_novlys][4] = {
3332 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3333 {..., ..., ..., ...},
3335 unsigned _novly_regions; /# number of overlay regions #/
3336 unsigned _ovly_region_table[_novly_regions][3] = {
3337 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3340 These functions will attempt to update GDB's mappedness state in the
3341 symbol section table, based on the target's mappedness state.
3343 To do this, we keep a cached copy of the target's _ovly_table, and
3344 attempt to detect when the cached copy is invalidated. The main
3345 entry point is "simple_overlay_update(SECT), which looks up SECT in
3346 the cached table and re-reads only the entry for that section from
3347 the target (whenever possible).
3350 /* Cached, dynamically allocated copies of the target data structures: */
3351 static unsigned (*cache_ovly_table
)[4] = 0;
3353 static unsigned (*cache_ovly_region_table
)[3] = 0;
3355 static unsigned cache_novlys
= 0;
3357 static unsigned cache_novly_regions
= 0;
3359 static CORE_ADDR cache_ovly_table_base
= 0;
3361 static CORE_ADDR cache_ovly_region_table_base
= 0;
3365 VMA
, SIZE
, LMA
, MAPPED
3367 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
3369 /* Throw away the cached copy of _ovly_table */
3371 simple_free_overlay_table (void)
3373 if (cache_ovly_table
)
3374 xfree (cache_ovly_table
);
3376 cache_ovly_table
= NULL
;
3377 cache_ovly_table_base
= 0;
3381 /* Throw away the cached copy of _ovly_region_table */
3383 simple_free_overlay_region_table (void)
3385 if (cache_ovly_region_table
)
3386 xfree (cache_ovly_region_table
);
3387 cache_novly_regions
= 0;
3388 cache_ovly_region_table
= NULL
;
3389 cache_ovly_region_table_base
= 0;
3393 /* Read an array of ints from the target into a local buffer.
3394 Convert to host order. int LEN is number of ints */
3396 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
, int len
)
3398 /* FIXME (alloca): Not safe if array is very large. */
3399 char *buf
= alloca (len
* TARGET_LONG_BYTES
);
3402 read_memory (memaddr
, buf
, len
* TARGET_LONG_BYTES
);
3403 for (i
= 0; i
< len
; i
++)
3404 myaddr
[i
] = extract_unsigned_integer (TARGET_LONG_BYTES
* i
+ buf
,
3408 /* Find and grab a copy of the target _ovly_table
3409 (and _novlys, which is needed for the table's size) */
3411 simple_read_overlay_table (void)
3413 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3415 simple_free_overlay_table ();
3416 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3419 error ("Error reading inferior's overlay table: "
3420 "couldn't find `_novlys' variable\n"
3421 "in inferior. Use `overlay manual' mode.");
3425 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3426 if (! ovly_table_msym
)
3428 error ("Error reading inferior's overlay table: couldn't find "
3429 "`_ovly_table' array\n"
3430 "in inferior. Use `overlay manual' mode.");
3434 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
), 4);
3436 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3437 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3438 read_target_long_array (cache_ovly_table_base
,
3439 (int *) cache_ovly_table
,
3442 return 1; /* SUCCESS */
3446 /* Find and grab a copy of the target _ovly_region_table
3447 (and _novly_regions, which is needed for the table's size) */
3449 simple_read_overlay_region_table (void)
3451 struct minimal_symbol
*msym
;
3453 simple_free_overlay_region_table ();
3454 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3456 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
3458 return 0; /* failure */
3459 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3460 if (cache_ovly_region_table
!= NULL
)
3462 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3465 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3466 read_target_long_array (cache_ovly_region_table_base
,
3467 (int *) cache_ovly_region_table
,
3468 cache_novly_regions
* 3);
3471 return 0; /* failure */
3474 return 0; /* failure */
3475 return 1; /* SUCCESS */
3479 /* Function: simple_overlay_update_1
3480 A helper function for simple_overlay_update. Assuming a cached copy
3481 of _ovly_table exists, look through it to find an entry whose vma,
3482 lma and size match those of OSECT. Re-read the entry and make sure
3483 it still matches OSECT (else the table may no longer be valid).
3484 Set OSECT's mapped state to match the entry. Return: 1 for
3485 success, 0 for failure. */
3488 simple_overlay_update_1 (struct obj_section
*osect
)
3491 bfd
*obfd
= osect
->objfile
->obfd
;
3492 asection
*bsect
= osect
->the_bfd_section
;
3494 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3495 for (i
= 0; i
< cache_novlys
; i
++)
3496 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3497 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3498 /* && cache_ovly_table[i][SIZE] == size */ )
3500 read_target_long_array (cache_ovly_table_base
+ i
* TARGET_LONG_BYTES
,
3501 (int *) cache_ovly_table
[i
], 4);
3502 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3503 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3504 /* && cache_ovly_table[i][SIZE] == size */ )
3506 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3509 else /* Warning! Warning! Target's ovly table has changed! */
3515 /* Function: simple_overlay_update
3516 If OSECT is NULL, then update all sections' mapped state
3517 (after re-reading the entire target _ovly_table).
3518 If OSECT is non-NULL, then try to find a matching entry in the
3519 cached ovly_table and update only OSECT's mapped state.
3520 If a cached entry can't be found or the cache isn't valid, then
3521 re-read the entire cache, and go ahead and update all sections. */
3524 simple_overlay_update (struct obj_section
*osect
)
3526 struct objfile
*objfile
;
3528 /* Were we given an osect to look up? NULL means do all of them. */
3530 /* Have we got a cached copy of the target's overlay table? */
3531 if (cache_ovly_table
!= NULL
)
3532 /* Does its cached location match what's currently in the symtab? */
3533 if (cache_ovly_table_base
==
3534 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3535 /* Then go ahead and try to look up this single section in the cache */
3536 if (simple_overlay_update_1 (osect
))
3537 /* Found it! We're done. */
3540 /* Cached table no good: need to read the entire table anew.
3541 Or else we want all the sections, in which case it's actually
3542 more efficient to read the whole table in one block anyway. */
3544 if (! simple_read_overlay_table ())
3547 /* Now may as well update all sections, even if only one was requested. */
3548 ALL_OBJSECTIONS (objfile
, osect
)
3549 if (section_is_overlay (osect
->the_bfd_section
))
3552 bfd
*obfd
= osect
->objfile
->obfd
;
3553 asection
*bsect
= osect
->the_bfd_section
;
3555 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3556 for (i
= 0; i
< cache_novlys
; i
++)
3557 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3558 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3559 /* && cache_ovly_table[i][SIZE] == size */ )
3560 { /* obj_section matches i'th entry in ovly_table */
3561 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3562 break; /* finished with inner for loop: break out */
3567 /* Set the output sections and output offsets for section SECTP in
3568 ABFD. The relocation code in BFD will read these offsets, so we
3569 need to be sure they're initialized. We map each section to itself,
3570 with no offset; this means that SECTP->vma will be honored. */
3573 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3575 sectp
->output_section
= sectp
;
3576 sectp
->output_offset
= 0;
3579 /* Relocate the contents of a debug section SECTP in ABFD. The
3580 contents are stored in BUF if it is non-NULL, or returned in a
3581 malloc'd buffer otherwise.
3583 For some platforms and debug info formats, shared libraries contain
3584 relocations against the debug sections (particularly for DWARF-2;
3585 one affected platform is PowerPC GNU/Linux, although it depends on
3586 the version of the linker in use). Also, ELF object files naturally
3587 have unresolved relocations for their debug sections. We need to apply
3588 the relocations in order to get the locations of symbols correct. */
3591 symfile_relocate_debug_section (bfd
*abfd
, asection
*sectp
, bfd_byte
*buf
)
3593 /* We're only interested in debugging sections with relocation
3595 if ((sectp
->flags
& SEC_RELOC
) == 0)
3597 if ((sectp
->flags
& SEC_DEBUGGING
) == 0)
3600 /* We will handle section offsets properly elsewhere, so relocate as if
3601 all sections begin at 0. */
3602 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3604 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
);
3608 _initialize_symfile (void)
3610 struct cmd_list_element
*c
;
3612 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
3613 "Load symbol table from executable file FILE.\n\
3614 The `file' command can also load symbol tables, as well as setting the file\n\
3615 to execute.", &cmdlist
);
3616 set_cmd_completer (c
, filename_completer
);
3618 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
3619 "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3620 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
3621 ADDR is the starting address of the file's text.\n\
3622 The optional arguments are section-name section-address pairs and\n\
3623 should be specified if the data and bss segments are not contiguous\n\
3624 with the text. SECT is a section name to be loaded at SECT_ADDR.",
3626 set_cmd_completer (c
, filename_completer
);
3628 c
= add_cmd ("add-shared-symbol-files", class_files
,
3629 add_shared_symbol_files_command
,
3630 "Load the symbols from shared objects in the dynamic linker's link map.",
3632 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
3635 c
= add_cmd ("load", class_files
, load_command
,
3636 "Dynamically load FILE into the running program, and record its symbols\n\
3637 for access from GDB.", &cmdlist
);
3638 set_cmd_completer (c
, filename_completer
);
3641 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
3642 (char *) &symbol_reloading
,
3643 "Set dynamic symbol table reloading multiple times in one run.",
3647 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3648 "Commands for debugging overlays.", &overlaylist
,
3649 "overlay ", 0, &cmdlist
);
3651 add_com_alias ("ovly", "overlay", class_alias
, 1);
3652 add_com_alias ("ov", "overlay", class_alias
, 1);
3654 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3655 "Assert that an overlay section is mapped.", &overlaylist
);
3657 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3658 "Assert that an overlay section is unmapped.", &overlaylist
);
3660 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3661 "List mappings of overlay sections.", &overlaylist
);
3663 add_cmd ("manual", class_support
, overlay_manual_command
,
3664 "Enable overlay debugging.", &overlaylist
);
3665 add_cmd ("off", class_support
, overlay_off_command
,
3666 "Disable overlay debugging.", &overlaylist
);
3667 add_cmd ("auto", class_support
, overlay_auto_command
,
3668 "Enable automatic overlay debugging.", &overlaylist
);
3669 add_cmd ("load-target", class_support
, overlay_load_command
,
3670 "Read the overlay mapping state from the target.", &overlaylist
);
3672 /* Filename extension to source language lookup table: */
3673 init_filename_language_table ();
3674 c
= add_set_cmd ("extension-language", class_files
, var_string_noescape
,
3676 "Set mapping between filename extension and source language.\n\
3677 Usage: set extension-language .foo bar",
3679 set_cmd_cfunc (c
, set_ext_lang_command
);
3681 add_info ("extensions", info_ext_lang_command
,
3682 "All filename extensions associated with a source language.");
3685 (add_set_cmd ("download-write-size", class_obscure
,
3686 var_integer
, (char *) &download_write_size
,
3687 "Set the write size used when downloading a program.\n"
3688 "Only used when downloading a program onto a remote\n"
3689 "target. Specify zero, or a negative value, to disable\n"
3690 "blocked writes. The actual size of each transfer is also\n"
3691 "limited by the size of the target packet and the memory\n"
3696 debug_file_directory
= xstrdup (DEBUGDIR
);
3698 ("debug-file-directory", class_support
, var_string
,
3699 (char *) &debug_file_directory
,
3700 "Set the directory where separate debug symbols are searched for.\n"
3701 "Separate debug symbols are first searched for in the same\n"
3702 "directory as the binary, then in the `" DEBUG_SUBDIRECTORY
3704 "and lastly at the path of the directory of the binary with\n"
3705 "the global debug-file directory prepended\n",
3707 add_show_from_set (c
, &showlist
);
3708 set_cmd_completer (c
, filename_completer
);