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). */
1168 /* Note: ezannoni 2000-04-17. This function used to have support for
1169 rombug (see remote-os9k.c). It consisted of a call to target_link()
1170 (target.c) to get the address of the text segment from the target,
1171 and pass that to symbol_file_add(). This is no longer supported. */
1174 symbol_file_command (char *args
, int from_tty
)
1178 struct cleanup
*cleanups
;
1179 int flags
= OBJF_USERLOADED
;
1185 symbol_file_clear (from_tty
);
1189 if ((argv
= buildargv (args
)) == NULL
)
1193 cleanups
= make_cleanup_freeargv (argv
);
1194 while (*argv
!= NULL
)
1196 if (strcmp (*argv
, "-readnow") == 0)
1197 flags
|= OBJF_READNOW
;
1198 else if (**argv
== '-')
1199 error (_("unknown option `%s'"), *argv
);
1204 symbol_file_add_main_1 (name
, from_tty
, flags
);
1211 error (_("no symbol file name was specified"));
1213 do_cleanups (cleanups
);
1217 /* Set the initial language.
1219 A better solution would be to record the language in the psymtab when reading
1220 partial symbols, and then use it (if known) to set the language. This would
1221 be a win for formats that encode the language in an easily discoverable place,
1222 such as DWARF. For stabs, we can jump through hoops looking for specially
1223 named symbols or try to intuit the language from the specific type of stabs
1224 we find, but we can't do that until later when we read in full symbols.
1228 set_initial_language (void)
1230 struct partial_symtab
*pst
;
1231 enum language lang
= language_unknown
;
1233 pst
= find_main_psymtab ();
1236 if (pst
->filename
!= NULL
)
1238 lang
= deduce_language_from_filename (pst
->filename
);
1240 if (lang
== language_unknown
)
1242 /* Make C the default language */
1245 set_language (lang
);
1246 expected_language
= current_language
; /* Don't warn the user */
1250 /* Open file specified by NAME and hand it off to BFD for preliminary
1251 analysis. Result is a newly initialized bfd *, which includes a newly
1252 malloc'd` copy of NAME (tilde-expanded and made absolute).
1253 In case of trouble, error() is called. */
1256 symfile_bfd_open (char *name
)
1260 char *absolute_name
;
1264 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
1266 /* Look down path for it, allocate 2nd new malloc'd copy. */
1267 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, name
, O_RDONLY
| O_BINARY
,
1269 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1272 char *exename
= alloca (strlen (name
) + 5);
1273 strcat (strcpy (exename
, name
), ".exe");
1274 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
1275 O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1280 make_cleanup (xfree
, name
);
1281 perror_with_name (name
);
1283 xfree (name
); /* Free 1st new malloc'd copy */
1284 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
1285 /* It'll be freed in free_objfile(). */
1287 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
1291 make_cleanup (xfree
, name
);
1292 error (_("\"%s\": can't open to read symbols: %s."), name
,
1293 bfd_errmsg (bfd_get_error ()));
1295 bfd_set_cacheable (sym_bfd
, 1);
1297 if (!bfd_check_format (sym_bfd
, bfd_object
))
1299 /* FIXME: should be checking for errors from bfd_close (for one thing,
1300 on error it does not free all the storage associated with the
1302 bfd_close (sym_bfd
); /* This also closes desc */
1303 make_cleanup (xfree
, name
);
1304 error (_("\"%s\": can't read symbols: %s."), name
,
1305 bfd_errmsg (bfd_get_error ()));
1310 /* Return the section index for the given section name. Return -1 if
1311 the section was not found. */
1313 get_section_index (struct objfile
*objfile
, char *section_name
)
1315 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1322 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
1323 startup by the _initialize routine in each object file format reader,
1324 to register information about each format the the reader is prepared
1328 add_symtab_fns (struct sym_fns
*sf
)
1330 sf
->next
= symtab_fns
;
1335 /* Initialize to read symbols from the symbol file sym_bfd. It either
1336 returns or calls error(). The result is an initialized struct sym_fns
1337 in the objfile structure, that contains cached information about the
1341 find_sym_fns (struct objfile
*objfile
)
1344 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
->obfd
);
1345 char *our_target
= bfd_get_target (objfile
->obfd
);
1347 if (our_flavour
== bfd_target_srec_flavour
1348 || our_flavour
== bfd_target_ihex_flavour
1349 || our_flavour
== bfd_target_tekhex_flavour
)
1350 return; /* No symbols. */
1352 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1354 if (our_flavour
== sf
->sym_flavour
)
1360 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1361 bfd_get_target (objfile
->obfd
));
1364 /* This function runs the load command of our current target. */
1367 load_command (char *arg
, int from_tty
)
1370 arg
= get_exec_file (1);
1371 target_load (arg
, from_tty
);
1373 /* After re-loading the executable, we don't really know which
1374 overlays are mapped any more. */
1375 overlay_cache_invalid
= 1;
1378 /* This version of "load" should be usable for any target. Currently
1379 it is just used for remote targets, not inftarg.c or core files,
1380 on the theory that only in that case is it useful.
1382 Avoiding xmodem and the like seems like a win (a) because we don't have
1383 to worry about finding it, and (b) On VMS, fork() is very slow and so
1384 we don't want to run a subprocess. On the other hand, I'm not sure how
1385 performance compares. */
1387 static int download_write_size
= 512;
1389 show_download_write_size (struct ui_file
*file
, int from_tty
,
1390 struct cmd_list_element
*c
, const char *value
)
1392 fprintf_filtered (file
, _("\
1393 The write size used when downloading a program is %s.\n"),
1396 static int validate_download
= 0;
1398 /* Callback service function for generic_load (bfd_map_over_sections). */
1401 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1403 bfd_size_type
*sum
= data
;
1405 *sum
+= bfd_get_section_size (asec
);
1408 /* Opaque data for load_section_callback. */
1409 struct load_section_data
{
1410 unsigned long load_offset
;
1411 unsigned long write_count
;
1412 unsigned long data_count
;
1413 bfd_size_type total_size
;
1416 /* Callback service function for generic_load (bfd_map_over_sections). */
1419 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1421 struct load_section_data
*args
= data
;
1423 if (bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
)
1425 bfd_size_type size
= bfd_get_section_size (asec
);
1429 struct cleanup
*old_chain
;
1430 CORE_ADDR lma
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1431 bfd_size_type block_size
;
1433 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1436 if (download_write_size
> 0 && size
> download_write_size
)
1437 block_size
= download_write_size
;
1441 buffer
= xmalloc (size
);
1442 old_chain
= make_cleanup (xfree
, buffer
);
1444 /* Is this really necessary? I guess it gives the user something
1445 to look at during a long download. */
1446 ui_out_message (uiout
, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1447 sect_name
, paddr_nz (size
), paddr_nz (lma
));
1449 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1455 bfd_size_type this_transfer
= size
- sent
;
1457 if (this_transfer
>= block_size
)
1458 this_transfer
= block_size
;
1459 len
= target_write_memory_partial (lma
, buffer
,
1460 this_transfer
, &err
);
1463 if (validate_download
)
1465 /* Broken memories and broken monitors manifest
1466 themselves here when bring new computers to
1467 life. This doubles already slow downloads. */
1468 /* NOTE: cagney/1999-10-18: A more efficient
1469 implementation might add a verify_memory()
1470 method to the target vector and then use
1471 that. remote.c could implement that method
1472 using the ``qCRC'' packet. */
1473 char *check
= xmalloc (len
);
1474 struct cleanup
*verify_cleanups
=
1475 make_cleanup (xfree
, check
);
1477 if (target_read_memory (lma
, check
, len
) != 0)
1478 error (_("Download verify read failed at 0x%s"),
1480 if (memcmp (buffer
, check
, len
) != 0)
1481 error (_("Download verify compare failed at 0x%s"),
1483 do_cleanups (verify_cleanups
);
1485 args
->data_count
+= len
;
1488 args
->write_count
+= 1;
1491 || (deprecated_ui_load_progress_hook
!= NULL
1492 && deprecated_ui_load_progress_hook (sect_name
, sent
)))
1493 error (_("Canceled the download"));
1495 if (deprecated_show_load_progress
!= NULL
)
1496 deprecated_show_load_progress (sect_name
, sent
, size
,
1500 while (sent
< size
);
1503 error (_("Memory access error while loading section %s."), sect_name
);
1505 do_cleanups (old_chain
);
1511 generic_load (char *args
, int from_tty
)
1515 time_t start_time
, end_time
; /* Start and end times of download */
1517 struct cleanup
*old_cleanups
;
1519 struct load_section_data cbdata
;
1522 cbdata
.load_offset
= 0; /* Offset to add to vma for each section. */
1523 cbdata
.write_count
= 0; /* Number of writes needed. */
1524 cbdata
.data_count
= 0; /* Number of bytes written to target memory. */
1525 cbdata
.total_size
= 0; /* Total size of all bfd sectors. */
1527 /* Parse the input argument - the user can specify a load offset as
1528 a second argument. */
1529 filename
= xmalloc (strlen (args
) + 1);
1530 old_cleanups
= make_cleanup (xfree
, filename
);
1531 strcpy (filename
, args
);
1532 offptr
= strchr (filename
, ' ');
1537 cbdata
.load_offset
= strtoul (offptr
, &endptr
, 0);
1538 if (offptr
== endptr
)
1539 error (_("Invalid download offset:%s."), offptr
);
1543 cbdata
.load_offset
= 0;
1545 /* Open the file for loading. */
1546 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1547 if (loadfile_bfd
== NULL
)
1549 perror_with_name (filename
);
1553 /* FIXME: should be checking for errors from bfd_close (for one thing,
1554 on error it does not free all the storage associated with the
1556 make_cleanup_bfd_close (loadfile_bfd
);
1558 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1560 error (_("\"%s\" is not an object file: %s"), filename
,
1561 bfd_errmsg (bfd_get_error ()));
1564 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1565 (void *) &cbdata
.total_size
);
1567 start_time
= time (NULL
);
1569 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1571 end_time
= time (NULL
);
1573 entry
= bfd_get_start_address (loadfile_bfd
);
1574 ui_out_text (uiout
, "Start address ");
1575 ui_out_field_fmt (uiout
, "address", "0x%s", paddr_nz (entry
));
1576 ui_out_text (uiout
, ", load size ");
1577 ui_out_field_fmt (uiout
, "load-size", "%lu", cbdata
.data_count
);
1578 ui_out_text (uiout
, "\n");
1579 /* We were doing this in remote-mips.c, I suspect it is right
1580 for other targets too. */
1583 /* FIXME: are we supposed to call symbol_file_add or not? According
1584 to a comment from remote-mips.c (where a call to symbol_file_add
1585 was commented out), making the call confuses GDB if more than one
1586 file is loaded in. Some targets do (e.g., remote-vx.c) but
1587 others don't (or didn't - perhaps they have all been deleted). */
1589 print_transfer_performance (gdb_stdout
, cbdata
.data_count
,
1590 cbdata
.write_count
, end_time
- start_time
);
1592 do_cleanups (old_cleanups
);
1595 /* Report how fast the transfer went. */
1597 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1598 replaced by print_transfer_performance (with a very different
1599 function signature). */
1602 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1605 print_transfer_performance (gdb_stdout
, data_count
,
1606 end_time
- start_time
, 0);
1610 print_transfer_performance (struct ui_file
*stream
,
1611 unsigned long data_count
,
1612 unsigned long write_count
,
1613 unsigned long time_count
)
1615 ui_out_text (uiout
, "Transfer rate: ");
1618 ui_out_field_fmt (uiout
, "transfer-rate", "%lu",
1619 (data_count
* 8) / time_count
);
1620 ui_out_text (uiout
, " bits/sec");
1624 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
1625 ui_out_text (uiout
, " bits in <1 sec");
1627 if (write_count
> 0)
1629 ui_out_text (uiout
, ", ");
1630 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
1631 ui_out_text (uiout
, " bytes/write");
1633 ui_out_text (uiout
, ".\n");
1636 /* This function allows the addition of incrementally linked object files.
1637 It does not modify any state in the target, only in the debugger. */
1638 /* Note: ezannoni 2000-04-13 This function/command used to have a
1639 special case syntax for the rombug target (Rombug is the boot
1640 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1641 rombug case, the user doesn't need to supply a text address,
1642 instead a call to target_link() (in target.c) would supply the
1643 value to use. We are now discontinuing this type of ad hoc syntax. */
1646 add_symbol_file_command (char *args
, int from_tty
)
1648 char *filename
= NULL
;
1649 int flags
= OBJF_USERLOADED
;
1651 int expecting_option
= 0;
1652 int section_index
= 0;
1656 int expecting_sec_name
= 0;
1657 int expecting_sec_addr
= 0;
1665 struct section_addr_info
*section_addrs
;
1666 struct sect_opt
*sect_opts
= NULL
;
1667 size_t num_sect_opts
= 0;
1668 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
1671 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
1672 * sizeof (struct sect_opt
));
1677 error (_("add-symbol-file takes a file name and an address"));
1679 /* Make a copy of the string that we can safely write into. */
1680 args
= xstrdup (args
);
1682 while (*args
!= '\000')
1684 /* Any leading spaces? */
1685 while (isspace (*args
))
1688 /* Point arg to the beginning of the argument. */
1691 /* Move args pointer over the argument. */
1692 while ((*args
!= '\000') && !isspace (*args
))
1695 /* If there are more arguments, terminate arg and
1697 if (*args
!= '\000')
1700 /* Now process the argument. */
1703 /* The first argument is the file name. */
1704 filename
= tilde_expand (arg
);
1705 make_cleanup (xfree
, filename
);
1710 /* The second argument is always the text address at which
1711 to load the program. */
1712 sect_opts
[section_index
].name
= ".text";
1713 sect_opts
[section_index
].value
= arg
;
1714 if (++section_index
> num_sect_opts
)
1717 sect_opts
= ((struct sect_opt
*)
1718 xrealloc (sect_opts
,
1720 * sizeof (struct sect_opt
)));
1725 /* It's an option (starting with '-') or it's an argument
1730 if (strcmp (arg
, "-readnow") == 0)
1731 flags
|= OBJF_READNOW
;
1732 else if (strcmp (arg
, "-s") == 0)
1734 expecting_sec_name
= 1;
1735 expecting_sec_addr
= 1;
1740 if (expecting_sec_name
)
1742 sect_opts
[section_index
].name
= arg
;
1743 expecting_sec_name
= 0;
1746 if (expecting_sec_addr
)
1748 sect_opts
[section_index
].value
= arg
;
1749 expecting_sec_addr
= 0;
1750 if (++section_index
> num_sect_opts
)
1753 sect_opts
= ((struct sect_opt
*)
1754 xrealloc (sect_opts
,
1756 * sizeof (struct sect_opt
)));
1760 error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
1766 /* Print the prompt for the query below. And save the arguments into
1767 a sect_addr_info structure to be passed around to other
1768 functions. We have to split this up into separate print
1769 statements because hex_string returns a local static
1772 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
1773 section_addrs
= alloc_section_addr_info (section_index
);
1774 make_cleanup (xfree
, section_addrs
);
1775 for (i
= 0; i
< section_index
; i
++)
1778 char *val
= sect_opts
[i
].value
;
1779 char *sec
= sect_opts
[i
].name
;
1781 addr
= parse_and_eval_address (val
);
1783 /* Here we store the section offsets in the order they were
1784 entered on the command line. */
1785 section_addrs
->other
[sec_num
].name
= sec
;
1786 section_addrs
->other
[sec_num
].addr
= addr
;
1787 printf_unfiltered ("\t%s_addr = %s\n",
1788 sec
, hex_string ((unsigned long)addr
));
1791 /* The object's sections are initialized when a
1792 call is made to build_objfile_section_table (objfile).
1793 This happens in reread_symbols.
1794 At this point, we don't know what file type this is,
1795 so we can't determine what section names are valid. */
1798 if (from_tty
&& (!query ("%s", "")))
1799 error (_("Not confirmed."));
1801 symbol_file_add (filename
, from_tty
, section_addrs
, 0, flags
);
1803 /* Getting new symbols may change our opinion about what is
1805 reinit_frame_cache ();
1806 do_cleanups (my_cleanups
);
1810 add_shared_symbol_files_command (char *args
, int from_tty
)
1812 #ifdef ADD_SHARED_SYMBOL_FILES
1813 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1815 error (_("This command is not available in this configuration of GDB."));
1819 /* Re-read symbols if a symbol-file has changed. */
1821 reread_symbols (void)
1823 struct objfile
*objfile
;
1826 struct stat new_statbuf
;
1829 /* With the addition of shared libraries, this should be modified,
1830 the load time should be saved in the partial symbol tables, since
1831 different tables may come from different source files. FIXME.
1832 This routine should then walk down each partial symbol table
1833 and see if the symbol table that it originates from has been changed */
1835 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
1839 #ifdef DEPRECATED_IBM6000_TARGET
1840 /* If this object is from a shared library, then you should
1841 stat on the library name, not member name. */
1843 if (objfile
->obfd
->my_archive
)
1844 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1847 res
= stat (objfile
->name
, &new_statbuf
);
1850 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1851 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
1855 new_modtime
= new_statbuf
.st_mtime
;
1856 if (new_modtime
!= objfile
->mtime
)
1858 struct cleanup
*old_cleanups
;
1859 struct section_offsets
*offsets
;
1861 char *obfd_filename
;
1863 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
1866 /* There are various functions like symbol_file_add,
1867 symfile_bfd_open, syms_from_objfile, etc., which might
1868 appear to do what we want. But they have various other
1869 effects which we *don't* want. So we just do stuff
1870 ourselves. We don't worry about mapped files (for one thing,
1871 any mapped file will be out of date). */
1873 /* If we get an error, blow away this objfile (not sure if
1874 that is the correct response for things like shared
1876 old_cleanups
= make_cleanup_free_objfile (objfile
);
1877 /* We need to do this whenever any symbols go away. */
1878 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1880 /* Clean up any state BFD has sitting around. We don't need
1881 to close the descriptor but BFD lacks a way of closing the
1882 BFD without closing the descriptor. */
1883 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1884 if (!bfd_close (objfile
->obfd
))
1885 error (_("Can't close BFD for %s: %s"), objfile
->name
,
1886 bfd_errmsg (bfd_get_error ()));
1887 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1888 if (objfile
->obfd
== NULL
)
1889 error (_("Can't open %s to read symbols."), objfile
->name
);
1890 /* bfd_openr sets cacheable to true, which is what we want. */
1891 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1892 error (_("Can't read symbols from %s: %s."), objfile
->name
,
1893 bfd_errmsg (bfd_get_error ()));
1895 /* Save the offsets, we will nuke them with the rest of the
1897 num_offsets
= objfile
->num_sections
;
1898 offsets
= ((struct section_offsets
*)
1899 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
1900 memcpy (offsets
, objfile
->section_offsets
,
1901 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
1903 /* Nuke all the state that we will re-read. Much of the following
1904 code which sets things to NULL really is necessary to tell
1905 other parts of GDB that there is nothing currently there. */
1907 /* FIXME: Do we have to free a whole linked list, or is this
1909 if (objfile
->global_psymbols
.list
)
1910 xfree (objfile
->global_psymbols
.list
);
1911 memset (&objfile
->global_psymbols
, 0,
1912 sizeof (objfile
->global_psymbols
));
1913 if (objfile
->static_psymbols
.list
)
1914 xfree (objfile
->static_psymbols
.list
);
1915 memset (&objfile
->static_psymbols
, 0,
1916 sizeof (objfile
->static_psymbols
));
1918 /* Free the obstacks for non-reusable objfiles */
1919 bcache_xfree (objfile
->psymbol_cache
);
1920 objfile
->psymbol_cache
= bcache_xmalloc ();
1921 bcache_xfree (objfile
->macro_cache
);
1922 objfile
->macro_cache
= bcache_xmalloc ();
1923 if (objfile
->demangled_names_hash
!= NULL
)
1925 htab_delete (objfile
->demangled_names_hash
);
1926 objfile
->demangled_names_hash
= NULL
;
1928 obstack_free (&objfile
->objfile_obstack
, 0);
1929 objfile
->sections
= NULL
;
1930 objfile
->symtabs
= NULL
;
1931 objfile
->psymtabs
= NULL
;
1932 objfile
->free_psymtabs
= NULL
;
1933 objfile
->cp_namespace_symtab
= NULL
;
1934 objfile
->msymbols
= NULL
;
1935 objfile
->deprecated_sym_private
= NULL
;
1936 objfile
->minimal_symbol_count
= 0;
1937 memset (&objfile
->msymbol_hash
, 0,
1938 sizeof (objfile
->msymbol_hash
));
1939 memset (&objfile
->msymbol_demangled_hash
, 0,
1940 sizeof (objfile
->msymbol_demangled_hash
));
1941 objfile
->fundamental_types
= NULL
;
1942 clear_objfile_data (objfile
);
1943 if (objfile
->sf
!= NULL
)
1945 (*objfile
->sf
->sym_finish
) (objfile
);
1948 /* We never make this a mapped file. */
1950 objfile
->psymbol_cache
= bcache_xmalloc ();
1951 objfile
->macro_cache
= bcache_xmalloc ();
1952 /* obstack_init also initializes the obstack so it is
1953 empty. We could use obstack_specify_allocation but
1954 gdb_obstack.h specifies the alloc/dealloc
1956 obstack_init (&objfile
->objfile_obstack
);
1957 if (build_objfile_section_table (objfile
))
1959 error (_("Can't find the file sections in `%s': %s"),
1960 objfile
->name
, bfd_errmsg (bfd_get_error ()));
1962 terminate_minimal_symbol_table (objfile
);
1964 /* We use the same section offsets as from last time. I'm not
1965 sure whether that is always correct for shared libraries. */
1966 objfile
->section_offsets
= (struct section_offsets
*)
1967 obstack_alloc (&objfile
->objfile_obstack
,
1968 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
1969 memcpy (objfile
->section_offsets
, offsets
,
1970 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
1971 objfile
->num_sections
= num_offsets
;
1973 /* What the hell is sym_new_init for, anyway? The concept of
1974 distinguishing between the main file and additional files
1975 in this way seems rather dubious. */
1976 if (objfile
== symfile_objfile
)
1978 (*objfile
->sf
->sym_new_init
) (objfile
);
1981 (*objfile
->sf
->sym_init
) (objfile
);
1982 clear_complaints (&symfile_complaints
, 1, 1);
1983 /* The "mainline" parameter is a hideous hack; I think leaving it
1984 zero is OK since dbxread.c also does what it needs to do if
1985 objfile->global_psymbols.size is 0. */
1986 (*objfile
->sf
->sym_read
) (objfile
, 0);
1987 if (!have_partial_symbols () && !have_full_symbols ())
1990 printf_unfiltered (_("(no debugging symbols found)\n"));
1993 objfile
->flags
|= OBJF_SYMS
;
1995 /* We're done reading the symbol file; finish off complaints. */
1996 clear_complaints (&symfile_complaints
, 0, 1);
1998 /* Getting new symbols may change our opinion about what is
2001 reinit_frame_cache ();
2003 /* Discard cleanups as symbol reading was successful. */
2004 discard_cleanups (old_cleanups
);
2006 /* If the mtime has changed between the time we set new_modtime
2007 and now, we *want* this to be out of date, so don't call stat
2009 objfile
->mtime
= new_modtime
;
2011 reread_separate_symbols (objfile
);
2018 clear_symtab_users ();
2019 /* At least one objfile has changed, so we can consider that
2020 the executable we're debugging has changed too. */
2021 observer_notify_executable_changed (NULL
);
2027 /* Handle separate debug info for OBJFILE, which has just been
2029 - If we had separate debug info before, but now we don't, get rid
2030 of the separated objfile.
2031 - If we didn't have separated debug info before, but now we do,
2032 read in the new separated debug info file.
2033 - If the debug link points to a different file, toss the old one
2034 and read the new one.
2035 This function does *not* handle the case where objfile is still
2036 using the same separate debug info file, but that file's timestamp
2037 has changed. That case should be handled by the loop in
2038 reread_symbols already. */
2040 reread_separate_symbols (struct objfile
*objfile
)
2043 unsigned long crc32
;
2045 /* Does the updated objfile's debug info live in a
2047 debug_file
= find_separate_debug_file (objfile
);
2049 if (objfile
->separate_debug_objfile
)
2051 /* There are two cases where we need to get rid of
2052 the old separated debug info objfile:
2053 - if the new primary objfile doesn't have
2054 separated debug info, or
2055 - if the new primary objfile has separate debug
2056 info, but it's under a different filename.
2058 If the old and new objfiles both have separate
2059 debug info, under the same filename, then we're
2060 okay --- if the separated file's contents have
2061 changed, we will have caught that when we
2062 visited it in this function's outermost
2065 || strcmp (debug_file
, objfile
->separate_debug_objfile
->name
) != 0)
2066 free_objfile (objfile
->separate_debug_objfile
);
2069 /* If the new objfile has separate debug info, and we
2070 haven't loaded it already, do so now. */
2072 && ! objfile
->separate_debug_objfile
)
2074 /* Use the same section offset table as objfile itself.
2075 Preserve the flags from objfile that make sense. */
2076 objfile
->separate_debug_objfile
2077 = (symbol_file_add_with_addrs_or_offsets
2078 (symfile_bfd_open (debug_file
),
2079 info_verbose
, /* from_tty: Don't override the default. */
2080 0, /* No addr table. */
2081 objfile
->section_offsets
, objfile
->num_sections
,
2082 0, /* Not mainline. See comments about this above. */
2083 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
2084 | OBJF_USERLOADED
)));
2085 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
2101 static filename_language
*filename_language_table
;
2102 static int fl_table_size
, fl_table_next
;
2105 add_filename_language (char *ext
, enum language lang
)
2107 if (fl_table_next
>= fl_table_size
)
2109 fl_table_size
+= 10;
2110 filename_language_table
=
2111 xrealloc (filename_language_table
,
2112 fl_table_size
* sizeof (*filename_language_table
));
2115 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2116 filename_language_table
[fl_table_next
].lang
= lang
;
2120 static char *ext_args
;
2122 show_ext_args (struct ui_file
*file
, int from_tty
,
2123 struct cmd_list_element
*c
, const char *value
)
2125 fprintf_filtered (file
, _("\
2126 Mapping between filename extension and source language is \"%s\".\n"),
2131 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2134 char *cp
= ext_args
;
2137 /* First arg is filename extension, starting with '.' */
2139 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2141 /* Find end of first arg. */
2142 while (*cp
&& !isspace (*cp
))
2146 error (_("'%s': two arguments required -- filename extension and language"),
2149 /* Null-terminate first arg */
2152 /* Find beginning of second arg, which should be a source language. */
2153 while (*cp
&& isspace (*cp
))
2157 error (_("'%s': two arguments required -- filename extension and language"),
2160 /* Lookup the language from among those we know. */
2161 lang
= language_enum (cp
);
2163 /* Now lookup the filename extension: do we already know it? */
2164 for (i
= 0; i
< fl_table_next
; i
++)
2165 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2168 if (i
>= fl_table_next
)
2170 /* new file extension */
2171 add_filename_language (ext_args
, lang
);
2175 /* redefining a previously known filename extension */
2178 /* query ("Really make files of type %s '%s'?", */
2179 /* ext_args, language_str (lang)); */
2181 xfree (filename_language_table
[i
].ext
);
2182 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2183 filename_language_table
[i
].lang
= lang
;
2188 info_ext_lang_command (char *args
, int from_tty
)
2192 printf_filtered (_("Filename extensions and the languages they represent:"));
2193 printf_filtered ("\n\n");
2194 for (i
= 0; i
< fl_table_next
; i
++)
2195 printf_filtered ("\t%s\t- %s\n",
2196 filename_language_table
[i
].ext
,
2197 language_str (filename_language_table
[i
].lang
));
2201 init_filename_language_table (void)
2203 if (fl_table_size
== 0) /* protect against repetition */
2207 filename_language_table
=
2208 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2209 add_filename_language (".c", language_c
);
2210 add_filename_language (".C", language_cplus
);
2211 add_filename_language (".cc", language_cplus
);
2212 add_filename_language (".cp", language_cplus
);
2213 add_filename_language (".cpp", language_cplus
);
2214 add_filename_language (".cxx", language_cplus
);
2215 add_filename_language (".c++", language_cplus
);
2216 add_filename_language (".java", language_java
);
2217 add_filename_language (".class", language_java
);
2218 add_filename_language (".m", language_objc
);
2219 add_filename_language (".f", language_fortran
);
2220 add_filename_language (".F", language_fortran
);
2221 add_filename_language (".s", language_asm
);
2222 add_filename_language (".S", language_asm
);
2223 add_filename_language (".pas", language_pascal
);
2224 add_filename_language (".p", language_pascal
);
2225 add_filename_language (".pp", language_pascal
);
2226 add_filename_language (".adb", language_ada
);
2227 add_filename_language (".ads", language_ada
);
2228 add_filename_language (".a", language_ada
);
2229 add_filename_language (".ada", language_ada
);
2234 deduce_language_from_filename (char *filename
)
2239 if (filename
!= NULL
)
2240 if ((cp
= strrchr (filename
, '.')) != NULL
)
2241 for (i
= 0; i
< fl_table_next
; i
++)
2242 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2243 return filename_language_table
[i
].lang
;
2245 return language_unknown
;
2250 Allocate and partly initialize a new symbol table. Return a pointer
2251 to it. error() if no space.
2253 Caller must set these fields:
2259 possibly free_named_symtabs (symtab->filename);
2263 allocate_symtab (char *filename
, struct objfile
*objfile
)
2265 struct symtab
*symtab
;
2267 symtab
= (struct symtab
*)
2268 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2269 memset (symtab
, 0, sizeof (*symtab
));
2270 symtab
->filename
= obsavestring (filename
, strlen (filename
),
2271 &objfile
->objfile_obstack
);
2272 symtab
->fullname
= NULL
;
2273 symtab
->language
= deduce_language_from_filename (filename
);
2274 symtab
->debugformat
= obsavestring ("unknown", 7,
2275 &objfile
->objfile_obstack
);
2277 /* Hook it to the objfile it comes from */
2279 symtab
->objfile
= objfile
;
2280 symtab
->next
= objfile
->symtabs
;
2281 objfile
->symtabs
= symtab
;
2283 /* FIXME: This should go away. It is only defined for the Z8000,
2284 and the Z8000 definition of this macro doesn't have anything to
2285 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
2286 here for convenience. */
2287 #ifdef INIT_EXTRA_SYMTAB_INFO
2288 INIT_EXTRA_SYMTAB_INFO (symtab
);
2294 struct partial_symtab
*
2295 allocate_psymtab (char *filename
, struct objfile
*objfile
)
2297 struct partial_symtab
*psymtab
;
2299 if (objfile
->free_psymtabs
)
2301 psymtab
= objfile
->free_psymtabs
;
2302 objfile
->free_psymtabs
= psymtab
->next
;
2305 psymtab
= (struct partial_symtab
*)
2306 obstack_alloc (&objfile
->objfile_obstack
,
2307 sizeof (struct partial_symtab
));
2309 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2310 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
2311 &objfile
->objfile_obstack
);
2312 psymtab
->symtab
= NULL
;
2314 /* Prepend it to the psymtab list for the objfile it belongs to.
2315 Psymtabs are searched in most recent inserted -> least recent
2318 psymtab
->objfile
= objfile
;
2319 psymtab
->next
= objfile
->psymtabs
;
2320 objfile
->psymtabs
= psymtab
;
2323 struct partial_symtab
**prev_pst
;
2324 psymtab
->objfile
= objfile
;
2325 psymtab
->next
= NULL
;
2326 prev_pst
= &(objfile
->psymtabs
);
2327 while ((*prev_pst
) != NULL
)
2328 prev_pst
= &((*prev_pst
)->next
);
2329 (*prev_pst
) = psymtab
;
2337 discard_psymtab (struct partial_symtab
*pst
)
2339 struct partial_symtab
**prev_pst
;
2342 Empty psymtabs happen as a result of header files which don't
2343 have any symbols in them. There can be a lot of them. But this
2344 check is wrong, in that a psymtab with N_SLINE entries but
2345 nothing else is not empty, but we don't realize that. Fixing
2346 that without slowing things down might be tricky. */
2348 /* First, snip it out of the psymtab chain */
2350 prev_pst
= &(pst
->objfile
->psymtabs
);
2351 while ((*prev_pst
) != pst
)
2352 prev_pst
= &((*prev_pst
)->next
);
2353 (*prev_pst
) = pst
->next
;
2355 /* Next, put it on a free list for recycling */
2357 pst
->next
= pst
->objfile
->free_psymtabs
;
2358 pst
->objfile
->free_psymtabs
= pst
;
2362 /* Reset all data structures in gdb which may contain references to symbol
2366 clear_symtab_users (void)
2368 /* Someday, we should do better than this, by only blowing away
2369 the things that really need to be blown. */
2370 clear_value_history ();
2372 clear_internalvars ();
2373 breakpoint_re_set ();
2374 set_default_breakpoint (0, 0, 0, 0);
2375 clear_current_source_symtab_and_line ();
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
);