1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
6 Contributed by Cygnus Support, using pieces from other GDB modules.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
37 #include "breakpoint.h"
39 #include "complaints.h"
41 #include "inferior.h" /* for write_pc */
42 #include "filenames.h" /* for DOSish file names */
43 #include "gdb-stabs.h"
44 #include "gdb_obstack.h"
45 #include "completer.h"
48 #include <readline/readline.h>
49 #include "gdb_assert.h"
52 #include <sys/types.h>
54 #include "gdb_string.h"
65 /* Some HP-UX related globals to clear when a new "main"
66 symbol file is loaded. HP-specific. */
68 extern int hp_som_som_object_present
;
69 extern int hp_cxx_exception_support_initialized
;
70 #define RESET_HP_UX_GLOBALS() do {\
71 hp_som_som_object_present = 0; /* indicates HP-compiled code */ \
72 hp_cxx_exception_support_initialized = 0; /* must reinitialize exception stuff */ \
76 int (*ui_load_progress_hook
) (const char *section
, unsigned long num
);
77 void (*show_load_progress
) (const char *section
,
78 unsigned long section_sent
,
79 unsigned long section_size
,
80 unsigned long total_sent
,
81 unsigned long total_size
);
82 void (*pre_add_symbol_hook
) (char *);
83 void (*post_add_symbol_hook
) (void);
84 void (*target_new_objfile_hook
) (struct objfile
*);
86 static void clear_symtab_users_cleanup (void *ignore
);
88 /* Global variables owned by this file */
89 int readnow_symbol_files
; /* Read full symbols immediately */
91 /* External variables and functions referenced. */
93 extern void report_transfer_performance (unsigned long, time_t, time_t);
95 /* Functions this file defines */
98 static int simple_read_overlay_region_table (void);
99 static void simple_free_overlay_region_table (void);
102 static void set_initial_language (void);
104 static void load_command (char *, int);
106 static void symbol_file_add_main_1 (char *args
, int from_tty
, int flags
);
108 static void add_symbol_file_command (char *, int);
110 static void add_shared_symbol_files_command (char *, int);
112 static void reread_separate_symbols (struct objfile
*objfile
);
114 static void cashier_psymtab (struct partial_symtab
*);
116 bfd
*symfile_bfd_open (char *);
118 int get_section_index (struct objfile
*, char *);
120 static void find_sym_fns (struct objfile
*);
122 static void decrement_reading_symtab (void *);
124 static void overlay_invalidate_all (void);
126 static int overlay_is_mapped (struct obj_section
*);
128 void list_overlays_command (char *, int);
130 void map_overlay_command (char *, int);
132 void unmap_overlay_command (char *, int);
134 static void overlay_auto_command (char *, int);
136 static void overlay_manual_command (char *, int);
138 static void overlay_off_command (char *, int);
140 static void overlay_load_command (char *, int);
142 static void overlay_command (char *, int);
144 static void simple_free_overlay_table (void);
146 static void read_target_long_array (CORE_ADDR
, unsigned int *, int);
148 static int simple_read_overlay_table (void);
150 static int simple_overlay_update_1 (struct obj_section
*);
152 static void add_filename_language (char *ext
, enum language lang
);
154 static void set_ext_lang_command (char *args
, int from_tty
);
156 static void info_ext_lang_command (char *args
, int from_tty
);
158 static char *find_separate_debug_file (struct objfile
*objfile
);
160 static void init_filename_language_table (void);
162 void _initialize_symfile (void);
164 /* List of all available sym_fns. On gdb startup, each object file reader
165 calls add_symtab_fns() to register information on each format it is
168 static struct sym_fns
*symtab_fns
= NULL
;
170 /* Flag for whether user will be reloading symbols multiple times.
171 Defaults to ON for VxWorks, otherwise OFF. */
173 #ifdef SYMBOL_RELOADING_DEFAULT
174 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
176 int symbol_reloading
= 0;
179 /* If non-zero, shared library symbols will be added automatically
180 when the inferior is created, new libraries are loaded, or when
181 attaching to the inferior. This is almost always what users will
182 want to have happen; but for very large programs, the startup time
183 will be excessive, and so if this is a problem, the user can clear
184 this flag and then add the shared library symbols as needed. Note
185 that there is a potential for confusion, since if the shared
186 library symbols are not loaded, commands like "info fun" will *not*
187 report all the functions that are actually present. */
189 int auto_solib_add
= 1;
191 /* For systems that support it, a threshold size in megabytes. If
192 automatically adding a new library's symbol table to those already
193 known to the debugger would cause the total shared library symbol
194 size to exceed this threshhold, then the shlib's symbols are not
195 added. The threshold is ignored if the user explicitly asks for a
196 shlib to be added, such as when using the "sharedlibrary"
199 int auto_solib_limit
;
202 /* Since this function is called from within qsort, in an ANSI environment
203 it must conform to the prototype for qsort, which specifies that the
204 comparison function takes two "void *" pointers. */
207 compare_symbols (const void *s1p
, const void *s2p
)
209 register struct symbol
**s1
, **s2
;
211 s1
= (struct symbol
**) s1p
;
212 s2
= (struct symbol
**) s2p
;
213 return (strcmp (SYMBOL_SOURCE_NAME (*s1
), SYMBOL_SOURCE_NAME (*s2
)));
220 compare_psymbols -- compare two partial symbols by name
224 Given pointers to pointers to two partial symbol table entries,
225 compare them by name and return -N, 0, or +N (ala strcmp).
226 Typically used by sorting routines like qsort().
230 Does direct compare of first two characters before punting
231 and passing to strcmp for longer compares. Note that the
232 original version had a bug whereby two null strings or two
233 identically named one character strings would return the
234 comparison of memory following the null byte.
239 compare_psymbols (const void *s1p
, const void *s2p
)
241 register struct partial_symbol
**s1
, **s2
;
242 register char *st1
, *st2
;
244 s1
= (struct partial_symbol
**) s1p
;
245 s2
= (struct partial_symbol
**) s2p
;
246 st1
= SYMBOL_SOURCE_NAME (*s1
);
247 st2
= SYMBOL_SOURCE_NAME (*s2
);
250 if ((st1
[0] - st2
[0]) || !st1
[0])
252 return (st1
[0] - st2
[0]);
254 else if ((st1
[1] - st2
[1]) || !st1
[1])
256 return (st1
[1] - st2
[1]);
260 return (strcmp (st1
, st2
));
265 sort_pst_symbols (struct partial_symtab
*pst
)
267 /* Sort the global list; don't sort the static list */
269 qsort (pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
,
270 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
274 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
277 sort_block_syms (register struct block
*b
)
279 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
280 sizeof (struct symbol
*), compare_symbols
);
283 /* Call sort_symtab_syms to sort alphabetically
284 the symbols of each block of one symtab. */
287 sort_symtab_syms (register struct symtab
*s
)
289 register struct blockvector
*bv
;
292 register struct block
*b
;
296 bv
= BLOCKVECTOR (s
);
297 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
298 for (i
= 0; i
< nbl
; i
++)
300 b
= BLOCKVECTOR_BLOCK (bv
, i
);
301 if (BLOCK_SHOULD_SORT (b
))
306 /* Make a null terminated copy of the string at PTR with SIZE characters in
307 the obstack pointed to by OBSTACKP . Returns the address of the copy.
308 Note that the string at PTR does not have to be null terminated, I.E. it
309 may be part of a larger string and we are only saving a substring. */
312 obsavestring (const char *ptr
, int size
, struct obstack
*obstackp
)
314 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
315 /* Open-coded memcpy--saves function call time. These strings are usually
316 short. FIXME: Is this really still true with a compiler that can
319 register const char *p1
= ptr
;
320 register char *p2
= p
;
321 const char *end
= ptr
+ size
;
329 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
330 in the obstack pointed to by OBSTACKP. */
333 obconcat (struct obstack
*obstackp
, const char *s1
, const char *s2
,
336 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
337 register char *val
= (char *) obstack_alloc (obstackp
, len
);
344 /* True if we are nested inside psymtab_to_symtab. */
346 int currently_reading_symtab
= 0;
349 decrement_reading_symtab (void *dummy
)
351 currently_reading_symtab
--;
354 /* Get the symbol table that corresponds to a partial_symtab.
355 This is fast after the first time you do it. In fact, there
356 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
360 psymtab_to_symtab (register struct partial_symtab
*pst
)
362 /* If it's been looked up before, return it. */
366 /* If it has not yet been read in, read it. */
369 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
370 currently_reading_symtab
++;
371 (*pst
->read_symtab
) (pst
);
372 do_cleanups (back_to
);
378 /* Initialize entry point information for this objfile. */
381 init_entry_point_info (struct objfile
*objfile
)
383 /* Save startup file's range of PC addresses to help blockframe.c
384 decide where the bottom of the stack is. */
386 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
388 /* Executable file -- record its entry point so we'll recognize
389 the startup file because it contains the entry point. */
390 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
394 /* Examination of non-executable.o files. Short-circuit this stuff. */
395 objfile
->ei
.entry_point
= INVALID_ENTRY_POINT
;
397 objfile
->ei
.entry_file_lowpc
= INVALID_ENTRY_LOWPC
;
398 objfile
->ei
.entry_file_highpc
= INVALID_ENTRY_HIGHPC
;
399 objfile
->ei
.entry_func_lowpc
= INVALID_ENTRY_LOWPC
;
400 objfile
->ei
.entry_func_highpc
= INVALID_ENTRY_HIGHPC
;
401 objfile
->ei
.main_func_lowpc
= INVALID_ENTRY_LOWPC
;
402 objfile
->ei
.main_func_highpc
= INVALID_ENTRY_HIGHPC
;
405 /* Get current entry point address. */
408 entry_point_address (void)
410 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
413 /* Remember the lowest-addressed loadable section we've seen.
414 This function is called via bfd_map_over_sections.
416 In case of equal vmas, the section with the largest size becomes the
417 lowest-addressed loadable section.
419 If the vmas and sizes are equal, the last section is considered the
420 lowest-addressed loadable section. */
423 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
425 asection
**lowest
= (asection
**) obj
;
427 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
430 *lowest
= sect
; /* First loadable section */
431 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
432 *lowest
= sect
; /* A lower loadable section */
433 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
434 && (bfd_section_size (abfd
, (*lowest
))
435 <= bfd_section_size (abfd
, sect
)))
440 /* Build (allocate and populate) a section_addr_info struct from
441 an existing section table. */
443 extern struct section_addr_info
*
444 build_section_addr_info_from_section_table (const struct section_table
*start
,
445 const struct section_table
*end
)
447 struct section_addr_info
*sap
;
448 const struct section_table
*stp
;
451 sap
= xmalloc (sizeof (struct section_addr_info
));
452 memset (sap
, 0, sizeof (struct section_addr_info
));
454 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
456 if (bfd_get_section_flags (stp
->bfd
,
457 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
458 && oidx
< MAX_SECTIONS
)
460 sap
->other
[oidx
].addr
= stp
->addr
;
461 sap
->other
[oidx
].name
462 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
463 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
472 /* Free all memory allocated by build_section_addr_info_from_section_table. */
475 free_section_addr_info (struct section_addr_info
*sap
)
479 for (idx
= 0; idx
< MAX_SECTIONS
; idx
++)
480 if (sap
->other
[idx
].name
)
481 xfree (sap
->other
[idx
].name
);
486 /* Initialize OBJFILE's sect_index_* members. */
488 init_objfile_sect_indices (struct objfile
*objfile
)
493 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
495 objfile
->sect_index_text
= sect
->index
;
497 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
499 objfile
->sect_index_data
= sect
->index
;
501 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
503 objfile
->sect_index_bss
= sect
->index
;
505 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
507 objfile
->sect_index_rodata
= sect
->index
;
509 /* This is where things get really weird... We MUST have valid
510 indices for the various sect_index_* members or gdb will abort.
511 So if for example, there is no ".text" section, we have to
512 accomodate that. Except when explicitly adding symbol files at
513 some address, section_offsets contains nothing but zeros, so it
514 doesn't matter which slot in section_offsets the individual
515 sect_index_* members index into. So if they are all zero, it is
516 safe to just point all the currently uninitialized indices to the
519 for (i
= 0; i
< objfile
->num_sections
; i
++)
521 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
526 if (i
== objfile
->num_sections
)
528 if (objfile
->sect_index_text
== -1)
529 objfile
->sect_index_text
= 0;
530 if (objfile
->sect_index_data
== -1)
531 objfile
->sect_index_data
= 0;
532 if (objfile
->sect_index_bss
== -1)
533 objfile
->sect_index_bss
= 0;
534 if (objfile
->sect_index_rodata
== -1)
535 objfile
->sect_index_rodata
= 0;
540 /* Parse the user's idea of an offset for dynamic linking, into our idea
541 of how to represent it for fast symbol reading. This is the default
542 version of the sym_fns.sym_offsets function for symbol readers that
543 don't need to do anything special. It allocates a section_offsets table
544 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
547 default_symfile_offsets (struct objfile
*objfile
,
548 struct section_addr_info
*addrs
)
552 objfile
->num_sections
= SECT_OFF_MAX
;
553 objfile
->section_offsets
= (struct section_offsets
*)
554 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
555 memset (objfile
->section_offsets
, 0, SIZEOF_SECTION_OFFSETS
);
557 /* Now calculate offsets for section that were specified by the
559 for (i
= 0; i
< MAX_SECTIONS
&& addrs
->other
[i
].name
; i
++)
561 struct other_sections
*osp
;
563 osp
= &addrs
->other
[i
] ;
567 /* Record all sections in offsets */
568 /* The section_offsets in the objfile are here filled in using
570 (objfile
->section_offsets
)->offsets
[osp
->sectindex
] = osp
->addr
;
573 /* Remember the bfd indexes for the .text, .data, .bss and
575 init_objfile_sect_indices (objfile
);
579 /* Process a symbol file, as either the main file or as a dynamically
582 OBJFILE is where the symbols are to be read from.
584 ADDRS is the list of section load addresses. If the user has given
585 an 'add-symbol-file' command, then this is the list of offsets and
586 addresses he or she provided as arguments to the command; or, if
587 we're handling a shared library, these are the actual addresses the
588 sections are loaded at, according to the inferior's dynamic linker
589 (as gleaned by GDB's shared library code). We convert each address
590 into an offset from the section VMA's as it appears in the object
591 file, and then call the file's sym_offsets function to convert this
592 into a format-specific offset table --- a `struct section_offsets'.
593 If ADDRS is non-zero, OFFSETS must be zero.
595 OFFSETS is a table of section offsets already in the right
596 format-specific representation. NUM_OFFSETS is the number of
597 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
598 assume this is the proper table the call to sym_offsets described
599 above would produce. Instead of calling sym_offsets, we just dump
600 it right into objfile->section_offsets. (When we're re-reading
601 symbols from an objfile, we don't have the original load address
602 list any more; all we have is the section offset table.) If
603 OFFSETS is non-zero, ADDRS must be zero.
605 MAINLINE is nonzero if this is the main symbol file, or zero if
606 it's an extra symbol file such as dynamically loaded code.
608 VERBO is nonzero if the caller has printed a verbose message about
609 the symbol reading (and complaints can be more terse about it). */
612 syms_from_objfile (struct objfile
*objfile
,
613 struct section_addr_info
*addrs
,
614 struct section_offsets
*offsets
,
619 asection
*lower_sect
;
621 CORE_ADDR lower_offset
;
622 struct section_addr_info local_addr
;
623 struct cleanup
*old_chain
;
626 gdb_assert (! (addrs
&& offsets
));
628 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
629 list. We now establish the convention that an addr of zero means
630 no load address was specified. */
631 if (! addrs
&& ! offsets
)
633 memset (&local_addr
, 0, sizeof (local_addr
));
637 /* Now either addrs or offsets is non-zero. */
639 init_entry_point_info (objfile
);
640 find_sym_fns (objfile
);
642 if (objfile
->sf
== NULL
)
643 return; /* No symbols. */
645 /* Make sure that partially constructed symbol tables will be cleaned up
646 if an error occurs during symbol reading. */
647 old_chain
= make_cleanup_free_objfile (objfile
);
651 /* We will modify the main symbol table, make sure that all its users
652 will be cleaned up if an error occurs during symbol reading. */
653 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
655 /* Since no error yet, throw away the old symbol table. */
657 if (symfile_objfile
!= NULL
)
659 free_objfile (symfile_objfile
);
660 symfile_objfile
= NULL
;
663 /* Currently we keep symbols from the add-symbol-file command.
664 If the user wants to get rid of them, they should do "symbol-file"
665 without arguments first. Not sure this is the best behavior
668 (*objfile
->sf
->sym_new_init
) (objfile
);
671 /* Convert addr into an offset rather than an absolute address.
672 We find the lowest address of a loaded segment in the objfile,
673 and assume that <addr> is where that got loaded.
675 We no longer warn if the lowest section is not a text segment (as
676 happens for the PA64 port. */
679 /* Find lowest loadable section to be used as starting point for
680 continguous sections. FIXME!! won't work without call to find
681 .text first, but this assumes text is lowest section. */
682 lower_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
683 if (lower_sect
== NULL
)
684 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
686 if (lower_sect
== NULL
)
687 warning ("no loadable sections found in added symbol-file %s",
690 if ((bfd_get_section_flags (objfile
->obfd
, lower_sect
) & SEC_CODE
) == 0)
691 warning ("Lowest section in %s is %s at %s",
693 bfd_section_name (objfile
->obfd
, lower_sect
),
694 paddr (bfd_section_vma (objfile
->obfd
, lower_sect
)));
695 if (lower_sect
!= NULL
)
696 lower_offset
= bfd_section_vma (objfile
->obfd
, lower_sect
);
700 /* Calculate offsets for the loadable sections.
701 FIXME! Sections must be in order of increasing loadable section
702 so that contiguous sections can use the lower-offset!!!
704 Adjust offsets if the segments are not contiguous.
705 If the section is contiguous, its offset should be set to
706 the offset of the highest loadable section lower than it
707 (the loadable section directly below it in memory).
708 this_offset = lower_offset = lower_addr - lower_orig_addr */
710 /* Calculate offsets for sections. */
712 for (i
=0 ; i
< MAX_SECTIONS
&& addrs
->other
[i
].name
; i
++)
714 if (addrs
->other
[i
].addr
!= 0)
716 sect
= bfd_get_section_by_name (objfile
->obfd
,
717 addrs
->other
[i
].name
);
721 -= bfd_section_vma (objfile
->obfd
, sect
);
722 lower_offset
= addrs
->other
[i
].addr
;
723 /* This is the index used by BFD. */
724 addrs
->other
[i
].sectindex
= sect
->index
;
728 warning ("section %s not found in %s",
729 addrs
->other
[i
].name
,
731 addrs
->other
[i
].addr
= 0;
735 addrs
->other
[i
].addr
= lower_offset
;
739 /* Initialize symbol reading routines for this objfile, allow complaints to
740 appear for this new file, and record how verbose to be, then do the
741 initial symbol reading for this file. */
743 (*objfile
->sf
->sym_init
) (objfile
);
744 clear_complaints (&symfile_complaints
, 1, verbo
);
747 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
750 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
752 /* Just copy in the offset table directly as given to us. */
753 objfile
->num_sections
= num_offsets
;
754 objfile
->section_offsets
755 = ((struct section_offsets
*)
756 obstack_alloc (&objfile
->psymbol_obstack
, size
));
757 memcpy (objfile
->section_offsets
, offsets
, size
);
759 init_objfile_sect_indices (objfile
);
762 #ifndef IBM6000_TARGET
763 /* This is a SVR4/SunOS specific hack, I think. In any event, it
764 screws RS/6000. sym_offsets should be doing this sort of thing,
765 because it knows the mapping between bfd sections and
767 /* This is a hack. As far as I can tell, section offsets are not
768 target dependent. They are all set to addr with a couple of
769 exceptions. The exceptions are sysvr4 shared libraries, whose
770 offsets are kept in solib structures anyway and rs6000 xcoff
771 which handles shared libraries in a completely unique way.
773 Section offsets are built similarly, except that they are built
774 by adding addr in all cases because there is no clear mapping
775 from section_offsets into actual sections. Note that solib.c
776 has a different algorithm for finding section offsets.
778 These should probably all be collapsed into some target
779 independent form of shared library support. FIXME. */
783 struct obj_section
*s
;
785 /* Map section offsets in "addr" back to the object's
786 sections by comparing the section names with bfd's
787 section names. Then adjust the section address by
788 the offset. */ /* for gdb/13815 */
790 ALL_OBJFILE_OSECTIONS (objfile
, s
)
792 CORE_ADDR s_addr
= 0;
796 !s_addr
&& i
< MAX_SECTIONS
&& addrs
->other
[i
].name
;
798 if (strcmp (bfd_section_name (s
->objfile
->obfd
,
800 addrs
->other
[i
].name
) == 0)
801 s_addr
= addrs
->other
[i
].addr
; /* end added for gdb/13815 */
803 s
->addr
-= s
->offset
;
805 s
->endaddr
-= s
->offset
;
806 s
->endaddr
+= s_addr
;
810 #endif /* not IBM6000_TARGET */
812 (*objfile
->sf
->sym_read
) (objfile
, mainline
);
814 /* Don't allow char * to have a typename (else would get caddr_t).
815 Ditto void *. FIXME: Check whether this is now done by all the
816 symbol readers themselves (many of them now do), and if so remove
819 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
820 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
822 /* Mark the objfile has having had initial symbol read attempted. Note
823 that this does not mean we found any symbols... */
825 objfile
->flags
|= OBJF_SYMS
;
827 /* Discard cleanups as symbol reading was successful. */
829 discard_cleanups (old_chain
);
831 /* Call this after reading in a new symbol table to give target
832 dependent code a crack at the new symbols. For instance, this
833 could be used to update the values of target-specific symbols GDB
834 needs to keep track of (such as _sigtramp, or whatever). */
836 TARGET_SYMFILE_POSTREAD (objfile
);
839 /* Perform required actions after either reading in the initial
840 symbols for a new objfile, or mapping in the symbols from a reusable
844 new_symfile_objfile (struct objfile
*objfile
, int mainline
, int verbo
)
847 /* If this is the main symbol file we have to clean up all users of the
848 old main symbol file. Otherwise it is sufficient to fixup all the
849 breakpoints that may have been redefined by this symbol file. */
852 /* OK, make it the "real" symbol file. */
853 symfile_objfile
= objfile
;
855 clear_symtab_users ();
859 breakpoint_re_set ();
862 /* We're done reading the symbol file; finish off complaints. */
863 clear_complaints (&symfile_complaints
, 0, verbo
);
866 /* Process a symbol file, as either the main file or as a dynamically
869 NAME is the file name (which will be tilde-expanded and made
870 absolute herein) (but we don't free or modify NAME itself).
872 FROM_TTY says how verbose to be.
874 MAINLINE specifies whether this is the main symbol file, or whether
875 it's an extra symbol file such as dynamically loaded code.
877 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
878 syms_from_objfile, above. ADDRS is ignored when MAINLINE is
881 Upon success, returns a pointer to the objfile that was added.
882 Upon failure, jumps back to command level (never returns). */
883 static struct objfile
*
884 symbol_file_add_with_addrs_or_offsets (char *name
, int from_tty
,
885 struct section_addr_info
*addrs
,
886 struct section_offsets
*offsets
,
888 int mainline
, int flags
)
890 struct objfile
*objfile
;
891 struct partial_symtab
*psymtab
;
894 struct section_addr_info orig_addrs
;
899 /* Open a bfd for the file, and give user a chance to burp if we'd be
900 interactively wiping out any existing symbols. */
902 abfd
= symfile_bfd_open (name
);
904 if ((have_full_symbols () || have_partial_symbols ())
907 && !query ("Load new symbol table from \"%s\"? ", name
))
908 error ("Not confirmed.");
910 objfile
= allocate_objfile (abfd
, flags
);
912 /* If the objfile uses a mapped symbol file, and we have a psymtab for
913 it, then skip reading any symbols at this time. */
915 if ((objfile
->flags
& OBJF_MAPPED
) && (objfile
->flags
& OBJF_SYMS
))
917 /* We mapped in an existing symbol table file that already has had
918 initial symbol reading performed, so we can skip that part. Notify
919 the user that instead of reading the symbols, they have been mapped.
921 if (from_tty
|| info_verbose
)
923 printf_filtered ("Mapped symbols for %s...", name
);
925 gdb_flush (gdb_stdout
);
927 init_entry_point_info (objfile
);
928 find_sym_fns (objfile
);
932 /* We either created a new mapped symbol table, mapped an existing
933 symbol table file which has not had initial symbol reading
934 performed, or need to read an unmapped symbol table. */
935 if (from_tty
|| info_verbose
)
937 if (pre_add_symbol_hook
)
938 pre_add_symbol_hook (name
);
941 printf_filtered ("Reading symbols from %s...", name
);
943 gdb_flush (gdb_stdout
);
946 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
950 /* We now have at least a partial symbol table. Check to see if the
951 user requested that all symbols be read on initial access via either
952 the gdb startup command line or on a per symbol file basis. Expand
953 all partial symbol tables for this objfile if so. */
955 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
957 if (from_tty
|| info_verbose
)
959 printf_filtered ("expanding to full symbols...");
961 gdb_flush (gdb_stdout
);
964 for (psymtab
= objfile
->psymtabs
;
966 psymtab
= psymtab
->next
)
968 psymtab_to_symtab (psymtab
);
972 debugfile
= find_separate_debug_file (objfile
);
977 objfile
->separate_debug_objfile
978 = symbol_file_add (debugfile
, from_tty
, &orig_addrs
, 0, flags
);
982 objfile
->separate_debug_objfile
983 = symbol_file_add (debugfile
, from_tty
, NULL
, 0, flags
);
985 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
988 /* Put the separate debug object before the normal one, this is so that
989 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
990 put_objfile_before (objfile
->separate_debug_objfile
, objfile
);
995 if (!have_partial_symbols () && !have_full_symbols ())
998 printf_filtered ("(no debugging symbols found)...");
1002 if (from_tty
|| info_verbose
)
1004 if (post_add_symbol_hook
)
1005 post_add_symbol_hook ();
1008 printf_filtered ("done.\n");
1012 /* We print some messages regardless of whether 'from_tty ||
1013 info_verbose' is true, so make sure they go out at the right
1015 gdb_flush (gdb_stdout
);
1017 if (objfile
->sf
== NULL
)
1018 return objfile
; /* No symbols. */
1020 new_symfile_objfile (objfile
, mainline
, from_tty
);
1022 if (target_new_objfile_hook
)
1023 target_new_objfile_hook (objfile
);
1029 /* Process a symbol file, as either the main file or as a dynamically
1030 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1033 symbol_file_add (char *name
, int from_tty
, struct section_addr_info
*addrs
,
1034 int mainline
, int flags
)
1036 return symbol_file_add_with_addrs_or_offsets (name
, from_tty
, addrs
, 0, 0,
1041 /* Call symbol_file_add() with default values and update whatever is
1042 affected by the loading of a new main().
1043 Used when the file is supplied in the gdb command line
1044 and by some targets with special loading requirements.
1045 The auxiliary function, symbol_file_add_main_1(), has the flags
1046 argument for the switches that can only be specified in the symbol_file
1050 symbol_file_add_main (char *args
, int from_tty
)
1052 symbol_file_add_main_1 (args
, from_tty
, 0);
1056 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1058 symbol_file_add (args
, from_tty
, NULL
, 1, flags
);
1061 RESET_HP_UX_GLOBALS ();
1064 /* Getting new symbols may change our opinion about
1065 what is frameless. */
1066 reinit_frame_cache ();
1068 set_initial_language ();
1072 symbol_file_clear (int from_tty
)
1074 if ((have_full_symbols () || have_partial_symbols ())
1076 && !query ("Discard symbol table from `%s'? ",
1077 symfile_objfile
->name
))
1078 error ("Not confirmed.");
1079 free_all_objfiles ();
1081 /* solib descriptors may have handles to objfiles. Since their
1082 storage has just been released, we'd better wipe the solib
1083 descriptors as well.
1085 #if defined(SOLIB_RESTART)
1089 symfile_objfile
= NULL
;
1091 printf_unfiltered ("No symbol file now.\n");
1093 RESET_HP_UX_GLOBALS ();
1098 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1101 bfd_size_type debuglink_size
;
1102 unsigned long crc32
;
1107 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1112 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1114 contents
= xmalloc (debuglink_size
);
1115 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1116 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1118 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1119 crc_offset
= strlen (contents
) + 1;
1120 crc_offset
= (crc_offset
+ 3) & ~3;
1122 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1129 separate_debug_file_exists (const char *name
, unsigned long crc
)
1131 unsigned long file_crc
= 0;
1133 char buffer
[8*1024];
1136 fd
= open (name
, O_RDONLY
| O_BINARY
);
1140 while ((count
= read (fd
, buffer
, sizeof (buffer
))) > 0)
1141 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1145 return crc
== file_crc
;
1148 static char *debug_file_directory
= NULL
;
1150 #if ! defined (DEBUG_SUBDIRECTORY)
1151 #define DEBUG_SUBDIRECTORY ".debug"
1155 find_separate_debug_file (struct objfile
*objfile
)
1162 bfd_size_type debuglink_size
;
1163 unsigned long crc32
;
1166 basename
= get_debug_link_info (objfile
, &crc32
);
1168 if (basename
== NULL
)
1171 dir
= xstrdup (objfile
->name
);
1173 /* Strip off the final filename part, leaving the directory name,
1174 followed by a slash. Objfile names should always be absolute and
1175 tilde-expanded, so there should always be a slash in there
1177 for (i
= strlen(dir
) - 1; i
>= 0; i
--)
1179 if (IS_DIR_SEPARATOR (dir
[i
]))
1182 gdb_assert (i
>= 0 && IS_DIR_SEPARATOR (dir
[i
]));
1185 debugfile
= alloca (strlen (debug_file_directory
) + 1
1187 + strlen (DEBUG_SUBDIRECTORY
)
1192 /* First try in the same directory as the original file. */
1193 strcpy (debugfile
, dir
);
1194 strcat (debugfile
, basename
);
1196 if (separate_debug_file_exists (debugfile
, crc32
))
1200 return xstrdup (debugfile
);
1203 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1204 strcpy (debugfile
, dir
);
1205 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1206 strcat (debugfile
, "/");
1207 strcat (debugfile
, basename
);
1209 if (separate_debug_file_exists (debugfile
, crc32
))
1213 return xstrdup (debugfile
);
1216 /* Then try in the global debugfile directory. */
1217 strcpy (debugfile
, debug_file_directory
);
1218 strcat (debugfile
, "/");
1219 strcat (debugfile
, dir
);
1220 strcat (debugfile
, basename
);
1222 if (separate_debug_file_exists (debugfile
, crc32
))
1226 return xstrdup (debugfile
);
1235 /* This is the symbol-file command. Read the file, analyze its
1236 symbols, and add a struct symtab to a symtab list. The syntax of
1237 the command is rather bizarre--(1) buildargv implements various
1238 quoting conventions which are undocumented and have little or
1239 nothing in common with the way things are quoted (or not quoted)
1240 elsewhere in GDB, (2) options are used, which are not generally
1241 used in GDB (perhaps "set mapped on", "set readnow on" would be
1242 better), (3) the order of options matters, which is contrary to GNU
1243 conventions (because it is confusing and inconvenient). */
1244 /* Note: ezannoni 2000-04-17. This function used to have support for
1245 rombug (see remote-os9k.c). It consisted of a call to target_link()
1246 (target.c) to get the address of the text segment from the target,
1247 and pass that to symbol_file_add(). This is no longer supported. */
1250 symbol_file_command (char *args
, int from_tty
)
1254 struct cleanup
*cleanups
;
1255 int flags
= OBJF_USERLOADED
;
1261 symbol_file_clear (from_tty
);
1265 if ((argv
= buildargv (args
)) == NULL
)
1269 cleanups
= make_cleanup_freeargv (argv
);
1270 while (*argv
!= NULL
)
1272 if (STREQ (*argv
, "-mapped"))
1273 flags
|= OBJF_MAPPED
;
1275 if (STREQ (*argv
, "-readnow"))
1276 flags
|= OBJF_READNOW
;
1279 error ("unknown option `%s'", *argv
);
1284 symbol_file_add_main_1 (name
, from_tty
, flags
);
1291 error ("no symbol file name was specified");
1293 do_cleanups (cleanups
);
1297 /* Set the initial language.
1299 A better solution would be to record the language in the psymtab when reading
1300 partial symbols, and then use it (if known) to set the language. This would
1301 be a win for formats that encode the language in an easily discoverable place,
1302 such as DWARF. For stabs, we can jump through hoops looking for specially
1303 named symbols or try to intuit the language from the specific type of stabs
1304 we find, but we can't do that until later when we read in full symbols.
1308 set_initial_language (void)
1310 struct partial_symtab
*pst
;
1311 enum language lang
= language_unknown
;
1313 pst
= find_main_psymtab ();
1316 if (pst
->filename
!= NULL
)
1318 lang
= deduce_language_from_filename (pst
->filename
);
1320 if (lang
== language_unknown
)
1322 /* Make C the default language */
1325 set_language (lang
);
1326 expected_language
= current_language
; /* Don't warn the user */
1330 /* Open file specified by NAME and hand it off to BFD for preliminary
1331 analysis. Result is a newly initialized bfd *, which includes a newly
1332 malloc'd` copy of NAME (tilde-expanded and made absolute).
1333 In case of trouble, error() is called. */
1336 symfile_bfd_open (char *name
)
1340 char *absolute_name
;
1344 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
1346 /* Look down path for it, allocate 2nd new malloc'd copy. */
1347 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1348 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1351 char *exename
= alloca (strlen (name
) + 5);
1352 strcat (strcpy (exename
, name
), ".exe");
1353 desc
= openp (getenv ("PATH"), 1, exename
, O_RDONLY
| O_BINARY
,
1359 make_cleanup (xfree
, name
);
1360 perror_with_name (name
);
1362 xfree (name
); /* Free 1st new malloc'd copy */
1363 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
1364 /* It'll be freed in free_objfile(). */
1366 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
1370 make_cleanup (xfree
, name
);
1371 error ("\"%s\": can't open to read symbols: %s.", name
,
1372 bfd_errmsg (bfd_get_error ()));
1374 sym_bfd
->cacheable
= 1;
1376 if (!bfd_check_format (sym_bfd
, bfd_object
))
1378 /* FIXME: should be checking for errors from bfd_close (for one thing,
1379 on error it does not free all the storage associated with the
1381 bfd_close (sym_bfd
); /* This also closes desc */
1382 make_cleanup (xfree
, name
);
1383 error ("\"%s\": can't read symbols: %s.", name
,
1384 bfd_errmsg (bfd_get_error ()));
1389 /* Return the section index for the given section name. Return -1 if
1390 the section was not found. */
1392 get_section_index (struct objfile
*objfile
, char *section_name
)
1394 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1401 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
1402 startup by the _initialize routine in each object file format reader,
1403 to register information about each format the the reader is prepared
1407 add_symtab_fns (struct sym_fns
*sf
)
1409 sf
->next
= symtab_fns
;
1414 /* Initialize to read symbols from the symbol file sym_bfd. It either
1415 returns or calls error(). The result is an initialized struct sym_fns
1416 in the objfile structure, that contains cached information about the
1420 find_sym_fns (struct objfile
*objfile
)
1423 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
->obfd
);
1424 char *our_target
= bfd_get_target (objfile
->obfd
);
1426 if (our_flavour
== bfd_target_srec_flavour
1427 || our_flavour
== bfd_target_ihex_flavour
1428 || our_flavour
== bfd_target_tekhex_flavour
)
1429 return; /* No symbols. */
1431 /* Special kludge for apollo. See dstread.c. */
1432 if (STREQN (our_target
, "apollo", 6))
1433 our_flavour
= (enum bfd_flavour
) -2;
1435 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1437 if (our_flavour
== sf
->sym_flavour
)
1443 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
1444 bfd_get_target (objfile
->obfd
));
1447 /* This function runs the load command of our current target. */
1450 load_command (char *arg
, int from_tty
)
1453 arg
= get_exec_file (1);
1454 target_load (arg
, from_tty
);
1456 /* After re-loading the executable, we don't really know which
1457 overlays are mapped any more. */
1458 overlay_cache_invalid
= 1;
1461 /* This version of "load" should be usable for any target. Currently
1462 it is just used for remote targets, not inftarg.c or core files,
1463 on the theory that only in that case is it useful.
1465 Avoiding xmodem and the like seems like a win (a) because we don't have
1466 to worry about finding it, and (b) On VMS, fork() is very slow and so
1467 we don't want to run a subprocess. On the other hand, I'm not sure how
1468 performance compares. */
1470 static int download_write_size
= 512;
1471 static int validate_download
= 0;
1473 /* Callback service function for generic_load (bfd_map_over_sections). */
1476 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1478 bfd_size_type
*sum
= data
;
1480 *sum
+= bfd_get_section_size_before_reloc (asec
);
1483 /* Opaque data for load_section_callback. */
1484 struct load_section_data
{
1485 unsigned long load_offset
;
1486 unsigned long write_count
;
1487 unsigned long data_count
;
1488 bfd_size_type total_size
;
1491 /* Callback service function for generic_load (bfd_map_over_sections). */
1494 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1496 struct load_section_data
*args
= data
;
1498 if (bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
)
1500 bfd_size_type size
= bfd_get_section_size_before_reloc (asec
);
1504 struct cleanup
*old_chain
;
1505 CORE_ADDR lma
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1506 bfd_size_type block_size
;
1508 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1511 if (download_write_size
> 0 && size
> download_write_size
)
1512 block_size
= download_write_size
;
1516 buffer
= xmalloc (size
);
1517 old_chain
= make_cleanup (xfree
, buffer
);
1519 /* Is this really necessary? I guess it gives the user something
1520 to look at during a long download. */
1521 ui_out_message (uiout
, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1522 sect_name
, paddr_nz (size
), paddr_nz (lma
));
1524 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1530 bfd_size_type this_transfer
= size
- sent
;
1532 if (this_transfer
>= block_size
)
1533 this_transfer
= block_size
;
1534 len
= target_write_memory_partial (lma
, buffer
,
1535 this_transfer
, &err
);
1538 if (validate_download
)
1540 /* Broken memories and broken monitors manifest
1541 themselves here when bring new computers to
1542 life. This doubles already slow downloads. */
1543 /* NOTE: cagney/1999-10-18: A more efficient
1544 implementation might add a verify_memory()
1545 method to the target vector and then use
1546 that. remote.c could implement that method
1547 using the ``qCRC'' packet. */
1548 char *check
= xmalloc (len
);
1549 struct cleanup
*verify_cleanups
=
1550 make_cleanup (xfree
, check
);
1552 if (target_read_memory (lma
, check
, len
) != 0)
1553 error ("Download verify read failed at 0x%s",
1555 if (memcmp (buffer
, check
, len
) != 0)
1556 error ("Download verify compare failed at 0x%s",
1558 do_cleanups (verify_cleanups
);
1560 args
->data_count
+= len
;
1563 args
->write_count
+= 1;
1566 || (ui_load_progress_hook
!= NULL
1567 && ui_load_progress_hook (sect_name
, sent
)))
1568 error ("Canceled the download");
1570 if (show_load_progress
!= NULL
)
1571 show_load_progress (sect_name
, sent
, size
,
1572 args
->data_count
, args
->total_size
);
1574 while (sent
< size
);
1577 error ("Memory access error while loading section %s.", sect_name
);
1579 do_cleanups (old_chain
);
1585 generic_load (char *args
, int from_tty
)
1589 time_t start_time
, end_time
; /* Start and end times of download */
1591 struct cleanup
*old_cleanups
;
1593 struct load_section_data cbdata
;
1596 cbdata
.load_offset
= 0; /* Offset to add to vma for each section. */
1597 cbdata
.write_count
= 0; /* Number of writes needed. */
1598 cbdata
.data_count
= 0; /* Number of bytes written to target memory. */
1599 cbdata
.total_size
= 0; /* Total size of all bfd sectors. */
1601 /* Parse the input argument - the user can specify a load offset as
1602 a second argument. */
1603 filename
= xmalloc (strlen (args
) + 1);
1604 old_cleanups
= make_cleanup (xfree
, filename
);
1605 strcpy (filename
, args
);
1606 offptr
= strchr (filename
, ' ');
1611 cbdata
.load_offset
= strtoul (offptr
, &endptr
, 0);
1612 if (offptr
== endptr
)
1613 error ("Invalid download offset:%s\n", offptr
);
1617 cbdata
.load_offset
= 0;
1619 /* Open the file for loading. */
1620 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1621 if (loadfile_bfd
== NULL
)
1623 perror_with_name (filename
);
1627 /* FIXME: should be checking for errors from bfd_close (for one thing,
1628 on error it does not free all the storage associated with the
1630 make_cleanup_bfd_close (loadfile_bfd
);
1632 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1634 error ("\"%s\" is not an object file: %s", filename
,
1635 bfd_errmsg (bfd_get_error ()));
1638 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1639 (void *) &cbdata
.total_size
);
1641 start_time
= time (NULL
);
1643 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1645 end_time
= time (NULL
);
1647 entry
= bfd_get_start_address (loadfile_bfd
);
1648 ui_out_text (uiout
, "Start address ");
1649 ui_out_field_fmt (uiout
, "address", "0x%s", paddr_nz (entry
));
1650 ui_out_text (uiout
, ", load size ");
1651 ui_out_field_fmt (uiout
, "load-size", "%lu", cbdata
.data_count
);
1652 ui_out_text (uiout
, "\n");
1653 /* We were doing this in remote-mips.c, I suspect it is right
1654 for other targets too. */
1657 /* FIXME: are we supposed to call symbol_file_add or not? According
1658 to a comment from remote-mips.c (where a call to symbol_file_add
1659 was commented out), making the call confuses GDB if more than one
1660 file is loaded in. Some targets do (e.g., remote-vx.c) but
1661 others don't (or didn't - perhaphs they have all been deleted). */
1663 print_transfer_performance (gdb_stdout
, cbdata
.data_count
,
1664 cbdata
.write_count
, end_time
- start_time
);
1666 do_cleanups (old_cleanups
);
1669 /* Report how fast the transfer went. */
1671 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1672 replaced by print_transfer_performance (with a very different
1673 function signature). */
1676 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1679 print_transfer_performance (gdb_stdout
, data_count
,
1680 end_time
- start_time
, 0);
1684 print_transfer_performance (struct ui_file
*stream
,
1685 unsigned long data_count
,
1686 unsigned long write_count
,
1687 unsigned long time_count
)
1689 ui_out_text (uiout
, "Transfer rate: ");
1692 ui_out_field_fmt (uiout
, "transfer-rate", "%lu",
1693 (data_count
* 8) / time_count
);
1694 ui_out_text (uiout
, " bits/sec");
1698 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
1699 ui_out_text (uiout
, " bits in <1 sec");
1701 if (write_count
> 0)
1703 ui_out_text (uiout
, ", ");
1704 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
1705 ui_out_text (uiout
, " bytes/write");
1707 ui_out_text (uiout
, ".\n");
1710 /* This function allows the addition of incrementally linked object files.
1711 It does not modify any state in the target, only in the debugger. */
1712 /* Note: ezannoni 2000-04-13 This function/command used to have a
1713 special case syntax for the rombug target (Rombug is the boot
1714 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1715 rombug case, the user doesn't need to supply a text address,
1716 instead a call to target_link() (in target.c) would supply the
1717 value to use. We are now discontinuing this type of ad hoc syntax. */
1721 add_symbol_file_command (char *args
, int from_tty
)
1723 char *filename
= NULL
;
1724 int flags
= OBJF_USERLOADED
;
1726 int expecting_option
= 0;
1727 int section_index
= 0;
1731 int expecting_sec_name
= 0;
1732 int expecting_sec_addr
= 0;
1738 } sect_opts
[SECT_OFF_MAX
];
1740 struct section_addr_info section_addrs
;
1741 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
1746 error ("add-symbol-file takes a file name and an address");
1748 /* Make a copy of the string that we can safely write into. */
1749 args
= xstrdup (args
);
1751 /* Ensure section_addrs is initialized */
1752 memset (§ion_addrs
, 0, sizeof (section_addrs
));
1754 while (*args
!= '\000')
1756 /* Any leading spaces? */
1757 while (isspace (*args
))
1760 /* Point arg to the beginning of the argument. */
1763 /* Move args pointer over the argument. */
1764 while ((*args
!= '\000') && !isspace (*args
))
1767 /* If there are more arguments, terminate arg and
1769 if (*args
!= '\000')
1772 /* Now process the argument. */
1775 /* The first argument is the file name. */
1776 filename
= tilde_expand (arg
);
1777 make_cleanup (xfree
, filename
);
1782 /* The second argument is always the text address at which
1783 to load the program. */
1784 sect_opts
[section_index
].name
= ".text";
1785 sect_opts
[section_index
].value
= arg
;
1790 /* It's an option (starting with '-') or it's an argument
1795 if (strcmp (arg
, "-mapped") == 0)
1796 flags
|= OBJF_MAPPED
;
1798 if (strcmp (arg
, "-readnow") == 0)
1799 flags
|= OBJF_READNOW
;
1801 if (strcmp (arg
, "-s") == 0)
1803 if (section_index
>= SECT_OFF_MAX
)
1804 error ("Too many sections specified.");
1805 expecting_sec_name
= 1;
1806 expecting_sec_addr
= 1;
1811 if (expecting_sec_name
)
1813 sect_opts
[section_index
].name
= arg
;
1814 expecting_sec_name
= 0;
1817 if (expecting_sec_addr
)
1819 sect_opts
[section_index
].value
= arg
;
1820 expecting_sec_addr
= 0;
1824 error ("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*");
1830 /* Print the prompt for the query below. And save the arguments into
1831 a sect_addr_info structure to be passed around to other
1832 functions. We have to split this up into separate print
1833 statements because local_hex_string returns a local static
1836 printf_filtered ("add symbol table from file \"%s\" at\n", filename
);
1837 for (i
= 0; i
< section_index
; i
++)
1840 char *val
= sect_opts
[i
].value
;
1841 char *sec
= sect_opts
[i
].name
;
1843 val
= sect_opts
[i
].value
;
1844 if (val
[0] == '0' && val
[1] == 'x')
1845 addr
= strtoul (val
+2, NULL
, 16);
1847 addr
= strtoul (val
, NULL
, 10);
1849 /* Here we store the section offsets in the order they were
1850 entered on the command line. */
1851 section_addrs
.other
[sec_num
].name
= sec
;
1852 section_addrs
.other
[sec_num
].addr
= addr
;
1853 printf_filtered ("\t%s_addr = %s\n",
1855 local_hex_string ((unsigned long)addr
));
1858 /* The object's sections are initialized when a
1859 call is made to build_objfile_section_table (objfile).
1860 This happens in reread_symbols.
1861 At this point, we don't know what file type this is,
1862 so we can't determine what section names are valid. */
1865 if (from_tty
&& (!query ("%s", "")))
1866 error ("Not confirmed.");
1868 symbol_file_add (filename
, from_tty
, §ion_addrs
, 0, flags
);
1870 /* Getting new symbols may change our opinion about what is
1872 reinit_frame_cache ();
1873 do_cleanups (my_cleanups
);
1877 add_shared_symbol_files_command (char *args
, int from_tty
)
1879 #ifdef ADD_SHARED_SYMBOL_FILES
1880 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1882 error ("This command is not available in this configuration of GDB.");
1886 /* Re-read symbols if a symbol-file has changed. */
1888 reread_symbols (void)
1890 struct objfile
*objfile
;
1893 struct stat new_statbuf
;
1896 /* With the addition of shared libraries, this should be modified,
1897 the load time should be saved in the partial symbol tables, since
1898 different tables may come from different source files. FIXME.
1899 This routine should then walk down each partial symbol table
1900 and see if the symbol table that it originates from has been changed */
1902 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
1906 #ifdef IBM6000_TARGET
1907 /* If this object is from a shared library, then you should
1908 stat on the library name, not member name. */
1910 if (objfile
->obfd
->my_archive
)
1911 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1914 res
= stat (objfile
->name
, &new_statbuf
);
1917 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1918 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1922 new_modtime
= new_statbuf
.st_mtime
;
1923 if (new_modtime
!= objfile
->mtime
)
1925 struct cleanup
*old_cleanups
;
1926 struct section_offsets
*offsets
;
1928 char *obfd_filename
;
1930 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1933 /* There are various functions like symbol_file_add,
1934 symfile_bfd_open, syms_from_objfile, etc., which might
1935 appear to do what we want. But they have various other
1936 effects which we *don't* want. So we just do stuff
1937 ourselves. We don't worry about mapped files (for one thing,
1938 any mapped file will be out of date). */
1940 /* If we get an error, blow away this objfile (not sure if
1941 that is the correct response for things like shared
1943 old_cleanups
= make_cleanup_free_objfile (objfile
);
1944 /* We need to do this whenever any symbols go away. */
1945 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1947 /* Clean up any state BFD has sitting around. We don't need
1948 to close the descriptor but BFD lacks a way of closing the
1949 BFD without closing the descriptor. */
1950 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1951 if (!bfd_close (objfile
->obfd
))
1952 error ("Can't close BFD for %s: %s", objfile
->name
,
1953 bfd_errmsg (bfd_get_error ()));
1954 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1955 if (objfile
->obfd
== NULL
)
1956 error ("Can't open %s to read symbols.", objfile
->name
);
1957 /* bfd_openr sets cacheable to true, which is what we want. */
1958 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1959 error ("Can't read symbols from %s: %s.", objfile
->name
,
1960 bfd_errmsg (bfd_get_error ()));
1962 /* Save the offsets, we will nuke them with the rest of the
1964 num_offsets
= objfile
->num_sections
;
1965 offsets
= (struct section_offsets
*) alloca (SIZEOF_SECTION_OFFSETS
);
1966 memcpy (offsets
, objfile
->section_offsets
, SIZEOF_SECTION_OFFSETS
);
1968 /* Nuke all the state that we will re-read. Much of the following
1969 code which sets things to NULL really is necessary to tell
1970 other parts of GDB that there is nothing currently there. */
1972 /* FIXME: Do we have to free a whole linked list, or is this
1974 if (objfile
->global_psymbols
.list
)
1975 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
1976 memset (&objfile
->global_psymbols
, 0,
1977 sizeof (objfile
->global_psymbols
));
1978 if (objfile
->static_psymbols
.list
)
1979 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
1980 memset (&objfile
->static_psymbols
, 0,
1981 sizeof (objfile
->static_psymbols
));
1983 /* Free the obstacks for non-reusable objfiles */
1984 bcache_xfree (objfile
->psymbol_cache
);
1985 objfile
->psymbol_cache
= bcache_xmalloc ();
1986 bcache_xfree (objfile
->macro_cache
);
1987 objfile
->macro_cache
= bcache_xmalloc ();
1988 if (objfile
->demangled_names_hash
!= NULL
)
1990 htab_delete (objfile
->demangled_names_hash
);
1991 objfile
->demangled_names_hash
= NULL
;
1993 obstack_free (&objfile
->psymbol_obstack
, 0);
1994 obstack_free (&objfile
->symbol_obstack
, 0);
1995 obstack_free (&objfile
->type_obstack
, 0);
1996 objfile
->sections
= NULL
;
1997 objfile
->symtabs
= NULL
;
1998 objfile
->psymtabs
= NULL
;
1999 objfile
->free_psymtabs
= NULL
;
2000 objfile
->msymbols
= NULL
;
2001 objfile
->minimal_symbol_count
= 0;
2002 memset (&objfile
->msymbol_hash
, 0,
2003 sizeof (objfile
->msymbol_hash
));
2004 memset (&objfile
->msymbol_demangled_hash
, 0,
2005 sizeof (objfile
->msymbol_demangled_hash
));
2006 objfile
->fundamental_types
= NULL
;
2007 if (objfile
->sf
!= NULL
)
2009 (*objfile
->sf
->sym_finish
) (objfile
);
2012 /* We never make this a mapped file. */
2014 /* obstack_specify_allocation also initializes the obstack so
2016 objfile
->psymbol_cache
= bcache_xmalloc ();
2017 objfile
->macro_cache
= bcache_xmalloc ();
2018 obstack_specify_allocation (&objfile
->psymbol_obstack
, 0, 0,
2020 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0,
2022 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0,
2024 if (build_objfile_section_table (objfile
))
2026 error ("Can't find the file sections in `%s': %s",
2027 objfile
->name
, bfd_errmsg (bfd_get_error ()));
2029 terminate_minimal_symbol_table (objfile
);
2031 /* We use the same section offsets as from last time. I'm not
2032 sure whether that is always correct for shared libraries. */
2033 objfile
->section_offsets
= (struct section_offsets
*)
2034 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
2035 memcpy (objfile
->section_offsets
, offsets
, SIZEOF_SECTION_OFFSETS
);
2036 objfile
->num_sections
= num_offsets
;
2038 /* What the hell is sym_new_init for, anyway? The concept of
2039 distinguishing between the main file and additional files
2040 in this way seems rather dubious. */
2041 if (objfile
== symfile_objfile
)
2043 (*objfile
->sf
->sym_new_init
) (objfile
);
2045 RESET_HP_UX_GLOBALS ();
2049 (*objfile
->sf
->sym_init
) (objfile
);
2050 clear_complaints (&symfile_complaints
, 1, 1);
2051 /* The "mainline" parameter is a hideous hack; I think leaving it
2052 zero is OK since dbxread.c also does what it needs to do if
2053 objfile->global_psymbols.size is 0. */
2054 (*objfile
->sf
->sym_read
) (objfile
, 0);
2055 if (!have_partial_symbols () && !have_full_symbols ())
2058 printf_filtered ("(no debugging symbols found)\n");
2061 objfile
->flags
|= OBJF_SYMS
;
2063 /* We're done reading the symbol file; finish off complaints. */
2064 clear_complaints (&symfile_complaints
, 0, 1);
2066 /* Getting new symbols may change our opinion about what is
2069 reinit_frame_cache ();
2071 /* Discard cleanups as symbol reading was successful. */
2072 discard_cleanups (old_cleanups
);
2074 /* If the mtime has changed between the time we set new_modtime
2075 and now, we *want* this to be out of date, so don't call stat
2077 objfile
->mtime
= new_modtime
;
2080 /* Call this after reading in a new symbol table to give target
2081 dependent code a crack at the new symbols. For instance, this
2082 could be used to update the values of target-specific symbols GDB
2083 needs to keep track of (such as _sigtramp, or whatever). */
2085 TARGET_SYMFILE_POSTREAD (objfile
);
2087 reread_separate_symbols (objfile
);
2093 clear_symtab_users ();
2097 /* Handle separate debug info for OBJFILE, which has just been
2099 - If we had separate debug info before, but now we don't, get rid
2100 of the separated objfile.
2101 - If we didn't have separated debug info before, but now we do,
2102 read in the new separated debug info file.
2103 - If the debug link points to a different file, toss the old one
2104 and read the new one.
2105 This function does *not* handle the case where objfile is still
2106 using the same separate debug info file, but that file's timestamp
2107 has changed. That case should be handled by the loop in
2108 reread_symbols already. */
2110 reread_separate_symbols (struct objfile
*objfile
)
2113 unsigned long crc32
;
2115 /* Does the updated objfile's debug info live in a
2117 debug_file
= find_separate_debug_file (objfile
);
2119 if (objfile
->separate_debug_objfile
)
2121 /* There are two cases where we need to get rid of
2122 the old separated debug info objfile:
2123 - if the new primary objfile doesn't have
2124 separated debug info, or
2125 - if the new primary objfile has separate debug
2126 info, but it's under a different filename.
2128 If the old and new objfiles both have separate
2129 debug info, under the same filename, then we're
2130 okay --- if the separated file's contents have
2131 changed, we will have caught that when we
2132 visited it in this function's outermost
2135 || strcmp (debug_file
, objfile
->separate_debug_objfile
->name
) != 0)
2136 free_objfile (objfile
->separate_debug_objfile
);
2139 /* If the new objfile has separate debug info, and we
2140 haven't loaded it already, do so now. */
2142 && ! objfile
->separate_debug_objfile
)
2144 /* Use the same section offset table as objfile itself.
2145 Preserve the flags from objfile that make sense. */
2146 objfile
->separate_debug_objfile
2147 = (symbol_file_add_with_addrs_or_offsets
2149 info_verbose
, /* from_tty: Don't override the default. */
2150 0, /* No addr table. */
2151 objfile
->section_offsets
, objfile
->num_sections
,
2152 0, /* Not mainline. See comments about this above. */
2153 objfile
->flags
& (OBJF_MAPPED
| OBJF_REORDERED
2154 | OBJF_SHARED
| OBJF_READNOW
2155 | OBJF_USERLOADED
)));
2156 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
2172 static filename_language
*filename_language_table
;
2173 static int fl_table_size
, fl_table_next
;
2176 add_filename_language (char *ext
, enum language lang
)
2178 if (fl_table_next
>= fl_table_size
)
2180 fl_table_size
+= 10;
2181 filename_language_table
=
2182 xrealloc (filename_language_table
,
2183 fl_table_size
* sizeof (*filename_language_table
));
2186 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2187 filename_language_table
[fl_table_next
].lang
= lang
;
2191 static char *ext_args
;
2194 set_ext_lang_command (char *args
, int from_tty
)
2197 char *cp
= ext_args
;
2200 /* First arg is filename extension, starting with '.' */
2202 error ("'%s': Filename extension must begin with '.'", ext_args
);
2204 /* Find end of first arg. */
2205 while (*cp
&& !isspace (*cp
))
2209 error ("'%s': two arguments required -- filename extension and language",
2212 /* Null-terminate first arg */
2215 /* Find beginning of second arg, which should be a source language. */
2216 while (*cp
&& isspace (*cp
))
2220 error ("'%s': two arguments required -- filename extension and language",
2223 /* Lookup the language from among those we know. */
2224 lang
= language_enum (cp
);
2226 /* Now lookup the filename extension: do we already know it? */
2227 for (i
= 0; i
< fl_table_next
; i
++)
2228 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2231 if (i
>= fl_table_next
)
2233 /* new file extension */
2234 add_filename_language (ext_args
, lang
);
2238 /* redefining a previously known filename extension */
2241 /* query ("Really make files of type %s '%s'?", */
2242 /* ext_args, language_str (lang)); */
2244 xfree (filename_language_table
[i
].ext
);
2245 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2246 filename_language_table
[i
].lang
= lang
;
2251 info_ext_lang_command (char *args
, int from_tty
)
2255 printf_filtered ("Filename extensions and the languages they represent:");
2256 printf_filtered ("\n\n");
2257 for (i
= 0; i
< fl_table_next
; i
++)
2258 printf_filtered ("\t%s\t- %s\n",
2259 filename_language_table
[i
].ext
,
2260 language_str (filename_language_table
[i
].lang
));
2264 init_filename_language_table (void)
2266 if (fl_table_size
== 0) /* protect against repetition */
2270 filename_language_table
=
2271 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2272 add_filename_language (".c", language_c
);
2273 add_filename_language (".C", language_cplus
);
2274 add_filename_language (".cc", language_cplus
);
2275 add_filename_language (".cp", language_cplus
);
2276 add_filename_language (".cpp", language_cplus
);
2277 add_filename_language (".cxx", language_cplus
);
2278 add_filename_language (".c++", language_cplus
);
2279 add_filename_language (".java", language_java
);
2280 add_filename_language (".class", language_java
);
2281 add_filename_language (".m", language_objc
);
2282 add_filename_language (".f", language_fortran
);
2283 add_filename_language (".F", language_fortran
);
2284 add_filename_language (".s", language_asm
);
2285 add_filename_language (".S", language_asm
);
2286 add_filename_language (".pas", language_pascal
);
2287 add_filename_language (".p", language_pascal
);
2288 add_filename_language (".pp", language_pascal
);
2293 deduce_language_from_filename (char *filename
)
2298 if (filename
!= NULL
)
2299 if ((cp
= strrchr (filename
, '.')) != NULL
)
2300 for (i
= 0; i
< fl_table_next
; i
++)
2301 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2302 return filename_language_table
[i
].lang
;
2304 return language_unknown
;
2309 Allocate and partly initialize a new symbol table. Return a pointer
2310 to it. error() if no space.
2312 Caller must set these fields:
2318 possibly free_named_symtabs (symtab->filename);
2322 allocate_symtab (char *filename
, struct objfile
*objfile
)
2324 register struct symtab
*symtab
;
2326 symtab
= (struct symtab
*)
2327 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct symtab
));
2328 memset (symtab
, 0, sizeof (*symtab
));
2329 symtab
->filename
= obsavestring (filename
, strlen (filename
),
2330 &objfile
->symbol_obstack
);
2331 symtab
->fullname
= NULL
;
2332 symtab
->language
= deduce_language_from_filename (filename
);
2333 symtab
->debugformat
= obsavestring ("unknown", 7,
2334 &objfile
->symbol_obstack
);
2336 /* Hook it to the objfile it comes from */
2338 symtab
->objfile
= objfile
;
2339 symtab
->next
= objfile
->symtabs
;
2340 objfile
->symtabs
= symtab
;
2342 /* FIXME: This should go away. It is only defined for the Z8000,
2343 and the Z8000 definition of this macro doesn't have anything to
2344 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
2345 here for convenience. */
2346 #ifdef INIT_EXTRA_SYMTAB_INFO
2347 INIT_EXTRA_SYMTAB_INFO (symtab
);
2353 struct partial_symtab
*
2354 allocate_psymtab (char *filename
, struct objfile
*objfile
)
2356 struct partial_symtab
*psymtab
;
2358 if (objfile
->free_psymtabs
)
2360 psymtab
= objfile
->free_psymtabs
;
2361 objfile
->free_psymtabs
= psymtab
->next
;
2364 psymtab
= (struct partial_symtab
*)
2365 obstack_alloc (&objfile
->psymbol_obstack
,
2366 sizeof (struct partial_symtab
));
2368 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2369 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
2370 &objfile
->psymbol_obstack
);
2371 psymtab
->symtab
= NULL
;
2373 /* Prepend it to the psymtab list for the objfile it belongs to.
2374 Psymtabs are searched in most recent inserted -> least recent
2377 psymtab
->objfile
= objfile
;
2378 psymtab
->next
= objfile
->psymtabs
;
2379 objfile
->psymtabs
= psymtab
;
2382 struct partial_symtab
**prev_pst
;
2383 psymtab
->objfile
= objfile
;
2384 psymtab
->next
= NULL
;
2385 prev_pst
= &(objfile
->psymtabs
);
2386 while ((*prev_pst
) != NULL
)
2387 prev_pst
= &((*prev_pst
)->next
);
2388 (*prev_pst
) = psymtab
;
2396 discard_psymtab (struct partial_symtab
*pst
)
2398 struct partial_symtab
**prev_pst
;
2401 Empty psymtabs happen as a result of header files which don't
2402 have any symbols in them. There can be a lot of them. But this
2403 check is wrong, in that a psymtab with N_SLINE entries but
2404 nothing else is not empty, but we don't realize that. Fixing
2405 that without slowing things down might be tricky. */
2407 /* First, snip it out of the psymtab chain */
2409 prev_pst
= &(pst
->objfile
->psymtabs
);
2410 while ((*prev_pst
) != pst
)
2411 prev_pst
= &((*prev_pst
)->next
);
2412 (*prev_pst
) = pst
->next
;
2414 /* Next, put it on a free list for recycling */
2416 pst
->next
= pst
->objfile
->free_psymtabs
;
2417 pst
->objfile
->free_psymtabs
= pst
;
2421 /* Reset all data structures in gdb which may contain references to symbol
2425 clear_symtab_users (void)
2427 /* Someday, we should do better than this, by only blowing away
2428 the things that really need to be blown. */
2429 clear_value_history ();
2431 clear_internalvars ();
2432 breakpoint_re_set ();
2433 set_default_breakpoint (0, 0, 0, 0);
2434 clear_current_source_symtab_and_line ();
2435 clear_pc_function_cache ();
2436 if (target_new_objfile_hook
)
2437 target_new_objfile_hook (NULL
);
2441 clear_symtab_users_cleanup (void *ignore
)
2443 clear_symtab_users ();
2446 /* clear_symtab_users_once:
2448 This function is run after symbol reading, or from a cleanup.
2449 If an old symbol table was obsoleted, the old symbol table
2450 has been blown away, but the other GDB data structures that may
2451 reference it have not yet been cleared or re-directed. (The old
2452 symtab was zapped, and the cleanup queued, in free_named_symtab()
2455 This function can be queued N times as a cleanup, or called
2456 directly; it will do all the work the first time, and then will be a
2457 no-op until the next time it is queued. This works by bumping a
2458 counter at queueing time. Much later when the cleanup is run, or at
2459 the end of symbol processing (in case the cleanup is discarded), if
2460 the queued count is greater than the "done-count", we do the work
2461 and set the done-count to the queued count. If the queued count is
2462 less than or equal to the done-count, we just ignore the call. This
2463 is needed because reading a single .o file will often replace many
2464 symtabs (one per .h file, for example), and we don't want to reset
2465 the breakpoints N times in the user's face.
2467 The reason we both queue a cleanup, and call it directly after symbol
2468 reading, is because the cleanup protects us in case of errors, but is
2469 discarded if symbol reading is successful. */
2472 /* FIXME: As free_named_symtabs is currently a big noop this function
2473 is no longer needed. */
2474 static void clear_symtab_users_once (void);
2476 static int clear_symtab_users_queued
;
2477 static int clear_symtab_users_done
;
2480 clear_symtab_users_once (void)
2482 /* Enforce once-per-`do_cleanups'-semantics */
2483 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2485 clear_symtab_users_done
= clear_symtab_users_queued
;
2487 clear_symtab_users ();
2491 /* Delete the specified psymtab, and any others that reference it. */
2494 cashier_psymtab (struct partial_symtab
*pst
)
2496 struct partial_symtab
*ps
, *pprev
= NULL
;
2499 /* Find its previous psymtab in the chain */
2500 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2509 /* Unhook it from the chain. */
2510 if (ps
== pst
->objfile
->psymtabs
)
2511 pst
->objfile
->psymtabs
= ps
->next
;
2513 pprev
->next
= ps
->next
;
2515 /* FIXME, we can't conveniently deallocate the entries in the
2516 partial_symbol lists (global_psymbols/static_psymbols) that
2517 this psymtab points to. These just take up space until all
2518 the psymtabs are reclaimed. Ditto the dependencies list and
2519 filename, which are all in the psymbol_obstack. */
2521 /* We need to cashier any psymtab that has this one as a dependency... */
2523 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2525 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2527 if (ps
->dependencies
[i
] == pst
)
2529 cashier_psymtab (ps
);
2530 goto again
; /* Must restart, chain has been munged. */
2537 /* If a symtab or psymtab for filename NAME is found, free it along
2538 with any dependent breakpoints, displays, etc.
2539 Used when loading new versions of object modules with the "add-file"
2540 command. This is only called on the top-level symtab or psymtab's name;
2541 it is not called for subsidiary files such as .h files.
2543 Return value is 1 if we blew away the environment, 0 if not.
2544 FIXME. The return value appears to never be used.
2546 FIXME. I think this is not the best way to do this. We should
2547 work on being gentler to the environment while still cleaning up
2548 all stray pointers into the freed symtab. */
2551 free_named_symtabs (char *name
)
2554 /* FIXME: With the new method of each objfile having it's own
2555 psymtab list, this function needs serious rethinking. In particular,
2556 why was it ever necessary to toss psymtabs with specific compilation
2557 unit filenames, as opposed to all psymtabs from a particular symbol
2559 Well, the answer is that some systems permit reloading of particular
2560 compilation units. We want to blow away any old info about these
2561 compilation units, regardless of which objfiles they arrived in. --gnu. */
2563 register struct symtab
*s
;
2564 register struct symtab
*prev
;
2565 register struct partial_symtab
*ps
;
2566 struct blockvector
*bv
;
2569 /* We only wack things if the symbol-reload switch is set. */
2570 if (!symbol_reloading
)
2573 /* Some symbol formats have trouble providing file names... */
2574 if (name
== 0 || *name
== '\0')
2577 /* Look for a psymtab with the specified name. */
2580 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2582 if (STREQ (name
, ps
->filename
))
2584 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2585 goto again2
; /* Must restart, chain has been munged */
2589 /* Look for a symtab with the specified name. */
2591 for (s
= symtab_list
; s
; s
= s
->next
)
2593 if (STREQ (name
, s
->filename
))
2600 if (s
== symtab_list
)
2601 symtab_list
= s
->next
;
2603 prev
->next
= s
->next
;
2605 /* For now, queue a delete for all breakpoints, displays, etc., whether
2606 or not they depend on the symtab being freed. This should be
2607 changed so that only those data structures affected are deleted. */
2609 /* But don't delete anything if the symtab is empty.
2610 This test is necessary due to a bug in "dbxread.c" that
2611 causes empty symtabs to be created for N_SO symbols that
2612 contain the pathname of the object file. (This problem
2613 has been fixed in GDB 3.9x). */
2615 bv
= BLOCKVECTOR (s
);
2616 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2617 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2618 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2620 complaint (&symfile_complaints
, "Replacing old symbols for `%s'",
2622 clear_symtab_users_queued
++;
2623 make_cleanup (clear_symtab_users_once
, 0);
2628 complaint (&symfile_complaints
, "Empty symbol table found for `%s'",
2636 /* It is still possible that some breakpoints will be affected
2637 even though no symtab was found, since the file might have
2638 been compiled without debugging, and hence not be associated
2639 with a symtab. In order to handle this correctly, we would need
2640 to keep a list of text address ranges for undebuggable files.
2641 For now, we do nothing, since this is a fairly obscure case. */
2645 /* FIXME, what about the minimal symbol table? */
2652 /* Allocate and partially fill a partial symtab. It will be
2653 completely filled at the end of the symbol list.
2655 FILENAME is the name of the symbol-file we are reading from. */
2657 struct partial_symtab
*
2658 start_psymtab_common (struct objfile
*objfile
,
2659 struct section_offsets
*section_offsets
, char *filename
,
2660 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2661 struct partial_symbol
**static_syms
)
2663 struct partial_symtab
*psymtab
;
2665 psymtab
= allocate_psymtab (filename
, objfile
);
2666 psymtab
->section_offsets
= section_offsets
;
2667 psymtab
->textlow
= textlow
;
2668 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2669 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2670 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2674 /* Add a symbol with a long value to a psymtab.
2675 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
2678 add_psymbol_to_list (char *name
, int namelength
, namespace_enum
namespace,
2679 enum address_class
class,
2680 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2681 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2682 enum language language
, struct objfile
*objfile
)
2684 register struct partial_symbol
*psym
;
2685 char *buf
= alloca (namelength
+ 1);
2686 /* psymbol is static so that there will be no uninitialized gaps in the
2687 structure which might contain random data, causing cache misses in
2689 static struct partial_symbol psymbol
;
2691 /* Create local copy of the partial symbol */
2692 memcpy (buf
, name
, namelength
);
2693 buf
[namelength
] = '\0';
2694 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2697 SYMBOL_VALUE (&psymbol
) = val
;
2701 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2703 SYMBOL_SECTION (&psymbol
) = 0;
2704 SYMBOL_LANGUAGE (&psymbol
) = language
;
2705 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2706 PSYMBOL_CLASS (&psymbol
) = class;
2708 SYMBOL_SET_NAMES (&psymbol
, buf
, namelength
, objfile
);
2710 /* Stash the partial symbol away in the cache */
2711 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), objfile
->psymbol_cache
);
2713 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2714 if (list
->next
>= list
->list
+ list
->size
)
2716 extend_psymbol_list (list
, objfile
);
2718 *list
->next
++ = psym
;
2719 OBJSTAT (objfile
, n_psyms
++);
2722 /* Add a symbol with a long value to a psymtab. This differs from
2723 * add_psymbol_to_list above in taking both a mangled and a demangled
2727 add_psymbol_with_dem_name_to_list (char *name
, int namelength
, char *dem_name
,
2728 int dem_namelength
, namespace_enum
namespace,
2729 enum address_class
class,
2730 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2731 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2732 enum language language
,
2733 struct objfile
*objfile
)
2735 register struct partial_symbol
*psym
;
2736 char *buf
= alloca (namelength
+ 1);
2737 /* psymbol is static so that there will be no uninitialized gaps in the
2738 structure which might contain random data, causing cache misses in
2740 static struct partial_symbol psymbol
;
2742 /* Create local copy of the partial symbol */
2744 memcpy (buf
, name
, namelength
);
2745 buf
[namelength
] = '\0';
2746 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, objfile
->psymbol_cache
);
2748 buf
= alloca (dem_namelength
+ 1);
2749 memcpy (buf
, dem_name
, dem_namelength
);
2750 buf
[dem_namelength
] = '\0';
2755 case language_cplus
:
2756 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol
) =
2757 bcache (buf
, dem_namelength
+ 1, objfile
->psymbol_cache
);
2759 /* FIXME What should be done for the default case? Ignoring for now. */
2762 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2765 SYMBOL_VALUE (&psymbol
) = val
;
2769 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2771 SYMBOL_SECTION (&psymbol
) = 0;
2772 SYMBOL_LANGUAGE (&psymbol
) = language
;
2773 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2774 PSYMBOL_CLASS (&psymbol
) = class;
2775 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2777 /* Stash the partial symbol away in the cache */
2778 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), objfile
->psymbol_cache
);
2780 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2781 if (list
->next
>= list
->list
+ list
->size
)
2783 extend_psymbol_list (list
, objfile
);
2785 *list
->next
++ = psym
;
2786 OBJSTAT (objfile
, n_psyms
++);
2789 /* Initialize storage for partial symbols. */
2792 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
2794 /* Free any previously allocated psymbol lists. */
2796 if (objfile
->global_psymbols
.list
)
2798 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
2800 if (objfile
->static_psymbols
.list
)
2802 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
2805 /* Current best guess is that approximately a twentieth
2806 of the total symbols (in a debugging file) are global or static
2809 objfile
->global_psymbols
.size
= total_symbols
/ 10;
2810 objfile
->static_psymbols
.size
= total_symbols
/ 10;
2812 if (objfile
->global_psymbols
.size
> 0)
2814 objfile
->global_psymbols
.next
=
2815 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
2816 xmmalloc (objfile
->md
, (objfile
->global_psymbols
.size
2817 * sizeof (struct partial_symbol
*)));
2819 if (objfile
->static_psymbols
.size
> 0)
2821 objfile
->static_psymbols
.next
=
2822 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
2823 xmmalloc (objfile
->md
, (objfile
->static_psymbols
.size
2824 * sizeof (struct partial_symbol
*)));
2829 The following code implements an abstraction for debugging overlay sections.
2831 The target model is as follows:
2832 1) The gnu linker will permit multiple sections to be mapped into the
2833 same VMA, each with its own unique LMA (or load address).
2834 2) It is assumed that some runtime mechanism exists for mapping the
2835 sections, one by one, from the load address into the VMA address.
2836 3) This code provides a mechanism for gdb to keep track of which
2837 sections should be considered to be mapped from the VMA to the LMA.
2838 This information is used for symbol lookup, and memory read/write.
2839 For instance, if a section has been mapped then its contents
2840 should be read from the VMA, otherwise from the LMA.
2842 Two levels of debugger support for overlays are available. One is
2843 "manual", in which the debugger relies on the user to tell it which
2844 overlays are currently mapped. This level of support is
2845 implemented entirely in the core debugger, and the information about
2846 whether a section is mapped is kept in the objfile->obj_section table.
2848 The second level of support is "automatic", and is only available if
2849 the target-specific code provides functionality to read the target's
2850 overlay mapping table, and translate its contents for the debugger
2851 (by updating the mapped state information in the obj_section tables).
2853 The interface is as follows:
2855 overlay map <name> -- tell gdb to consider this section mapped
2856 overlay unmap <name> -- tell gdb to consider this section unmapped
2857 overlay list -- list the sections that GDB thinks are mapped
2858 overlay read-target -- get the target's state of what's mapped
2859 overlay off/manual/auto -- set overlay debugging state
2860 Functional interface:
2861 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2862 section, return that section.
2863 find_pc_overlay(pc): find any overlay section that contains
2864 the pc, either in its VMA or its LMA
2865 overlay_is_mapped(sect): true if overlay is marked as mapped
2866 section_is_overlay(sect): true if section's VMA != LMA
2867 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2868 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2869 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2870 overlay_mapped_address(...): map an address from section's LMA to VMA
2871 overlay_unmapped_address(...): map an address from section's VMA to LMA
2872 symbol_overlayed_address(...): Return a "current" address for symbol:
2873 either in VMA or LMA depending on whether
2874 the symbol's section is currently mapped
2877 /* Overlay debugging state: */
2879 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2880 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
2882 /* Target vector for refreshing overlay mapped state */
2883 static void simple_overlay_update (struct obj_section
*);
2884 void (*target_overlay_update
) (struct obj_section
*) = simple_overlay_update
;
2886 /* Function: section_is_overlay (SECTION)
2887 Returns true if SECTION has VMA not equal to LMA, ie.
2888 SECTION is loaded at an address different from where it will "run". */
2891 section_is_overlay (asection
*section
)
2893 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2895 if (overlay_debugging
)
2896 if (section
&& section
->lma
!= 0 &&
2897 section
->vma
!= section
->lma
)
2903 /* Function: overlay_invalidate_all (void)
2904 Invalidate the mapped state of all overlay sections (mark it as stale). */
2907 overlay_invalidate_all (void)
2909 struct objfile
*objfile
;
2910 struct obj_section
*sect
;
2912 ALL_OBJSECTIONS (objfile
, sect
)
2913 if (section_is_overlay (sect
->the_bfd_section
))
2914 sect
->ovly_mapped
= -1;
2917 /* Function: overlay_is_mapped (SECTION)
2918 Returns true if section is an overlay, and is currently mapped.
2919 Private: public access is thru function section_is_mapped.
2921 Access to the ovly_mapped flag is restricted to this function, so
2922 that we can do automatic update. If the global flag
2923 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2924 overlay_invalidate_all. If the mapped state of the particular
2925 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2928 overlay_is_mapped (struct obj_section
*osect
)
2930 if (osect
== 0 || !section_is_overlay (osect
->the_bfd_section
))
2933 switch (overlay_debugging
)
2937 return 0; /* overlay debugging off */
2938 case ovly_auto
: /* overlay debugging automatic */
2939 /* Unles there is a target_overlay_update function,
2940 there's really nothing useful to do here (can't really go auto) */
2941 if (target_overlay_update
)
2943 if (overlay_cache_invalid
)
2945 overlay_invalidate_all ();
2946 overlay_cache_invalid
= 0;
2948 if (osect
->ovly_mapped
== -1)
2949 (*target_overlay_update
) (osect
);
2951 /* fall thru to manual case */
2952 case ovly_on
: /* overlay debugging manual */
2953 return osect
->ovly_mapped
== 1;
2957 /* Function: section_is_mapped
2958 Returns true if section is an overlay, and is currently mapped. */
2961 section_is_mapped (asection
*section
)
2963 struct objfile
*objfile
;
2964 struct obj_section
*osect
;
2966 if (overlay_debugging
)
2967 if (section
&& section_is_overlay (section
))
2968 ALL_OBJSECTIONS (objfile
, osect
)
2969 if (osect
->the_bfd_section
== section
)
2970 return overlay_is_mapped (osect
);
2975 /* Function: pc_in_unmapped_range
2976 If PC falls into the lma range of SECTION, return true, else false. */
2979 pc_in_unmapped_range (CORE_ADDR pc
, asection
*section
)
2981 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2985 if (overlay_debugging
)
2986 if (section
&& section_is_overlay (section
))
2988 size
= bfd_get_section_size_before_reloc (section
);
2989 if (section
->lma
<= pc
&& pc
< section
->lma
+ size
)
2995 /* Function: pc_in_mapped_range
2996 If PC falls into the vma range of SECTION, return true, else false. */
2999 pc_in_mapped_range (CORE_ADDR pc
, asection
*section
)
3001 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3005 if (overlay_debugging
)
3006 if (section
&& section_is_overlay (section
))
3008 size
= bfd_get_section_size_before_reloc (section
);
3009 if (section
->vma
<= pc
&& pc
< section
->vma
+ size
)
3016 /* Return true if the mapped ranges of sections A and B overlap, false
3019 sections_overlap (asection
*a
, asection
*b
)
3021 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3023 CORE_ADDR a_start
= a
->vma
;
3024 CORE_ADDR a_end
= a
->vma
+ bfd_get_section_size_before_reloc (a
);
3025 CORE_ADDR b_start
= b
->vma
;
3026 CORE_ADDR b_end
= b
->vma
+ bfd_get_section_size_before_reloc (b
);
3028 return (a_start
< b_end
&& b_start
< a_end
);
3031 /* Function: overlay_unmapped_address (PC, SECTION)
3032 Returns the address corresponding to PC in the unmapped (load) range.
3033 May be the same as PC. */
3036 overlay_unmapped_address (CORE_ADDR pc
, asection
*section
)
3038 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
3040 if (overlay_debugging
)
3041 if (section
&& section_is_overlay (section
) &&
3042 pc_in_mapped_range (pc
, section
))
3043 return pc
+ section
->lma
- section
->vma
;
3048 /* Function: overlay_mapped_address (PC, SECTION)
3049 Returns the address corresponding to PC in the mapped (runtime) range.
3050 May be the same as PC. */
3053 overlay_mapped_address (CORE_ADDR pc
, asection
*section
)
3055 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3057 if (overlay_debugging
)
3058 if (section
&& section_is_overlay (section
) &&
3059 pc_in_unmapped_range (pc
, section
))
3060 return pc
+ section
->vma
- section
->lma
;
3066 /* Function: symbol_overlayed_address
3067 Return one of two addresses (relative to the VMA or to the LMA),
3068 depending on whether the section is mapped or not. */
3071 symbol_overlayed_address (CORE_ADDR address
, asection
*section
)
3073 if (overlay_debugging
)
3075 /* If the symbol has no section, just return its regular address. */
3078 /* If the symbol's section is not an overlay, just return its address */
3079 if (!section_is_overlay (section
))
3081 /* If the symbol's section is mapped, just return its address */
3082 if (section_is_mapped (section
))
3085 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3086 * then return its LOADED address rather than its vma address!!
3088 return overlay_unmapped_address (address
, section
);
3093 /* Function: find_pc_overlay (PC)
3094 Return the best-match overlay section for PC:
3095 If PC matches a mapped overlay section's VMA, return that section.
3096 Else if PC matches an unmapped section's VMA, return that section.
3097 Else if PC matches an unmapped section's LMA, return that section. */
3100 find_pc_overlay (CORE_ADDR pc
)
3102 struct objfile
*objfile
;
3103 struct obj_section
*osect
, *best_match
= NULL
;
3105 if (overlay_debugging
)
3106 ALL_OBJSECTIONS (objfile
, osect
)
3107 if (section_is_overlay (osect
->the_bfd_section
))
3109 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
))
3111 if (overlay_is_mapped (osect
))
3112 return osect
->the_bfd_section
;
3116 else if (pc_in_unmapped_range (pc
, osect
->the_bfd_section
))
3119 return best_match
? best_match
->the_bfd_section
: NULL
;
3122 /* Function: find_pc_mapped_section (PC)
3123 If PC falls into the VMA address range of an overlay section that is
3124 currently marked as MAPPED, return that section. Else return NULL. */
3127 find_pc_mapped_section (CORE_ADDR pc
)
3129 struct objfile
*objfile
;
3130 struct obj_section
*osect
;
3132 if (overlay_debugging
)
3133 ALL_OBJSECTIONS (objfile
, osect
)
3134 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
) &&
3135 overlay_is_mapped (osect
))
3136 return osect
->the_bfd_section
;
3141 /* Function: list_overlays_command
3142 Print a list of mapped sections and their PC ranges */
3145 list_overlays_command (char *args
, int from_tty
)
3148 struct objfile
*objfile
;
3149 struct obj_section
*osect
;
3151 if (overlay_debugging
)
3152 ALL_OBJSECTIONS (objfile
, osect
)
3153 if (overlay_is_mapped (osect
))
3159 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3160 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3161 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3162 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3164 printf_filtered ("Section %s, loaded at ", name
);
3165 print_address_numeric (lma
, 1, gdb_stdout
);
3166 puts_filtered (" - ");
3167 print_address_numeric (lma
+ size
, 1, gdb_stdout
);
3168 printf_filtered (", mapped at ");
3169 print_address_numeric (vma
, 1, gdb_stdout
);
3170 puts_filtered (" - ");
3171 print_address_numeric (vma
+ size
, 1, gdb_stdout
);
3172 puts_filtered ("\n");
3177 printf_filtered ("No sections are mapped.\n");
3180 /* Function: map_overlay_command
3181 Mark the named section as mapped (ie. residing at its VMA address). */
3184 map_overlay_command (char *args
, int from_tty
)
3186 struct objfile
*objfile
, *objfile2
;
3187 struct obj_section
*sec
, *sec2
;
3190 if (!overlay_debugging
)
3192 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3193 the 'overlay manual' command.");
3195 if (args
== 0 || *args
== 0)
3196 error ("Argument required: name of an overlay section");
3198 /* First, find a section matching the user supplied argument */
3199 ALL_OBJSECTIONS (objfile
, sec
)
3200 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3202 /* Now, check to see if the section is an overlay. */
3203 bfdsec
= sec
->the_bfd_section
;
3204 if (!section_is_overlay (bfdsec
))
3205 continue; /* not an overlay section */
3207 /* Mark the overlay as "mapped" */
3208 sec
->ovly_mapped
= 1;
3210 /* Next, make a pass and unmap any sections that are
3211 overlapped by this new section: */
3212 ALL_OBJSECTIONS (objfile2
, sec2
)
3213 if (sec2
->ovly_mapped
3215 && sec
->the_bfd_section
!= sec2
->the_bfd_section
3216 && sections_overlap (sec
->the_bfd_section
,
3217 sec2
->the_bfd_section
))
3220 printf_filtered ("Note: section %s unmapped by overlap\n",
3221 bfd_section_name (objfile
->obfd
,
3222 sec2
->the_bfd_section
));
3223 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3227 error ("No overlay section called %s", args
);
3230 /* Function: unmap_overlay_command
3231 Mark the overlay section as unmapped
3232 (ie. resident in its LMA address range, rather than the VMA range). */
3235 unmap_overlay_command (char *args
, int from_tty
)
3237 struct objfile
*objfile
;
3238 struct obj_section
*sec
;
3240 if (!overlay_debugging
)
3242 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3243 the 'overlay manual' command.");
3245 if (args
== 0 || *args
== 0)
3246 error ("Argument required: name of an overlay section");
3248 /* First, find a section matching the user supplied argument */
3249 ALL_OBJSECTIONS (objfile
, sec
)
3250 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3252 if (!sec
->ovly_mapped
)
3253 error ("Section %s is not mapped", args
);
3254 sec
->ovly_mapped
= 0;
3257 error ("No overlay section called %s", args
);
3260 /* Function: overlay_auto_command
3261 A utility command to turn on overlay debugging.
3262 Possibly this should be done via a set/show command. */
3265 overlay_auto_command (char *args
, int from_tty
)
3267 overlay_debugging
= ovly_auto
;
3268 enable_overlay_breakpoints ();
3270 printf_filtered ("Automatic overlay debugging enabled.");
3273 /* Function: overlay_manual_command
3274 A utility command to turn on overlay debugging.
3275 Possibly this should be done via a set/show command. */
3278 overlay_manual_command (char *args
, int from_tty
)
3280 overlay_debugging
= ovly_on
;
3281 disable_overlay_breakpoints ();
3283 printf_filtered ("Overlay debugging enabled.");
3286 /* Function: overlay_off_command
3287 A utility command to turn on overlay debugging.
3288 Possibly this should be done via a set/show command. */
3291 overlay_off_command (char *args
, int from_tty
)
3293 overlay_debugging
= ovly_off
;
3294 disable_overlay_breakpoints ();
3296 printf_filtered ("Overlay debugging disabled.");
3300 overlay_load_command (char *args
, int from_tty
)
3302 if (target_overlay_update
)
3303 (*target_overlay_update
) (NULL
);
3305 error ("This target does not know how to read its overlay state.");
3308 /* Function: overlay_command
3309 A place-holder for a mis-typed command */
3311 /* Command list chain containing all defined "overlay" subcommands. */
3312 struct cmd_list_element
*overlaylist
;
3315 overlay_command (char *args
, int from_tty
)
3318 ("\"overlay\" must be followed by the name of an overlay command.\n");
3319 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3323 /* Target Overlays for the "Simplest" overlay manager:
3325 This is GDB's default target overlay layer. It works with the
3326 minimal overlay manager supplied as an example by Cygnus. The
3327 entry point is via a function pointer "target_overlay_update",
3328 so targets that use a different runtime overlay manager can
3329 substitute their own overlay_update function and take over the
3332 The overlay_update function pokes around in the target's data structures
3333 to see what overlays are mapped, and updates GDB's overlay mapping with
3336 In this simple implementation, the target data structures are as follows:
3337 unsigned _novlys; /# number of overlay sections #/
3338 unsigned _ovly_table[_novlys][4] = {
3339 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3340 {..., ..., ..., ...},
3342 unsigned _novly_regions; /# number of overlay regions #/
3343 unsigned _ovly_region_table[_novly_regions][3] = {
3344 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3347 These functions will attempt to update GDB's mappedness state in the
3348 symbol section table, based on the target's mappedness state.
3350 To do this, we keep a cached copy of the target's _ovly_table, and
3351 attempt to detect when the cached copy is invalidated. The main
3352 entry point is "simple_overlay_update(SECT), which looks up SECT in
3353 the cached table and re-reads only the entry for that section from
3354 the target (whenever possible).
3357 /* Cached, dynamically allocated copies of the target data structures: */
3358 static unsigned (*cache_ovly_table
)[4] = 0;
3360 static unsigned (*cache_ovly_region_table
)[3] = 0;
3362 static unsigned cache_novlys
= 0;
3364 static unsigned cache_novly_regions
= 0;
3366 static CORE_ADDR cache_ovly_table_base
= 0;
3368 static CORE_ADDR cache_ovly_region_table_base
= 0;
3372 VMA
, SIZE
, LMA
, MAPPED
3374 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
3376 /* Throw away the cached copy of _ovly_table */
3378 simple_free_overlay_table (void)
3380 if (cache_ovly_table
)
3381 xfree (cache_ovly_table
);
3383 cache_ovly_table
= NULL
;
3384 cache_ovly_table_base
= 0;
3388 /* Throw away the cached copy of _ovly_region_table */
3390 simple_free_overlay_region_table (void)
3392 if (cache_ovly_region_table
)
3393 xfree (cache_ovly_region_table
);
3394 cache_novly_regions
= 0;
3395 cache_ovly_region_table
= NULL
;
3396 cache_ovly_region_table_base
= 0;
3400 /* Read an array of ints from the target into a local buffer.
3401 Convert to host order. int LEN is number of ints */
3403 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
, int len
)
3405 /* FIXME (alloca): Not safe if array is very large. */
3406 char *buf
= alloca (len
* TARGET_LONG_BYTES
);
3409 read_memory (memaddr
, buf
, len
* TARGET_LONG_BYTES
);
3410 for (i
= 0; i
< len
; i
++)
3411 myaddr
[i
] = extract_unsigned_integer (TARGET_LONG_BYTES
* i
+ buf
,
3415 /* Find and grab a copy of the target _ovly_table
3416 (and _novlys, which is needed for the table's size) */
3418 simple_read_overlay_table (void)
3420 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3422 simple_free_overlay_table ();
3423 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3426 error ("Error reading inferior's overlay table: "
3427 "couldn't find `_novlys' variable\n"
3428 "in inferior. Use `overlay manual' mode.");
3432 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3433 if (! ovly_table_msym
)
3435 error ("Error reading inferior's overlay table: couldn't find "
3436 "`_ovly_table' array\n"
3437 "in inferior. Use `overlay manual' mode.");
3441 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
), 4);
3443 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3444 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3445 read_target_long_array (cache_ovly_table_base
,
3446 (int *) cache_ovly_table
,
3449 return 1; /* SUCCESS */
3453 /* Find and grab a copy of the target _ovly_region_table
3454 (and _novly_regions, which is needed for the table's size) */
3456 simple_read_overlay_region_table (void)
3458 struct minimal_symbol
*msym
;
3460 simple_free_overlay_region_table ();
3461 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3463 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
3465 return 0; /* failure */
3466 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3467 if (cache_ovly_region_table
!= NULL
)
3469 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3472 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3473 read_target_long_array (cache_ovly_region_table_base
,
3474 (int *) cache_ovly_region_table
,
3475 cache_novly_regions
* 3);
3478 return 0; /* failure */
3481 return 0; /* failure */
3482 return 1; /* SUCCESS */
3486 /* Function: simple_overlay_update_1
3487 A helper function for simple_overlay_update. Assuming a cached copy
3488 of _ovly_table exists, look through it to find an entry whose vma,
3489 lma and size match those of OSECT. Re-read the entry and make sure
3490 it still matches OSECT (else the table may no longer be valid).
3491 Set OSECT's mapped state to match the entry. Return: 1 for
3492 success, 0 for failure. */
3495 simple_overlay_update_1 (struct obj_section
*osect
)
3498 bfd
*obfd
= osect
->objfile
->obfd
;
3499 asection
*bsect
= osect
->the_bfd_section
;
3501 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3502 for (i
= 0; i
< cache_novlys
; i
++)
3503 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3504 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3505 /* && cache_ovly_table[i][SIZE] == size */ )
3507 read_target_long_array (cache_ovly_table_base
+ i
* TARGET_LONG_BYTES
,
3508 (int *) cache_ovly_table
[i
], 4);
3509 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3510 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3511 /* && cache_ovly_table[i][SIZE] == size */ )
3513 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3516 else /* Warning! Warning! Target's ovly table has changed! */
3522 /* Function: simple_overlay_update
3523 If OSECT is NULL, then update all sections' mapped state
3524 (after re-reading the entire target _ovly_table).
3525 If OSECT is non-NULL, then try to find a matching entry in the
3526 cached ovly_table and update only OSECT's mapped state.
3527 If a cached entry can't be found or the cache isn't valid, then
3528 re-read the entire cache, and go ahead and update all sections. */
3531 simple_overlay_update (struct obj_section
*osect
)
3533 struct objfile
*objfile
;
3535 /* Were we given an osect to look up? NULL means do all of them. */
3537 /* Have we got a cached copy of the target's overlay table? */
3538 if (cache_ovly_table
!= NULL
)
3539 /* Does its cached location match what's currently in the symtab? */
3540 if (cache_ovly_table_base
==
3541 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3542 /* Then go ahead and try to look up this single section in the cache */
3543 if (simple_overlay_update_1 (osect
))
3544 /* Found it! We're done. */
3547 /* Cached table no good: need to read the entire table anew.
3548 Or else we want all the sections, in which case it's actually
3549 more efficient to read the whole table in one block anyway. */
3551 if (! simple_read_overlay_table ())
3554 /* Now may as well update all sections, even if only one was requested. */
3555 ALL_OBJSECTIONS (objfile
, osect
)
3556 if (section_is_overlay (osect
->the_bfd_section
))
3559 bfd
*obfd
= osect
->objfile
->obfd
;
3560 asection
*bsect
= osect
->the_bfd_section
;
3562 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3563 for (i
= 0; i
< cache_novlys
; i
++)
3564 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3565 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3566 /* && cache_ovly_table[i][SIZE] == size */ )
3567 { /* obj_section matches i'th entry in ovly_table */
3568 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3569 break; /* finished with inner for loop: break out */
3574 /* Set the output sections and output offsets for section SECTP in
3575 ABFD. The relocation code in BFD will read these offsets, so we
3576 need to be sure they're initialized. We map each section to itself,
3577 with no offset; this means that SECTP->vma will be honored. */
3580 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3582 sectp
->output_section
= sectp
;
3583 sectp
->output_offset
= 0;
3586 /* Relocate the contents of a debug section SECTP in ABFD. The
3587 contents are stored in BUF if it is non-NULL, or returned in a
3588 malloc'd buffer otherwise.
3590 For some platforms and debug info formats, shared libraries contain
3591 relocations against the debug sections (particularly for DWARF-2;
3592 one affected platform is PowerPC GNU/Linux, although it depends on
3593 the version of the linker in use). Also, ELF object files naturally
3594 have unresolved relocations for their debug sections. We need to apply
3595 the relocations in order to get the locations of symbols correct. */
3598 symfile_relocate_debug_section (bfd
*abfd
, asection
*sectp
, bfd_byte
*buf
)
3600 /* We're only interested in debugging sections with relocation
3602 if ((sectp
->flags
& SEC_RELOC
) == 0)
3604 if ((sectp
->flags
& SEC_DEBUGGING
) == 0)
3607 /* We will handle section offsets properly elsewhere, so relocate as if
3608 all sections begin at 0. */
3609 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3611 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
);
3615 _initialize_symfile (void)
3617 struct cmd_list_element
*c
;
3619 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
3620 "Load symbol table from executable file FILE.\n\
3621 The `file' command can also load symbol tables, as well as setting the file\n\
3622 to execute.", &cmdlist
);
3623 set_cmd_completer (c
, filename_completer
);
3625 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
3626 "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3627 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
3628 ADDR is the starting address of the file's text.\n\
3629 The optional arguments are section-name section-address pairs and\n\
3630 should be specified if the data and bss segments are not contiguous\n\
3631 with the text. SECT is a section name to be loaded at SECT_ADDR.",
3633 set_cmd_completer (c
, filename_completer
);
3635 c
= add_cmd ("add-shared-symbol-files", class_files
,
3636 add_shared_symbol_files_command
,
3637 "Load the symbols from shared objects in the dynamic linker's link map.",
3639 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
3642 c
= add_cmd ("load", class_files
, load_command
,
3643 "Dynamically load FILE into the running program, and record its symbols\n\
3644 for access from GDB.", &cmdlist
);
3645 set_cmd_completer (c
, filename_completer
);
3648 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
3649 (char *) &symbol_reloading
,
3650 "Set dynamic symbol table reloading multiple times in one run.",
3654 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3655 "Commands for debugging overlays.", &overlaylist
,
3656 "overlay ", 0, &cmdlist
);
3658 add_com_alias ("ovly", "overlay", class_alias
, 1);
3659 add_com_alias ("ov", "overlay", class_alias
, 1);
3661 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3662 "Assert that an overlay section is mapped.", &overlaylist
);
3664 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3665 "Assert that an overlay section is unmapped.", &overlaylist
);
3667 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3668 "List mappings of overlay sections.", &overlaylist
);
3670 add_cmd ("manual", class_support
, overlay_manual_command
,
3671 "Enable overlay debugging.", &overlaylist
);
3672 add_cmd ("off", class_support
, overlay_off_command
,
3673 "Disable overlay debugging.", &overlaylist
);
3674 add_cmd ("auto", class_support
, overlay_auto_command
,
3675 "Enable automatic overlay debugging.", &overlaylist
);
3676 add_cmd ("load-target", class_support
, overlay_load_command
,
3677 "Read the overlay mapping state from the target.", &overlaylist
);
3679 /* Filename extension to source language lookup table: */
3680 init_filename_language_table ();
3681 c
= add_set_cmd ("extension-language", class_files
, var_string_noescape
,
3683 "Set mapping between filename extension and source language.\n\
3684 Usage: set extension-language .foo bar",
3686 set_cmd_cfunc (c
, set_ext_lang_command
);
3688 add_info ("extensions", info_ext_lang_command
,
3689 "All filename extensions associated with a source language.");
3692 (add_set_cmd ("download-write-size", class_obscure
,
3693 var_integer
, (char *) &download_write_size
,
3694 "Set the write size used when downloading a program.\n"
3695 "Only used when downloading a program onto a remote\n"
3696 "target. Specify zero, or a negative value, to disable\n"
3697 "blocked writes. The actual size of each transfer is also\n"
3698 "limited by the size of the target packet and the memory\n"
3703 debug_file_directory
= xstrdup (DEBUGDIR
);
3705 ("debug-file-directory", class_support
, var_string
,
3706 (char *) &debug_file_directory
,
3707 "Set the directory where separate debug symbols are searched for.\n"
3708 "Separate debug symbols are first searched for in the same\n"
3709 "directory as the binary, then in the `" DEBUG_SUBDIRECTORY
3711 "and lastly at the path of the directory of the binary with\n"
3712 "the global debug-file directory prepended\n",
3714 add_show_from_set (c
, &showlist
);
3715 set_cmd_completer (c
, filename_completer
);