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 to
1656 a comment from remote-mips.c (where a call to symbol_file_add was
1657 commented out), making the call confuses GDB if more than one file is
1658 loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
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 ()));
2023 /* We use the same section offsets as from last time. I'm not
2024 sure whether that is always correct for shared libraries. */
2025 objfile
->section_offsets
= (struct section_offsets
*)
2026 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
2027 memcpy (objfile
->section_offsets
, offsets
, SIZEOF_SECTION_OFFSETS
);
2028 objfile
->num_sections
= num_offsets
;
2030 /* What the hell is sym_new_init for, anyway? The concept of
2031 distinguishing between the main file and additional files
2032 in this way seems rather dubious. */
2033 if (objfile
== symfile_objfile
)
2035 (*objfile
->sf
->sym_new_init
) (objfile
);
2037 RESET_HP_UX_GLOBALS ();
2041 (*objfile
->sf
->sym_init
) (objfile
);
2042 clear_complaints (&symfile_complaints
, 1, 1);
2043 /* The "mainline" parameter is a hideous hack; I think leaving it
2044 zero is OK since dbxread.c also does what it needs to do if
2045 objfile->global_psymbols.size is 0. */
2046 (*objfile
->sf
->sym_read
) (objfile
, 0);
2047 if (!have_partial_symbols () && !have_full_symbols ())
2050 printf_filtered ("(no debugging symbols found)\n");
2053 objfile
->flags
|= OBJF_SYMS
;
2055 /* We're done reading the symbol file; finish off complaints. */
2056 clear_complaints (&symfile_complaints
, 0, 1);
2058 /* Getting new symbols may change our opinion about what is
2061 reinit_frame_cache ();
2063 /* Discard cleanups as symbol reading was successful. */
2064 discard_cleanups (old_cleanups
);
2066 /* If the mtime has changed between the time we set new_modtime
2067 and now, we *want* this to be out of date, so don't call stat
2069 objfile
->mtime
= new_modtime
;
2072 /* Call this after reading in a new symbol table to give target
2073 dependent code a crack at the new symbols. For instance, this
2074 could be used to update the values of target-specific symbols GDB
2075 needs to keep track of (such as _sigtramp, or whatever). */
2077 TARGET_SYMFILE_POSTREAD (objfile
);
2079 reread_separate_symbols (objfile
);
2085 clear_symtab_users ();
2089 /* Handle separate debug info for OBJFILE, which has just been
2091 - If we had separate debug info before, but now we don't, get rid
2092 of the separated objfile.
2093 - If we didn't have separated debug info before, but now we do,
2094 read in the new separated debug info file.
2095 - If the debug link points to a different file, toss the old one
2096 and read the new one.
2097 This function does *not* handle the case where objfile is still
2098 using the same separate debug info file, but that file's timestamp
2099 has changed. That case should be handled by the loop in
2100 reread_symbols already. */
2102 reread_separate_symbols (struct objfile
*objfile
)
2105 unsigned long crc32
;
2107 /* Does the updated objfile's debug info live in a
2109 debug_file
= find_separate_debug_file (objfile
);
2111 if (objfile
->separate_debug_objfile
)
2113 /* There are two cases where we need to get rid of
2114 the old separated debug info objfile:
2115 - if the new primary objfile doesn't have
2116 separated debug info, or
2117 - if the new primary objfile has separate debug
2118 info, but it's under a different filename.
2120 If the old and new objfiles both have separate
2121 debug info, under the same filename, then we're
2122 okay --- if the separated file's contents have
2123 changed, we will have caught that when we
2124 visited it in this function's outermost
2127 || strcmp (debug_file
, objfile
->separate_debug_objfile
->name
) != 0)
2128 free_objfile (objfile
->separate_debug_objfile
);
2131 /* If the new objfile has separate debug info, and we
2132 haven't loaded it already, do so now. */
2134 && ! objfile
->separate_debug_objfile
)
2136 /* Use the same section offset table as objfile itself.
2137 Preserve the flags from objfile that make sense. */
2138 objfile
->separate_debug_objfile
2139 = (symbol_file_add_with_addrs_or_offsets
2141 info_verbose
, /* from_tty: Don't override the default. */
2142 0, /* No addr table. */
2143 objfile
->section_offsets
, objfile
->num_sections
,
2144 0, /* Not mainline. See comments about this above. */
2145 objfile
->flags
& (OBJF_MAPPED
| OBJF_REORDERED
2146 | OBJF_SHARED
| OBJF_READNOW
2147 | OBJF_USERLOADED
)));
2148 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
2164 static filename_language
*filename_language_table
;
2165 static int fl_table_size
, fl_table_next
;
2168 add_filename_language (char *ext
, enum language lang
)
2170 if (fl_table_next
>= fl_table_size
)
2172 fl_table_size
+= 10;
2173 filename_language_table
=
2174 xrealloc (filename_language_table
,
2175 fl_table_size
* sizeof (*filename_language_table
));
2178 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2179 filename_language_table
[fl_table_next
].lang
= lang
;
2183 static char *ext_args
;
2186 set_ext_lang_command (char *args
, int from_tty
)
2189 char *cp
= ext_args
;
2192 /* First arg is filename extension, starting with '.' */
2194 error ("'%s': Filename extension must begin with '.'", ext_args
);
2196 /* Find end of first arg. */
2197 while (*cp
&& !isspace (*cp
))
2201 error ("'%s': two arguments required -- filename extension and language",
2204 /* Null-terminate first arg */
2207 /* Find beginning of second arg, which should be a source language. */
2208 while (*cp
&& isspace (*cp
))
2212 error ("'%s': two arguments required -- filename extension and language",
2215 /* Lookup the language from among those we know. */
2216 lang
= language_enum (cp
);
2218 /* Now lookup the filename extension: do we already know it? */
2219 for (i
= 0; i
< fl_table_next
; i
++)
2220 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2223 if (i
>= fl_table_next
)
2225 /* new file extension */
2226 add_filename_language (ext_args
, lang
);
2230 /* redefining a previously known filename extension */
2233 /* query ("Really make files of type %s '%s'?", */
2234 /* ext_args, language_str (lang)); */
2236 xfree (filename_language_table
[i
].ext
);
2237 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2238 filename_language_table
[i
].lang
= lang
;
2243 info_ext_lang_command (char *args
, int from_tty
)
2247 printf_filtered ("Filename extensions and the languages they represent:");
2248 printf_filtered ("\n\n");
2249 for (i
= 0; i
< fl_table_next
; i
++)
2250 printf_filtered ("\t%s\t- %s\n",
2251 filename_language_table
[i
].ext
,
2252 language_str (filename_language_table
[i
].lang
));
2256 init_filename_language_table (void)
2258 if (fl_table_size
== 0) /* protect against repetition */
2262 filename_language_table
=
2263 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2264 add_filename_language (".c", language_c
);
2265 add_filename_language (".C", language_cplus
);
2266 add_filename_language (".cc", language_cplus
);
2267 add_filename_language (".cp", language_cplus
);
2268 add_filename_language (".cpp", language_cplus
);
2269 add_filename_language (".cxx", language_cplus
);
2270 add_filename_language (".c++", language_cplus
);
2271 add_filename_language (".java", language_java
);
2272 add_filename_language (".class", language_java
);
2273 add_filename_language (".m", language_objc
);
2274 add_filename_language (".f", language_fortran
);
2275 add_filename_language (".F", language_fortran
);
2276 add_filename_language (".s", language_asm
);
2277 add_filename_language (".S", language_asm
);
2278 add_filename_language (".pas", language_pascal
);
2279 add_filename_language (".p", language_pascal
);
2280 add_filename_language (".pp", language_pascal
);
2285 deduce_language_from_filename (char *filename
)
2290 if (filename
!= NULL
)
2291 if ((cp
= strrchr (filename
, '.')) != NULL
)
2292 for (i
= 0; i
< fl_table_next
; i
++)
2293 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2294 return filename_language_table
[i
].lang
;
2296 return language_unknown
;
2301 Allocate and partly initialize a new symbol table. Return a pointer
2302 to it. error() if no space.
2304 Caller must set these fields:
2310 possibly free_named_symtabs (symtab->filename);
2314 allocate_symtab (char *filename
, struct objfile
*objfile
)
2316 register struct symtab
*symtab
;
2318 symtab
= (struct symtab
*)
2319 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct symtab
));
2320 memset (symtab
, 0, sizeof (*symtab
));
2321 symtab
->filename
= obsavestring (filename
, strlen (filename
),
2322 &objfile
->symbol_obstack
);
2323 symtab
->fullname
= NULL
;
2324 symtab
->language
= deduce_language_from_filename (filename
);
2325 symtab
->debugformat
= obsavestring ("unknown", 7,
2326 &objfile
->symbol_obstack
);
2328 /* Hook it to the objfile it comes from */
2330 symtab
->objfile
= objfile
;
2331 symtab
->next
= objfile
->symtabs
;
2332 objfile
->symtabs
= symtab
;
2334 /* FIXME: This should go away. It is only defined for the Z8000,
2335 and the Z8000 definition of this macro doesn't have anything to
2336 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
2337 here for convenience. */
2338 #ifdef INIT_EXTRA_SYMTAB_INFO
2339 INIT_EXTRA_SYMTAB_INFO (symtab
);
2345 struct partial_symtab
*
2346 allocate_psymtab (char *filename
, struct objfile
*objfile
)
2348 struct partial_symtab
*psymtab
;
2350 if (objfile
->free_psymtabs
)
2352 psymtab
= objfile
->free_psymtabs
;
2353 objfile
->free_psymtabs
= psymtab
->next
;
2356 psymtab
= (struct partial_symtab
*)
2357 obstack_alloc (&objfile
->psymbol_obstack
,
2358 sizeof (struct partial_symtab
));
2360 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2361 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
2362 &objfile
->psymbol_obstack
);
2363 psymtab
->symtab
= NULL
;
2365 /* Prepend it to the psymtab list for the objfile it belongs to.
2366 Psymtabs are searched in most recent inserted -> least recent
2369 psymtab
->objfile
= objfile
;
2370 psymtab
->next
= objfile
->psymtabs
;
2371 objfile
->psymtabs
= psymtab
;
2374 struct partial_symtab
**prev_pst
;
2375 psymtab
->objfile
= objfile
;
2376 psymtab
->next
= NULL
;
2377 prev_pst
= &(objfile
->psymtabs
);
2378 while ((*prev_pst
) != NULL
)
2379 prev_pst
= &((*prev_pst
)->next
);
2380 (*prev_pst
) = psymtab
;
2388 discard_psymtab (struct partial_symtab
*pst
)
2390 struct partial_symtab
**prev_pst
;
2393 Empty psymtabs happen as a result of header files which don't
2394 have any symbols in them. There can be a lot of them. But this
2395 check is wrong, in that a psymtab with N_SLINE entries but
2396 nothing else is not empty, but we don't realize that. Fixing
2397 that without slowing things down might be tricky. */
2399 /* First, snip it out of the psymtab chain */
2401 prev_pst
= &(pst
->objfile
->psymtabs
);
2402 while ((*prev_pst
) != pst
)
2403 prev_pst
= &((*prev_pst
)->next
);
2404 (*prev_pst
) = pst
->next
;
2406 /* Next, put it on a free list for recycling */
2408 pst
->next
= pst
->objfile
->free_psymtabs
;
2409 pst
->objfile
->free_psymtabs
= pst
;
2413 /* Reset all data structures in gdb which may contain references to symbol
2417 clear_symtab_users (void)
2419 /* Someday, we should do better than this, by only blowing away
2420 the things that really need to be blown. */
2421 clear_value_history ();
2423 clear_internalvars ();
2424 breakpoint_re_set ();
2425 set_default_breakpoint (0, 0, 0, 0);
2426 clear_current_source_symtab_and_line ();
2427 clear_pc_function_cache ();
2428 if (target_new_objfile_hook
)
2429 target_new_objfile_hook (NULL
);
2433 clear_symtab_users_cleanup (void *ignore
)
2435 clear_symtab_users ();
2438 /* clear_symtab_users_once:
2440 This function is run after symbol reading, or from a cleanup.
2441 If an old symbol table was obsoleted, the old symbol table
2442 has been blown away, but the other GDB data structures that may
2443 reference it have not yet been cleared or re-directed. (The old
2444 symtab was zapped, and the cleanup queued, in free_named_symtab()
2447 This function can be queued N times as a cleanup, or called
2448 directly; it will do all the work the first time, and then will be a
2449 no-op until the next time it is queued. This works by bumping a
2450 counter at queueing time. Much later when the cleanup is run, or at
2451 the end of symbol processing (in case the cleanup is discarded), if
2452 the queued count is greater than the "done-count", we do the work
2453 and set the done-count to the queued count. If the queued count is
2454 less than or equal to the done-count, we just ignore the call. This
2455 is needed because reading a single .o file will often replace many
2456 symtabs (one per .h file, for example), and we don't want to reset
2457 the breakpoints N times in the user's face.
2459 The reason we both queue a cleanup, and call it directly after symbol
2460 reading, is because the cleanup protects us in case of errors, but is
2461 discarded if symbol reading is successful. */
2464 /* FIXME: As free_named_symtabs is currently a big noop this function
2465 is no longer needed. */
2466 static void clear_symtab_users_once (void);
2468 static int clear_symtab_users_queued
;
2469 static int clear_symtab_users_done
;
2472 clear_symtab_users_once (void)
2474 /* Enforce once-per-`do_cleanups'-semantics */
2475 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2477 clear_symtab_users_done
= clear_symtab_users_queued
;
2479 clear_symtab_users ();
2483 /* Delete the specified psymtab, and any others that reference it. */
2486 cashier_psymtab (struct partial_symtab
*pst
)
2488 struct partial_symtab
*ps
, *pprev
= NULL
;
2491 /* Find its previous psymtab in the chain */
2492 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2501 /* Unhook it from the chain. */
2502 if (ps
== pst
->objfile
->psymtabs
)
2503 pst
->objfile
->psymtabs
= ps
->next
;
2505 pprev
->next
= ps
->next
;
2507 /* FIXME, we can't conveniently deallocate the entries in the
2508 partial_symbol lists (global_psymbols/static_psymbols) that
2509 this psymtab points to. These just take up space until all
2510 the psymtabs are reclaimed. Ditto the dependencies list and
2511 filename, which are all in the psymbol_obstack. */
2513 /* We need to cashier any psymtab that has this one as a dependency... */
2515 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2517 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2519 if (ps
->dependencies
[i
] == pst
)
2521 cashier_psymtab (ps
);
2522 goto again
; /* Must restart, chain has been munged. */
2529 /* If a symtab or psymtab for filename NAME is found, free it along
2530 with any dependent breakpoints, displays, etc.
2531 Used when loading new versions of object modules with the "add-file"
2532 command. This is only called on the top-level symtab or psymtab's name;
2533 it is not called for subsidiary files such as .h files.
2535 Return value is 1 if we blew away the environment, 0 if not.
2536 FIXME. The return value appears to never be used.
2538 FIXME. I think this is not the best way to do this. We should
2539 work on being gentler to the environment while still cleaning up
2540 all stray pointers into the freed symtab. */
2543 free_named_symtabs (char *name
)
2546 /* FIXME: With the new method of each objfile having it's own
2547 psymtab list, this function needs serious rethinking. In particular,
2548 why was it ever necessary to toss psymtabs with specific compilation
2549 unit filenames, as opposed to all psymtabs from a particular symbol
2551 Well, the answer is that some systems permit reloading of particular
2552 compilation units. We want to blow away any old info about these
2553 compilation units, regardless of which objfiles they arrived in. --gnu. */
2555 register struct symtab
*s
;
2556 register struct symtab
*prev
;
2557 register struct partial_symtab
*ps
;
2558 struct blockvector
*bv
;
2561 /* We only wack things if the symbol-reload switch is set. */
2562 if (!symbol_reloading
)
2565 /* Some symbol formats have trouble providing file names... */
2566 if (name
== 0 || *name
== '\0')
2569 /* Look for a psymtab with the specified name. */
2572 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2574 if (STREQ (name
, ps
->filename
))
2576 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2577 goto again2
; /* Must restart, chain has been munged */
2581 /* Look for a symtab with the specified name. */
2583 for (s
= symtab_list
; s
; s
= s
->next
)
2585 if (STREQ (name
, s
->filename
))
2592 if (s
== symtab_list
)
2593 symtab_list
= s
->next
;
2595 prev
->next
= s
->next
;
2597 /* For now, queue a delete for all breakpoints, displays, etc., whether
2598 or not they depend on the symtab being freed. This should be
2599 changed so that only those data structures affected are deleted. */
2601 /* But don't delete anything if the symtab is empty.
2602 This test is necessary due to a bug in "dbxread.c" that
2603 causes empty symtabs to be created for N_SO symbols that
2604 contain the pathname of the object file. (This problem
2605 has been fixed in GDB 3.9x). */
2607 bv
= BLOCKVECTOR (s
);
2608 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2609 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2610 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2612 complaint (&symfile_complaints
, "Replacing old symbols for `%s'",
2614 clear_symtab_users_queued
++;
2615 make_cleanup (clear_symtab_users_once
, 0);
2620 complaint (&symfile_complaints
, "Empty symbol table found for `%s'",
2628 /* It is still possible that some breakpoints will be affected
2629 even though no symtab was found, since the file might have
2630 been compiled without debugging, and hence not be associated
2631 with a symtab. In order to handle this correctly, we would need
2632 to keep a list of text address ranges for undebuggable files.
2633 For now, we do nothing, since this is a fairly obscure case. */
2637 /* FIXME, what about the minimal symbol table? */
2644 /* Allocate and partially fill a partial symtab. It will be
2645 completely filled at the end of the symbol list.
2647 FILENAME is the name of the symbol-file we are reading from. */
2649 struct partial_symtab
*
2650 start_psymtab_common (struct objfile
*objfile
,
2651 struct section_offsets
*section_offsets
, char *filename
,
2652 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2653 struct partial_symbol
**static_syms
)
2655 struct partial_symtab
*psymtab
;
2657 psymtab
= allocate_psymtab (filename
, objfile
);
2658 psymtab
->section_offsets
= section_offsets
;
2659 psymtab
->textlow
= textlow
;
2660 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2661 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2662 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2666 /* Add a symbol with a long value to a psymtab.
2667 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
2670 add_psymbol_to_list (char *name
, int namelength
, namespace_enum
namespace,
2671 enum address_class
class,
2672 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2673 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2674 enum language language
, struct objfile
*objfile
)
2676 register struct partial_symbol
*psym
;
2677 char *buf
= alloca (namelength
+ 1);
2678 /* psymbol is static so that there will be no uninitialized gaps in the
2679 structure which might contain random data, causing cache misses in
2681 static struct partial_symbol psymbol
;
2683 /* Create local copy of the partial symbol */
2684 memcpy (buf
, name
, namelength
);
2685 buf
[namelength
] = '\0';
2686 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, objfile
->psymbol_cache
);
2687 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2690 SYMBOL_VALUE (&psymbol
) = val
;
2694 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2696 SYMBOL_SECTION (&psymbol
) = 0;
2697 SYMBOL_LANGUAGE (&psymbol
) = language
;
2698 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2699 PSYMBOL_CLASS (&psymbol
) = class;
2700 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2702 /* Stash the partial symbol away in the cache */
2703 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), objfile
->psymbol_cache
);
2705 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2706 if (list
->next
>= list
->list
+ list
->size
)
2708 extend_psymbol_list (list
, objfile
);
2710 *list
->next
++ = psym
;
2711 OBJSTAT (objfile
, n_psyms
++);
2714 /* Add a symbol with a long value to a psymtab. This differs from
2715 * add_psymbol_to_list above in taking both a mangled and a demangled
2719 add_psymbol_with_dem_name_to_list (char *name
, int namelength
, char *dem_name
,
2720 int dem_namelength
, namespace_enum
namespace,
2721 enum address_class
class,
2722 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2723 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2724 enum language language
,
2725 struct objfile
*objfile
)
2727 register struct partial_symbol
*psym
;
2728 char *buf
= alloca (namelength
+ 1);
2729 /* psymbol is static so that there will be no uninitialized gaps in the
2730 structure which might contain random data, causing cache misses in
2732 static struct partial_symbol psymbol
;
2734 /* Create local copy of the partial symbol */
2736 memcpy (buf
, name
, namelength
);
2737 buf
[namelength
] = '\0';
2738 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, objfile
->psymbol_cache
);
2740 buf
= alloca (dem_namelength
+ 1);
2741 memcpy (buf
, dem_name
, dem_namelength
);
2742 buf
[dem_namelength
] = '\0';
2747 case language_cplus
:
2748 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol
) =
2749 bcache (buf
, dem_namelength
+ 1, objfile
->psymbol_cache
);
2751 /* FIXME What should be done for the default case? Ignoring for now. */
2754 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2757 SYMBOL_VALUE (&psymbol
) = val
;
2761 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2763 SYMBOL_SECTION (&psymbol
) = 0;
2764 SYMBOL_LANGUAGE (&psymbol
) = language
;
2765 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2766 PSYMBOL_CLASS (&psymbol
) = class;
2767 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2769 /* Stash the partial symbol away in the cache */
2770 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), objfile
->psymbol_cache
);
2772 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2773 if (list
->next
>= list
->list
+ list
->size
)
2775 extend_psymbol_list (list
, objfile
);
2777 *list
->next
++ = psym
;
2778 OBJSTAT (objfile
, n_psyms
++);
2781 /* Initialize storage for partial symbols. */
2784 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
2786 /* Free any previously allocated psymbol lists. */
2788 if (objfile
->global_psymbols
.list
)
2790 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
2792 if (objfile
->static_psymbols
.list
)
2794 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
2797 /* Current best guess is that approximately a twentieth
2798 of the total symbols (in a debugging file) are global or static
2801 objfile
->global_psymbols
.size
= total_symbols
/ 10;
2802 objfile
->static_psymbols
.size
= total_symbols
/ 10;
2804 if (objfile
->global_psymbols
.size
> 0)
2806 objfile
->global_psymbols
.next
=
2807 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
2808 xmmalloc (objfile
->md
, (objfile
->global_psymbols
.size
2809 * sizeof (struct partial_symbol
*)));
2811 if (objfile
->static_psymbols
.size
> 0)
2813 objfile
->static_psymbols
.next
=
2814 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
2815 xmmalloc (objfile
->md
, (objfile
->static_psymbols
.size
2816 * sizeof (struct partial_symbol
*)));
2821 The following code implements an abstraction for debugging overlay sections.
2823 The target model is as follows:
2824 1) The gnu linker will permit multiple sections to be mapped into the
2825 same VMA, each with its own unique LMA (or load address).
2826 2) It is assumed that some runtime mechanism exists for mapping the
2827 sections, one by one, from the load address into the VMA address.
2828 3) This code provides a mechanism for gdb to keep track of which
2829 sections should be considered to be mapped from the VMA to the LMA.
2830 This information is used for symbol lookup, and memory read/write.
2831 For instance, if a section has been mapped then its contents
2832 should be read from the VMA, otherwise from the LMA.
2834 Two levels of debugger support for overlays are available. One is
2835 "manual", in which the debugger relies on the user to tell it which
2836 overlays are currently mapped. This level of support is
2837 implemented entirely in the core debugger, and the information about
2838 whether a section is mapped is kept in the objfile->obj_section table.
2840 The second level of support is "automatic", and is only available if
2841 the target-specific code provides functionality to read the target's
2842 overlay mapping table, and translate its contents for the debugger
2843 (by updating the mapped state information in the obj_section tables).
2845 The interface is as follows:
2847 overlay map <name> -- tell gdb to consider this section mapped
2848 overlay unmap <name> -- tell gdb to consider this section unmapped
2849 overlay list -- list the sections that GDB thinks are mapped
2850 overlay read-target -- get the target's state of what's mapped
2851 overlay off/manual/auto -- set overlay debugging state
2852 Functional interface:
2853 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2854 section, return that section.
2855 find_pc_overlay(pc): find any overlay section that contains
2856 the pc, either in its VMA or its LMA
2857 overlay_is_mapped(sect): true if overlay is marked as mapped
2858 section_is_overlay(sect): true if section's VMA != LMA
2859 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2860 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2861 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2862 overlay_mapped_address(...): map an address from section's LMA to VMA
2863 overlay_unmapped_address(...): map an address from section's VMA to LMA
2864 symbol_overlayed_address(...): Return a "current" address for symbol:
2865 either in VMA or LMA depending on whether
2866 the symbol's section is currently mapped
2869 /* Overlay debugging state: */
2871 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2872 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
2874 /* Target vector for refreshing overlay mapped state */
2875 static void simple_overlay_update (struct obj_section
*);
2876 void (*target_overlay_update
) (struct obj_section
*) = simple_overlay_update
;
2878 /* Function: section_is_overlay (SECTION)
2879 Returns true if SECTION has VMA not equal to LMA, ie.
2880 SECTION is loaded at an address different from where it will "run". */
2883 section_is_overlay (asection
*section
)
2885 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2887 if (overlay_debugging
)
2888 if (section
&& section
->lma
!= 0 &&
2889 section
->vma
!= section
->lma
)
2895 /* Function: overlay_invalidate_all (void)
2896 Invalidate the mapped state of all overlay sections (mark it as stale). */
2899 overlay_invalidate_all (void)
2901 struct objfile
*objfile
;
2902 struct obj_section
*sect
;
2904 ALL_OBJSECTIONS (objfile
, sect
)
2905 if (section_is_overlay (sect
->the_bfd_section
))
2906 sect
->ovly_mapped
= -1;
2909 /* Function: overlay_is_mapped (SECTION)
2910 Returns true if section is an overlay, and is currently mapped.
2911 Private: public access is thru function section_is_mapped.
2913 Access to the ovly_mapped flag is restricted to this function, so
2914 that we can do automatic update. If the global flag
2915 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2916 overlay_invalidate_all. If the mapped state of the particular
2917 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2920 overlay_is_mapped (struct obj_section
*osect
)
2922 if (osect
== 0 || !section_is_overlay (osect
->the_bfd_section
))
2925 switch (overlay_debugging
)
2929 return 0; /* overlay debugging off */
2930 case ovly_auto
: /* overlay debugging automatic */
2931 /* Unles there is a target_overlay_update function,
2932 there's really nothing useful to do here (can't really go auto) */
2933 if (target_overlay_update
)
2935 if (overlay_cache_invalid
)
2937 overlay_invalidate_all ();
2938 overlay_cache_invalid
= 0;
2940 if (osect
->ovly_mapped
== -1)
2941 (*target_overlay_update
) (osect
);
2943 /* fall thru to manual case */
2944 case ovly_on
: /* overlay debugging manual */
2945 return osect
->ovly_mapped
== 1;
2949 /* Function: section_is_mapped
2950 Returns true if section is an overlay, and is currently mapped. */
2953 section_is_mapped (asection
*section
)
2955 struct objfile
*objfile
;
2956 struct obj_section
*osect
;
2958 if (overlay_debugging
)
2959 if (section
&& section_is_overlay (section
))
2960 ALL_OBJSECTIONS (objfile
, osect
)
2961 if (osect
->the_bfd_section
== section
)
2962 return overlay_is_mapped (osect
);
2967 /* Function: pc_in_unmapped_range
2968 If PC falls into the lma range of SECTION, return true, else false. */
2971 pc_in_unmapped_range (CORE_ADDR pc
, asection
*section
)
2973 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2977 if (overlay_debugging
)
2978 if (section
&& section_is_overlay (section
))
2980 size
= bfd_get_section_size_before_reloc (section
);
2981 if (section
->lma
<= pc
&& pc
< section
->lma
+ size
)
2987 /* Function: pc_in_mapped_range
2988 If PC falls into the vma range of SECTION, return true, else false. */
2991 pc_in_mapped_range (CORE_ADDR pc
, asection
*section
)
2993 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2997 if (overlay_debugging
)
2998 if (section
&& section_is_overlay (section
))
3000 size
= bfd_get_section_size_before_reloc (section
);
3001 if (section
->vma
<= pc
&& pc
< section
->vma
+ size
)
3008 /* Return true if the mapped ranges of sections A and B overlap, false
3011 sections_overlap (asection
*a
, asection
*b
)
3013 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3015 CORE_ADDR a_start
= a
->vma
;
3016 CORE_ADDR a_end
= a
->vma
+ bfd_get_section_size_before_reloc (a
);
3017 CORE_ADDR b_start
= b
->vma
;
3018 CORE_ADDR b_end
= b
->vma
+ bfd_get_section_size_before_reloc (b
);
3020 return (a_start
< b_end
&& b_start
< a_end
);
3023 /* Function: overlay_unmapped_address (PC, SECTION)
3024 Returns the address corresponding to PC in the unmapped (load) range.
3025 May be the same as PC. */
3028 overlay_unmapped_address (CORE_ADDR pc
, asection
*section
)
3030 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
3032 if (overlay_debugging
)
3033 if (section
&& section_is_overlay (section
) &&
3034 pc_in_mapped_range (pc
, section
))
3035 return pc
+ section
->lma
- section
->vma
;
3040 /* Function: overlay_mapped_address (PC, SECTION)
3041 Returns the address corresponding to PC in the mapped (runtime) range.
3042 May be the same as PC. */
3045 overlay_mapped_address (CORE_ADDR pc
, asection
*section
)
3047 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3049 if (overlay_debugging
)
3050 if (section
&& section_is_overlay (section
) &&
3051 pc_in_unmapped_range (pc
, section
))
3052 return pc
+ section
->vma
- section
->lma
;
3058 /* Function: symbol_overlayed_address
3059 Return one of two addresses (relative to the VMA or to the LMA),
3060 depending on whether the section is mapped or not. */
3063 symbol_overlayed_address (CORE_ADDR address
, asection
*section
)
3065 if (overlay_debugging
)
3067 /* If the symbol has no section, just return its regular address. */
3070 /* If the symbol's section is not an overlay, just return its address */
3071 if (!section_is_overlay (section
))
3073 /* If the symbol's section is mapped, just return its address */
3074 if (section_is_mapped (section
))
3077 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3078 * then return its LOADED address rather than its vma address!!
3080 return overlay_unmapped_address (address
, section
);
3085 /* Function: find_pc_overlay (PC)
3086 Return the best-match overlay section for PC:
3087 If PC matches a mapped overlay section's VMA, return that section.
3088 Else if PC matches an unmapped section's VMA, return that section.
3089 Else if PC matches an unmapped section's LMA, return that section. */
3092 find_pc_overlay (CORE_ADDR pc
)
3094 struct objfile
*objfile
;
3095 struct obj_section
*osect
, *best_match
= NULL
;
3097 if (overlay_debugging
)
3098 ALL_OBJSECTIONS (objfile
, osect
)
3099 if (section_is_overlay (osect
->the_bfd_section
))
3101 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
))
3103 if (overlay_is_mapped (osect
))
3104 return osect
->the_bfd_section
;
3108 else if (pc_in_unmapped_range (pc
, osect
->the_bfd_section
))
3111 return best_match
? best_match
->the_bfd_section
: NULL
;
3114 /* Function: find_pc_mapped_section (PC)
3115 If PC falls into the VMA address range of an overlay section that is
3116 currently marked as MAPPED, return that section. Else return NULL. */
3119 find_pc_mapped_section (CORE_ADDR pc
)
3121 struct objfile
*objfile
;
3122 struct obj_section
*osect
;
3124 if (overlay_debugging
)
3125 ALL_OBJSECTIONS (objfile
, osect
)
3126 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
) &&
3127 overlay_is_mapped (osect
))
3128 return osect
->the_bfd_section
;
3133 /* Function: list_overlays_command
3134 Print a list of mapped sections and their PC ranges */
3137 list_overlays_command (char *args
, int from_tty
)
3140 struct objfile
*objfile
;
3141 struct obj_section
*osect
;
3143 if (overlay_debugging
)
3144 ALL_OBJSECTIONS (objfile
, osect
)
3145 if (overlay_is_mapped (osect
))
3151 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3152 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3153 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3154 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3156 printf_filtered ("Section %s, loaded at ", name
);
3157 print_address_numeric (lma
, 1, gdb_stdout
);
3158 puts_filtered (" - ");
3159 print_address_numeric (lma
+ size
, 1, gdb_stdout
);
3160 printf_filtered (", mapped at ");
3161 print_address_numeric (vma
, 1, gdb_stdout
);
3162 puts_filtered (" - ");
3163 print_address_numeric (vma
+ size
, 1, gdb_stdout
);
3164 puts_filtered ("\n");
3169 printf_filtered ("No sections are mapped.\n");
3172 /* Function: map_overlay_command
3173 Mark the named section as mapped (ie. residing at its VMA address). */
3176 map_overlay_command (char *args
, int from_tty
)
3178 struct objfile
*objfile
, *objfile2
;
3179 struct obj_section
*sec
, *sec2
;
3182 if (!overlay_debugging
)
3184 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3185 the 'overlay manual' command.");
3187 if (args
== 0 || *args
== 0)
3188 error ("Argument required: name of an overlay section");
3190 /* First, find a section matching the user supplied argument */
3191 ALL_OBJSECTIONS (objfile
, sec
)
3192 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3194 /* Now, check to see if the section is an overlay. */
3195 bfdsec
= sec
->the_bfd_section
;
3196 if (!section_is_overlay (bfdsec
))
3197 continue; /* not an overlay section */
3199 /* Mark the overlay as "mapped" */
3200 sec
->ovly_mapped
= 1;
3202 /* Next, make a pass and unmap any sections that are
3203 overlapped by this new section: */
3204 ALL_OBJSECTIONS (objfile2
, sec2
)
3205 if (sec2
->ovly_mapped
3207 && sec
->the_bfd_section
!= sec2
->the_bfd_section
3208 && sections_overlap (sec
->the_bfd_section
,
3209 sec2
->the_bfd_section
))
3212 printf_filtered ("Note: section %s unmapped by overlap\n",
3213 bfd_section_name (objfile
->obfd
,
3214 sec2
->the_bfd_section
));
3215 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3219 error ("No overlay section called %s", args
);
3222 /* Function: unmap_overlay_command
3223 Mark the overlay section as unmapped
3224 (ie. resident in its LMA address range, rather than the VMA range). */
3227 unmap_overlay_command (char *args
, int from_tty
)
3229 struct objfile
*objfile
;
3230 struct obj_section
*sec
;
3232 if (!overlay_debugging
)
3234 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3235 the 'overlay manual' command.");
3237 if (args
== 0 || *args
== 0)
3238 error ("Argument required: name of an overlay section");
3240 /* First, find a section matching the user supplied argument */
3241 ALL_OBJSECTIONS (objfile
, sec
)
3242 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3244 if (!sec
->ovly_mapped
)
3245 error ("Section %s is not mapped", args
);
3246 sec
->ovly_mapped
= 0;
3249 error ("No overlay section called %s", args
);
3252 /* Function: overlay_auto_command
3253 A utility command to turn on overlay debugging.
3254 Possibly this should be done via a set/show command. */
3257 overlay_auto_command (char *args
, int from_tty
)
3259 overlay_debugging
= ovly_auto
;
3260 enable_overlay_breakpoints ();
3262 printf_filtered ("Automatic overlay debugging enabled.");
3265 /* Function: overlay_manual_command
3266 A utility command to turn on overlay debugging.
3267 Possibly this should be done via a set/show command. */
3270 overlay_manual_command (char *args
, int from_tty
)
3272 overlay_debugging
= ovly_on
;
3273 disable_overlay_breakpoints ();
3275 printf_filtered ("Overlay debugging enabled.");
3278 /* Function: overlay_off_command
3279 A utility command to turn on overlay debugging.
3280 Possibly this should be done via a set/show command. */
3283 overlay_off_command (char *args
, int from_tty
)
3285 overlay_debugging
= ovly_off
;
3286 disable_overlay_breakpoints ();
3288 printf_filtered ("Overlay debugging disabled.");
3292 overlay_load_command (char *args
, int from_tty
)
3294 if (target_overlay_update
)
3295 (*target_overlay_update
) (NULL
);
3297 error ("This target does not know how to read its overlay state.");
3300 /* Function: overlay_command
3301 A place-holder for a mis-typed command */
3303 /* Command list chain containing all defined "overlay" subcommands. */
3304 struct cmd_list_element
*overlaylist
;
3307 overlay_command (char *args
, int from_tty
)
3310 ("\"overlay\" must be followed by the name of an overlay command.\n");
3311 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3315 /* Target Overlays for the "Simplest" overlay manager:
3317 This is GDB's default target overlay layer. It works with the
3318 minimal overlay manager supplied as an example by Cygnus. The
3319 entry point is via a function pointer "target_overlay_update",
3320 so targets that use a different runtime overlay manager can
3321 substitute their own overlay_update function and take over the
3324 The overlay_update function pokes around in the target's data structures
3325 to see what overlays are mapped, and updates GDB's overlay mapping with
3328 In this simple implementation, the target data structures are as follows:
3329 unsigned _novlys; /# number of overlay sections #/
3330 unsigned _ovly_table[_novlys][4] = {
3331 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3332 {..., ..., ..., ...},
3334 unsigned _novly_regions; /# number of overlay regions #/
3335 unsigned _ovly_region_table[_novly_regions][3] = {
3336 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3339 These functions will attempt to update GDB's mappedness state in the
3340 symbol section table, based on the target's mappedness state.
3342 To do this, we keep a cached copy of the target's _ovly_table, and
3343 attempt to detect when the cached copy is invalidated. The main
3344 entry point is "simple_overlay_update(SECT), which looks up SECT in
3345 the cached table and re-reads only the entry for that section from
3346 the target (whenever possible).
3349 /* Cached, dynamically allocated copies of the target data structures: */
3350 static unsigned (*cache_ovly_table
)[4] = 0;
3352 static unsigned (*cache_ovly_region_table
)[3] = 0;
3354 static unsigned cache_novlys
= 0;
3356 static unsigned cache_novly_regions
= 0;
3358 static CORE_ADDR cache_ovly_table_base
= 0;
3360 static CORE_ADDR cache_ovly_region_table_base
= 0;
3364 VMA
, SIZE
, LMA
, MAPPED
3366 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
3368 /* Throw away the cached copy of _ovly_table */
3370 simple_free_overlay_table (void)
3372 if (cache_ovly_table
)
3373 xfree (cache_ovly_table
);
3375 cache_ovly_table
= NULL
;
3376 cache_ovly_table_base
= 0;
3380 /* Throw away the cached copy of _ovly_region_table */
3382 simple_free_overlay_region_table (void)
3384 if (cache_ovly_region_table
)
3385 xfree (cache_ovly_region_table
);
3386 cache_novly_regions
= 0;
3387 cache_ovly_region_table
= NULL
;
3388 cache_ovly_region_table_base
= 0;
3392 /* Read an array of ints from the target into a local buffer.
3393 Convert to host order. int LEN is number of ints */
3395 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
, int len
)
3397 /* FIXME (alloca): Not safe if array is very large. */
3398 char *buf
= alloca (len
* TARGET_LONG_BYTES
);
3401 read_memory (memaddr
, buf
, len
* TARGET_LONG_BYTES
);
3402 for (i
= 0; i
< len
; i
++)
3403 myaddr
[i
] = extract_unsigned_integer (TARGET_LONG_BYTES
* i
+ buf
,
3407 /* Find and grab a copy of the target _ovly_table
3408 (and _novlys, which is needed for the table's size) */
3410 simple_read_overlay_table (void)
3412 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3414 simple_free_overlay_table ();
3415 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3418 error ("Error reading inferior's overlay table: "
3419 "couldn't find `_novlys' variable\n"
3420 "in inferior. Use `overlay manual' mode.");
3424 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3425 if (! ovly_table_msym
)
3427 error ("Error reading inferior's overlay table: couldn't find "
3428 "`_ovly_table' array\n"
3429 "in inferior. Use `overlay manual' mode.");
3433 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
), 4);
3435 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3436 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3437 read_target_long_array (cache_ovly_table_base
,
3438 (int *) cache_ovly_table
,
3441 return 1; /* SUCCESS */
3445 /* Find and grab a copy of the target _ovly_region_table
3446 (and _novly_regions, which is needed for the table's size) */
3448 simple_read_overlay_region_table (void)
3450 struct minimal_symbol
*msym
;
3452 simple_free_overlay_region_table ();
3453 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3455 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
3457 return 0; /* failure */
3458 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3459 if (cache_ovly_region_table
!= NULL
)
3461 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3464 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3465 read_target_long_array (cache_ovly_region_table_base
,
3466 (int *) cache_ovly_region_table
,
3467 cache_novly_regions
* 3);
3470 return 0; /* failure */
3473 return 0; /* failure */
3474 return 1; /* SUCCESS */
3478 /* Function: simple_overlay_update_1
3479 A helper function for simple_overlay_update. Assuming a cached copy
3480 of _ovly_table exists, look through it to find an entry whose vma,
3481 lma and size match those of OSECT. Re-read the entry and make sure
3482 it still matches OSECT (else the table may no longer be valid).
3483 Set OSECT's mapped state to match the entry. Return: 1 for
3484 success, 0 for failure. */
3487 simple_overlay_update_1 (struct obj_section
*osect
)
3490 bfd
*obfd
= osect
->objfile
->obfd
;
3491 asection
*bsect
= osect
->the_bfd_section
;
3493 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3494 for (i
= 0; i
< cache_novlys
; i
++)
3495 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3496 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3497 /* && cache_ovly_table[i][SIZE] == size */ )
3499 read_target_long_array (cache_ovly_table_base
+ i
* TARGET_LONG_BYTES
,
3500 (int *) cache_ovly_table
[i
], 4);
3501 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3502 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3503 /* && cache_ovly_table[i][SIZE] == size */ )
3505 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3508 else /* Warning! Warning! Target's ovly table has changed! */
3514 /* Function: simple_overlay_update
3515 If OSECT is NULL, then update all sections' mapped state
3516 (after re-reading the entire target _ovly_table).
3517 If OSECT is non-NULL, then try to find a matching entry in the
3518 cached ovly_table and update only OSECT's mapped state.
3519 If a cached entry can't be found or the cache isn't valid, then
3520 re-read the entire cache, and go ahead and update all sections. */
3523 simple_overlay_update (struct obj_section
*osect
)
3525 struct objfile
*objfile
;
3527 /* Were we given an osect to look up? NULL means do all of them. */
3529 /* Have we got a cached copy of the target's overlay table? */
3530 if (cache_ovly_table
!= NULL
)
3531 /* Does its cached location match what's currently in the symtab? */
3532 if (cache_ovly_table_base
==
3533 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3534 /* Then go ahead and try to look up this single section in the cache */
3535 if (simple_overlay_update_1 (osect
))
3536 /* Found it! We're done. */
3539 /* Cached table no good: need to read the entire table anew.
3540 Or else we want all the sections, in which case it's actually
3541 more efficient to read the whole table in one block anyway. */
3543 if (! simple_read_overlay_table ())
3546 /* Now may as well update all sections, even if only one was requested. */
3547 ALL_OBJSECTIONS (objfile
, osect
)
3548 if (section_is_overlay (osect
->the_bfd_section
))
3551 bfd
*obfd
= osect
->objfile
->obfd
;
3552 asection
*bsect
= osect
->the_bfd_section
;
3554 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3555 for (i
= 0; i
< cache_novlys
; i
++)
3556 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3557 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3558 /* && cache_ovly_table[i][SIZE] == size */ )
3559 { /* obj_section matches i'th entry in ovly_table */
3560 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3561 break; /* finished with inner for loop: break out */
3566 /* Set the output sections and output offsets for section SECTP in
3567 ABFD. The relocation code in BFD will read these offsets, so we
3568 need to be sure they're initialized. We map each section to itself,
3569 with no offset; this means that SECTP->vma will be honored. */
3572 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3574 sectp
->output_section
= sectp
;
3575 sectp
->output_offset
= 0;
3578 /* Relocate the contents of a debug section SECTP in ABFD. The
3579 contents are stored in BUF if it is non-NULL, or returned in a
3580 malloc'd buffer otherwise.
3582 For some platforms and debug info formats, shared libraries contain
3583 relocations against the debug sections (particularly for DWARF-2;
3584 one affected platform is PowerPC GNU/Linux, although it depends on
3585 the version of the linker in use). Also, ELF object files naturally
3586 have unresolved relocations for their debug sections. We need to apply
3587 the relocations in order to get the locations of symbols correct. */
3590 symfile_relocate_debug_section (bfd
*abfd
, asection
*sectp
, bfd_byte
*buf
)
3592 /* We're only interested in debugging sections with relocation
3594 if ((sectp
->flags
& SEC_RELOC
) == 0)
3596 if ((sectp
->flags
& SEC_DEBUGGING
) == 0)
3599 /* We will handle section offsets properly elsewhere, so relocate as if
3600 all sections begin at 0. */
3601 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3603 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
);
3607 _initialize_symfile (void)
3609 struct cmd_list_element
*c
;
3611 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
3612 "Load symbol table from executable file FILE.\n\
3613 The `file' command can also load symbol tables, as well as setting the file\n\
3614 to execute.", &cmdlist
);
3615 set_cmd_completer (c
, filename_completer
);
3617 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
3618 "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3619 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
3620 ADDR is the starting address of the file's text.\n\
3621 The optional arguments are section-name section-address pairs and\n\
3622 should be specified if the data and bss segments are not contiguous\n\
3623 with the text. SECT is a section name to be loaded at SECT_ADDR.",
3625 set_cmd_completer (c
, filename_completer
);
3627 c
= add_cmd ("add-shared-symbol-files", class_files
,
3628 add_shared_symbol_files_command
,
3629 "Load the symbols from shared objects in the dynamic linker's link map.",
3631 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
3634 c
= add_cmd ("load", class_files
, load_command
,
3635 "Dynamically load FILE into the running program, and record its symbols\n\
3636 for access from GDB.", &cmdlist
);
3637 set_cmd_completer (c
, filename_completer
);
3640 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
3641 (char *) &symbol_reloading
,
3642 "Set dynamic symbol table reloading multiple times in one run.",
3646 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3647 "Commands for debugging overlays.", &overlaylist
,
3648 "overlay ", 0, &cmdlist
);
3650 add_com_alias ("ovly", "overlay", class_alias
, 1);
3651 add_com_alias ("ov", "overlay", class_alias
, 1);
3653 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3654 "Assert that an overlay section is mapped.", &overlaylist
);
3656 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3657 "Assert that an overlay section is unmapped.", &overlaylist
);
3659 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3660 "List mappings of overlay sections.", &overlaylist
);
3662 add_cmd ("manual", class_support
, overlay_manual_command
,
3663 "Enable overlay debugging.", &overlaylist
);
3664 add_cmd ("off", class_support
, overlay_off_command
,
3665 "Disable overlay debugging.", &overlaylist
);
3666 add_cmd ("auto", class_support
, overlay_auto_command
,
3667 "Enable automatic overlay debugging.", &overlaylist
);
3668 add_cmd ("load-target", class_support
, overlay_load_command
,
3669 "Read the overlay mapping state from the target.", &overlaylist
);
3671 /* Filename extension to source language lookup table: */
3672 init_filename_language_table ();
3673 c
= add_set_cmd ("extension-language", class_files
, var_string_noescape
,
3675 "Set mapping between filename extension and source language.\n\
3676 Usage: set extension-language .foo bar",
3678 set_cmd_cfunc (c
, set_ext_lang_command
);
3680 add_info ("extensions", info_ext_lang_command
,
3681 "All filename extensions associated with a source language.");
3684 (add_set_cmd ("download-write-size", class_obscure
,
3685 var_integer
, (char *) &download_write_size
,
3686 "Set the write size used when downloading a program.\n"
3687 "Only used when downloading a program onto a remote\n"
3688 "target. Specify zero, or a negative value, to disable\n"
3689 "blocked writes. The actual size of each transfer is also\n"
3690 "limited by the size of the target packet and the memory\n"
3695 debug_file_directory
= xstrdup (DEBUGDIR
);
3697 ("debug-file-directory", class_support
, var_string
,
3698 (char *) &debug_file_directory
,
3699 "Set the directory where separate debug symbols are searched for.\n"
3700 "Separate debug symbols are first searched for in the same\n"
3701 "directory as the binary, then in the `" DEBUG_SUBDIRECTORY
3703 "and lastly at the path of the directory of the binary with\n"
3704 "the global debug-file directory prepended\n",
3706 add_show_from_set (c
, &showlist
);
3707 set_cmd_completer (c
, filename_completer
);