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, 2004 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"
53 #include <sys/types.h>
55 #include "gdb_string.h"
64 int (*deprecated_ui_load_progress_hook
) (const char *section
, unsigned long num
);
65 void (*deprecated_show_load_progress
) (const char *section
,
66 unsigned long section_sent
,
67 unsigned long section_size
,
68 unsigned long total_sent
,
69 unsigned long total_size
);
70 void (*deprecated_pre_add_symbol_hook
) (const char *);
71 void (*deprecated_post_add_symbol_hook
) (void);
72 void (*deprecated_target_new_objfile_hook
) (struct objfile
*);
74 static void clear_symtab_users_cleanup (void *ignore
);
76 /* Global variables owned by this file */
77 int readnow_symbol_files
; /* Read full symbols immediately */
79 /* External variables and functions referenced. */
81 extern void report_transfer_performance (unsigned long, time_t, time_t);
83 /* Functions this file defines */
86 static int simple_read_overlay_region_table (void);
87 static void simple_free_overlay_region_table (void);
90 static void set_initial_language (void);
92 static void load_command (char *, int);
94 static void symbol_file_add_main_1 (char *args
, int from_tty
, int flags
);
96 static void add_symbol_file_command (char *, int);
98 static void add_shared_symbol_files_command (char *, int);
100 static void reread_separate_symbols (struct objfile
*objfile
);
102 static void cashier_psymtab (struct partial_symtab
*);
104 bfd
*symfile_bfd_open (char *);
106 int get_section_index (struct objfile
*, char *);
108 static void find_sym_fns (struct objfile
*);
110 static void decrement_reading_symtab (void *);
112 static void overlay_invalidate_all (void);
114 static int overlay_is_mapped (struct obj_section
*);
116 void list_overlays_command (char *, int);
118 void map_overlay_command (char *, int);
120 void unmap_overlay_command (char *, int);
122 static void overlay_auto_command (char *, int);
124 static void overlay_manual_command (char *, int);
126 static void overlay_off_command (char *, int);
128 static void overlay_load_command (char *, int);
130 static void overlay_command (char *, int);
132 static void simple_free_overlay_table (void);
134 static void read_target_long_array (CORE_ADDR
, unsigned int *, int);
136 static int simple_read_overlay_table (void);
138 static int simple_overlay_update_1 (struct obj_section
*);
140 static void add_filename_language (char *ext
, enum language lang
);
142 static void info_ext_lang_command (char *args
, int from_tty
);
144 static char *find_separate_debug_file (struct objfile
*objfile
);
146 static void init_filename_language_table (void);
148 void _initialize_symfile (void);
150 /* List of all available sym_fns. On gdb startup, each object file reader
151 calls add_symtab_fns() to register information on each format it is
154 static struct sym_fns
*symtab_fns
= NULL
;
156 /* Flag for whether user will be reloading symbols multiple times.
157 Defaults to ON for VxWorks, otherwise OFF. */
159 #ifdef SYMBOL_RELOADING_DEFAULT
160 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
162 int symbol_reloading
= 0;
165 show_symbol_reloading (struct ui_file
*file
, int from_tty
,
166 struct cmd_list_element
*c
, const char *value
)
168 fprintf_filtered (file
, _("\
169 Dynamic symbol table reloading multiple times in one run is %s.\n"),
174 /* If non-zero, shared library symbols will be added automatically
175 when the inferior is created, new libraries are loaded, or when
176 attaching to the inferior. This is almost always what users will
177 want to have happen; but for very large programs, the startup time
178 will be excessive, and so if this is a problem, the user can clear
179 this flag and then add the shared library symbols as needed. Note
180 that there is a potential for confusion, since if the shared
181 library symbols are not loaded, commands like "info fun" will *not*
182 report all the functions that are actually present. */
184 int auto_solib_add
= 1;
186 /* For systems that support it, a threshold size in megabytes. If
187 automatically adding a new library's symbol table to those already
188 known to the debugger would cause the total shared library symbol
189 size to exceed this threshhold, then the shlib's symbols are not
190 added. The threshold is ignored if the user explicitly asks for a
191 shlib to be added, such as when using the "sharedlibrary"
194 int auto_solib_limit
;
197 /* This compares two partial symbols by names, using strcmp_iw_ordered
198 for the comparison. */
201 compare_psymbols (const void *s1p
, const void *s2p
)
203 struct partial_symbol
*const *s1
= s1p
;
204 struct partial_symbol
*const *s2
= s2p
;
206 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1
),
207 SYMBOL_SEARCH_NAME (*s2
));
211 sort_pst_symbols (struct partial_symtab
*pst
)
213 /* Sort the global list; don't sort the static list */
215 qsort (pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
,
216 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
220 /* Make a null terminated copy of the string at PTR with SIZE characters in
221 the obstack pointed to by OBSTACKP . Returns the address of the copy.
222 Note that the string at PTR does not have to be null terminated, I.E. it
223 may be part of a larger string and we are only saving a substring. */
226 obsavestring (const char *ptr
, int size
, struct obstack
*obstackp
)
228 char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
229 /* Open-coded memcpy--saves function call time. These strings are usually
230 short. FIXME: Is this really still true with a compiler that can
233 const char *p1
= ptr
;
235 const char *end
= ptr
+ size
;
243 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
244 in the obstack pointed to by OBSTACKP. */
247 obconcat (struct obstack
*obstackp
, const char *s1
, const char *s2
,
250 int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
251 char *val
= (char *) obstack_alloc (obstackp
, len
);
258 /* True if we are nested inside psymtab_to_symtab. */
260 int currently_reading_symtab
= 0;
263 decrement_reading_symtab (void *dummy
)
265 currently_reading_symtab
--;
268 /* Get the symbol table that corresponds to a partial_symtab.
269 This is fast after the first time you do it. In fact, there
270 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
274 psymtab_to_symtab (struct partial_symtab
*pst
)
276 /* If it's been looked up before, return it. */
280 /* If it has not yet been read in, read it. */
283 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
284 currently_reading_symtab
++;
285 (*pst
->read_symtab
) (pst
);
286 do_cleanups (back_to
);
292 /* Remember the lowest-addressed loadable section we've seen.
293 This function is called via bfd_map_over_sections.
295 In case of equal vmas, the section with the largest size becomes the
296 lowest-addressed loadable section.
298 If the vmas and sizes are equal, the last section is considered the
299 lowest-addressed loadable section. */
302 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
304 asection
**lowest
= (asection
**) obj
;
306 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
309 *lowest
= sect
; /* First loadable section */
310 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
311 *lowest
= sect
; /* A lower loadable section */
312 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
313 && (bfd_section_size (abfd
, (*lowest
))
314 <= bfd_section_size (abfd
, sect
)))
318 /* Create a new section_addr_info, with room for NUM_SECTIONS. */
320 struct section_addr_info
*
321 alloc_section_addr_info (size_t num_sections
)
323 struct section_addr_info
*sap
;
326 size
= (sizeof (struct section_addr_info
)
327 + sizeof (struct other_sections
) * (num_sections
- 1));
328 sap
= (struct section_addr_info
*) xmalloc (size
);
329 memset (sap
, 0, size
);
330 sap
->num_sections
= num_sections
;
336 /* Return a freshly allocated copy of ADDRS. The section names, if
337 any, are also freshly allocated copies of those in ADDRS. */
338 struct section_addr_info
*
339 copy_section_addr_info (struct section_addr_info
*addrs
)
341 struct section_addr_info
*copy
342 = alloc_section_addr_info (addrs
->num_sections
);
345 copy
->num_sections
= addrs
->num_sections
;
346 for (i
= 0; i
< addrs
->num_sections
; i
++)
348 copy
->other
[i
].addr
= addrs
->other
[i
].addr
;
349 if (addrs
->other
[i
].name
)
350 copy
->other
[i
].name
= xstrdup (addrs
->other
[i
].name
);
352 copy
->other
[i
].name
= NULL
;
353 copy
->other
[i
].sectindex
= addrs
->other
[i
].sectindex
;
361 /* Build (allocate and populate) a section_addr_info struct from
362 an existing section table. */
364 extern struct section_addr_info
*
365 build_section_addr_info_from_section_table (const struct section_table
*start
,
366 const struct section_table
*end
)
368 struct section_addr_info
*sap
;
369 const struct section_table
*stp
;
372 sap
= alloc_section_addr_info (end
- start
);
374 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
376 if (bfd_get_section_flags (stp
->bfd
,
377 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
378 && oidx
< end
- start
)
380 sap
->other
[oidx
].addr
= stp
->addr
;
381 sap
->other
[oidx
].name
382 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
383 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
392 /* Free all memory allocated by build_section_addr_info_from_section_table. */
395 free_section_addr_info (struct section_addr_info
*sap
)
399 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
400 if (sap
->other
[idx
].name
)
401 xfree (sap
->other
[idx
].name
);
406 /* Initialize OBJFILE's sect_index_* members. */
408 init_objfile_sect_indices (struct objfile
*objfile
)
413 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
415 objfile
->sect_index_text
= sect
->index
;
417 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
419 objfile
->sect_index_data
= sect
->index
;
421 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
423 objfile
->sect_index_bss
= sect
->index
;
425 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
427 objfile
->sect_index_rodata
= sect
->index
;
429 /* This is where things get really weird... We MUST have valid
430 indices for the various sect_index_* members or gdb will abort.
431 So if for example, there is no ".text" section, we have to
432 accomodate that. Except when explicitly adding symbol files at
433 some address, section_offsets contains nothing but zeros, so it
434 doesn't matter which slot in section_offsets the individual
435 sect_index_* members index into. So if they are all zero, it is
436 safe to just point all the currently uninitialized indices to the
439 for (i
= 0; i
< objfile
->num_sections
; i
++)
441 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
446 if (i
== objfile
->num_sections
)
448 if (objfile
->sect_index_text
== -1)
449 objfile
->sect_index_text
= 0;
450 if (objfile
->sect_index_data
== -1)
451 objfile
->sect_index_data
= 0;
452 if (objfile
->sect_index_bss
== -1)
453 objfile
->sect_index_bss
= 0;
454 if (objfile
->sect_index_rodata
== -1)
455 objfile
->sect_index_rodata
= 0;
460 /* Parse the user's idea of an offset for dynamic linking, into our idea
461 of how to represent it for fast symbol reading. This is the default
462 version of the sym_fns.sym_offsets function for symbol readers that
463 don't need to do anything special. It allocates a section_offsets table
464 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
467 default_symfile_offsets (struct objfile
*objfile
,
468 struct section_addr_info
*addrs
)
472 objfile
->num_sections
= bfd_count_sections (objfile
->obfd
);
473 objfile
->section_offsets
= (struct section_offsets
*)
474 obstack_alloc (&objfile
->objfile_obstack
,
475 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
476 memset (objfile
->section_offsets
, 0,
477 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
479 /* Now calculate offsets for section that were specified by the
481 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
483 struct other_sections
*osp
;
485 osp
= &addrs
->other
[i
] ;
489 /* Record all sections in offsets */
490 /* The section_offsets in the objfile are here filled in using
492 (objfile
->section_offsets
)->offsets
[osp
->sectindex
] = osp
->addr
;
495 /* Remember the bfd indexes for the .text, .data, .bss and
497 init_objfile_sect_indices (objfile
);
501 /* Process a symbol file, as either the main file or as a dynamically
504 OBJFILE is where the symbols are to be read from.
506 ADDRS is the list of section load addresses. If the user has given
507 an 'add-symbol-file' command, then this is the list of offsets and
508 addresses he or she provided as arguments to the command; or, if
509 we're handling a shared library, these are the actual addresses the
510 sections are loaded at, according to the inferior's dynamic linker
511 (as gleaned by GDB's shared library code). We convert each address
512 into an offset from the section VMA's as it appears in the object
513 file, and then call the file's sym_offsets function to convert this
514 into a format-specific offset table --- a `struct section_offsets'.
515 If ADDRS is non-zero, OFFSETS must be zero.
517 OFFSETS is a table of section offsets already in the right
518 format-specific representation. NUM_OFFSETS is the number of
519 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
520 assume this is the proper table the call to sym_offsets described
521 above would produce. Instead of calling sym_offsets, we just dump
522 it right into objfile->section_offsets. (When we're re-reading
523 symbols from an objfile, we don't have the original load address
524 list any more; all we have is the section offset table.) If
525 OFFSETS is non-zero, ADDRS must be zero.
527 MAINLINE is nonzero if this is the main symbol file, or zero if
528 it's an extra symbol file such as dynamically loaded code.
530 VERBO is nonzero if the caller has printed a verbose message about
531 the symbol reading (and complaints can be more terse about it). */
534 syms_from_objfile (struct objfile
*objfile
,
535 struct section_addr_info
*addrs
,
536 struct section_offsets
*offsets
,
541 struct section_addr_info
*local_addr
= NULL
;
542 struct cleanup
*old_chain
;
544 gdb_assert (! (addrs
&& offsets
));
546 init_entry_point_info (objfile
);
547 find_sym_fns (objfile
);
549 if (objfile
->sf
== NULL
)
550 return; /* No symbols. */
552 /* Make sure that partially constructed symbol tables will be cleaned up
553 if an error occurs during symbol reading. */
554 old_chain
= make_cleanup_free_objfile (objfile
);
556 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
557 list. We now establish the convention that an addr of zero means
558 no load address was specified. */
559 if (! addrs
&& ! offsets
)
562 = alloc_section_addr_info (bfd_count_sections (objfile
->obfd
));
563 make_cleanup (xfree
, local_addr
);
567 /* Now either addrs or offsets is non-zero. */
571 /* We will modify the main symbol table, make sure that all its users
572 will be cleaned up if an error occurs during symbol reading. */
573 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
575 /* Since no error yet, throw away the old symbol table. */
577 if (symfile_objfile
!= NULL
)
579 free_objfile (symfile_objfile
);
580 symfile_objfile
= NULL
;
583 /* Currently we keep symbols from the add-symbol-file command.
584 If the user wants to get rid of them, they should do "symbol-file"
585 without arguments first. Not sure this is the best behavior
588 (*objfile
->sf
->sym_new_init
) (objfile
);
591 /* Convert addr into an offset rather than an absolute address.
592 We find the lowest address of a loaded segment in the objfile,
593 and assume that <addr> is where that got loaded.
595 We no longer warn if the lowest section is not a text segment (as
596 happens for the PA64 port. */
597 if (!mainline
&& addrs
&& addrs
->other
[0].name
)
599 asection
*lower_sect
;
601 CORE_ADDR lower_offset
;
604 /* Find lowest loadable section to be used as starting point for
605 continguous sections. FIXME!! won't work without call to find
606 .text first, but this assumes text is lowest section. */
607 lower_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
608 if (lower_sect
== NULL
)
609 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
611 if (lower_sect
== NULL
)
612 warning (_("no loadable sections found in added symbol-file %s"),
615 if ((bfd_get_section_flags (objfile
->obfd
, lower_sect
) & SEC_CODE
) == 0)
616 warning (_("Lowest section in %s is %s at %s"),
618 bfd_section_name (objfile
->obfd
, lower_sect
),
619 paddr (bfd_section_vma (objfile
->obfd
, lower_sect
)));
620 if (lower_sect
!= NULL
)
621 lower_offset
= bfd_section_vma (objfile
->obfd
, lower_sect
);
625 /* Calculate offsets for the loadable sections.
626 FIXME! Sections must be in order of increasing loadable section
627 so that contiguous sections can use the lower-offset!!!
629 Adjust offsets if the segments are not contiguous.
630 If the section is contiguous, its offset should be set to
631 the offset of the highest loadable section lower than it
632 (the loadable section directly below it in memory).
633 this_offset = lower_offset = lower_addr - lower_orig_addr */
635 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
637 if (addrs
->other
[i
].addr
!= 0)
639 sect
= bfd_get_section_by_name (objfile
->obfd
,
640 addrs
->other
[i
].name
);
644 -= bfd_section_vma (objfile
->obfd
, sect
);
645 lower_offset
= addrs
->other
[i
].addr
;
646 /* This is the index used by BFD. */
647 addrs
->other
[i
].sectindex
= sect
->index
;
651 warning (_("section %s not found in %s"),
652 addrs
->other
[i
].name
,
654 addrs
->other
[i
].addr
= 0;
658 addrs
->other
[i
].addr
= lower_offset
;
662 /* Initialize symbol reading routines for this objfile, allow complaints to
663 appear for this new file, and record how verbose to be, then do the
664 initial symbol reading for this file. */
666 (*objfile
->sf
->sym_init
) (objfile
);
667 clear_complaints (&symfile_complaints
, 1, verbo
);
670 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
673 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
675 /* Just copy in the offset table directly as given to us. */
676 objfile
->num_sections
= num_offsets
;
677 objfile
->section_offsets
678 = ((struct section_offsets
*)
679 obstack_alloc (&objfile
->objfile_obstack
, size
));
680 memcpy (objfile
->section_offsets
, offsets
, size
);
682 init_objfile_sect_indices (objfile
);
685 #ifndef DEPRECATED_IBM6000_TARGET
686 /* This is a SVR4/SunOS specific hack, I think. In any event, it
687 screws RS/6000. sym_offsets should be doing this sort of thing,
688 because it knows the mapping between bfd sections and
690 /* This is a hack. As far as I can tell, section offsets are not
691 target dependent. They are all set to addr with a couple of
692 exceptions. The exceptions are sysvr4 shared libraries, whose
693 offsets are kept in solib structures anyway and rs6000 xcoff
694 which handles shared libraries in a completely unique way.
696 Section offsets are built similarly, except that they are built
697 by adding addr in all cases because there is no clear mapping
698 from section_offsets into actual sections. Note that solib.c
699 has a different algorithm for finding section offsets.
701 These should probably all be collapsed into some target
702 independent form of shared library support. FIXME. */
706 struct obj_section
*s
;
708 /* Map section offsets in "addr" back to the object's
709 sections by comparing the section names with bfd's
710 section names. Then adjust the section address by
711 the offset. */ /* for gdb/13815 */
713 ALL_OBJFILE_OSECTIONS (objfile
, s
)
715 CORE_ADDR s_addr
= 0;
719 !s_addr
&& i
< addrs
->num_sections
&& addrs
->other
[i
].name
;
721 if (strcmp (bfd_section_name (s
->objfile
->obfd
,
723 addrs
->other
[i
].name
) == 0)
724 s_addr
= addrs
->other
[i
].addr
; /* end added for gdb/13815 */
726 s
->addr
-= s
->offset
;
728 s
->endaddr
-= s
->offset
;
729 s
->endaddr
+= s_addr
;
733 #endif /* not DEPRECATED_IBM6000_TARGET */
735 (*objfile
->sf
->sym_read
) (objfile
, mainline
);
737 /* Don't allow char * to have a typename (else would get caddr_t).
738 Ditto void *. FIXME: Check whether this is now done by all the
739 symbol readers themselves (many of them now do), and if so remove
742 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
743 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
745 /* Mark the objfile has having had initial symbol read attempted. Note
746 that this does not mean we found any symbols... */
748 objfile
->flags
|= OBJF_SYMS
;
750 /* Discard cleanups as symbol reading was successful. */
752 discard_cleanups (old_chain
);
755 /* Perform required actions after either reading in the initial
756 symbols for a new objfile, or mapping in the symbols from a reusable
760 new_symfile_objfile (struct objfile
*objfile
, int mainline
, int verbo
)
763 /* If this is the main symbol file we have to clean up all users of the
764 old main symbol file. Otherwise it is sufficient to fixup all the
765 breakpoints that may have been redefined by this symbol file. */
768 /* OK, make it the "real" symbol file. */
769 symfile_objfile
= objfile
;
771 clear_symtab_users ();
775 breakpoint_re_set ();
778 /* We're done reading the symbol file; finish off complaints. */
779 clear_complaints (&symfile_complaints
, 0, verbo
);
782 /* Process a symbol file, as either the main file or as a dynamically
785 ABFD is a BFD already open on the file, as from symfile_bfd_open.
786 This BFD will be closed on error, and is always consumed by this function.
788 FROM_TTY says how verbose to be.
790 MAINLINE specifies whether this is the main symbol file, or whether
791 it's an extra symbol file such as dynamically loaded code.
793 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
794 syms_from_objfile, above. ADDRS is ignored when MAINLINE is
797 Upon success, returns a pointer to the objfile that was added.
798 Upon failure, jumps back to command level (never returns). */
799 static struct objfile
*
800 symbol_file_add_with_addrs_or_offsets (bfd
*abfd
, int from_tty
,
801 struct section_addr_info
*addrs
,
802 struct section_offsets
*offsets
,
804 int mainline
, int flags
)
806 struct objfile
*objfile
;
807 struct partial_symtab
*psymtab
;
809 struct section_addr_info
*orig_addrs
= NULL
;
810 struct cleanup
*my_cleanups
;
811 const char *name
= bfd_get_filename (abfd
);
813 my_cleanups
= make_cleanup_bfd_close (abfd
);
815 /* Give user a chance to burp if we'd be
816 interactively wiping out any existing symbols. */
818 if ((have_full_symbols () || have_partial_symbols ())
821 && !query ("Load new symbol table from \"%s\"? ", name
))
822 error (_("Not confirmed."));
824 objfile
= allocate_objfile (abfd
, flags
);
825 discard_cleanups (my_cleanups
);
829 orig_addrs
= copy_section_addr_info (addrs
);
830 make_cleanup_free_section_addr_info (orig_addrs
);
833 /* We either created a new mapped symbol table, mapped an existing
834 symbol table file which has not had initial symbol reading
835 performed, or need to read an unmapped symbol table. */
836 if (from_tty
|| info_verbose
)
838 if (deprecated_pre_add_symbol_hook
)
839 deprecated_pre_add_symbol_hook (name
);
842 printf_unfiltered (_("Reading symbols from %s..."), name
);
844 gdb_flush (gdb_stdout
);
847 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
850 /* We now have at least a partial symbol table. Check to see if the
851 user requested that all symbols be read on initial access via either
852 the gdb startup command line or on a per symbol file basis. Expand
853 all partial symbol tables for this objfile if so. */
855 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
857 if (from_tty
|| info_verbose
)
859 printf_unfiltered (_("expanding to full symbols..."));
861 gdb_flush (gdb_stdout
);
864 for (psymtab
= objfile
->psymtabs
;
866 psymtab
= psymtab
->next
)
868 psymtab_to_symtab (psymtab
);
872 debugfile
= find_separate_debug_file (objfile
);
877 objfile
->separate_debug_objfile
878 = symbol_file_add (debugfile
, from_tty
, orig_addrs
, 0, flags
);
882 objfile
->separate_debug_objfile
883 = symbol_file_add (debugfile
, from_tty
, NULL
, 0, flags
);
885 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
888 /* Put the separate debug object before the normal one, this is so that
889 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
890 put_objfile_before (objfile
->separate_debug_objfile
, objfile
);
895 if (!have_partial_symbols () && !have_full_symbols ())
898 printf_filtered (_("(no debugging symbols found)"));
899 if (from_tty
|| info_verbose
)
900 printf_filtered ("...");
902 printf_filtered ("\n");
906 if (from_tty
|| info_verbose
)
908 if (deprecated_post_add_symbol_hook
)
909 deprecated_post_add_symbol_hook ();
912 printf_unfiltered (_("done.\n"));
916 /* We print some messages regardless of whether 'from_tty ||
917 info_verbose' is true, so make sure they go out at the right
919 gdb_flush (gdb_stdout
);
921 do_cleanups (my_cleanups
);
923 if (objfile
->sf
== NULL
)
924 return objfile
; /* No symbols. */
926 new_symfile_objfile (objfile
, mainline
, from_tty
);
928 if (deprecated_target_new_objfile_hook
)
929 deprecated_target_new_objfile_hook (objfile
);
931 bfd_cache_close_all ();
936 /* Process the symbol file ABFD, as either the main file or as a
937 dynamically loaded file.
939 See symbol_file_add_with_addrs_or_offsets's comments for
942 symbol_file_add_from_bfd (bfd
*abfd
, int from_tty
,
943 struct section_addr_info
*addrs
,
944 int mainline
, int flags
)
946 return symbol_file_add_with_addrs_or_offsets (abfd
,
947 from_tty
, addrs
, 0, 0,
952 /* Process a symbol file, as either the main file or as a dynamically
953 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
956 symbol_file_add (char *name
, int from_tty
, struct section_addr_info
*addrs
,
957 int mainline
, int flags
)
959 return symbol_file_add_from_bfd (symfile_bfd_open (name
), from_tty
,
960 addrs
, mainline
, flags
);
964 /* Call symbol_file_add() with default values and update whatever is
965 affected by the loading of a new main().
966 Used when the file is supplied in the gdb command line
967 and by some targets with special loading requirements.
968 The auxiliary function, symbol_file_add_main_1(), has the flags
969 argument for the switches that can only be specified in the symbol_file
973 symbol_file_add_main (char *args
, int from_tty
)
975 symbol_file_add_main_1 (args
, from_tty
, 0);
979 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
981 symbol_file_add (args
, from_tty
, NULL
, 1, flags
);
983 /* Getting new symbols may change our opinion about
984 what is frameless. */
985 reinit_frame_cache ();
987 set_initial_language ();
991 symbol_file_clear (int from_tty
)
993 if ((have_full_symbols () || have_partial_symbols ())
995 && !query ("Discard symbol table from `%s'? ",
996 symfile_objfile
->name
))
997 error (_("Not confirmed."));
998 free_all_objfiles ();
1000 /* solib descriptors may have handles to objfiles. Since their
1001 storage has just been released, we'd better wipe the solib
1002 descriptors as well.
1004 #if defined(SOLIB_RESTART)
1008 symfile_objfile
= NULL
;
1010 printf_unfiltered (_("No symbol file now.\n"));
1014 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1017 bfd_size_type debuglink_size
;
1018 unsigned long crc32
;
1023 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1028 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1030 contents
= xmalloc (debuglink_size
);
1031 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1032 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1034 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1035 crc_offset
= strlen (contents
) + 1;
1036 crc_offset
= (crc_offset
+ 3) & ~3;
1038 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1045 separate_debug_file_exists (const char *name
, unsigned long crc
)
1047 unsigned long file_crc
= 0;
1049 char buffer
[8*1024];
1052 fd
= open (name
, O_RDONLY
| O_BINARY
);
1056 while ((count
= read (fd
, buffer
, sizeof (buffer
))) > 0)
1057 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1061 return crc
== file_crc
;
1064 static char *debug_file_directory
= NULL
;
1066 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1067 struct cmd_list_element
*c
, const char *value
)
1069 fprintf_filtered (file
, _("\
1070 The directory where separate debug symbols are searched for is \"%s\".\n"),
1074 #if ! defined (DEBUG_SUBDIRECTORY)
1075 #define DEBUG_SUBDIRECTORY ".debug"
1079 find_separate_debug_file (struct objfile
*objfile
)
1086 bfd_size_type debuglink_size
;
1087 unsigned long crc32
;
1090 basename
= get_debug_link_info (objfile
, &crc32
);
1092 if (basename
== NULL
)
1095 dir
= xstrdup (objfile
->name
);
1097 /* Strip off the final filename part, leaving the directory name,
1098 followed by a slash. Objfile names should always be absolute and
1099 tilde-expanded, so there should always be a slash in there
1101 for (i
= strlen(dir
) - 1; i
>= 0; i
--)
1103 if (IS_DIR_SEPARATOR (dir
[i
]))
1106 gdb_assert (i
>= 0 && IS_DIR_SEPARATOR (dir
[i
]));
1109 debugfile
= alloca (strlen (debug_file_directory
) + 1
1111 + strlen (DEBUG_SUBDIRECTORY
)
1116 /* First try in the same directory as the original file. */
1117 strcpy (debugfile
, dir
);
1118 strcat (debugfile
, basename
);
1120 if (separate_debug_file_exists (debugfile
, crc32
))
1124 return xstrdup (debugfile
);
1127 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1128 strcpy (debugfile
, dir
);
1129 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1130 strcat (debugfile
, "/");
1131 strcat (debugfile
, basename
);
1133 if (separate_debug_file_exists (debugfile
, crc32
))
1137 return xstrdup (debugfile
);
1140 /* Then try in the global debugfile directory. */
1141 strcpy (debugfile
, debug_file_directory
);
1142 strcat (debugfile
, "/");
1143 strcat (debugfile
, dir
);
1144 strcat (debugfile
, basename
);
1146 if (separate_debug_file_exists (debugfile
, crc32
))
1150 return xstrdup (debugfile
);
1159 /* This is the symbol-file command. Read the file, analyze its
1160 symbols, and add a struct symtab to a symtab list. The syntax of
1161 the command is rather bizarre--(1) buildargv implements various
1162 quoting conventions which are undocumented and have little or
1163 nothing in common with the way things are quoted (or not quoted)
1164 elsewhere in GDB, (2) options are used, which are not generally
1165 used in GDB (perhaps "set mapped on", "set readnow on" would be
1166 better), (3) the order of options matters, which is contrary to GNU
1167 conventions (because it is confusing and inconvenient). */
1170 symbol_file_command (char *args
, int from_tty
)
1174 struct cleanup
*cleanups
;
1175 int flags
= OBJF_USERLOADED
;
1181 symbol_file_clear (from_tty
);
1185 if ((argv
= buildargv (args
)) == NULL
)
1189 cleanups
= make_cleanup_freeargv (argv
);
1190 while (*argv
!= NULL
)
1192 if (strcmp (*argv
, "-readnow") == 0)
1193 flags
|= OBJF_READNOW
;
1194 else if (**argv
== '-')
1195 error (_("unknown option `%s'"), *argv
);
1200 symbol_file_add_main_1 (name
, from_tty
, flags
);
1207 error (_("no symbol file name was specified"));
1209 do_cleanups (cleanups
);
1213 /* Set the initial language.
1215 A better solution would be to record the language in the psymtab when reading
1216 partial symbols, and then use it (if known) to set the language. This would
1217 be a win for formats that encode the language in an easily discoverable place,
1218 such as DWARF. For stabs, we can jump through hoops looking for specially
1219 named symbols or try to intuit the language from the specific type of stabs
1220 we find, but we can't do that until later when we read in full symbols.
1224 set_initial_language (void)
1226 struct partial_symtab
*pst
;
1227 enum language lang
= language_unknown
;
1229 pst
= find_main_psymtab ();
1232 if (pst
->filename
!= NULL
)
1234 lang
= deduce_language_from_filename (pst
->filename
);
1236 if (lang
== language_unknown
)
1238 /* Make C the default language */
1241 set_language (lang
);
1242 expected_language
= current_language
; /* Don't warn the user */
1246 /* Open file specified by NAME and hand it off to BFD for preliminary
1247 analysis. Result is a newly initialized bfd *, which includes a newly
1248 malloc'd` copy of NAME (tilde-expanded and made absolute).
1249 In case of trouble, error() is called. */
1252 symfile_bfd_open (char *name
)
1256 char *absolute_name
;
1260 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
1262 /* Look down path for it, allocate 2nd new malloc'd copy. */
1263 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, name
, O_RDONLY
| O_BINARY
,
1265 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1268 char *exename
= alloca (strlen (name
) + 5);
1269 strcat (strcpy (exename
, name
), ".exe");
1270 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
1271 O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1276 make_cleanup (xfree
, name
);
1277 perror_with_name (name
);
1279 xfree (name
); /* Free 1st new malloc'd copy */
1280 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
1281 /* It'll be freed in free_objfile(). */
1283 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
1287 make_cleanup (xfree
, name
);
1288 error (_("\"%s\": can't open to read symbols: %s."), name
,
1289 bfd_errmsg (bfd_get_error ()));
1291 bfd_set_cacheable (sym_bfd
, 1);
1293 if (!bfd_check_format (sym_bfd
, bfd_object
))
1295 /* FIXME: should be checking for errors from bfd_close (for one thing,
1296 on error it does not free all the storage associated with the
1298 bfd_close (sym_bfd
); /* This also closes desc */
1299 make_cleanup (xfree
, name
);
1300 error (_("\"%s\": can't read symbols: %s."), name
,
1301 bfd_errmsg (bfd_get_error ()));
1306 /* Return the section index for the given section name. Return -1 if
1307 the section was not found. */
1309 get_section_index (struct objfile
*objfile
, char *section_name
)
1311 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1318 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
1319 startup by the _initialize routine in each object file format reader,
1320 to register information about each format the the reader is prepared
1324 add_symtab_fns (struct sym_fns
*sf
)
1326 sf
->next
= symtab_fns
;
1331 /* Initialize to read symbols from the symbol file sym_bfd. It either
1332 returns or calls error(). The result is an initialized struct sym_fns
1333 in the objfile structure, that contains cached information about the
1337 find_sym_fns (struct objfile
*objfile
)
1340 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
->obfd
);
1341 char *our_target
= bfd_get_target (objfile
->obfd
);
1343 if (our_flavour
== bfd_target_srec_flavour
1344 || our_flavour
== bfd_target_ihex_flavour
1345 || our_flavour
== bfd_target_tekhex_flavour
)
1346 return; /* No symbols. */
1348 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1350 if (our_flavour
== sf
->sym_flavour
)
1356 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1357 bfd_get_target (objfile
->obfd
));
1360 /* This function runs the load command of our current target. */
1363 load_command (char *arg
, int from_tty
)
1366 arg
= get_exec_file (1);
1367 target_load (arg
, from_tty
);
1369 /* After re-loading the executable, we don't really know which
1370 overlays are mapped any more. */
1371 overlay_cache_invalid
= 1;
1374 /* This version of "load" should be usable for any target. Currently
1375 it is just used for remote targets, not inftarg.c or core files,
1376 on the theory that only in that case is it useful.
1378 Avoiding xmodem and the like seems like a win (a) because we don't have
1379 to worry about finding it, and (b) On VMS, fork() is very slow and so
1380 we don't want to run a subprocess. On the other hand, I'm not sure how
1381 performance compares. */
1383 static int download_write_size
= 512;
1385 show_download_write_size (struct ui_file
*file
, int from_tty
,
1386 struct cmd_list_element
*c
, const char *value
)
1388 fprintf_filtered (file
, _("\
1389 The write size used when downloading a program is %s.\n"),
1392 static int validate_download
= 0;
1394 /* Callback service function for generic_load (bfd_map_over_sections). */
1397 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1399 bfd_size_type
*sum
= data
;
1401 *sum
+= bfd_get_section_size (asec
);
1404 /* Opaque data for load_section_callback. */
1405 struct load_section_data
{
1406 unsigned long load_offset
;
1407 unsigned long write_count
;
1408 unsigned long data_count
;
1409 bfd_size_type total_size
;
1412 /* Callback service function for generic_load (bfd_map_over_sections). */
1415 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1417 struct load_section_data
*args
= data
;
1419 if (bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
)
1421 bfd_size_type size
= bfd_get_section_size (asec
);
1425 struct cleanup
*old_chain
;
1426 CORE_ADDR lma
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1427 bfd_size_type block_size
;
1429 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1432 if (download_write_size
> 0 && size
> download_write_size
)
1433 block_size
= download_write_size
;
1437 buffer
= xmalloc (size
);
1438 old_chain
= make_cleanup (xfree
, buffer
);
1440 /* Is this really necessary? I guess it gives the user something
1441 to look at during a long download. */
1442 ui_out_message (uiout
, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1443 sect_name
, paddr_nz (size
), paddr_nz (lma
));
1445 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1451 bfd_size_type this_transfer
= size
- sent
;
1453 if (this_transfer
>= block_size
)
1454 this_transfer
= block_size
;
1455 len
= target_write_memory_partial (lma
, buffer
,
1456 this_transfer
, &err
);
1459 if (validate_download
)
1461 /* Broken memories and broken monitors manifest
1462 themselves here when bring new computers to
1463 life. This doubles already slow downloads. */
1464 /* NOTE: cagney/1999-10-18: A more efficient
1465 implementation might add a verify_memory()
1466 method to the target vector and then use
1467 that. remote.c could implement that method
1468 using the ``qCRC'' packet. */
1469 char *check
= xmalloc (len
);
1470 struct cleanup
*verify_cleanups
=
1471 make_cleanup (xfree
, check
);
1473 if (target_read_memory (lma
, check
, len
) != 0)
1474 error (_("Download verify read failed at 0x%s"),
1476 if (memcmp (buffer
, check
, len
) != 0)
1477 error (_("Download verify compare failed at 0x%s"),
1479 do_cleanups (verify_cleanups
);
1481 args
->data_count
+= len
;
1484 args
->write_count
+= 1;
1487 || (deprecated_ui_load_progress_hook
!= NULL
1488 && deprecated_ui_load_progress_hook (sect_name
, sent
)))
1489 error (_("Canceled the download"));
1491 if (deprecated_show_load_progress
!= NULL
)
1492 deprecated_show_load_progress (sect_name
, sent
, size
,
1496 while (sent
< size
);
1499 error (_("Memory access error while loading section %s."), sect_name
);
1501 do_cleanups (old_chain
);
1507 generic_load (char *args
, int from_tty
)
1511 time_t start_time
, end_time
; /* Start and end times of download */
1513 struct cleanup
*old_cleanups
;
1515 struct load_section_data cbdata
;
1518 cbdata
.load_offset
= 0; /* Offset to add to vma for each section. */
1519 cbdata
.write_count
= 0; /* Number of writes needed. */
1520 cbdata
.data_count
= 0; /* Number of bytes written to target memory. */
1521 cbdata
.total_size
= 0; /* Total size of all bfd sectors. */
1523 /* Parse the input argument - the user can specify a load offset as
1524 a second argument. */
1525 filename
= xmalloc (strlen (args
) + 1);
1526 old_cleanups
= make_cleanup (xfree
, filename
);
1527 strcpy (filename
, args
);
1528 offptr
= strchr (filename
, ' ');
1533 cbdata
.load_offset
= strtoul (offptr
, &endptr
, 0);
1534 if (offptr
== endptr
)
1535 error (_("Invalid download offset:%s."), offptr
);
1539 cbdata
.load_offset
= 0;
1541 /* Open the file for loading. */
1542 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1543 if (loadfile_bfd
== NULL
)
1545 perror_with_name (filename
);
1549 /* FIXME: should be checking for errors from bfd_close (for one thing,
1550 on error it does not free all the storage associated with the
1552 make_cleanup_bfd_close (loadfile_bfd
);
1554 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1556 error (_("\"%s\" is not an object file: %s"), filename
,
1557 bfd_errmsg (bfd_get_error ()));
1560 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1561 (void *) &cbdata
.total_size
);
1563 start_time
= time (NULL
);
1565 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1567 end_time
= time (NULL
);
1569 entry
= bfd_get_start_address (loadfile_bfd
);
1570 ui_out_text (uiout
, "Start address ");
1571 ui_out_field_fmt (uiout
, "address", "0x%s", paddr_nz (entry
));
1572 ui_out_text (uiout
, ", load size ");
1573 ui_out_field_fmt (uiout
, "load-size", "%lu", cbdata
.data_count
);
1574 ui_out_text (uiout
, "\n");
1575 /* We were doing this in remote-mips.c, I suspect it is right
1576 for other targets too. */
1579 /* FIXME: are we supposed to call symbol_file_add or not? According
1580 to a comment from remote-mips.c (where a call to symbol_file_add
1581 was commented out), making the call confuses GDB if more than one
1582 file is loaded in. Some targets do (e.g., remote-vx.c) but
1583 others don't (or didn't - perhaps they have all been deleted). */
1585 print_transfer_performance (gdb_stdout
, cbdata
.data_count
,
1586 cbdata
.write_count
, end_time
- start_time
);
1588 do_cleanups (old_cleanups
);
1591 /* Report how fast the transfer went. */
1593 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1594 replaced by print_transfer_performance (with a very different
1595 function signature). */
1598 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1601 print_transfer_performance (gdb_stdout
, data_count
,
1602 end_time
- start_time
, 0);
1606 print_transfer_performance (struct ui_file
*stream
,
1607 unsigned long data_count
,
1608 unsigned long write_count
,
1609 unsigned long time_count
)
1611 ui_out_text (uiout
, "Transfer rate: ");
1614 ui_out_field_fmt (uiout
, "transfer-rate", "%lu",
1615 (data_count
* 8) / time_count
);
1616 ui_out_text (uiout
, " bits/sec");
1620 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
1621 ui_out_text (uiout
, " bits in <1 sec");
1623 if (write_count
> 0)
1625 ui_out_text (uiout
, ", ");
1626 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
1627 ui_out_text (uiout
, " bytes/write");
1629 ui_out_text (uiout
, ".\n");
1632 /* This function allows the addition of incrementally linked object files.
1633 It does not modify any state in the target, only in the debugger. */
1634 /* Note: ezannoni 2000-04-13 This function/command used to have a
1635 special case syntax for the rombug target (Rombug is the boot
1636 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1637 rombug case, the user doesn't need to supply a text address,
1638 instead a call to target_link() (in target.c) would supply the
1639 value to use. We are now discontinuing this type of ad hoc syntax. */
1642 add_symbol_file_command (char *args
, int from_tty
)
1644 char *filename
= NULL
;
1645 int flags
= OBJF_USERLOADED
;
1647 int expecting_option
= 0;
1648 int section_index
= 0;
1652 int expecting_sec_name
= 0;
1653 int expecting_sec_addr
= 0;
1661 struct section_addr_info
*section_addrs
;
1662 struct sect_opt
*sect_opts
= NULL
;
1663 size_t num_sect_opts
= 0;
1664 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
1667 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
1668 * sizeof (struct sect_opt
));
1673 error (_("add-symbol-file takes a file name and an address"));
1675 /* Make a copy of the string that we can safely write into. */
1676 args
= xstrdup (args
);
1678 while (*args
!= '\000')
1680 /* Any leading spaces? */
1681 while (isspace (*args
))
1684 /* Point arg to the beginning of the argument. */
1687 /* Move args pointer over the argument. */
1688 while ((*args
!= '\000') && !isspace (*args
))
1691 /* If there are more arguments, terminate arg and
1693 if (*args
!= '\000')
1696 /* Now process the argument. */
1699 /* The first argument is the file name. */
1700 filename
= tilde_expand (arg
);
1701 make_cleanup (xfree
, filename
);
1706 /* The second argument is always the text address at which
1707 to load the program. */
1708 sect_opts
[section_index
].name
= ".text";
1709 sect_opts
[section_index
].value
= arg
;
1710 if (++section_index
> num_sect_opts
)
1713 sect_opts
= ((struct sect_opt
*)
1714 xrealloc (sect_opts
,
1716 * sizeof (struct sect_opt
)));
1721 /* It's an option (starting with '-') or it's an argument
1726 if (strcmp (arg
, "-readnow") == 0)
1727 flags
|= OBJF_READNOW
;
1728 else if (strcmp (arg
, "-s") == 0)
1730 expecting_sec_name
= 1;
1731 expecting_sec_addr
= 1;
1736 if (expecting_sec_name
)
1738 sect_opts
[section_index
].name
= arg
;
1739 expecting_sec_name
= 0;
1742 if (expecting_sec_addr
)
1744 sect_opts
[section_index
].value
= arg
;
1745 expecting_sec_addr
= 0;
1746 if (++section_index
> num_sect_opts
)
1749 sect_opts
= ((struct sect_opt
*)
1750 xrealloc (sect_opts
,
1752 * sizeof (struct sect_opt
)));
1756 error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
1762 /* Print the prompt for the query below. And save the arguments into
1763 a sect_addr_info structure to be passed around to other
1764 functions. We have to split this up into separate print
1765 statements because hex_string returns a local static
1768 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
1769 section_addrs
= alloc_section_addr_info (section_index
);
1770 make_cleanup (xfree
, section_addrs
);
1771 for (i
= 0; i
< section_index
; i
++)
1774 char *val
= sect_opts
[i
].value
;
1775 char *sec
= sect_opts
[i
].name
;
1777 addr
= parse_and_eval_address (val
);
1779 /* Here we store the section offsets in the order they were
1780 entered on the command line. */
1781 section_addrs
->other
[sec_num
].name
= sec
;
1782 section_addrs
->other
[sec_num
].addr
= addr
;
1783 printf_unfiltered ("\t%s_addr = %s\n",
1784 sec
, hex_string ((unsigned long)addr
));
1787 /* The object's sections are initialized when a
1788 call is made to build_objfile_section_table (objfile).
1789 This happens in reread_symbols.
1790 At this point, we don't know what file type this is,
1791 so we can't determine what section names are valid. */
1794 if (from_tty
&& (!query ("%s", "")))
1795 error (_("Not confirmed."));
1797 symbol_file_add (filename
, from_tty
, section_addrs
, 0, flags
);
1799 /* Getting new symbols may change our opinion about what is
1801 reinit_frame_cache ();
1802 do_cleanups (my_cleanups
);
1806 add_shared_symbol_files_command (char *args
, int from_tty
)
1808 #ifdef ADD_SHARED_SYMBOL_FILES
1809 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1811 error (_("This command is not available in this configuration of GDB."));
1815 /* Re-read symbols if a symbol-file has changed. */
1817 reread_symbols (void)
1819 struct objfile
*objfile
;
1822 struct stat new_statbuf
;
1825 /* With the addition of shared libraries, this should be modified,
1826 the load time should be saved in the partial symbol tables, since
1827 different tables may come from different source files. FIXME.
1828 This routine should then walk down each partial symbol table
1829 and see if the symbol table that it originates from has been changed */
1831 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
1835 #ifdef DEPRECATED_IBM6000_TARGET
1836 /* If this object is from a shared library, then you should
1837 stat on the library name, not member name. */
1839 if (objfile
->obfd
->my_archive
)
1840 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1843 res
= stat (objfile
->name
, &new_statbuf
);
1846 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1847 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
1851 new_modtime
= new_statbuf
.st_mtime
;
1852 if (new_modtime
!= objfile
->mtime
)
1854 struct cleanup
*old_cleanups
;
1855 struct section_offsets
*offsets
;
1857 char *obfd_filename
;
1859 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
1862 /* There are various functions like symbol_file_add,
1863 symfile_bfd_open, syms_from_objfile, etc., which might
1864 appear to do what we want. But they have various other
1865 effects which we *don't* want. So we just do stuff
1866 ourselves. We don't worry about mapped files (for one thing,
1867 any mapped file will be out of date). */
1869 /* If we get an error, blow away this objfile (not sure if
1870 that is the correct response for things like shared
1872 old_cleanups
= make_cleanup_free_objfile (objfile
);
1873 /* We need to do this whenever any symbols go away. */
1874 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1876 /* Clean up any state BFD has sitting around. We don't need
1877 to close the descriptor but BFD lacks a way of closing the
1878 BFD without closing the descriptor. */
1879 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1880 if (!bfd_close (objfile
->obfd
))
1881 error (_("Can't close BFD for %s: %s"), objfile
->name
,
1882 bfd_errmsg (bfd_get_error ()));
1883 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1884 if (objfile
->obfd
== NULL
)
1885 error (_("Can't open %s to read symbols."), objfile
->name
);
1886 /* bfd_openr sets cacheable to true, which is what we want. */
1887 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1888 error (_("Can't read symbols from %s: %s."), objfile
->name
,
1889 bfd_errmsg (bfd_get_error ()));
1891 /* Save the offsets, we will nuke them with the rest of the
1893 num_offsets
= objfile
->num_sections
;
1894 offsets
= ((struct section_offsets
*)
1895 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
1896 memcpy (offsets
, objfile
->section_offsets
,
1897 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
1899 /* Nuke all the state that we will re-read. Much of the following
1900 code which sets things to NULL really is necessary to tell
1901 other parts of GDB that there is nothing currently there. */
1903 /* FIXME: Do we have to free a whole linked list, or is this
1905 if (objfile
->global_psymbols
.list
)
1906 xfree (objfile
->global_psymbols
.list
);
1907 memset (&objfile
->global_psymbols
, 0,
1908 sizeof (objfile
->global_psymbols
));
1909 if (objfile
->static_psymbols
.list
)
1910 xfree (objfile
->static_psymbols
.list
);
1911 memset (&objfile
->static_psymbols
, 0,
1912 sizeof (objfile
->static_psymbols
));
1914 /* Free the obstacks for non-reusable objfiles */
1915 bcache_xfree (objfile
->psymbol_cache
);
1916 objfile
->psymbol_cache
= bcache_xmalloc ();
1917 bcache_xfree (objfile
->macro_cache
);
1918 objfile
->macro_cache
= bcache_xmalloc ();
1919 if (objfile
->demangled_names_hash
!= NULL
)
1921 htab_delete (objfile
->demangled_names_hash
);
1922 objfile
->demangled_names_hash
= NULL
;
1924 obstack_free (&objfile
->objfile_obstack
, 0);
1925 objfile
->sections
= NULL
;
1926 objfile
->symtabs
= NULL
;
1927 objfile
->psymtabs
= NULL
;
1928 objfile
->free_psymtabs
= NULL
;
1929 objfile
->cp_namespace_symtab
= NULL
;
1930 objfile
->msymbols
= NULL
;
1931 objfile
->deprecated_sym_private
= NULL
;
1932 objfile
->minimal_symbol_count
= 0;
1933 memset (&objfile
->msymbol_hash
, 0,
1934 sizeof (objfile
->msymbol_hash
));
1935 memset (&objfile
->msymbol_demangled_hash
, 0,
1936 sizeof (objfile
->msymbol_demangled_hash
));
1937 objfile
->fundamental_types
= NULL
;
1938 clear_objfile_data (objfile
);
1939 if (objfile
->sf
!= NULL
)
1941 (*objfile
->sf
->sym_finish
) (objfile
);
1944 /* We never make this a mapped file. */
1946 objfile
->psymbol_cache
= bcache_xmalloc ();
1947 objfile
->macro_cache
= bcache_xmalloc ();
1948 /* obstack_init also initializes the obstack so it is
1949 empty. We could use obstack_specify_allocation but
1950 gdb_obstack.h specifies the alloc/dealloc
1952 obstack_init (&objfile
->objfile_obstack
);
1953 if (build_objfile_section_table (objfile
))
1955 error (_("Can't find the file sections in `%s': %s"),
1956 objfile
->name
, bfd_errmsg (bfd_get_error ()));
1958 terminate_minimal_symbol_table (objfile
);
1960 /* We use the same section offsets as from last time. I'm not
1961 sure whether that is always correct for shared libraries. */
1962 objfile
->section_offsets
= (struct section_offsets
*)
1963 obstack_alloc (&objfile
->objfile_obstack
,
1964 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
1965 memcpy (objfile
->section_offsets
, offsets
,
1966 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
1967 objfile
->num_sections
= num_offsets
;
1969 /* What the hell is sym_new_init for, anyway? The concept of
1970 distinguishing between the main file and additional files
1971 in this way seems rather dubious. */
1972 if (objfile
== symfile_objfile
)
1974 (*objfile
->sf
->sym_new_init
) (objfile
);
1977 (*objfile
->sf
->sym_init
) (objfile
);
1978 clear_complaints (&symfile_complaints
, 1, 1);
1979 /* The "mainline" parameter is a hideous hack; I think leaving it
1980 zero is OK since dbxread.c also does what it needs to do if
1981 objfile->global_psymbols.size is 0. */
1982 (*objfile
->sf
->sym_read
) (objfile
, 0);
1983 if (!have_partial_symbols () && !have_full_symbols ())
1986 printf_unfiltered (_("(no debugging symbols found)\n"));
1989 objfile
->flags
|= OBJF_SYMS
;
1991 /* We're done reading the symbol file; finish off complaints. */
1992 clear_complaints (&symfile_complaints
, 0, 1);
1994 /* Getting new symbols may change our opinion about what is
1997 reinit_frame_cache ();
1999 /* Discard cleanups as symbol reading was successful. */
2000 discard_cleanups (old_cleanups
);
2002 /* If the mtime has changed between the time we set new_modtime
2003 and now, we *want* this to be out of date, so don't call stat
2005 objfile
->mtime
= new_modtime
;
2007 reread_separate_symbols (objfile
);
2014 clear_symtab_users ();
2015 /* At least one objfile has changed, so we can consider that
2016 the executable we're debugging has changed too. */
2017 observer_notify_executable_changed (NULL
);
2023 /* Handle separate debug info for OBJFILE, which has just been
2025 - If we had separate debug info before, but now we don't, get rid
2026 of the separated objfile.
2027 - If we didn't have separated debug info before, but now we do,
2028 read in the new separated debug info file.
2029 - If the debug link points to a different file, toss the old one
2030 and read the new one.
2031 This function does *not* handle the case where objfile is still
2032 using the same separate debug info file, but that file's timestamp
2033 has changed. That case should be handled by the loop in
2034 reread_symbols already. */
2036 reread_separate_symbols (struct objfile
*objfile
)
2039 unsigned long crc32
;
2041 /* Does the updated objfile's debug info live in a
2043 debug_file
= find_separate_debug_file (objfile
);
2045 if (objfile
->separate_debug_objfile
)
2047 /* There are two cases where we need to get rid of
2048 the old separated debug info objfile:
2049 - if the new primary objfile doesn't have
2050 separated debug info, or
2051 - if the new primary objfile has separate debug
2052 info, but it's under a different filename.
2054 If the old and new objfiles both have separate
2055 debug info, under the same filename, then we're
2056 okay --- if the separated file's contents have
2057 changed, we will have caught that when we
2058 visited it in this function's outermost
2061 || strcmp (debug_file
, objfile
->separate_debug_objfile
->name
) != 0)
2062 free_objfile (objfile
->separate_debug_objfile
);
2065 /* If the new objfile has separate debug info, and we
2066 haven't loaded it already, do so now. */
2068 && ! objfile
->separate_debug_objfile
)
2070 /* Use the same section offset table as objfile itself.
2071 Preserve the flags from objfile that make sense. */
2072 objfile
->separate_debug_objfile
2073 = (symbol_file_add_with_addrs_or_offsets
2074 (symfile_bfd_open (debug_file
),
2075 info_verbose
, /* from_tty: Don't override the default. */
2076 0, /* No addr table. */
2077 objfile
->section_offsets
, objfile
->num_sections
,
2078 0, /* Not mainline. See comments about this above. */
2079 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
2080 | OBJF_USERLOADED
)));
2081 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
2097 static filename_language
*filename_language_table
;
2098 static int fl_table_size
, fl_table_next
;
2101 add_filename_language (char *ext
, enum language lang
)
2103 if (fl_table_next
>= fl_table_size
)
2105 fl_table_size
+= 10;
2106 filename_language_table
=
2107 xrealloc (filename_language_table
,
2108 fl_table_size
* sizeof (*filename_language_table
));
2111 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2112 filename_language_table
[fl_table_next
].lang
= lang
;
2116 static char *ext_args
;
2118 show_ext_args (struct ui_file
*file
, int from_tty
,
2119 struct cmd_list_element
*c
, const char *value
)
2121 fprintf_filtered (file
, _("\
2122 Mapping between filename extension and source language is \"%s\".\n"),
2127 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2130 char *cp
= ext_args
;
2133 /* First arg is filename extension, starting with '.' */
2135 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2137 /* Find end of first arg. */
2138 while (*cp
&& !isspace (*cp
))
2142 error (_("'%s': two arguments required -- filename extension and language"),
2145 /* Null-terminate first arg */
2148 /* Find beginning of second arg, which should be a source language. */
2149 while (*cp
&& isspace (*cp
))
2153 error (_("'%s': two arguments required -- filename extension and language"),
2156 /* Lookup the language from among those we know. */
2157 lang
= language_enum (cp
);
2159 /* Now lookup the filename extension: do we already know it? */
2160 for (i
= 0; i
< fl_table_next
; i
++)
2161 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2164 if (i
>= fl_table_next
)
2166 /* new file extension */
2167 add_filename_language (ext_args
, lang
);
2171 /* redefining a previously known filename extension */
2174 /* query ("Really make files of type %s '%s'?", */
2175 /* ext_args, language_str (lang)); */
2177 xfree (filename_language_table
[i
].ext
);
2178 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2179 filename_language_table
[i
].lang
= lang
;
2184 info_ext_lang_command (char *args
, int from_tty
)
2188 printf_filtered (_("Filename extensions and the languages they represent:"));
2189 printf_filtered ("\n\n");
2190 for (i
= 0; i
< fl_table_next
; i
++)
2191 printf_filtered ("\t%s\t- %s\n",
2192 filename_language_table
[i
].ext
,
2193 language_str (filename_language_table
[i
].lang
));
2197 init_filename_language_table (void)
2199 if (fl_table_size
== 0) /* protect against repetition */
2203 filename_language_table
=
2204 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2205 add_filename_language (".c", language_c
);
2206 add_filename_language (".C", language_cplus
);
2207 add_filename_language (".cc", language_cplus
);
2208 add_filename_language (".cp", language_cplus
);
2209 add_filename_language (".cpp", language_cplus
);
2210 add_filename_language (".cxx", language_cplus
);
2211 add_filename_language (".c++", language_cplus
);
2212 add_filename_language (".java", language_java
);
2213 add_filename_language (".class", language_java
);
2214 add_filename_language (".m", language_objc
);
2215 add_filename_language (".f", language_fortran
);
2216 add_filename_language (".F", language_fortran
);
2217 add_filename_language (".s", language_asm
);
2218 add_filename_language (".S", language_asm
);
2219 add_filename_language (".pas", language_pascal
);
2220 add_filename_language (".p", language_pascal
);
2221 add_filename_language (".pp", language_pascal
);
2222 add_filename_language (".adb", language_ada
);
2223 add_filename_language (".ads", language_ada
);
2224 add_filename_language (".a", language_ada
);
2225 add_filename_language (".ada", language_ada
);
2230 deduce_language_from_filename (char *filename
)
2235 if (filename
!= NULL
)
2236 if ((cp
= strrchr (filename
, '.')) != NULL
)
2237 for (i
= 0; i
< fl_table_next
; i
++)
2238 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2239 return filename_language_table
[i
].lang
;
2241 return language_unknown
;
2246 Allocate and partly initialize a new symbol table. Return a pointer
2247 to it. error() if no space.
2249 Caller must set these fields:
2255 possibly free_named_symtabs (symtab->filename);
2259 allocate_symtab (char *filename
, struct objfile
*objfile
)
2261 struct symtab
*symtab
;
2263 symtab
= (struct symtab
*)
2264 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2265 memset (symtab
, 0, sizeof (*symtab
));
2266 symtab
->filename
= obsavestring (filename
, strlen (filename
),
2267 &objfile
->objfile_obstack
);
2268 symtab
->fullname
= NULL
;
2269 symtab
->language
= deduce_language_from_filename (filename
);
2270 symtab
->debugformat
= obsavestring ("unknown", 7,
2271 &objfile
->objfile_obstack
);
2273 /* Hook it to the objfile it comes from */
2275 symtab
->objfile
= objfile
;
2276 symtab
->next
= objfile
->symtabs
;
2277 objfile
->symtabs
= symtab
;
2279 /* FIXME: This should go away. It is only defined for the Z8000,
2280 and the Z8000 definition of this macro doesn't have anything to
2281 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
2282 here for convenience. */
2283 #ifdef INIT_EXTRA_SYMTAB_INFO
2284 INIT_EXTRA_SYMTAB_INFO (symtab
);
2290 struct partial_symtab
*
2291 allocate_psymtab (char *filename
, struct objfile
*objfile
)
2293 struct partial_symtab
*psymtab
;
2295 if (objfile
->free_psymtabs
)
2297 psymtab
= objfile
->free_psymtabs
;
2298 objfile
->free_psymtabs
= psymtab
->next
;
2301 psymtab
= (struct partial_symtab
*)
2302 obstack_alloc (&objfile
->objfile_obstack
,
2303 sizeof (struct partial_symtab
));
2305 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2306 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
2307 &objfile
->objfile_obstack
);
2308 psymtab
->symtab
= NULL
;
2310 /* Prepend it to the psymtab list for the objfile it belongs to.
2311 Psymtabs are searched in most recent inserted -> least recent
2314 psymtab
->objfile
= objfile
;
2315 psymtab
->next
= objfile
->psymtabs
;
2316 objfile
->psymtabs
= psymtab
;
2319 struct partial_symtab
**prev_pst
;
2320 psymtab
->objfile
= objfile
;
2321 psymtab
->next
= NULL
;
2322 prev_pst
= &(objfile
->psymtabs
);
2323 while ((*prev_pst
) != NULL
)
2324 prev_pst
= &((*prev_pst
)->next
);
2325 (*prev_pst
) = psymtab
;
2333 discard_psymtab (struct partial_symtab
*pst
)
2335 struct partial_symtab
**prev_pst
;
2338 Empty psymtabs happen as a result of header files which don't
2339 have any symbols in them. There can be a lot of them. But this
2340 check is wrong, in that a psymtab with N_SLINE entries but
2341 nothing else is not empty, but we don't realize that. Fixing
2342 that without slowing things down might be tricky. */
2344 /* First, snip it out of the psymtab chain */
2346 prev_pst
= &(pst
->objfile
->psymtabs
);
2347 while ((*prev_pst
) != pst
)
2348 prev_pst
= &((*prev_pst
)->next
);
2349 (*prev_pst
) = pst
->next
;
2351 /* Next, put it on a free list for recycling */
2353 pst
->next
= pst
->objfile
->free_psymtabs
;
2354 pst
->objfile
->free_psymtabs
= pst
;
2358 /* Reset all data structures in gdb which may contain references to symbol
2362 clear_symtab_users (void)
2364 /* Someday, we should do better than this, by only blowing away
2365 the things that really need to be blown. */
2367 /* Clear the "current" symtab first, because it is no longer valid.
2368 breakpoint_re_set may try to access the current symtab. */
2369 clear_current_source_symtab_and_line ();
2371 clear_value_history ();
2373 clear_internalvars ();
2374 breakpoint_re_set ();
2375 set_default_breakpoint (0, 0, 0, 0);
2376 clear_pc_function_cache ();
2377 if (deprecated_target_new_objfile_hook
)
2378 deprecated_target_new_objfile_hook (NULL
);
2382 clear_symtab_users_cleanup (void *ignore
)
2384 clear_symtab_users ();
2387 /* clear_symtab_users_once:
2389 This function is run after symbol reading, or from a cleanup.
2390 If an old symbol table was obsoleted, the old symbol table
2391 has been blown away, but the other GDB data structures that may
2392 reference it have not yet been cleared or re-directed. (The old
2393 symtab was zapped, and the cleanup queued, in free_named_symtab()
2396 This function can be queued N times as a cleanup, or called
2397 directly; it will do all the work the first time, and then will be a
2398 no-op until the next time it is queued. This works by bumping a
2399 counter at queueing time. Much later when the cleanup is run, or at
2400 the end of symbol processing (in case the cleanup is discarded), if
2401 the queued count is greater than the "done-count", we do the work
2402 and set the done-count to the queued count. If the queued count is
2403 less than or equal to the done-count, we just ignore the call. This
2404 is needed because reading a single .o file will often replace many
2405 symtabs (one per .h file, for example), and we don't want to reset
2406 the breakpoints N times in the user's face.
2408 The reason we both queue a cleanup, and call it directly after symbol
2409 reading, is because the cleanup protects us in case of errors, but is
2410 discarded if symbol reading is successful. */
2413 /* FIXME: As free_named_symtabs is currently a big noop this function
2414 is no longer needed. */
2415 static void clear_symtab_users_once (void);
2417 static int clear_symtab_users_queued
;
2418 static int clear_symtab_users_done
;
2421 clear_symtab_users_once (void)
2423 /* Enforce once-per-`do_cleanups'-semantics */
2424 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2426 clear_symtab_users_done
= clear_symtab_users_queued
;
2428 clear_symtab_users ();
2432 /* Delete the specified psymtab, and any others that reference it. */
2435 cashier_psymtab (struct partial_symtab
*pst
)
2437 struct partial_symtab
*ps
, *pprev
= NULL
;
2440 /* Find its previous psymtab in the chain */
2441 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2450 /* Unhook it from the chain. */
2451 if (ps
== pst
->objfile
->psymtabs
)
2452 pst
->objfile
->psymtabs
= ps
->next
;
2454 pprev
->next
= ps
->next
;
2456 /* FIXME, we can't conveniently deallocate the entries in the
2457 partial_symbol lists (global_psymbols/static_psymbols) that
2458 this psymtab points to. These just take up space until all
2459 the psymtabs are reclaimed. Ditto the dependencies list and
2460 filename, which are all in the objfile_obstack. */
2462 /* We need to cashier any psymtab that has this one as a dependency... */
2464 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2466 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2468 if (ps
->dependencies
[i
] == pst
)
2470 cashier_psymtab (ps
);
2471 goto again
; /* Must restart, chain has been munged. */
2478 /* If a symtab or psymtab for filename NAME is found, free it along
2479 with any dependent breakpoints, displays, etc.
2480 Used when loading new versions of object modules with the "add-file"
2481 command. This is only called on the top-level symtab or psymtab's name;
2482 it is not called for subsidiary files such as .h files.
2484 Return value is 1 if we blew away the environment, 0 if not.
2485 FIXME. The return value appears to never be used.
2487 FIXME. I think this is not the best way to do this. We should
2488 work on being gentler to the environment while still cleaning up
2489 all stray pointers into the freed symtab. */
2492 free_named_symtabs (char *name
)
2495 /* FIXME: With the new method of each objfile having it's own
2496 psymtab list, this function needs serious rethinking. In particular,
2497 why was it ever necessary to toss psymtabs with specific compilation
2498 unit filenames, as opposed to all psymtabs from a particular symbol
2500 Well, the answer is that some systems permit reloading of particular
2501 compilation units. We want to blow away any old info about these
2502 compilation units, regardless of which objfiles they arrived in. --gnu. */
2505 struct symtab
*prev
;
2506 struct partial_symtab
*ps
;
2507 struct blockvector
*bv
;
2510 /* We only wack things if the symbol-reload switch is set. */
2511 if (!symbol_reloading
)
2514 /* Some symbol formats have trouble providing file names... */
2515 if (name
== 0 || *name
== '\0')
2518 /* Look for a psymtab with the specified name. */
2521 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2523 if (strcmp (name
, ps
->filename
) == 0)
2525 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2526 goto again2
; /* Must restart, chain has been munged */
2530 /* Look for a symtab with the specified name. */
2532 for (s
= symtab_list
; s
; s
= s
->next
)
2534 if (strcmp (name
, s
->filename
) == 0)
2541 if (s
== symtab_list
)
2542 symtab_list
= s
->next
;
2544 prev
->next
= s
->next
;
2546 /* For now, queue a delete for all breakpoints, displays, etc., whether
2547 or not they depend on the symtab being freed. This should be
2548 changed so that only those data structures affected are deleted. */
2550 /* But don't delete anything if the symtab is empty.
2551 This test is necessary due to a bug in "dbxread.c" that
2552 causes empty symtabs to be created for N_SO symbols that
2553 contain the pathname of the object file. (This problem
2554 has been fixed in GDB 3.9x). */
2556 bv
= BLOCKVECTOR (s
);
2557 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2558 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2559 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2561 complaint (&symfile_complaints
, _("Replacing old symbols for `%s'"),
2563 clear_symtab_users_queued
++;
2564 make_cleanup (clear_symtab_users_once
, 0);
2568 complaint (&symfile_complaints
, _("Empty symbol table found for `%s'"),
2575 /* It is still possible that some breakpoints will be affected
2576 even though no symtab was found, since the file might have
2577 been compiled without debugging, and hence not be associated
2578 with a symtab. In order to handle this correctly, we would need
2579 to keep a list of text address ranges for undebuggable files.
2580 For now, we do nothing, since this is a fairly obscure case. */
2584 /* FIXME, what about the minimal symbol table? */
2591 /* Allocate and partially fill a partial symtab. It will be
2592 completely filled at the end of the symbol list.
2594 FILENAME is the name of the symbol-file we are reading from. */
2596 struct partial_symtab
*
2597 start_psymtab_common (struct objfile
*objfile
,
2598 struct section_offsets
*section_offsets
, char *filename
,
2599 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2600 struct partial_symbol
**static_syms
)
2602 struct partial_symtab
*psymtab
;
2604 psymtab
= allocate_psymtab (filename
, objfile
);
2605 psymtab
->section_offsets
= section_offsets
;
2606 psymtab
->textlow
= textlow
;
2607 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2608 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2609 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2613 /* Add a symbol with a long value to a psymtab.
2614 Since one arg is a struct, we pass in a ptr and deref it (sigh).
2615 Return the partial symbol that has been added. */
2617 /* NOTE: carlton/2003-09-11: The reason why we return the partial
2618 symbol is so that callers can get access to the symbol's demangled
2619 name, which they don't have any cheap way to determine otherwise.
2620 (Currenly, dwarf2read.c is the only file who uses that information,
2621 though it's possible that other readers might in the future.)
2622 Elena wasn't thrilled about that, and I don't blame her, but we
2623 couldn't come up with a better way to get that information. If
2624 it's needed in other situations, we could consider breaking up
2625 SYMBOL_SET_NAMES to provide access to the demangled name lookup
2628 const struct partial_symbol
*
2629 add_psymbol_to_list (char *name
, int namelength
, domain_enum domain
,
2630 enum address_class
class,
2631 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2632 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2633 enum language language
, struct objfile
*objfile
)
2635 struct partial_symbol
*psym
;
2636 char *buf
= alloca (namelength
+ 1);
2637 /* psymbol is static so that there will be no uninitialized gaps in the
2638 structure which might contain random data, causing cache misses in
2640 static struct partial_symbol psymbol
;
2642 /* Create local copy of the partial symbol */
2643 memcpy (buf
, name
, namelength
);
2644 buf
[namelength
] = '\0';
2645 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2648 SYMBOL_VALUE (&psymbol
) = val
;
2652 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2654 SYMBOL_SECTION (&psymbol
) = 0;
2655 SYMBOL_LANGUAGE (&psymbol
) = language
;
2656 PSYMBOL_DOMAIN (&psymbol
) = domain
;
2657 PSYMBOL_CLASS (&psymbol
) = class;
2659 SYMBOL_SET_NAMES (&psymbol
, buf
, namelength
, objfile
);
2661 /* Stash the partial symbol away in the cache */
2662 psym
= deprecated_bcache (&psymbol
, sizeof (struct partial_symbol
),
2663 objfile
->psymbol_cache
);
2665 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2666 if (list
->next
>= list
->list
+ list
->size
)
2668 extend_psymbol_list (list
, objfile
);
2670 *list
->next
++ = psym
;
2671 OBJSTAT (objfile
, n_psyms
++);
2676 /* Add a symbol with a long value to a psymtab. This differs from
2677 * add_psymbol_to_list above in taking both a mangled and a demangled
2681 add_psymbol_with_dem_name_to_list (char *name
, int namelength
, char *dem_name
,
2682 int dem_namelength
, domain_enum domain
,
2683 enum address_class
class,
2684 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2685 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2686 enum language language
,
2687 struct objfile
*objfile
)
2689 struct partial_symbol
*psym
;
2690 char *buf
= alloca (namelength
+ 1);
2691 /* psymbol is static so that there will be no uninitialized gaps in the
2692 structure which might contain random data, causing cache misses in
2694 static struct partial_symbol psymbol
;
2696 /* Create local copy of the partial symbol */
2698 memcpy (buf
, name
, namelength
);
2699 buf
[namelength
] = '\0';
2700 DEPRECATED_SYMBOL_NAME (&psymbol
) = deprecated_bcache (buf
, namelength
+ 1,
2701 objfile
->psymbol_cache
);
2703 buf
= alloca (dem_namelength
+ 1);
2704 memcpy (buf
, dem_name
, dem_namelength
);
2705 buf
[dem_namelength
] = '\0';
2710 case language_cplus
:
2711 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol
) =
2712 deprecated_bcache (buf
, dem_namelength
+ 1, objfile
->psymbol_cache
);
2714 /* FIXME What should be done for the default case? Ignoring for now. */
2717 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2720 SYMBOL_VALUE (&psymbol
) = val
;
2724 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2726 SYMBOL_SECTION (&psymbol
) = 0;
2727 SYMBOL_LANGUAGE (&psymbol
) = language
;
2728 PSYMBOL_DOMAIN (&psymbol
) = domain
;
2729 PSYMBOL_CLASS (&psymbol
) = class;
2730 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2732 /* Stash the partial symbol away in the cache */
2733 psym
= deprecated_bcache (&psymbol
, sizeof (struct partial_symbol
),
2734 objfile
->psymbol_cache
);
2736 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2737 if (list
->next
>= list
->list
+ list
->size
)
2739 extend_psymbol_list (list
, objfile
);
2741 *list
->next
++ = psym
;
2742 OBJSTAT (objfile
, n_psyms
++);
2745 /* Initialize storage for partial symbols. */
2748 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
2750 /* Free any previously allocated psymbol lists. */
2752 if (objfile
->global_psymbols
.list
)
2754 xfree (objfile
->global_psymbols
.list
);
2756 if (objfile
->static_psymbols
.list
)
2758 xfree (objfile
->static_psymbols
.list
);
2761 /* Current best guess is that approximately a twentieth
2762 of the total symbols (in a debugging file) are global or static
2765 objfile
->global_psymbols
.size
= total_symbols
/ 10;
2766 objfile
->static_psymbols
.size
= total_symbols
/ 10;
2768 if (objfile
->global_psymbols
.size
> 0)
2770 objfile
->global_psymbols
.next
=
2771 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
2772 xmalloc ((objfile
->global_psymbols
.size
2773 * sizeof (struct partial_symbol
*)));
2775 if (objfile
->static_psymbols
.size
> 0)
2777 objfile
->static_psymbols
.next
=
2778 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
2779 xmalloc ((objfile
->static_psymbols
.size
2780 * sizeof (struct partial_symbol
*)));
2785 The following code implements an abstraction for debugging overlay sections.
2787 The target model is as follows:
2788 1) The gnu linker will permit multiple sections to be mapped into the
2789 same VMA, each with its own unique LMA (or load address).
2790 2) It is assumed that some runtime mechanism exists for mapping the
2791 sections, one by one, from the load address into the VMA address.
2792 3) This code provides a mechanism for gdb to keep track of which
2793 sections should be considered to be mapped from the VMA to the LMA.
2794 This information is used for symbol lookup, and memory read/write.
2795 For instance, if a section has been mapped then its contents
2796 should be read from the VMA, otherwise from the LMA.
2798 Two levels of debugger support for overlays are available. One is
2799 "manual", in which the debugger relies on the user to tell it which
2800 overlays are currently mapped. This level of support is
2801 implemented entirely in the core debugger, and the information about
2802 whether a section is mapped is kept in the objfile->obj_section table.
2804 The second level of support is "automatic", and is only available if
2805 the target-specific code provides functionality to read the target's
2806 overlay mapping table, and translate its contents for the debugger
2807 (by updating the mapped state information in the obj_section tables).
2809 The interface is as follows:
2811 overlay map <name> -- tell gdb to consider this section mapped
2812 overlay unmap <name> -- tell gdb to consider this section unmapped
2813 overlay list -- list the sections that GDB thinks are mapped
2814 overlay read-target -- get the target's state of what's mapped
2815 overlay off/manual/auto -- set overlay debugging state
2816 Functional interface:
2817 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2818 section, return that section.
2819 find_pc_overlay(pc): find any overlay section that contains
2820 the pc, either in its VMA or its LMA
2821 overlay_is_mapped(sect): true if overlay is marked as mapped
2822 section_is_overlay(sect): true if section's VMA != LMA
2823 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2824 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2825 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2826 overlay_mapped_address(...): map an address from section's LMA to VMA
2827 overlay_unmapped_address(...): map an address from section's VMA to LMA
2828 symbol_overlayed_address(...): Return a "current" address for symbol:
2829 either in VMA or LMA depending on whether
2830 the symbol's section is currently mapped
2833 /* Overlay debugging state: */
2835 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2836 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
2838 /* Target vector for refreshing overlay mapped state */
2839 static void simple_overlay_update (struct obj_section
*);
2840 void (*target_overlay_update
) (struct obj_section
*) = simple_overlay_update
;
2842 /* Function: section_is_overlay (SECTION)
2843 Returns true if SECTION has VMA not equal to LMA, ie.
2844 SECTION is loaded at an address different from where it will "run". */
2847 section_is_overlay (asection
*section
)
2849 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2851 if (overlay_debugging
)
2852 if (section
&& section
->lma
!= 0 &&
2853 section
->vma
!= section
->lma
)
2859 /* Function: overlay_invalidate_all (void)
2860 Invalidate the mapped state of all overlay sections (mark it as stale). */
2863 overlay_invalidate_all (void)
2865 struct objfile
*objfile
;
2866 struct obj_section
*sect
;
2868 ALL_OBJSECTIONS (objfile
, sect
)
2869 if (section_is_overlay (sect
->the_bfd_section
))
2870 sect
->ovly_mapped
= -1;
2873 /* Function: overlay_is_mapped (SECTION)
2874 Returns true if section is an overlay, and is currently mapped.
2875 Private: public access is thru function section_is_mapped.
2877 Access to the ovly_mapped flag is restricted to this function, so
2878 that we can do automatic update. If the global flag
2879 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2880 overlay_invalidate_all. If the mapped state of the particular
2881 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2884 overlay_is_mapped (struct obj_section
*osect
)
2886 if (osect
== 0 || !section_is_overlay (osect
->the_bfd_section
))
2889 switch (overlay_debugging
)
2893 return 0; /* overlay debugging off */
2894 case ovly_auto
: /* overlay debugging automatic */
2895 /* Unles there is a target_overlay_update function,
2896 there's really nothing useful to do here (can't really go auto) */
2897 if (target_overlay_update
)
2899 if (overlay_cache_invalid
)
2901 overlay_invalidate_all ();
2902 overlay_cache_invalid
= 0;
2904 if (osect
->ovly_mapped
== -1)
2905 (*target_overlay_update
) (osect
);
2907 /* fall thru to manual case */
2908 case ovly_on
: /* overlay debugging manual */
2909 return osect
->ovly_mapped
== 1;
2913 /* Function: section_is_mapped
2914 Returns true if section is an overlay, and is currently mapped. */
2917 section_is_mapped (asection
*section
)
2919 struct objfile
*objfile
;
2920 struct obj_section
*osect
;
2922 if (overlay_debugging
)
2923 if (section
&& section_is_overlay (section
))
2924 ALL_OBJSECTIONS (objfile
, osect
)
2925 if (osect
->the_bfd_section
== section
)
2926 return overlay_is_mapped (osect
);
2931 /* Function: pc_in_unmapped_range
2932 If PC falls into the lma range of SECTION, return true, else false. */
2935 pc_in_unmapped_range (CORE_ADDR pc
, asection
*section
)
2937 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2941 if (overlay_debugging
)
2942 if (section
&& section_is_overlay (section
))
2944 size
= bfd_get_section_size (section
);
2945 if (section
->lma
<= pc
&& pc
< section
->lma
+ size
)
2951 /* Function: pc_in_mapped_range
2952 If PC falls into the vma range of SECTION, return true, else false. */
2955 pc_in_mapped_range (CORE_ADDR pc
, asection
*section
)
2957 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2961 if (overlay_debugging
)
2962 if (section
&& section_is_overlay (section
))
2964 size
= bfd_get_section_size (section
);
2965 if (section
->vma
<= pc
&& pc
< section
->vma
+ size
)
2972 /* Return true if the mapped ranges of sections A and B overlap, false
2975 sections_overlap (asection
*a
, asection
*b
)
2977 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2979 CORE_ADDR a_start
= a
->vma
;
2980 CORE_ADDR a_end
= a
->vma
+ bfd_get_section_size (a
);
2981 CORE_ADDR b_start
= b
->vma
;
2982 CORE_ADDR b_end
= b
->vma
+ bfd_get_section_size (b
);
2984 return (a_start
< b_end
&& b_start
< a_end
);
2987 /* Function: overlay_unmapped_address (PC, SECTION)
2988 Returns the address corresponding to PC in the unmapped (load) range.
2989 May be the same as PC. */
2992 overlay_unmapped_address (CORE_ADDR pc
, asection
*section
)
2994 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2996 if (overlay_debugging
)
2997 if (section
&& section_is_overlay (section
) &&
2998 pc_in_mapped_range (pc
, section
))
2999 return pc
+ section
->lma
- section
->vma
;
3004 /* Function: overlay_mapped_address (PC, SECTION)
3005 Returns the address corresponding to PC in the mapped (runtime) range.
3006 May be the same as PC. */
3009 overlay_mapped_address (CORE_ADDR pc
, asection
*section
)
3011 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
3013 if (overlay_debugging
)
3014 if (section
&& section_is_overlay (section
) &&
3015 pc_in_unmapped_range (pc
, section
))
3016 return pc
+ section
->vma
- section
->lma
;
3022 /* Function: symbol_overlayed_address
3023 Return one of two addresses (relative to the VMA or to the LMA),
3024 depending on whether the section is mapped or not. */
3027 symbol_overlayed_address (CORE_ADDR address
, asection
*section
)
3029 if (overlay_debugging
)
3031 /* If the symbol has no section, just return its regular address. */
3034 /* If the symbol's section is not an overlay, just return its address */
3035 if (!section_is_overlay (section
))
3037 /* If the symbol's section is mapped, just return its address */
3038 if (section_is_mapped (section
))
3041 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3042 * then return its LOADED address rather than its vma address!!
3044 return overlay_unmapped_address (address
, section
);
3049 /* Function: find_pc_overlay (PC)
3050 Return the best-match overlay section for PC:
3051 If PC matches a mapped overlay section's VMA, return that section.
3052 Else if PC matches an unmapped section's VMA, return that section.
3053 Else if PC matches an unmapped section's LMA, return that section. */
3056 find_pc_overlay (CORE_ADDR pc
)
3058 struct objfile
*objfile
;
3059 struct obj_section
*osect
, *best_match
= NULL
;
3061 if (overlay_debugging
)
3062 ALL_OBJSECTIONS (objfile
, osect
)
3063 if (section_is_overlay (osect
->the_bfd_section
))
3065 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
))
3067 if (overlay_is_mapped (osect
))
3068 return osect
->the_bfd_section
;
3072 else if (pc_in_unmapped_range (pc
, osect
->the_bfd_section
))
3075 return best_match
? best_match
->the_bfd_section
: NULL
;
3078 /* Function: find_pc_mapped_section (PC)
3079 If PC falls into the VMA address range of an overlay section that is
3080 currently marked as MAPPED, return that section. Else return NULL. */
3083 find_pc_mapped_section (CORE_ADDR pc
)
3085 struct objfile
*objfile
;
3086 struct obj_section
*osect
;
3088 if (overlay_debugging
)
3089 ALL_OBJSECTIONS (objfile
, osect
)
3090 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
) &&
3091 overlay_is_mapped (osect
))
3092 return osect
->the_bfd_section
;
3097 /* Function: list_overlays_command
3098 Print a list of mapped sections and their PC ranges */
3101 list_overlays_command (char *args
, int from_tty
)
3104 struct objfile
*objfile
;
3105 struct obj_section
*osect
;
3107 if (overlay_debugging
)
3108 ALL_OBJSECTIONS (objfile
, osect
)
3109 if (overlay_is_mapped (osect
))
3115 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3116 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3117 size
= bfd_get_section_size (osect
->the_bfd_section
);
3118 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3120 printf_filtered ("Section %s, loaded at ", name
);
3121 deprecated_print_address_numeric (lma
, 1, gdb_stdout
);
3122 puts_filtered (" - ");
3123 deprecated_print_address_numeric (lma
+ size
, 1, gdb_stdout
);
3124 printf_filtered (", mapped at ");
3125 deprecated_print_address_numeric (vma
, 1, gdb_stdout
);
3126 puts_filtered (" - ");
3127 deprecated_print_address_numeric (vma
+ size
, 1, gdb_stdout
);
3128 puts_filtered ("\n");
3133 printf_filtered (_("No sections are mapped.\n"));
3136 /* Function: map_overlay_command
3137 Mark the named section as mapped (ie. residing at its VMA address). */
3140 map_overlay_command (char *args
, int from_tty
)
3142 struct objfile
*objfile
, *objfile2
;
3143 struct obj_section
*sec
, *sec2
;
3146 if (!overlay_debugging
)
3148 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3149 the 'overlay manual' command."));
3151 if (args
== 0 || *args
== 0)
3152 error (_("Argument required: name of an overlay section"));
3154 /* First, find a section matching the user supplied argument */
3155 ALL_OBJSECTIONS (objfile
, sec
)
3156 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3158 /* Now, check to see if the section is an overlay. */
3159 bfdsec
= sec
->the_bfd_section
;
3160 if (!section_is_overlay (bfdsec
))
3161 continue; /* not an overlay section */
3163 /* Mark the overlay as "mapped" */
3164 sec
->ovly_mapped
= 1;
3166 /* Next, make a pass and unmap any sections that are
3167 overlapped by this new section: */
3168 ALL_OBJSECTIONS (objfile2
, sec2
)
3169 if (sec2
->ovly_mapped
3171 && sec
->the_bfd_section
!= sec2
->the_bfd_section
3172 && sections_overlap (sec
->the_bfd_section
,
3173 sec2
->the_bfd_section
))
3176 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3177 bfd_section_name (objfile
->obfd
,
3178 sec2
->the_bfd_section
));
3179 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3183 error (_("No overlay section called %s"), args
);
3186 /* Function: unmap_overlay_command
3187 Mark the overlay section as unmapped
3188 (ie. resident in its LMA address range, rather than the VMA range). */
3191 unmap_overlay_command (char *args
, int from_tty
)
3193 struct objfile
*objfile
;
3194 struct obj_section
*sec
;
3196 if (!overlay_debugging
)
3198 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3199 the 'overlay manual' command."));
3201 if (args
== 0 || *args
== 0)
3202 error (_("Argument required: name of an overlay section"));
3204 /* First, find a section matching the user supplied argument */
3205 ALL_OBJSECTIONS (objfile
, sec
)
3206 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3208 if (!sec
->ovly_mapped
)
3209 error (_("Section %s is not mapped"), args
);
3210 sec
->ovly_mapped
= 0;
3213 error (_("No overlay section called %s"), args
);
3216 /* Function: overlay_auto_command
3217 A utility command to turn on overlay debugging.
3218 Possibly this should be done via a set/show command. */
3221 overlay_auto_command (char *args
, int from_tty
)
3223 overlay_debugging
= ovly_auto
;
3224 enable_overlay_breakpoints ();
3226 printf_unfiltered (_("Automatic overlay debugging enabled."));
3229 /* Function: overlay_manual_command
3230 A utility command to turn on overlay debugging.
3231 Possibly this should be done via a set/show command. */
3234 overlay_manual_command (char *args
, int from_tty
)
3236 overlay_debugging
= ovly_on
;
3237 disable_overlay_breakpoints ();
3239 printf_unfiltered (_("Overlay debugging enabled."));
3242 /* Function: overlay_off_command
3243 A utility command to turn on overlay debugging.
3244 Possibly this should be done via a set/show command. */
3247 overlay_off_command (char *args
, int from_tty
)
3249 overlay_debugging
= ovly_off
;
3250 disable_overlay_breakpoints ();
3252 printf_unfiltered (_("Overlay debugging disabled."));
3256 overlay_load_command (char *args
, int from_tty
)
3258 if (target_overlay_update
)
3259 (*target_overlay_update
) (NULL
);
3261 error (_("This target does not know how to read its overlay state."));
3264 /* Function: overlay_command
3265 A place-holder for a mis-typed command */
3267 /* Command list chain containing all defined "overlay" subcommands. */
3268 struct cmd_list_element
*overlaylist
;
3271 overlay_command (char *args
, int from_tty
)
3274 ("\"overlay\" must be followed by the name of an overlay command.\n");
3275 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3279 /* Target Overlays for the "Simplest" overlay manager:
3281 This is GDB's default target overlay layer. It works with the
3282 minimal overlay manager supplied as an example by Cygnus. The
3283 entry point is via a function pointer "target_overlay_update",
3284 so targets that use a different runtime overlay manager can
3285 substitute their own overlay_update function and take over the
3288 The overlay_update function pokes around in the target's data structures
3289 to see what overlays are mapped, and updates GDB's overlay mapping with
3292 In this simple implementation, the target data structures are as follows:
3293 unsigned _novlys; /# number of overlay sections #/
3294 unsigned _ovly_table[_novlys][4] = {
3295 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3296 {..., ..., ..., ...},
3298 unsigned _novly_regions; /# number of overlay regions #/
3299 unsigned _ovly_region_table[_novly_regions][3] = {
3300 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3303 These functions will attempt to update GDB's mappedness state in the
3304 symbol section table, based on the target's mappedness state.
3306 To do this, we keep a cached copy of the target's _ovly_table, and
3307 attempt to detect when the cached copy is invalidated. The main
3308 entry point is "simple_overlay_update(SECT), which looks up SECT in
3309 the cached table and re-reads only the entry for that section from
3310 the target (whenever possible).
3313 /* Cached, dynamically allocated copies of the target data structures: */
3314 static unsigned (*cache_ovly_table
)[4] = 0;
3316 static unsigned (*cache_ovly_region_table
)[3] = 0;
3318 static unsigned cache_novlys
= 0;
3320 static unsigned cache_novly_regions
= 0;
3322 static CORE_ADDR cache_ovly_table_base
= 0;
3324 static CORE_ADDR cache_ovly_region_table_base
= 0;
3328 VMA
, SIZE
, LMA
, MAPPED
3330 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
3332 /* Throw away the cached copy of _ovly_table */
3334 simple_free_overlay_table (void)
3336 if (cache_ovly_table
)
3337 xfree (cache_ovly_table
);
3339 cache_ovly_table
= NULL
;
3340 cache_ovly_table_base
= 0;
3344 /* Throw away the cached copy of _ovly_region_table */
3346 simple_free_overlay_region_table (void)
3348 if (cache_ovly_region_table
)
3349 xfree (cache_ovly_region_table
);
3350 cache_novly_regions
= 0;
3351 cache_ovly_region_table
= NULL
;
3352 cache_ovly_region_table_base
= 0;
3356 /* Read an array of ints from the target into a local buffer.
3357 Convert to host order. int LEN is number of ints */
3359 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
, int len
)
3361 /* FIXME (alloca): Not safe if array is very large. */
3362 char *buf
= alloca (len
* TARGET_LONG_BYTES
);
3365 read_memory (memaddr
, buf
, len
* TARGET_LONG_BYTES
);
3366 for (i
= 0; i
< len
; i
++)
3367 myaddr
[i
] = extract_unsigned_integer (TARGET_LONG_BYTES
* i
+ buf
,
3371 /* Find and grab a copy of the target _ovly_table
3372 (and _novlys, which is needed for the table's size) */
3374 simple_read_overlay_table (void)
3376 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3378 simple_free_overlay_table ();
3379 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3382 error (_("Error reading inferior's overlay table: "
3383 "couldn't find `_novlys' variable\n"
3384 "in inferior. Use `overlay manual' mode."));
3388 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3389 if (! ovly_table_msym
)
3391 error (_("Error reading inferior's overlay table: couldn't find "
3392 "`_ovly_table' array\n"
3393 "in inferior. Use `overlay manual' mode."));
3397 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
), 4);
3399 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3400 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3401 read_target_long_array (cache_ovly_table_base
,
3402 (int *) cache_ovly_table
,
3405 return 1; /* SUCCESS */
3409 /* Find and grab a copy of the target _ovly_region_table
3410 (and _novly_regions, which is needed for the table's size) */
3412 simple_read_overlay_region_table (void)
3414 struct minimal_symbol
*msym
;
3416 simple_free_overlay_region_table ();
3417 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3419 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
3421 return 0; /* failure */
3422 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3423 if (cache_ovly_region_table
!= NULL
)
3425 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3428 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3429 read_target_long_array (cache_ovly_region_table_base
,
3430 (int *) cache_ovly_region_table
,
3431 cache_novly_regions
* 3);
3434 return 0; /* failure */
3437 return 0; /* failure */
3438 return 1; /* SUCCESS */
3442 /* Function: simple_overlay_update_1
3443 A helper function for simple_overlay_update. Assuming a cached copy
3444 of _ovly_table exists, look through it to find an entry whose vma,
3445 lma and size match those of OSECT. Re-read the entry and make sure
3446 it still matches OSECT (else the table may no longer be valid).
3447 Set OSECT's mapped state to match the entry. Return: 1 for
3448 success, 0 for failure. */
3451 simple_overlay_update_1 (struct obj_section
*osect
)
3454 bfd
*obfd
= osect
->objfile
->obfd
;
3455 asection
*bsect
= osect
->the_bfd_section
;
3457 size
= bfd_get_section_size (osect
->the_bfd_section
);
3458 for (i
= 0; i
< cache_novlys
; i
++)
3459 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3460 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3461 /* && cache_ovly_table[i][SIZE] == size */ )
3463 read_target_long_array (cache_ovly_table_base
+ i
* TARGET_LONG_BYTES
,
3464 (int *) cache_ovly_table
[i
], 4);
3465 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3466 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3467 /* && cache_ovly_table[i][SIZE] == size */ )
3469 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3472 else /* Warning! Warning! Target's ovly table has changed! */
3478 /* Function: simple_overlay_update
3479 If OSECT is NULL, then update all sections' mapped state
3480 (after re-reading the entire target _ovly_table).
3481 If OSECT is non-NULL, then try to find a matching entry in the
3482 cached ovly_table and update only OSECT's mapped state.
3483 If a cached entry can't be found or the cache isn't valid, then
3484 re-read the entire cache, and go ahead and update all sections. */
3487 simple_overlay_update (struct obj_section
*osect
)
3489 struct objfile
*objfile
;
3491 /* Were we given an osect to look up? NULL means do all of them. */
3493 /* Have we got a cached copy of the target's overlay table? */
3494 if (cache_ovly_table
!= NULL
)
3495 /* Does its cached location match what's currently in the symtab? */
3496 if (cache_ovly_table_base
==
3497 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3498 /* Then go ahead and try to look up this single section in the cache */
3499 if (simple_overlay_update_1 (osect
))
3500 /* Found it! We're done. */
3503 /* Cached table no good: need to read the entire table anew.
3504 Or else we want all the sections, in which case it's actually
3505 more efficient to read the whole table in one block anyway. */
3507 if (! simple_read_overlay_table ())
3510 /* Now may as well update all sections, even if only one was requested. */
3511 ALL_OBJSECTIONS (objfile
, osect
)
3512 if (section_is_overlay (osect
->the_bfd_section
))
3515 bfd
*obfd
= osect
->objfile
->obfd
;
3516 asection
*bsect
= osect
->the_bfd_section
;
3518 size
= bfd_get_section_size (bsect
);
3519 for (i
= 0; i
< cache_novlys
; i
++)
3520 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3521 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3522 /* && cache_ovly_table[i][SIZE] == size */ )
3523 { /* obj_section matches i'th entry in ovly_table */
3524 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3525 break; /* finished with inner for loop: break out */
3530 /* Set the output sections and output offsets for section SECTP in
3531 ABFD. The relocation code in BFD will read these offsets, so we
3532 need to be sure they're initialized. We map each section to itself,
3533 with no offset; this means that SECTP->vma will be honored. */
3536 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3538 sectp
->output_section
= sectp
;
3539 sectp
->output_offset
= 0;
3542 /* Relocate the contents of a debug section SECTP in ABFD. The
3543 contents are stored in BUF if it is non-NULL, or returned in a
3544 malloc'd buffer otherwise.
3546 For some platforms and debug info formats, shared libraries contain
3547 relocations against the debug sections (particularly for DWARF-2;
3548 one affected platform is PowerPC GNU/Linux, although it depends on
3549 the version of the linker in use). Also, ELF object files naturally
3550 have unresolved relocations for their debug sections. We need to apply
3551 the relocations in order to get the locations of symbols correct. */
3554 symfile_relocate_debug_section (bfd
*abfd
, asection
*sectp
, bfd_byte
*buf
)
3556 /* We're only interested in debugging sections with relocation
3558 if ((sectp
->flags
& SEC_RELOC
) == 0)
3560 if ((sectp
->flags
& SEC_DEBUGGING
) == 0)
3563 /* We will handle section offsets properly elsewhere, so relocate as if
3564 all sections begin at 0. */
3565 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3567 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3571 _initialize_symfile (void)
3573 struct cmd_list_element
*c
;
3575 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3576 Load symbol table from executable file FILE.\n\
3577 The `file' command can also load symbol tables, as well as setting the file\n\
3578 to execute."), &cmdlist
);
3579 set_cmd_completer (c
, filename_completer
);
3581 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3582 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3583 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
3584 ADDR is the starting address of the file's text.\n\
3585 The optional arguments are section-name section-address pairs and\n\
3586 should be specified if the data and bss segments are not contiguous\n\
3587 with the text. SECT is a section name to be loaded at SECT_ADDR."),
3589 set_cmd_completer (c
, filename_completer
);
3591 c
= add_cmd ("add-shared-symbol-files", class_files
,
3592 add_shared_symbol_files_command
, _("\
3593 Load the symbols from shared objects in the dynamic linker's link map."),
3595 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
3598 c
= add_cmd ("load", class_files
, load_command
, _("\
3599 Dynamically load FILE into the running program, and record its symbols\n\
3600 for access from GDB."), &cmdlist
);
3601 set_cmd_completer (c
, filename_completer
);
3603 add_setshow_boolean_cmd ("symbol-reloading", class_support
,
3604 &symbol_reloading
, _("\
3605 Set dynamic symbol table reloading multiple times in one run."), _("\
3606 Show dynamic symbol table reloading multiple times in one run."), NULL
,
3608 show_symbol_reloading
,
3609 &setlist
, &showlist
);
3611 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3612 _("Commands for debugging overlays."), &overlaylist
,
3613 "overlay ", 0, &cmdlist
);
3615 add_com_alias ("ovly", "overlay", class_alias
, 1);
3616 add_com_alias ("ov", "overlay", class_alias
, 1);
3618 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3619 _("Assert that an overlay section is mapped."), &overlaylist
);
3621 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3622 _("Assert that an overlay section is unmapped."), &overlaylist
);
3624 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3625 _("List mappings of overlay sections."), &overlaylist
);
3627 add_cmd ("manual", class_support
, overlay_manual_command
,
3628 _("Enable overlay debugging."), &overlaylist
);
3629 add_cmd ("off", class_support
, overlay_off_command
,
3630 _("Disable overlay debugging."), &overlaylist
);
3631 add_cmd ("auto", class_support
, overlay_auto_command
,
3632 _("Enable automatic overlay debugging."), &overlaylist
);
3633 add_cmd ("load-target", class_support
, overlay_load_command
,
3634 _("Read the overlay mapping state from the target."), &overlaylist
);
3636 /* Filename extension to source language lookup table: */
3637 init_filename_language_table ();
3638 add_setshow_string_noescape_cmd ("extension-language", class_files
,
3640 Set mapping between filename extension and source language."), _("\
3641 Show mapping between filename extension and source language."), _("\
3642 Usage: set extension-language .foo bar"),
3643 set_ext_lang_command
,
3645 &setlist
, &showlist
);
3647 add_info ("extensions", info_ext_lang_command
,
3648 _("All filename extensions associated with a source language."));
3650 add_setshow_integer_cmd ("download-write-size", class_obscure
,
3651 &download_write_size
, _("\
3652 Set the write size used when downloading a program."), _("\
3653 Show the write size used when downloading a program."), _("\
3654 Only used when downloading a program onto a remote\n\
3655 target. Specify zero, or a negative value, to disable\n\
3656 blocked writes. The actual size of each transfer is also\n\
3657 limited by the size of the target packet and the memory\n\
3660 show_download_write_size
,
3661 &setlist
, &showlist
);
3663 debug_file_directory
= xstrdup (DEBUGDIR
);
3664 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
3665 &debug_file_directory
, _("\
3666 Set the directory where separate debug symbols are searched for."), _("\
3667 Show the directory where separate debug symbols are searched for."), _("\
3668 Separate debug symbols are first searched for in the same\n\
3669 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
3670 and lastly at the path of the directory of the binary with\n\
3671 the global debug-file directory prepended."),
3673 show_debug_file_directory
,
3674 &setlist
, &showlist
);