1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support, using pieces from other GDB modules.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "arch-utils.h"
37 #include "breakpoint.h"
39 #include "complaints.h"
43 #include "filenames.h" /* for DOSish file names */
44 #include "gdb-stabs.h"
45 #include "gdb_obstack.h"
46 #include "completer.h"
49 #include "readline/readline.h"
50 #include "gdb_assert.h"
54 #include "parser-defs.h"
60 #include <sys/types.h>
62 #include "gdb_string.h"
69 int (*deprecated_ui_load_progress_hook
) (const char *section
, unsigned long num
);
70 void (*deprecated_show_load_progress
) (const char *section
,
71 unsigned long section_sent
,
72 unsigned long section_size
,
73 unsigned long total_sent
,
74 unsigned long total_size
);
75 void (*deprecated_pre_add_symbol_hook
) (const char *);
76 void (*deprecated_post_add_symbol_hook
) (void);
78 static void clear_symtab_users_cleanup (void *ignore
);
80 /* Global variables owned by this file */
81 int readnow_symbol_files
; /* Read full symbols immediately */
83 /* External variables and functions referenced. */
85 extern void report_transfer_performance (unsigned long, time_t, time_t);
87 /* Functions this file defines */
90 static int simple_read_overlay_region_table (void);
91 static void simple_free_overlay_region_table (void);
94 static void load_command (char *, int);
96 static void symbol_file_add_main_1 (char *args
, int from_tty
, int flags
);
98 static void add_symbol_file_command (char *, int);
100 static void cashier_psymtab (struct partial_symtab
*);
102 bfd
*symfile_bfd_open (char *);
104 int get_section_index (struct objfile
*, char *);
106 static struct sym_fns
*find_sym_fns (bfd
*);
108 static void decrement_reading_symtab (void *);
110 static void overlay_invalidate_all (void);
112 void list_overlays_command (char *, int);
114 void map_overlay_command (char *, int);
116 void unmap_overlay_command (char *, int);
118 static void overlay_auto_command (char *, int);
120 static void overlay_manual_command (char *, int);
122 static void overlay_off_command (char *, int);
124 static void overlay_load_command (char *, int);
126 static void overlay_command (char *, int);
128 static void simple_free_overlay_table (void);
130 static void read_target_long_array (CORE_ADDR
, unsigned int *, int, int,
133 static int simple_read_overlay_table (void);
135 static int simple_overlay_update_1 (struct obj_section
*);
137 static void add_filename_language (char *ext
, enum language lang
);
139 static void info_ext_lang_command (char *args
, int from_tty
);
141 static void init_filename_language_table (void);
143 static void symfile_find_segment_sections (struct objfile
*objfile
);
145 void _initialize_symfile (void);
147 /* List of all available sym_fns. On gdb startup, each object file reader
148 calls add_symtab_fns() to register information on each format it is
151 static struct sym_fns
*symtab_fns
= NULL
;
153 /* Flag for whether user will be reloading symbols multiple times.
154 Defaults to ON for VxWorks, otherwise OFF. */
156 #ifdef SYMBOL_RELOADING_DEFAULT
157 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
159 int symbol_reloading
= 0;
162 show_symbol_reloading (struct ui_file
*file
, int from_tty
,
163 struct cmd_list_element
*c
, const char *value
)
165 fprintf_filtered (file
, _("\
166 Dynamic symbol table reloading multiple times in one run is %s.\n"),
170 /* If non-zero, shared library symbols will be added automatically
171 when the inferior is created, new libraries are loaded, or when
172 attaching to the inferior. This is almost always what users will
173 want to have happen; but for very large programs, the startup time
174 will be excessive, and so if this is a problem, the user can clear
175 this flag and then add the shared library symbols as needed. Note
176 that there is a potential for confusion, since if the shared
177 library symbols are not loaded, commands like "info fun" will *not*
178 report all the functions that are actually present. */
180 int auto_solib_add
= 1;
182 /* For systems that support it, a threshold size in megabytes. If
183 automatically adding a new library's symbol table to those already
184 known to the debugger would cause the total shared library symbol
185 size to exceed this threshhold, then the shlib's symbols are not
186 added. The threshold is ignored if the user explicitly asks for a
187 shlib to be added, such as when using the "sharedlibrary"
190 int auto_solib_limit
;
193 /* This compares two partial symbols by names, using strcmp_iw_ordered
194 for the comparison. */
197 compare_psymbols (const void *s1p
, const void *s2p
)
199 struct partial_symbol
*const *s1
= s1p
;
200 struct partial_symbol
*const *s2
= s2p
;
202 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1
),
203 SYMBOL_SEARCH_NAME (*s2
));
207 sort_pst_symbols (struct partial_symtab
*pst
)
209 /* Sort the global list; don't sort the static list */
211 qsort (pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
,
212 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
216 /* Make a null terminated copy of the string at PTR with SIZE characters in
217 the obstack pointed to by OBSTACKP . Returns the address of the copy.
218 Note that the string at PTR does not have to be null terminated, I.E. it
219 may be part of a larger string and we are only saving a substring. */
222 obsavestring (const char *ptr
, int size
, struct obstack
*obstackp
)
224 char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
225 /* Open-coded memcpy--saves function call time. These strings are usually
226 short. FIXME: Is this really still true with a compiler that can
229 const char *p1
= ptr
;
231 const char *end
= ptr
+ size
;
239 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
240 in the obstack pointed to by OBSTACKP. */
243 obconcat (struct obstack
*obstackp
, const char *s1
, const char *s2
,
246 int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
247 char *val
= (char *) obstack_alloc (obstackp
, len
);
254 /* True if we are nested inside psymtab_to_symtab. */
256 int currently_reading_symtab
= 0;
259 decrement_reading_symtab (void *dummy
)
261 currently_reading_symtab
--;
264 /* Get the symbol table that corresponds to a partial_symtab.
265 This is fast after the first time you do it. In fact, there
266 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
270 psymtab_to_symtab (struct partial_symtab
*pst
)
272 /* If it's been looked up before, return it. */
276 /* If it has not yet been read in, read it. */
279 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
280 currently_reading_symtab
++;
281 (*pst
->read_symtab
) (pst
);
282 do_cleanups (back_to
);
288 /* Remember the lowest-addressed loadable section we've seen.
289 This function is called via bfd_map_over_sections.
291 In case of equal vmas, the section with the largest size becomes the
292 lowest-addressed loadable section.
294 If the vmas and sizes are equal, the last section is considered the
295 lowest-addressed loadable section. */
298 find_lowest_section (bfd
*abfd
, asection
*sect
, void *obj
)
300 asection
**lowest
= (asection
**) obj
;
302 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
305 *lowest
= sect
; /* First loadable section */
306 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
307 *lowest
= sect
; /* A lower loadable section */
308 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
309 && (bfd_section_size (abfd
, (*lowest
))
310 <= bfd_section_size (abfd
, sect
)))
314 /* Create a new section_addr_info, with room for NUM_SECTIONS. */
316 struct section_addr_info
*
317 alloc_section_addr_info (size_t num_sections
)
319 struct section_addr_info
*sap
;
322 size
= (sizeof (struct section_addr_info
)
323 + sizeof (struct other_sections
) * (num_sections
- 1));
324 sap
= (struct section_addr_info
*) xmalloc (size
);
325 memset (sap
, 0, size
);
326 sap
->num_sections
= num_sections
;
332 /* Return a freshly allocated copy of ADDRS. The section names, if
333 any, are also freshly allocated copies of those in ADDRS. */
334 struct section_addr_info
*
335 copy_section_addr_info (struct section_addr_info
*addrs
)
337 struct section_addr_info
*copy
338 = alloc_section_addr_info (addrs
->num_sections
);
341 copy
->num_sections
= addrs
->num_sections
;
342 for (i
= 0; i
< addrs
->num_sections
; i
++)
344 copy
->other
[i
].addr
= addrs
->other
[i
].addr
;
345 if (addrs
->other
[i
].name
)
346 copy
->other
[i
].name
= xstrdup (addrs
->other
[i
].name
);
348 copy
->other
[i
].name
= NULL
;
349 copy
->other
[i
].sectindex
= addrs
->other
[i
].sectindex
;
357 /* Build (allocate and populate) a section_addr_info struct from
358 an existing section table. */
360 extern struct section_addr_info
*
361 build_section_addr_info_from_section_table (const struct target_section
*start
,
362 const struct target_section
*end
)
364 struct section_addr_info
*sap
;
365 const struct target_section
*stp
;
368 sap
= alloc_section_addr_info (end
- start
);
370 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
372 if (bfd_get_section_flags (stp
->bfd
,
373 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
374 && oidx
< end
- start
)
376 sap
->other
[oidx
].addr
= stp
->addr
;
377 sap
->other
[oidx
].name
378 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
379 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
388 /* Free all memory allocated by build_section_addr_info_from_section_table. */
391 free_section_addr_info (struct section_addr_info
*sap
)
395 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
396 if (sap
->other
[idx
].name
)
397 xfree (sap
->other
[idx
].name
);
402 /* Initialize OBJFILE's sect_index_* members. */
404 init_objfile_sect_indices (struct objfile
*objfile
)
409 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
411 objfile
->sect_index_text
= sect
->index
;
413 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
415 objfile
->sect_index_data
= sect
->index
;
417 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
419 objfile
->sect_index_bss
= sect
->index
;
421 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
423 objfile
->sect_index_rodata
= sect
->index
;
425 /* This is where things get really weird... We MUST have valid
426 indices for the various sect_index_* members or gdb will abort.
427 So if for example, there is no ".text" section, we have to
428 accomodate that. First, check for a file with the standard
429 one or two segments. */
431 symfile_find_segment_sections (objfile
);
433 /* Except when explicitly adding symbol files at some address,
434 section_offsets contains nothing but zeros, so it doesn't matter
435 which slot in section_offsets the individual sect_index_* members
436 index into. So if they are all zero, it is safe to just point
437 all the currently uninitialized indices to the first slot. But
438 beware: if this is the main executable, it may be relocated
439 later, e.g. by the remote qOffsets packet, and then this will
440 be wrong! That's why we try segments first. */
442 for (i
= 0; i
< objfile
->num_sections
; i
++)
444 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
449 if (i
== objfile
->num_sections
)
451 if (objfile
->sect_index_text
== -1)
452 objfile
->sect_index_text
= 0;
453 if (objfile
->sect_index_data
== -1)
454 objfile
->sect_index_data
= 0;
455 if (objfile
->sect_index_bss
== -1)
456 objfile
->sect_index_bss
= 0;
457 if (objfile
->sect_index_rodata
== -1)
458 objfile
->sect_index_rodata
= 0;
462 /* The arguments to place_section. */
464 struct place_section_arg
466 struct section_offsets
*offsets
;
470 /* Find a unique offset to use for loadable section SECT if
471 the user did not provide an offset. */
474 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
476 struct place_section_arg
*arg
= obj
;
477 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
479 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
481 /* We are only interested in allocated sections. */
482 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
485 /* If the user specified an offset, honor it. */
486 if (offsets
[sect
->index
] != 0)
489 /* Otherwise, let's try to find a place for the section. */
490 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
497 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
499 int indx
= cur_sec
->index
;
500 CORE_ADDR cur_offset
;
502 /* We don't need to compare against ourself. */
506 /* We can only conflict with allocated sections. */
507 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
510 /* If the section offset is 0, either the section has not been placed
511 yet, or it was the lowest section placed (in which case LOWEST
512 will be past its end). */
513 if (offsets
[indx
] == 0)
516 /* If this section would overlap us, then we must move up. */
517 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
518 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
520 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
521 start_addr
= (start_addr
+ align
- 1) & -align
;
526 /* Otherwise, we appear to be OK. So far. */
531 offsets
[sect
->index
] = start_addr
;
532 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
535 /* Parse the user's idea of an offset for dynamic linking, into our idea
536 of how to represent it for fast symbol reading. This is the default
537 version of the sym_fns.sym_offsets function for symbol readers that
538 don't need to do anything special. It allocates a section_offsets table
539 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
542 default_symfile_offsets (struct objfile
*objfile
,
543 struct section_addr_info
*addrs
)
547 objfile
->num_sections
= bfd_count_sections (objfile
->obfd
);
548 objfile
->section_offsets
= (struct section_offsets
*)
549 obstack_alloc (&objfile
->objfile_obstack
,
550 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
551 memset (objfile
->section_offsets
, 0,
552 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
554 /* Now calculate offsets for section that were specified by the
556 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
558 struct other_sections
*osp
;
560 osp
= &addrs
->other
[i
] ;
564 /* Record all sections in offsets */
565 /* The section_offsets in the objfile are here filled in using
567 (objfile
->section_offsets
)->offsets
[osp
->sectindex
] = osp
->addr
;
570 /* For relocatable files, all loadable sections will start at zero.
571 The zero is meaningless, so try to pick arbitrary addresses such
572 that no loadable sections overlap. This algorithm is quadratic,
573 but the number of sections in a single object file is generally
575 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
577 struct place_section_arg arg
;
578 bfd
*abfd
= objfile
->obfd
;
580 CORE_ADDR lowest
= 0;
582 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
583 /* We do not expect this to happen; just skip this step if the
584 relocatable file has a section with an assigned VMA. */
585 if (bfd_section_vma (abfd
, cur_sec
) != 0)
590 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
592 /* Pick non-overlapping offsets for sections the user did not
594 arg
.offsets
= objfile
->section_offsets
;
596 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
598 /* Correctly filling in the section offsets is not quite
599 enough. Relocatable files have two properties that
600 (most) shared objects do not:
602 - Their debug information will contain relocations. Some
603 shared libraries do also, but many do not, so this can not
606 - If there are multiple code sections they will be loaded
607 at different relative addresses in memory than they are
608 in the objfile, since all sections in the file will start
611 Because GDB has very limited ability to map from an
612 address in debug info to the correct code section,
613 it relies on adding SECT_OFF_TEXT to things which might be
614 code. If we clear all the section offsets, and set the
615 section VMAs instead, then symfile_relocate_debug_section
616 will return meaningful debug information pointing at the
619 GDB has too many different data structures for section
620 addresses - a bfd, objfile, and so_list all have section
621 tables, as does exec_ops. Some of these could probably
624 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
625 cur_sec
= cur_sec
->next
)
627 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
630 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
631 exec_set_section_address (bfd_get_filename (abfd
), cur_sec
->index
,
632 offsets
[cur_sec
->index
]);
633 offsets
[cur_sec
->index
] = 0;
638 /* Remember the bfd indexes for the .text, .data, .bss and
640 init_objfile_sect_indices (objfile
);
644 /* Divide the file into segments, which are individual relocatable units.
645 This is the default version of the sym_fns.sym_segments function for
646 symbol readers that do not have an explicit representation of segments.
647 It assumes that object files do not have segments, and fully linked
648 files have a single segment. */
650 struct symfile_segment_data
*
651 default_symfile_segments (bfd
*abfd
)
655 struct symfile_segment_data
*data
;
658 /* Relocatable files contain enough information to position each
659 loadable section independently; they should not be relocated
661 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
664 /* Make sure there is at least one loadable section in the file. */
665 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
667 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
675 low
= bfd_get_section_vma (abfd
, sect
);
676 high
= low
+ bfd_get_section_size (sect
);
678 data
= XZALLOC (struct symfile_segment_data
);
679 data
->num_segments
= 1;
680 data
->segment_bases
= XCALLOC (1, CORE_ADDR
);
681 data
->segment_sizes
= XCALLOC (1, CORE_ADDR
);
683 num_sections
= bfd_count_sections (abfd
);
684 data
->segment_info
= XCALLOC (num_sections
, int);
686 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
690 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
693 vma
= bfd_get_section_vma (abfd
, sect
);
696 if (vma
+ bfd_get_section_size (sect
) > high
)
697 high
= vma
+ bfd_get_section_size (sect
);
699 data
->segment_info
[i
] = 1;
702 data
->segment_bases
[0] = low
;
703 data
->segment_sizes
[0] = high
- low
;
708 /* Process a symbol file, as either the main file or as a dynamically
711 OBJFILE is where the symbols are to be read from.
713 ADDRS is the list of section load addresses. If the user has given
714 an 'add-symbol-file' command, then this is the list of offsets and
715 addresses he or she provided as arguments to the command; or, if
716 we're handling a shared library, these are the actual addresses the
717 sections are loaded at, according to the inferior's dynamic linker
718 (as gleaned by GDB's shared library code). We convert each address
719 into an offset from the section VMA's as it appears in the object
720 file, and then call the file's sym_offsets function to convert this
721 into a format-specific offset table --- a `struct section_offsets'.
722 If ADDRS is non-zero, OFFSETS must be zero.
724 OFFSETS is a table of section offsets already in the right
725 format-specific representation. NUM_OFFSETS is the number of
726 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
727 assume this is the proper table the call to sym_offsets described
728 above would produce. Instead of calling sym_offsets, we just dump
729 it right into objfile->section_offsets. (When we're re-reading
730 symbols from an objfile, we don't have the original load address
731 list any more; all we have is the section offset table.) If
732 OFFSETS is non-zero, ADDRS must be zero.
734 ADD_FLAGS encodes verbosity level, whether this is main symbol or
735 an extra symbol file such as dynamically loaded code, and wether
736 breakpoint reset should be deferred. */
739 syms_from_objfile (struct objfile
*objfile
,
740 struct section_addr_info
*addrs
,
741 struct section_offsets
*offsets
,
745 struct section_addr_info
*local_addr
= NULL
;
746 struct cleanup
*old_chain
;
747 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
749 gdb_assert (! (addrs
&& offsets
));
751 init_entry_point_info (objfile
);
752 objfile
->sf
= find_sym_fns (objfile
->obfd
);
754 if (objfile
->sf
== NULL
)
755 return; /* No symbols. */
757 /* Make sure that partially constructed symbol tables will be cleaned up
758 if an error occurs during symbol reading. */
759 old_chain
= make_cleanup_free_objfile (objfile
);
761 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
762 list. We now establish the convention that an addr of zero means
763 no load address was specified. */
764 if (! addrs
&& ! offsets
)
767 = alloc_section_addr_info (bfd_count_sections (objfile
->obfd
));
768 make_cleanup (xfree
, local_addr
);
772 /* Now either addrs or offsets is non-zero. */
776 /* We will modify the main symbol table, make sure that all its users
777 will be cleaned up if an error occurs during symbol reading. */
778 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
780 /* Since no error yet, throw away the old symbol table. */
782 if (symfile_objfile
!= NULL
)
784 free_objfile (symfile_objfile
);
785 gdb_assert (symfile_objfile
== NULL
);
788 /* Currently we keep symbols from the add-symbol-file command.
789 If the user wants to get rid of them, they should do "symbol-file"
790 without arguments first. Not sure this is the best behavior
793 (*objfile
->sf
->sym_new_init
) (objfile
);
796 /* Convert addr into an offset rather than an absolute address.
797 We find the lowest address of a loaded segment in the objfile,
798 and assume that <addr> is where that got loaded.
800 We no longer warn if the lowest section is not a text segment (as
801 happens for the PA64 port. */
802 if (!mainline
&& addrs
&& addrs
->other
[0].name
)
804 asection
*lower_sect
;
806 CORE_ADDR lower_offset
;
809 /* Find lowest loadable section to be used as starting point for
810 continguous sections. FIXME!! won't work without call to find
811 .text first, but this assumes text is lowest section. */
812 lower_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
813 if (lower_sect
== NULL
)
814 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
816 if (lower_sect
== NULL
)
818 warning (_("no loadable sections found in added symbol-file %s"),
823 lower_offset
= bfd_section_vma (objfile
->obfd
, lower_sect
);
825 /* Calculate offsets for the loadable sections.
826 FIXME! Sections must be in order of increasing loadable section
827 so that contiguous sections can use the lower-offset!!!
829 Adjust offsets if the segments are not contiguous.
830 If the section is contiguous, its offset should be set to
831 the offset of the highest loadable section lower than it
832 (the loadable section directly below it in memory).
833 this_offset = lower_offset = lower_addr - lower_orig_addr */
835 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
837 if (addrs
->other
[i
].addr
!= 0)
839 sect
= bfd_get_section_by_name (objfile
->obfd
,
840 addrs
->other
[i
].name
);
844 -= bfd_section_vma (objfile
->obfd
, sect
);
845 lower_offset
= addrs
->other
[i
].addr
;
846 /* This is the index used by BFD. */
847 addrs
->other
[i
].sectindex
= sect
->index
;
851 warning (_("section %s not found in %s"),
852 addrs
->other
[i
].name
,
854 addrs
->other
[i
].addr
= 0;
858 addrs
->other
[i
].addr
= lower_offset
;
862 /* Initialize symbol reading routines for this objfile, allow complaints to
863 appear for this new file, and record how verbose to be, then do the
864 initial symbol reading for this file. */
866 (*objfile
->sf
->sym_init
) (objfile
);
867 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
870 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
873 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
875 /* Just copy in the offset table directly as given to us. */
876 objfile
->num_sections
= num_offsets
;
877 objfile
->section_offsets
878 = ((struct section_offsets
*)
879 obstack_alloc (&objfile
->objfile_obstack
, size
));
880 memcpy (objfile
->section_offsets
, offsets
, size
);
882 init_objfile_sect_indices (objfile
);
885 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
887 /* Discard cleanups as symbol reading was successful. */
889 discard_cleanups (old_chain
);
893 /* Perform required actions after either reading in the initial
894 symbols for a new objfile, or mapping in the symbols from a reusable
898 new_symfile_objfile (struct objfile
*objfile
, int add_flags
)
901 /* If this is the main symbol file we have to clean up all users of the
902 old main symbol file. Otherwise it is sufficient to fixup all the
903 breakpoints that may have been redefined by this symbol file. */
904 if (add_flags
& SYMFILE_MAINLINE
)
906 /* OK, make it the "real" symbol file. */
907 symfile_objfile
= objfile
;
909 clear_symtab_users ();
911 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
913 breakpoint_re_set ();
916 /* We're done reading the symbol file; finish off complaints. */
917 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
920 /* Process a symbol file, as either the main file or as a dynamically
923 ABFD is a BFD already open on the file, as from symfile_bfd_open.
924 This BFD will be closed on error, and is always consumed by this function.
926 ADD_FLAGS encodes verbosity, whether this is main symbol file or
927 extra, such as dynamically loaded code, and what to do with breakpoins.
929 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
930 syms_from_objfile, above.
931 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
933 Upon success, returns a pointer to the objfile that was added.
934 Upon failure, jumps back to command level (never returns). */
936 static struct objfile
*
937 symbol_file_add_with_addrs_or_offsets (bfd
*abfd
,
939 struct section_addr_info
*addrs
,
940 struct section_offsets
*offsets
,
944 struct objfile
*objfile
;
945 struct partial_symtab
*psymtab
;
946 struct cleanup
*my_cleanups
;
947 const char *name
= bfd_get_filename (abfd
);
948 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
950 my_cleanups
= make_cleanup_bfd_close (abfd
);
952 /* Give user a chance to burp if we'd be
953 interactively wiping out any existing symbols. */
955 if ((have_full_symbols () || have_partial_symbols ())
956 && (add_flags
& SYMFILE_MAINLINE
)
958 && !query (_("Load new symbol table from \"%s\"? "), name
))
959 error (_("Not confirmed."));
961 objfile
= allocate_objfile (abfd
, flags
);
962 discard_cleanups (my_cleanups
);
964 /* We either created a new mapped symbol table, mapped an existing
965 symbol table file which has not had initial symbol reading
966 performed, or need to read an unmapped symbol table. */
967 if (from_tty
|| info_verbose
)
969 if (deprecated_pre_add_symbol_hook
)
970 deprecated_pre_add_symbol_hook (name
);
973 printf_unfiltered (_("Reading symbols from %s..."), name
);
975 gdb_flush (gdb_stdout
);
978 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
981 /* We now have at least a partial symbol table. Check to see if the
982 user requested that all symbols be read on initial access via either
983 the gdb startup command line or on a per symbol file basis. Expand
984 all partial symbol tables for this objfile if so. */
986 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
988 if (from_tty
|| info_verbose
)
990 printf_unfiltered (_("expanding to full symbols..."));
992 gdb_flush (gdb_stdout
);
995 for (psymtab
= objfile
->psymtabs
;
997 psymtab
= psymtab
->next
)
999 psymtab_to_symtab (psymtab
);
1003 if ((from_tty
|| info_verbose
)
1004 && !objfile_has_symbols (objfile
))
1007 printf_unfiltered (_("(no debugging symbols found)..."));
1011 if (from_tty
|| info_verbose
)
1013 if (deprecated_post_add_symbol_hook
)
1014 deprecated_post_add_symbol_hook ();
1016 printf_unfiltered (_("done.\n"));
1019 /* We print some messages regardless of whether 'from_tty ||
1020 info_verbose' is true, so make sure they go out at the right
1022 gdb_flush (gdb_stdout
);
1024 do_cleanups (my_cleanups
);
1026 if (objfile
->sf
== NULL
)
1028 observer_notify_new_objfile (objfile
);
1029 return objfile
; /* No symbols. */
1032 new_symfile_objfile (objfile
, add_flags
);
1034 observer_notify_new_objfile (objfile
);
1036 bfd_cache_close_all ();
1040 /* Add BFD as a separate debug file for OBJFILE. */
1043 symbol_file_add_separate (bfd
*bfd
, int symfile_flags
, struct objfile
*objfile
)
1045 /* Currently only one separate debug objfile is supported. */
1046 gdb_assert (objfile
&& objfile
->separate_debug_objfile
== NULL
);
1048 objfile
->separate_debug_objfile
=
1049 symbol_file_add_with_addrs_or_offsets
1050 (bfd
, symfile_flags
,
1051 0, /* No addr table. */
1052 objfile
->section_offsets
, objfile
->num_sections
,
1053 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1054 | OBJF_USERLOADED
));
1055 objfile
->separate_debug_objfile
->separate_debug_objfile_backlink
1058 /* Put the separate debug object before the normal one, this is so that
1059 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
1060 put_objfile_before (objfile
->separate_debug_objfile
, objfile
);
1063 /* Process the symbol file ABFD, as either the main file or as a
1064 dynamically loaded file.
1066 See symbol_file_add_with_addrs_or_offsets's comments for
1069 symbol_file_add_from_bfd (bfd
*abfd
, int add_flags
,
1070 struct section_addr_info
*addrs
,
1073 return symbol_file_add_with_addrs_or_offsets (abfd
, add_flags
, addrs
, 0, 0,
1078 /* Process a symbol file, as either the main file or as a dynamically
1079 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1082 symbol_file_add (char *name
, int add_flags
, struct section_addr_info
*addrs
,
1085 return symbol_file_add_from_bfd (symfile_bfd_open (name
), add_flags
, addrs
,
1090 /* Call symbol_file_add() with default values and update whatever is
1091 affected by the loading of a new main().
1092 Used when the file is supplied in the gdb command line
1093 and by some targets with special loading requirements.
1094 The auxiliary function, symbol_file_add_main_1(), has the flags
1095 argument for the switches that can only be specified in the symbol_file
1099 symbol_file_add_main (char *args
, int from_tty
)
1101 symbol_file_add_main_1 (args
, from_tty
, 0);
1105 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1107 const int add_flags
= SYMFILE_MAINLINE
| (from_tty
? SYMFILE_VERBOSE
: 0);
1108 symbol_file_add (args
, add_flags
, NULL
, flags
);
1110 /* Getting new symbols may change our opinion about
1111 what is frameless. */
1112 reinit_frame_cache ();
1114 set_initial_language ();
1118 symbol_file_clear (int from_tty
)
1120 if ((have_full_symbols () || have_partial_symbols ())
1123 ? !query (_("Discard symbol table from `%s'? "),
1124 symfile_objfile
->name
)
1125 : !query (_("Discard symbol table? "))))
1126 error (_("Not confirmed."));
1128 free_all_objfiles ();
1130 /* solib descriptors may have handles to objfiles. Since their
1131 storage has just been released, we'd better wipe the solib
1132 descriptors as well. */
1133 no_shared_libraries (NULL
, from_tty
);
1135 gdb_assert (symfile_objfile
== NULL
);
1137 printf_unfiltered (_("No symbol file now.\n"));
1146 /* Locate NT_GNU_BUILD_ID from ABFD and return its content. */
1148 static struct build_id
*
1149 build_id_bfd_get (bfd
*abfd
)
1151 struct build_id
*retval
;
1153 if (!bfd_check_format (abfd
, bfd_object
)
1154 || bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1155 || elf_tdata (abfd
)->build_id
== NULL
)
1158 retval
= xmalloc (sizeof *retval
- 1 + elf_tdata (abfd
)->build_id_size
);
1159 retval
->size
= elf_tdata (abfd
)->build_id_size
;
1160 memcpy (retval
->data
, elf_tdata (abfd
)->build_id
, retval
->size
);
1165 /* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value. */
1168 build_id_verify (const char *filename
, struct build_id
*check
)
1171 struct build_id
*found
= NULL
;
1174 /* We expect to be silent on the non-existing files. */
1175 if (remote_filename_p (filename
))
1176 abfd
= remote_bfd_open (filename
, gnutarget
);
1178 abfd
= bfd_openr (filename
, gnutarget
);
1182 found
= build_id_bfd_get (abfd
);
1185 warning (_("File \"%s\" has no build-id, file skipped"), filename
);
1186 else if (found
->size
!= check
->size
1187 || memcmp (found
->data
, check
->data
, found
->size
) != 0)
1188 warning (_("File \"%s\" has a different build-id, file skipped"), filename
);
1192 if (!bfd_close (abfd
))
1193 warning (_("cannot close \"%s\": %s"), filename
,
1194 bfd_errmsg (bfd_get_error ()));
1202 build_id_to_debug_filename (struct build_id
*build_id
)
1204 char *link
, *debugdir
, *retval
= NULL
;
1206 /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
1207 link
= alloca (strlen (debug_file_directory
) + (sizeof "/.build-id/" - 1) + 1
1208 + 2 * build_id
->size
+ (sizeof ".debug" - 1) + 1);
1210 /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1211 cause "/.build-id/..." lookups. */
1213 debugdir
= debug_file_directory
;
1216 char *s
, *debugdir_end
;
1217 gdb_byte
*data
= build_id
->data
;
1218 size_t size
= build_id
->size
;
1220 while (*debugdir
== DIRNAME_SEPARATOR
)
1223 debugdir_end
= strchr (debugdir
, DIRNAME_SEPARATOR
);
1224 if (debugdir_end
== NULL
)
1225 debugdir_end
= &debugdir
[strlen (debugdir
)];
1227 memcpy (link
, debugdir
, debugdir_end
- debugdir
);
1228 s
= &link
[debugdir_end
- debugdir
];
1229 s
+= sprintf (s
, "/.build-id/");
1233 s
+= sprintf (s
, "%02x", (unsigned) *data
++);
1238 s
+= sprintf (s
, "%02x", (unsigned) *data
++);
1239 strcpy (s
, ".debug");
1241 /* lrealpath() is expensive even for the usually non-existent files. */
1242 if (access (link
, F_OK
) == 0)
1243 retval
= lrealpath (link
);
1245 if (retval
!= NULL
&& !build_id_verify (retval
, build_id
))
1254 debugdir
= debugdir_end
;
1256 while (*debugdir
!= 0);
1262 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1265 bfd_size_type debuglink_size
;
1266 unsigned long crc32
;
1271 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1276 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1278 contents
= xmalloc (debuglink_size
);
1279 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1280 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1282 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1283 crc_offset
= strlen (contents
) + 1;
1284 crc_offset
= (crc_offset
+ 3) & ~3;
1286 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1293 separate_debug_file_exists (const char *name
, unsigned long crc
,
1294 struct objfile
*parent_objfile
)
1296 unsigned long file_crc
= 0;
1298 gdb_byte buffer
[8*1024];
1300 struct stat parent_stat
, abfd_stat
;
1302 /* Find a separate debug info file as if symbols would be present in
1303 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1304 section can contain just the basename of PARENT_OBJFILE without any
1305 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1306 the separate debug infos with the same basename can exist. */
1308 if (strcmp (name
, parent_objfile
->name
) == 0)
1311 if (remote_filename_p (name
))
1312 abfd
= remote_bfd_open (name
, gnutarget
);
1314 abfd
= bfd_openr (name
, gnutarget
);
1319 /* Verify symlinks were not the cause of strcmp name difference above.
1321 Some operating systems, e.g. Windows, do not provide a meaningful
1322 st_ino; they always set it to zero. (Windows does provide a
1323 meaningful st_dev.) Do not indicate a duplicate library in that
1324 case. While there is no guarantee that a system that provides
1325 meaningful inode numbers will never set st_ino to zero, this is
1326 merely an optimization, so we do not need to worry about false
1329 if (bfd_stat (abfd
, &abfd_stat
) == 0
1330 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0
1331 && abfd_stat
.st_dev
== parent_stat
.st_dev
1332 && abfd_stat
.st_ino
== parent_stat
.st_ino
1333 && abfd_stat
.st_ino
!= 0)
1339 while ((count
= bfd_bread (buffer
, sizeof (buffer
), abfd
)) > 0)
1340 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1344 if (crc
!= file_crc
)
1346 warning (_("the debug information found in \"%s\""
1347 " does not match \"%s\" (CRC mismatch).\n"),
1348 name
, parent_objfile
->name
);
1355 char *debug_file_directory
= NULL
;
1357 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1358 struct cmd_list_element
*c
, const char *value
)
1360 fprintf_filtered (file
, _("\
1361 The directory where separate debug symbols are searched for is \"%s\".\n"),
1365 #if ! defined (DEBUG_SUBDIRECTORY)
1366 #define DEBUG_SUBDIRECTORY ".debug"
1370 find_separate_debug_file_by_buildid (struct objfile
*objfile
)
1373 char *basename
, *name_copy
, *debugdir
;
1375 char *debugfile
= NULL
;
1376 char *canon_name
= NULL
;
1377 bfd_size_type debuglink_size
;
1378 unsigned long crc32
;
1380 struct build_id
*build_id
;
1382 build_id
= build_id_bfd_get (objfile
->obfd
);
1383 if (build_id
!= NULL
)
1385 char *build_id_name
;
1387 build_id_name
= build_id_to_debug_filename (build_id
);
1389 /* Prevent looping on a stripped .debug file. */
1390 if (build_id_name
!= NULL
&& strcmp (build_id_name
, objfile
->name
) == 0)
1392 warning (_("\"%s\": separate debug info file has no debug info"),
1394 xfree (build_id_name
);
1396 else if (build_id_name
!= NULL
)
1397 return build_id_name
;
1403 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1406 char *basename
, *name_copy
, *debugdir
;
1408 char *debugfile
= NULL
;
1409 char *canon_name
= NULL
;
1410 bfd_size_type debuglink_size
;
1411 unsigned long crc32
;
1414 basename
= get_debug_link_info (objfile
, &crc32
);
1416 if (basename
== NULL
)
1417 /* There's no separate debug info, hence there's no way we could
1418 load it => no warning. */
1419 goto cleanup_return_debugfile
;
1421 dir
= xstrdup (objfile
->name
);
1423 /* Strip off the final filename part, leaving the directory name,
1424 followed by a slash. Objfile names should always be absolute and
1425 tilde-expanded, so there should always be a slash in there
1427 for (i
= strlen(dir
) - 1; i
>= 0; i
--)
1429 if (IS_DIR_SEPARATOR (dir
[i
]))
1432 gdb_assert (i
>= 0 && IS_DIR_SEPARATOR (dir
[i
]));
1435 /* Set I to max (strlen (canon_name), strlen (dir)). */
1436 canon_name
= lrealpath (dir
);
1438 if (canon_name
&& strlen (canon_name
) > i
)
1439 i
= strlen (canon_name
);
1441 debugfile
= xmalloc (strlen (debug_file_directory
) + 1
1443 + strlen (DEBUG_SUBDIRECTORY
)
1448 /* First try in the same directory as the original file. */
1449 strcpy (debugfile
, dir
);
1450 strcat (debugfile
, basename
);
1452 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1453 goto cleanup_return_debugfile
;
1455 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1456 strcpy (debugfile
, dir
);
1457 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1458 strcat (debugfile
, "/");
1459 strcat (debugfile
, basename
);
1461 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1462 goto cleanup_return_debugfile
;
1464 /* Then try in the global debugfile directories.
1466 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1467 cause "/..." lookups. */
1469 debugdir
= debug_file_directory
;
1474 while (*debugdir
== DIRNAME_SEPARATOR
)
1477 debugdir_end
= strchr (debugdir
, DIRNAME_SEPARATOR
);
1478 if (debugdir_end
== NULL
)
1479 debugdir_end
= &debugdir
[strlen (debugdir
)];
1481 memcpy (debugfile
, debugdir
, debugdir_end
- debugdir
);
1482 debugfile
[debugdir_end
- debugdir
] = 0;
1483 strcat (debugfile
, "/");
1484 strcat (debugfile
, dir
);
1485 strcat (debugfile
, basename
);
1487 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1488 goto cleanup_return_debugfile
;
1490 /* If the file is in the sysroot, try using its base path in the
1491 global debugfile directory. */
1493 && strncmp (canon_name
, gdb_sysroot
, strlen (gdb_sysroot
)) == 0
1494 && IS_DIR_SEPARATOR (canon_name
[strlen (gdb_sysroot
)]))
1496 memcpy (debugfile
, debugdir
, debugdir_end
- debugdir
);
1497 debugfile
[debugdir_end
- debugdir
] = 0;
1498 strcat (debugfile
, canon_name
+ strlen (gdb_sysroot
));
1499 strcat (debugfile
, "/");
1500 strcat (debugfile
, basename
);
1502 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1503 goto cleanup_return_debugfile
;
1506 debugdir
= debugdir_end
;
1508 while (*debugdir
!= 0);
1513 cleanup_return_debugfile
:
1521 /* This is the symbol-file command. Read the file, analyze its
1522 symbols, and add a struct symtab to a symtab list. The syntax of
1523 the command is rather bizarre:
1525 1. The function buildargv implements various quoting conventions
1526 which are undocumented and have little or nothing in common with
1527 the way things are quoted (or not quoted) elsewhere in GDB.
1529 2. Options are used, which are not generally used in GDB (perhaps
1530 "set mapped on", "set readnow on" would be better)
1532 3. The order of options matters, which is contrary to GNU
1533 conventions (because it is confusing and inconvenient). */
1536 symbol_file_command (char *args
, int from_tty
)
1542 symbol_file_clear (from_tty
);
1546 char **argv
= gdb_buildargv (args
);
1547 int flags
= OBJF_USERLOADED
;
1548 struct cleanup
*cleanups
;
1551 cleanups
= make_cleanup_freeargv (argv
);
1552 while (*argv
!= NULL
)
1554 if (strcmp (*argv
, "-readnow") == 0)
1555 flags
|= OBJF_READNOW
;
1556 else if (**argv
== '-')
1557 error (_("unknown option `%s'"), *argv
);
1560 symbol_file_add_main_1 (*argv
, from_tty
, flags
);
1568 error (_("no symbol file name was specified"));
1570 do_cleanups (cleanups
);
1574 /* Set the initial language.
1576 FIXME: A better solution would be to record the language in the
1577 psymtab when reading partial symbols, and then use it (if known) to
1578 set the language. This would be a win for formats that encode the
1579 language in an easily discoverable place, such as DWARF. For
1580 stabs, we can jump through hoops looking for specially named
1581 symbols or try to intuit the language from the specific type of
1582 stabs we find, but we can't do that until later when we read in
1586 set_initial_language (void)
1588 struct partial_symtab
*pst
;
1589 enum language lang
= language_unknown
;
1591 pst
= find_main_psymtab ();
1594 if (pst
->filename
!= NULL
)
1595 lang
= deduce_language_from_filename (pst
->filename
);
1597 if (lang
== language_unknown
)
1599 /* Make C the default language */
1603 set_language (lang
);
1604 expected_language
= current_language
; /* Don't warn the user. */
1608 /* Open the file specified by NAME and hand it off to BFD for
1609 preliminary analysis. Return a newly initialized bfd *, which
1610 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1611 absolute). In case of trouble, error() is called. */
1614 symfile_bfd_open (char *name
)
1618 char *absolute_name
;
1620 if (remote_filename_p (name
))
1622 name
= xstrdup (name
);
1623 sym_bfd
= remote_bfd_open (name
, gnutarget
);
1626 make_cleanup (xfree
, name
);
1627 error (_("`%s': can't open to read symbols: %s."), name
,
1628 bfd_errmsg (bfd_get_error ()));
1631 if (!bfd_check_format (sym_bfd
, bfd_object
))
1633 bfd_close (sym_bfd
);
1634 make_cleanup (xfree
, name
);
1635 error (_("`%s': can't read symbols: %s."), name
,
1636 bfd_errmsg (bfd_get_error ()));
1642 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy. */
1644 /* Look down path for it, allocate 2nd new malloc'd copy. */
1645 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, name
,
1646 O_RDONLY
| O_BINARY
, &absolute_name
);
1647 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1650 char *exename
= alloca (strlen (name
) + 5);
1651 strcat (strcpy (exename
, name
), ".exe");
1652 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
1653 O_RDONLY
| O_BINARY
, &absolute_name
);
1658 make_cleanup (xfree
, name
);
1659 perror_with_name (name
);
1662 /* Free 1st new malloc'd copy, but keep the 2nd malloc'd copy in
1663 bfd. It'll be freed in free_objfile(). */
1665 name
= absolute_name
;
1667 sym_bfd
= bfd_fopen (name
, gnutarget
, FOPEN_RB
, desc
);
1671 make_cleanup (xfree
, name
);
1672 error (_("`%s': can't open to read symbols: %s."), name
,
1673 bfd_errmsg (bfd_get_error ()));
1675 bfd_set_cacheable (sym_bfd
, 1);
1677 if (!bfd_check_format (sym_bfd
, bfd_object
))
1679 /* FIXME: should be checking for errors from bfd_close (for one
1680 thing, on error it does not free all the storage associated
1682 bfd_close (sym_bfd
); /* This also closes desc. */
1683 make_cleanup (xfree
, name
);
1684 error (_("`%s': can't read symbols: %s."), name
,
1685 bfd_errmsg (bfd_get_error ()));
1688 /* bfd_usrdata exists for applications and libbfd must not touch it. */
1689 gdb_assert (bfd_usrdata (sym_bfd
) == NULL
);
1694 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1695 the section was not found. */
1698 get_section_index (struct objfile
*objfile
, char *section_name
)
1700 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1708 /* Link SF into the global symtab_fns list. Called on startup by the
1709 _initialize routine in each object file format reader, to register
1710 information about each format the the reader is prepared to
1714 add_symtab_fns (struct sym_fns
*sf
)
1716 sf
->next
= symtab_fns
;
1720 /* Initialize OBJFILE to read symbols from its associated BFD. It
1721 either returns or calls error(). The result is an initialized
1722 struct sym_fns in the objfile structure, that contains cached
1723 information about the symbol file. */
1725 static struct sym_fns
*
1726 find_sym_fns (bfd
*abfd
)
1729 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1731 if (our_flavour
== bfd_target_srec_flavour
1732 || our_flavour
== bfd_target_ihex_flavour
1733 || our_flavour
== bfd_target_tekhex_flavour
)
1734 return NULL
; /* No symbols. */
1736 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1737 if (our_flavour
== sf
->sym_flavour
)
1740 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1741 bfd_get_target (abfd
));
1745 /* This function runs the load command of our current target. */
1748 load_command (char *arg
, int from_tty
)
1750 /* The user might be reloading because the binary has changed. Take
1751 this opportunity to check. */
1752 reopen_exec_file ();
1760 parg
= arg
= get_exec_file (1);
1762 /* Count how many \ " ' tab space there are in the name. */
1763 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1771 /* We need to quote this string so buildargv can pull it apart. */
1772 char *temp
= xmalloc (strlen (arg
) + count
+ 1 );
1776 make_cleanup (xfree
, temp
);
1779 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1781 strncpy (ptemp
, prev
, parg
- prev
);
1782 ptemp
+= parg
- prev
;
1786 strcpy (ptemp
, prev
);
1792 target_load (arg
, from_tty
);
1794 /* After re-loading the executable, we don't really know which
1795 overlays are mapped any more. */
1796 overlay_cache_invalid
= 1;
1799 /* This version of "load" should be usable for any target. Currently
1800 it is just used for remote targets, not inftarg.c or core files,
1801 on the theory that only in that case is it useful.
1803 Avoiding xmodem and the like seems like a win (a) because we don't have
1804 to worry about finding it, and (b) On VMS, fork() is very slow and so
1805 we don't want to run a subprocess. On the other hand, I'm not sure how
1806 performance compares. */
1808 static int validate_download
= 0;
1810 /* Callback service function for generic_load (bfd_map_over_sections). */
1813 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1815 bfd_size_type
*sum
= data
;
1817 *sum
+= bfd_get_section_size (asec
);
1820 /* Opaque data for load_section_callback. */
1821 struct load_section_data
{
1822 unsigned long load_offset
;
1823 struct load_progress_data
*progress_data
;
1824 VEC(memory_write_request_s
) *requests
;
1827 /* Opaque data for load_progress. */
1828 struct load_progress_data
{
1829 /* Cumulative data. */
1830 unsigned long write_count
;
1831 unsigned long data_count
;
1832 bfd_size_type total_size
;
1835 /* Opaque data for load_progress for a single section. */
1836 struct load_progress_section_data
{
1837 struct load_progress_data
*cumulative
;
1839 /* Per-section data. */
1840 const char *section_name
;
1841 ULONGEST section_sent
;
1842 ULONGEST section_size
;
1847 /* Target write callback routine for progress reporting. */
1850 load_progress (ULONGEST bytes
, void *untyped_arg
)
1852 struct load_progress_section_data
*args
= untyped_arg
;
1853 struct load_progress_data
*totals
;
1856 /* Writing padding data. No easy way to get at the cumulative
1857 stats, so just ignore this. */
1860 totals
= args
->cumulative
;
1862 if (bytes
== 0 && args
->section_sent
== 0)
1864 /* The write is just starting. Let the user know we've started
1866 ui_out_message (uiout
, 0, "Loading section %s, size %s lma %s\n",
1867 args
->section_name
, hex_string (args
->section_size
),
1868 paddress (target_gdbarch
, args
->lma
));
1872 if (validate_download
)
1874 /* Broken memories and broken monitors manifest themselves here
1875 when bring new computers to life. This doubles already slow
1877 /* NOTE: cagney/1999-10-18: A more efficient implementation
1878 might add a verify_memory() method to the target vector and
1879 then use that. remote.c could implement that method using
1880 the ``qCRC'' packet. */
1881 gdb_byte
*check
= xmalloc (bytes
);
1882 struct cleanup
*verify_cleanups
= make_cleanup (xfree
, check
);
1884 if (target_read_memory (args
->lma
, check
, bytes
) != 0)
1885 error (_("Download verify read failed at %s"),
1886 paddress (target_gdbarch
, args
->lma
));
1887 if (memcmp (args
->buffer
, check
, bytes
) != 0)
1888 error (_("Download verify compare failed at %s"),
1889 paddress (target_gdbarch
, args
->lma
));
1890 do_cleanups (verify_cleanups
);
1892 totals
->data_count
+= bytes
;
1894 args
->buffer
+= bytes
;
1895 totals
->write_count
+= 1;
1896 args
->section_sent
+= bytes
;
1898 || (deprecated_ui_load_progress_hook
!= NULL
1899 && deprecated_ui_load_progress_hook (args
->section_name
,
1900 args
->section_sent
)))
1901 error (_("Canceled the download"));
1903 if (deprecated_show_load_progress
!= NULL
)
1904 deprecated_show_load_progress (args
->section_name
,
1908 totals
->total_size
);
1911 /* Callback service function for generic_load (bfd_map_over_sections). */
1914 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1916 struct memory_write_request
*new_request
;
1917 struct load_section_data
*args
= data
;
1918 struct load_progress_section_data
*section_data
;
1919 bfd_size_type size
= bfd_get_section_size (asec
);
1921 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1923 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1929 new_request
= VEC_safe_push (memory_write_request_s
,
1930 args
->requests
, NULL
);
1931 memset (new_request
, 0, sizeof (struct memory_write_request
));
1932 section_data
= xcalloc (1, sizeof (struct load_progress_section_data
));
1933 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1934 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size be in instead? */
1935 new_request
->data
= xmalloc (size
);
1936 new_request
->baton
= section_data
;
1938 buffer
= new_request
->data
;
1940 section_data
->cumulative
= args
->progress_data
;
1941 section_data
->section_name
= sect_name
;
1942 section_data
->section_size
= size
;
1943 section_data
->lma
= new_request
->begin
;
1944 section_data
->buffer
= buffer
;
1946 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1949 /* Clean up an entire memory request vector, including load
1950 data and progress records. */
1953 clear_memory_write_data (void *arg
)
1955 VEC(memory_write_request_s
) **vec_p
= arg
;
1956 VEC(memory_write_request_s
) *vec
= *vec_p
;
1958 struct memory_write_request
*mr
;
1960 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
1965 VEC_free (memory_write_request_s
, vec
);
1969 generic_load (char *args
, int from_tty
)
1972 struct timeval start_time
, end_time
;
1974 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, 0);
1975 struct load_section_data cbdata
;
1976 struct load_progress_data total_progress
;
1981 memset (&cbdata
, 0, sizeof (cbdata
));
1982 memset (&total_progress
, 0, sizeof (total_progress
));
1983 cbdata
.progress_data
= &total_progress
;
1985 make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
1988 error_no_arg (_("file to load"));
1990 argv
= gdb_buildargv (args
);
1991 make_cleanup_freeargv (argv
);
1993 filename
= tilde_expand (argv
[0]);
1994 make_cleanup (xfree
, filename
);
1996 if (argv
[1] != NULL
)
2000 cbdata
.load_offset
= strtoul (argv
[1], &endptr
, 0);
2002 /* If the last word was not a valid number then
2003 treat it as a file name with spaces in. */
2004 if (argv
[1] == endptr
)
2005 error (_("Invalid download offset:%s."), argv
[1]);
2007 if (argv
[2] != NULL
)
2008 error (_("Too many parameters."));
2011 /* Open the file for loading. */
2012 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
2013 if (loadfile_bfd
== NULL
)
2015 perror_with_name (filename
);
2019 /* FIXME: should be checking for errors from bfd_close (for one thing,
2020 on error it does not free all the storage associated with the
2022 make_cleanup_bfd_close (loadfile_bfd
);
2024 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
2026 error (_("\"%s\" is not an object file: %s"), filename
,
2027 bfd_errmsg (bfd_get_error ()));
2030 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
2031 (void *) &total_progress
.total_size
);
2033 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
2035 gettimeofday (&start_time
, NULL
);
2037 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
2038 load_progress
) != 0)
2039 error (_("Load failed"));
2041 gettimeofday (&end_time
, NULL
);
2043 entry
= bfd_get_start_address (loadfile_bfd
);
2044 ui_out_text (uiout
, "Start address ");
2045 ui_out_field_fmt (uiout
, "address", "%s", paddress (target_gdbarch
, entry
));
2046 ui_out_text (uiout
, ", load size ");
2047 ui_out_field_fmt (uiout
, "load-size", "%lu", total_progress
.data_count
);
2048 ui_out_text (uiout
, "\n");
2049 /* We were doing this in remote-mips.c, I suspect it is right
2050 for other targets too. */
2051 regcache_write_pc (get_current_regcache (), entry
);
2053 /* FIXME: are we supposed to call symbol_file_add or not? According
2054 to a comment from remote-mips.c (where a call to symbol_file_add
2055 was commented out), making the call confuses GDB if more than one
2056 file is loaded in. Some targets do (e.g., remote-vx.c) but
2057 others don't (or didn't - perhaps they have all been deleted). */
2059 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
2060 total_progress
.write_count
,
2061 &start_time
, &end_time
);
2063 do_cleanups (old_cleanups
);
2066 /* Report how fast the transfer went. */
2068 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
2069 replaced by print_transfer_performance (with a very different
2070 function signature). */
2073 report_transfer_performance (unsigned long data_count
, time_t start_time
,
2076 struct timeval start
, end
;
2078 start
.tv_sec
= start_time
;
2080 end
.tv_sec
= end_time
;
2083 print_transfer_performance (gdb_stdout
, data_count
, 0, &start
, &end
);
2087 print_transfer_performance (struct ui_file
*stream
,
2088 unsigned long data_count
,
2089 unsigned long write_count
,
2090 const struct timeval
*start_time
,
2091 const struct timeval
*end_time
)
2093 ULONGEST time_count
;
2095 /* Compute the elapsed time in milliseconds, as a tradeoff between
2096 accuracy and overflow. */
2097 time_count
= (end_time
->tv_sec
- start_time
->tv_sec
) * 1000;
2098 time_count
+= (end_time
->tv_usec
- start_time
->tv_usec
) / 1000;
2100 ui_out_text (uiout
, "Transfer rate: ");
2103 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / time_count
;
2105 if (ui_out_is_mi_like_p (uiout
))
2107 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
* 8);
2108 ui_out_text (uiout
, " bits/sec");
2110 else if (rate
< 1024)
2112 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
);
2113 ui_out_text (uiout
, " bytes/sec");
2117 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
/ 1024);
2118 ui_out_text (uiout
, " KB/sec");
2123 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
2124 ui_out_text (uiout
, " bits in <1 sec");
2126 if (write_count
> 0)
2128 ui_out_text (uiout
, ", ");
2129 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
2130 ui_out_text (uiout
, " bytes/write");
2132 ui_out_text (uiout
, ".\n");
2135 /* This function allows the addition of incrementally linked object files.
2136 It does not modify any state in the target, only in the debugger. */
2137 /* Note: ezannoni 2000-04-13 This function/command used to have a
2138 special case syntax for the rombug target (Rombug is the boot
2139 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2140 rombug case, the user doesn't need to supply a text address,
2141 instead a call to target_link() (in target.c) would supply the
2142 value to use. We are now discontinuing this type of ad hoc syntax. */
2145 add_symbol_file_command (char *args
, int from_tty
)
2147 struct gdbarch
*gdbarch
= get_current_arch ();
2148 char *filename
= NULL
;
2149 int flags
= OBJF_USERLOADED
;
2151 int expecting_option
= 0;
2152 int section_index
= 0;
2156 int expecting_sec_name
= 0;
2157 int expecting_sec_addr
= 0;
2166 struct section_addr_info
*section_addrs
;
2167 struct sect_opt
*sect_opts
= NULL
;
2168 size_t num_sect_opts
= 0;
2169 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2172 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
2173 * sizeof (struct sect_opt
));
2178 error (_("add-symbol-file takes a file name and an address"));
2180 argv
= gdb_buildargv (args
);
2181 make_cleanup_freeargv (argv
);
2183 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2185 /* Process the argument. */
2188 /* The first argument is the file name. */
2189 filename
= tilde_expand (arg
);
2190 make_cleanup (xfree
, filename
);
2195 /* The second argument is always the text address at which
2196 to load the program. */
2197 sect_opts
[section_index
].name
= ".text";
2198 sect_opts
[section_index
].value
= arg
;
2199 if (++section_index
>= num_sect_opts
)
2202 sect_opts
= ((struct sect_opt
*)
2203 xrealloc (sect_opts
,
2205 * sizeof (struct sect_opt
)));
2210 /* It's an option (starting with '-') or it's an argument
2215 if (strcmp (arg
, "-readnow") == 0)
2216 flags
|= OBJF_READNOW
;
2217 else if (strcmp (arg
, "-s") == 0)
2219 expecting_sec_name
= 1;
2220 expecting_sec_addr
= 1;
2225 if (expecting_sec_name
)
2227 sect_opts
[section_index
].name
= arg
;
2228 expecting_sec_name
= 0;
2231 if (expecting_sec_addr
)
2233 sect_opts
[section_index
].value
= arg
;
2234 expecting_sec_addr
= 0;
2235 if (++section_index
>= num_sect_opts
)
2238 sect_opts
= ((struct sect_opt
*)
2239 xrealloc (sect_opts
,
2241 * sizeof (struct sect_opt
)));
2245 error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
2250 /* This command takes at least two arguments. The first one is a
2251 filename, and the second is the address where this file has been
2252 loaded. Abort now if this address hasn't been provided by the
2254 if (section_index
< 1)
2255 error (_("The address where %s has been loaded is missing"), filename
);
2257 /* Print the prompt for the query below. And save the arguments into
2258 a sect_addr_info structure to be passed around to other
2259 functions. We have to split this up into separate print
2260 statements because hex_string returns a local static
2263 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
2264 section_addrs
= alloc_section_addr_info (section_index
);
2265 make_cleanup (xfree
, section_addrs
);
2266 for (i
= 0; i
< section_index
; i
++)
2269 char *val
= sect_opts
[i
].value
;
2270 char *sec
= sect_opts
[i
].name
;
2272 addr
= parse_and_eval_address (val
);
2274 /* Here we store the section offsets in the order they were
2275 entered on the command line. */
2276 section_addrs
->other
[sec_num
].name
= sec
;
2277 section_addrs
->other
[sec_num
].addr
= addr
;
2278 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2279 paddress (gdbarch
, addr
));
2282 /* The object's sections are initialized when a
2283 call is made to build_objfile_section_table (objfile).
2284 This happens in reread_symbols.
2285 At this point, we don't know what file type this is,
2286 so we can't determine what section names are valid. */
2289 if (from_tty
&& (!query ("%s", "")))
2290 error (_("Not confirmed."));
2292 symbol_file_add (filename
, from_tty
? SYMFILE_VERBOSE
: 0,
2293 section_addrs
, flags
);
2295 /* Getting new symbols may change our opinion about what is
2297 reinit_frame_cache ();
2298 do_cleanups (my_cleanups
);
2302 /* Re-read symbols if a symbol-file has changed. */
2304 reread_symbols (void)
2306 struct objfile
*objfile
;
2309 struct stat new_statbuf
;
2312 /* With the addition of shared libraries, this should be modified,
2313 the load time should be saved in the partial symbol tables, since
2314 different tables may come from different source files. FIXME.
2315 This routine should then walk down each partial symbol table
2316 and see if the symbol table that it originates from has been changed */
2318 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2320 /* solib-sunos.c creates one objfile with obfd. */
2321 if (objfile
->obfd
== NULL
)
2324 /* Separate debug objfiles are handled in the main objfile. */
2325 if (objfile
->separate_debug_objfile_backlink
)
2328 #ifdef DEPRECATED_IBM6000_TARGET
2329 /* If this object is from a shared library, then you should
2330 stat on the library name, not member name. */
2332 if (objfile
->obfd
->my_archive
)
2333 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2336 res
= stat (objfile
->name
, &new_statbuf
);
2339 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2340 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2344 new_modtime
= new_statbuf
.st_mtime
;
2345 if (new_modtime
!= objfile
->mtime
)
2347 struct cleanup
*old_cleanups
;
2348 struct section_offsets
*offsets
;
2350 char *obfd_filename
;
2352 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2355 /* There are various functions like symbol_file_add,
2356 symfile_bfd_open, syms_from_objfile, etc., which might
2357 appear to do what we want. But they have various other
2358 effects which we *don't* want. So we just do stuff
2359 ourselves. We don't worry about mapped files (for one thing,
2360 any mapped file will be out of date). */
2362 /* If we get an error, blow away this objfile (not sure if
2363 that is the correct response for things like shared
2365 old_cleanups
= make_cleanup_free_objfile (objfile
);
2366 /* We need to do this whenever any symbols go away. */
2367 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2369 if (exec_bfd
!= NULL
&& strcmp (bfd_get_filename (objfile
->obfd
),
2370 bfd_get_filename (exec_bfd
)) == 0)
2372 /* Reload EXEC_BFD without asking anything. */
2374 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2377 /* Clean up any state BFD has sitting around. We don't need
2378 to close the descriptor but BFD lacks a way of closing the
2379 BFD without closing the descriptor. */
2380 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2381 if (!bfd_close (objfile
->obfd
))
2382 error (_("Can't close BFD for %s: %s"), objfile
->name
,
2383 bfd_errmsg (bfd_get_error ()));
2384 if (remote_filename_p (obfd_filename
))
2385 objfile
->obfd
= remote_bfd_open (obfd_filename
, gnutarget
);
2387 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
2388 if (objfile
->obfd
== NULL
)
2389 error (_("Can't open %s to read symbols."), objfile
->name
);
2391 objfile
->obfd
= gdb_bfd_ref (objfile
->obfd
);
2392 /* bfd_openr sets cacheable to true, which is what we want. */
2393 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2394 error (_("Can't read symbols from %s: %s."), objfile
->name
,
2395 bfd_errmsg (bfd_get_error ()));
2397 /* Save the offsets, we will nuke them with the rest of the
2399 num_offsets
= objfile
->num_sections
;
2400 offsets
= ((struct section_offsets
*)
2401 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2402 memcpy (offsets
, objfile
->section_offsets
,
2403 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2405 /* Remove any references to this objfile in the global
2407 preserve_values (objfile
);
2409 /* Nuke all the state that we will re-read. Much of the following
2410 code which sets things to NULL really is necessary to tell
2411 other parts of GDB that there is nothing currently there.
2413 Try to keep the freeing order compatible with free_objfile. */
2415 if (objfile
->sf
!= NULL
)
2417 (*objfile
->sf
->sym_finish
) (objfile
);
2420 clear_objfile_data (objfile
);
2422 /* Free the separate debug objfile if there is one. It will be
2423 automatically recreated by sym_read. */
2424 if (objfile
->separate_debug_objfile
)
2426 /* Note: no need to clear separate_debug_objfile field as it is
2427 done by free_objfile. */
2428 free_objfile (objfile
->separate_debug_objfile
);
2431 /* FIXME: Do we have to free a whole linked list, or is this
2433 if (objfile
->global_psymbols
.list
)
2434 xfree (objfile
->global_psymbols
.list
);
2435 memset (&objfile
->global_psymbols
, 0,
2436 sizeof (objfile
->global_psymbols
));
2437 if (objfile
->static_psymbols
.list
)
2438 xfree (objfile
->static_psymbols
.list
);
2439 memset (&objfile
->static_psymbols
, 0,
2440 sizeof (objfile
->static_psymbols
));
2442 /* Free the obstacks for non-reusable objfiles */
2443 bcache_xfree (objfile
->psymbol_cache
);
2444 objfile
->psymbol_cache
= bcache_xmalloc ();
2445 bcache_xfree (objfile
->macro_cache
);
2446 objfile
->macro_cache
= bcache_xmalloc ();
2447 bcache_xfree (objfile
->filename_cache
);
2448 objfile
->filename_cache
= bcache_xmalloc ();
2449 if (objfile
->demangled_names_hash
!= NULL
)
2451 htab_delete (objfile
->demangled_names_hash
);
2452 objfile
->demangled_names_hash
= NULL
;
2454 obstack_free (&objfile
->objfile_obstack
, 0);
2455 objfile
->sections
= NULL
;
2456 objfile
->symtabs
= NULL
;
2457 objfile
->psymtabs
= NULL
;
2458 objfile
->psymtabs_addrmap
= NULL
;
2459 objfile
->free_psymtabs
= NULL
;
2460 objfile
->cp_namespace_symtab
= NULL
;
2461 objfile
->msymbols
= NULL
;
2462 objfile
->deprecated_sym_private
= NULL
;
2463 objfile
->minimal_symbol_count
= 0;
2464 memset (&objfile
->msymbol_hash
, 0,
2465 sizeof (objfile
->msymbol_hash
));
2466 memset (&objfile
->msymbol_demangled_hash
, 0,
2467 sizeof (objfile
->msymbol_demangled_hash
));
2469 objfile
->psymbol_cache
= bcache_xmalloc ();
2470 objfile
->macro_cache
= bcache_xmalloc ();
2471 objfile
->filename_cache
= bcache_xmalloc ();
2472 /* obstack_init also initializes the obstack so it is
2473 empty. We could use obstack_specify_allocation but
2474 gdb_obstack.h specifies the alloc/dealloc
2476 obstack_init (&objfile
->objfile_obstack
);
2477 if (build_objfile_section_table (objfile
))
2479 error (_("Can't find the file sections in `%s': %s"),
2480 objfile
->name
, bfd_errmsg (bfd_get_error ()));
2482 terminate_minimal_symbol_table (objfile
);
2484 /* We use the same section offsets as from last time. I'm not
2485 sure whether that is always correct for shared libraries. */
2486 objfile
->section_offsets
= (struct section_offsets
*)
2487 obstack_alloc (&objfile
->objfile_obstack
,
2488 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2489 memcpy (objfile
->section_offsets
, offsets
,
2490 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2491 objfile
->num_sections
= num_offsets
;
2493 /* What the hell is sym_new_init for, anyway? The concept of
2494 distinguishing between the main file and additional files
2495 in this way seems rather dubious. */
2496 if (objfile
== symfile_objfile
)
2498 (*objfile
->sf
->sym_new_init
) (objfile
);
2501 (*objfile
->sf
->sym_init
) (objfile
);
2502 clear_complaints (&symfile_complaints
, 1, 1);
2503 /* Do not set flags as this is safe and we don't want to be
2505 (*objfile
->sf
->sym_read
) (objfile
, 0);
2506 if (!objfile_has_symbols (objfile
))
2509 printf_unfiltered (_("(no debugging symbols found)\n"));
2513 /* We're done reading the symbol file; finish off complaints. */
2514 clear_complaints (&symfile_complaints
, 0, 1);
2516 /* Getting new symbols may change our opinion about what is
2519 reinit_frame_cache ();
2521 /* Discard cleanups as symbol reading was successful. */
2522 discard_cleanups (old_cleanups
);
2524 /* If the mtime has changed between the time we set new_modtime
2525 and now, we *want* this to be out of date, so don't call stat
2527 objfile
->mtime
= new_modtime
;
2529 init_entry_point_info (objfile
);
2535 /* Notify objfiles that we've modified objfile sections. */
2536 objfiles_changed ();
2538 clear_symtab_users ();
2539 /* At least one objfile has changed, so we can consider that
2540 the executable we're debugging has changed too. */
2541 observer_notify_executable_changed ();
2554 static filename_language
*filename_language_table
;
2555 static int fl_table_size
, fl_table_next
;
2558 add_filename_language (char *ext
, enum language lang
)
2560 if (fl_table_next
>= fl_table_size
)
2562 fl_table_size
+= 10;
2563 filename_language_table
=
2564 xrealloc (filename_language_table
,
2565 fl_table_size
* sizeof (*filename_language_table
));
2568 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2569 filename_language_table
[fl_table_next
].lang
= lang
;
2573 static char *ext_args
;
2575 show_ext_args (struct ui_file
*file
, int from_tty
,
2576 struct cmd_list_element
*c
, const char *value
)
2578 fprintf_filtered (file
, _("\
2579 Mapping between filename extension and source language is \"%s\".\n"),
2584 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2587 char *cp
= ext_args
;
2590 /* First arg is filename extension, starting with '.' */
2592 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2594 /* Find end of first arg. */
2595 while (*cp
&& !isspace (*cp
))
2599 error (_("'%s': two arguments required -- filename extension and language"),
2602 /* Null-terminate first arg */
2605 /* Find beginning of second arg, which should be a source language. */
2606 while (*cp
&& isspace (*cp
))
2610 error (_("'%s': two arguments required -- filename extension and language"),
2613 /* Lookup the language from among those we know. */
2614 lang
= language_enum (cp
);
2616 /* Now lookup the filename extension: do we already know it? */
2617 for (i
= 0; i
< fl_table_next
; i
++)
2618 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2621 if (i
>= fl_table_next
)
2623 /* new file extension */
2624 add_filename_language (ext_args
, lang
);
2628 /* redefining a previously known filename extension */
2631 /* query ("Really make files of type %s '%s'?", */
2632 /* ext_args, language_str (lang)); */
2634 xfree (filename_language_table
[i
].ext
);
2635 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2636 filename_language_table
[i
].lang
= lang
;
2641 info_ext_lang_command (char *args
, int from_tty
)
2645 printf_filtered (_("Filename extensions and the languages they represent:"));
2646 printf_filtered ("\n\n");
2647 for (i
= 0; i
< fl_table_next
; i
++)
2648 printf_filtered ("\t%s\t- %s\n",
2649 filename_language_table
[i
].ext
,
2650 language_str (filename_language_table
[i
].lang
));
2654 init_filename_language_table (void)
2656 if (fl_table_size
== 0) /* protect against repetition */
2660 filename_language_table
=
2661 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2662 add_filename_language (".c", language_c
);
2663 add_filename_language (".C", language_cplus
);
2664 add_filename_language (".cc", language_cplus
);
2665 add_filename_language (".cp", language_cplus
);
2666 add_filename_language (".cpp", language_cplus
);
2667 add_filename_language (".cxx", language_cplus
);
2668 add_filename_language (".c++", language_cplus
);
2669 add_filename_language (".java", language_java
);
2670 add_filename_language (".class", language_java
);
2671 add_filename_language (".m", language_objc
);
2672 add_filename_language (".f", language_fortran
);
2673 add_filename_language (".F", language_fortran
);
2674 add_filename_language (".s", language_asm
);
2675 add_filename_language (".sx", language_asm
);
2676 add_filename_language (".S", language_asm
);
2677 add_filename_language (".pas", language_pascal
);
2678 add_filename_language (".p", language_pascal
);
2679 add_filename_language (".pp", language_pascal
);
2680 add_filename_language (".adb", language_ada
);
2681 add_filename_language (".ads", language_ada
);
2682 add_filename_language (".a", language_ada
);
2683 add_filename_language (".ada", language_ada
);
2688 deduce_language_from_filename (char *filename
)
2693 if (filename
!= NULL
)
2694 if ((cp
= strrchr (filename
, '.')) != NULL
)
2695 for (i
= 0; i
< fl_table_next
; i
++)
2696 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2697 return filename_language_table
[i
].lang
;
2699 return language_unknown
;
2704 Allocate and partly initialize a new symbol table. Return a pointer
2705 to it. error() if no space.
2707 Caller must set these fields:
2713 possibly free_named_symtabs (symtab->filename);
2717 allocate_symtab (char *filename
, struct objfile
*objfile
)
2719 struct symtab
*symtab
;
2721 symtab
= (struct symtab
*)
2722 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2723 memset (symtab
, 0, sizeof (*symtab
));
2724 symtab
->filename
= (char *) bcache (filename
, strlen (filename
) + 1,
2725 objfile
->filename_cache
);
2726 symtab
->fullname
= NULL
;
2727 symtab
->language
= deduce_language_from_filename (filename
);
2728 symtab
->debugformat
= "unknown";
2730 /* Hook it to the objfile it comes from */
2732 symtab
->objfile
= objfile
;
2733 symtab
->next
= objfile
->symtabs
;
2734 objfile
->symtabs
= symtab
;
2739 struct partial_symtab
*
2740 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
2742 struct partial_symtab
*psymtab
;
2744 if (objfile
->free_psymtabs
)
2746 psymtab
= objfile
->free_psymtabs
;
2747 objfile
->free_psymtabs
= psymtab
->next
;
2750 psymtab
= (struct partial_symtab
*)
2751 obstack_alloc (&objfile
->objfile_obstack
,
2752 sizeof (struct partial_symtab
));
2754 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2755 psymtab
->filename
= (char *) bcache (filename
, strlen (filename
) + 1,
2756 objfile
->filename_cache
);
2757 psymtab
->symtab
= NULL
;
2759 /* Prepend it to the psymtab list for the objfile it belongs to.
2760 Psymtabs are searched in most recent inserted -> least recent
2763 psymtab
->objfile
= objfile
;
2764 psymtab
->next
= objfile
->psymtabs
;
2765 objfile
->psymtabs
= psymtab
;
2768 struct partial_symtab
**prev_pst
;
2769 psymtab
->objfile
= objfile
;
2770 psymtab
->next
= NULL
;
2771 prev_pst
= &(objfile
->psymtabs
);
2772 while ((*prev_pst
) != NULL
)
2773 prev_pst
= &((*prev_pst
)->next
);
2774 (*prev_pst
) = psymtab
;
2782 discard_psymtab (struct partial_symtab
*pst
)
2784 struct partial_symtab
**prev_pst
;
2787 Empty psymtabs happen as a result of header files which don't
2788 have any symbols in them. There can be a lot of them. But this
2789 check is wrong, in that a psymtab with N_SLINE entries but
2790 nothing else is not empty, but we don't realize that. Fixing
2791 that without slowing things down might be tricky. */
2793 /* First, snip it out of the psymtab chain */
2795 prev_pst
= &(pst
->objfile
->psymtabs
);
2796 while ((*prev_pst
) != pst
)
2797 prev_pst
= &((*prev_pst
)->next
);
2798 (*prev_pst
) = pst
->next
;
2800 /* Next, put it on a free list for recycling */
2802 pst
->next
= pst
->objfile
->free_psymtabs
;
2803 pst
->objfile
->free_psymtabs
= pst
;
2807 /* Reset all data structures in gdb which may contain references to symbol
2811 clear_symtab_users (void)
2813 /* Someday, we should do better than this, by only blowing away
2814 the things that really need to be blown. */
2816 /* Clear the "current" symtab first, because it is no longer valid.
2817 breakpoint_re_set may try to access the current symtab. */
2818 clear_current_source_symtab_and_line ();
2821 breakpoint_re_set ();
2822 set_default_breakpoint (0, NULL
, 0, 0, 0);
2823 clear_pc_function_cache ();
2824 observer_notify_new_objfile (NULL
);
2826 /* Clear globals which might have pointed into a removed objfile.
2827 FIXME: It's not clear which of these are supposed to persist
2828 between expressions and which ought to be reset each time. */
2829 expression_context_block
= NULL
;
2830 innermost_block
= NULL
;
2832 /* Varobj may refer to old symbols, perform a cleanup. */
2833 varobj_invalidate ();
2838 clear_symtab_users_cleanup (void *ignore
)
2840 clear_symtab_users ();
2843 /* clear_symtab_users_once:
2845 This function is run after symbol reading, or from a cleanup.
2846 If an old symbol table was obsoleted, the old symbol table
2847 has been blown away, but the other GDB data structures that may
2848 reference it have not yet been cleared or re-directed. (The old
2849 symtab was zapped, and the cleanup queued, in free_named_symtab()
2852 This function can be queued N times as a cleanup, or called
2853 directly; it will do all the work the first time, and then will be a
2854 no-op until the next time it is queued. This works by bumping a
2855 counter at queueing time. Much later when the cleanup is run, or at
2856 the end of symbol processing (in case the cleanup is discarded), if
2857 the queued count is greater than the "done-count", we do the work
2858 and set the done-count to the queued count. If the queued count is
2859 less than or equal to the done-count, we just ignore the call. This
2860 is needed because reading a single .o file will often replace many
2861 symtabs (one per .h file, for example), and we don't want to reset
2862 the breakpoints N times in the user's face.
2864 The reason we both queue a cleanup, and call it directly after symbol
2865 reading, is because the cleanup protects us in case of errors, but is
2866 discarded if symbol reading is successful. */
2869 /* FIXME: As free_named_symtabs is currently a big noop this function
2870 is no longer needed. */
2871 static void clear_symtab_users_once (void);
2873 static int clear_symtab_users_queued
;
2874 static int clear_symtab_users_done
;
2877 clear_symtab_users_once (void)
2879 /* Enforce once-per-`do_cleanups'-semantics */
2880 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2882 clear_symtab_users_done
= clear_symtab_users_queued
;
2884 clear_symtab_users ();
2888 /* Delete the specified psymtab, and any others that reference it. */
2891 cashier_psymtab (struct partial_symtab
*pst
)
2893 struct partial_symtab
*ps
, *pprev
= NULL
;
2896 /* Find its previous psymtab in the chain */
2897 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2906 /* Unhook it from the chain. */
2907 if (ps
== pst
->objfile
->psymtabs
)
2908 pst
->objfile
->psymtabs
= ps
->next
;
2910 pprev
->next
= ps
->next
;
2912 /* FIXME, we can't conveniently deallocate the entries in the
2913 partial_symbol lists (global_psymbols/static_psymbols) that
2914 this psymtab points to. These just take up space until all
2915 the psymtabs are reclaimed. Ditto the dependencies list and
2916 filename, which are all in the objfile_obstack. */
2918 /* We need to cashier any psymtab that has this one as a dependency... */
2920 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2922 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2924 if (ps
->dependencies
[i
] == pst
)
2926 cashier_psymtab (ps
);
2927 goto again
; /* Must restart, chain has been munged. */
2934 /* If a symtab or psymtab for filename NAME is found, free it along
2935 with any dependent breakpoints, displays, etc.
2936 Used when loading new versions of object modules with the "add-file"
2937 command. This is only called on the top-level symtab or psymtab's name;
2938 it is not called for subsidiary files such as .h files.
2940 Return value is 1 if we blew away the environment, 0 if not.
2941 FIXME. The return value appears to never be used.
2943 FIXME. I think this is not the best way to do this. We should
2944 work on being gentler to the environment while still cleaning up
2945 all stray pointers into the freed symtab. */
2948 free_named_symtabs (char *name
)
2951 /* FIXME: With the new method of each objfile having it's own
2952 psymtab list, this function needs serious rethinking. In particular,
2953 why was it ever necessary to toss psymtabs with specific compilation
2954 unit filenames, as opposed to all psymtabs from a particular symbol
2956 Well, the answer is that some systems permit reloading of particular
2957 compilation units. We want to blow away any old info about these
2958 compilation units, regardless of which objfiles they arrived in. --gnu. */
2961 struct symtab
*prev
;
2962 struct partial_symtab
*ps
;
2963 struct blockvector
*bv
;
2966 /* We only wack things if the symbol-reload switch is set. */
2967 if (!symbol_reloading
)
2970 /* Some symbol formats have trouble providing file names... */
2971 if (name
== 0 || *name
== '\0')
2974 /* Look for a psymtab with the specified name. */
2977 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2979 if (strcmp (name
, ps
->filename
) == 0)
2981 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2982 goto again2
; /* Must restart, chain has been munged */
2986 /* Look for a symtab with the specified name. */
2988 for (s
= symtab_list
; s
; s
= s
->next
)
2990 if (strcmp (name
, s
->filename
) == 0)
2997 if (s
== symtab_list
)
2998 symtab_list
= s
->next
;
3000 prev
->next
= s
->next
;
3002 /* For now, queue a delete for all breakpoints, displays, etc., whether
3003 or not they depend on the symtab being freed. This should be
3004 changed so that only those data structures affected are deleted. */
3006 /* But don't delete anything if the symtab is empty.
3007 This test is necessary due to a bug in "dbxread.c" that
3008 causes empty symtabs to be created for N_SO symbols that
3009 contain the pathname of the object file. (This problem
3010 has been fixed in GDB 3.9x). */
3012 bv
= BLOCKVECTOR (s
);
3013 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
3014 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
3015 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
3017 complaint (&symfile_complaints
, _("Replacing old symbols for `%s'"),
3019 clear_symtab_users_queued
++;
3020 make_cleanup (clear_symtab_users_once
, 0);
3024 complaint (&symfile_complaints
, _("Empty symbol table found for `%s'"),
3031 /* It is still possible that some breakpoints will be affected
3032 even though no symtab was found, since the file might have
3033 been compiled without debugging, and hence not be associated
3034 with a symtab. In order to handle this correctly, we would need
3035 to keep a list of text address ranges for undebuggable files.
3036 For now, we do nothing, since this is a fairly obscure case. */
3040 /* FIXME, what about the minimal symbol table? */
3047 /* Allocate and partially fill a partial symtab. It will be
3048 completely filled at the end of the symbol list.
3050 FILENAME is the name of the symbol-file we are reading from. */
3052 struct partial_symtab
*
3053 start_psymtab_common (struct objfile
*objfile
,
3054 struct section_offsets
*section_offsets
,
3055 const char *filename
,
3056 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
3057 struct partial_symbol
**static_syms
)
3059 struct partial_symtab
*psymtab
;
3061 psymtab
= allocate_psymtab (filename
, objfile
);
3062 psymtab
->section_offsets
= section_offsets
;
3063 psymtab
->textlow
= textlow
;
3064 psymtab
->texthigh
= psymtab
->textlow
; /* default */
3065 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
3066 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
3070 /* Helper function, initialises partial symbol structure and stashes
3071 it into objfile's bcache. Note that our caching mechanism will
3072 use all fields of struct partial_symbol to determine hash value of the
3073 structure. In other words, having two symbols with the same name but
3074 different domain (or address) is possible and correct. */
3076 static const struct partial_symbol
*
3077 add_psymbol_to_bcache (char *name
, int namelength
, int copy_name
,
3079 enum address_class
class,
3080 long val
, /* Value as a long */
3081 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
3082 enum language language
, struct objfile
*objfile
,
3085 /* psymbol is static so that there will be no uninitialized gaps in the
3086 structure which might contain random data, causing cache misses in
3088 static struct partial_symbol psymbol
;
3090 /* However, we must ensure that the entire 'value' field has been
3091 zeroed before assigning to it, because an assignment may not
3092 write the entire field. */
3093 memset (&psymbol
.ginfo
.value
, 0, sizeof (psymbol
.ginfo
.value
));
3094 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
3097 SYMBOL_VALUE (&psymbol
) = val
;
3101 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
3103 SYMBOL_SECTION (&psymbol
) = 0;
3104 SYMBOL_LANGUAGE (&psymbol
) = language
;
3105 PSYMBOL_DOMAIN (&psymbol
) = domain
;
3106 PSYMBOL_CLASS (&psymbol
) = class;
3108 SYMBOL_SET_NAMES (&psymbol
, name
, namelength
, copy_name
, objfile
);
3110 /* Stash the partial symbol away in the cache */
3111 return bcache_full (&psymbol
, sizeof (struct partial_symbol
),
3112 objfile
->psymbol_cache
, added
);
3115 /* Helper function, adds partial symbol to the given partial symbol
3119 append_psymbol_to_list (struct psymbol_allocation_list
*list
,
3120 const struct partial_symbol
*psym
,
3121 struct objfile
*objfile
)
3123 if (list
->next
>= list
->list
+ list
->size
)
3124 extend_psymbol_list (list
, objfile
);
3125 *list
->next
++ = (struct partial_symbol
*) psym
;
3126 OBJSTAT (objfile
, n_psyms
++);
3129 /* Add a symbol with a long value to a psymtab.
3130 Since one arg is a struct, we pass in a ptr and deref it (sigh).
3131 Return the partial symbol that has been added. */
3133 /* NOTE: carlton/2003-09-11: The reason why we return the partial
3134 symbol is so that callers can get access to the symbol's demangled
3135 name, which they don't have any cheap way to determine otherwise.
3136 (Currenly, dwarf2read.c is the only file who uses that information,
3137 though it's possible that other readers might in the future.)
3138 Elena wasn't thrilled about that, and I don't blame her, but we
3139 couldn't come up with a better way to get that information. If
3140 it's needed in other situations, we could consider breaking up
3141 SYMBOL_SET_NAMES to provide access to the demangled name lookup
3144 const struct partial_symbol
*
3145 add_psymbol_to_list (char *name
, int namelength
, int copy_name
,
3147 enum address_class
class,
3148 struct psymbol_allocation_list
*list
,
3149 long val
, /* Value as a long */
3150 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
3151 enum language language
, struct objfile
*objfile
)
3153 const struct partial_symbol
*psym
;
3157 /* Stash the partial symbol away in the cache */
3158 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, class,
3159 val
, coreaddr
, language
, objfile
, &added
);
3161 /* Do not duplicate global partial symbols. */
3162 if (list
== &objfile
->global_psymbols
3166 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
3167 append_psymbol_to_list (list
, psym
, objfile
);
3171 /* Initialize storage for partial symbols. */
3174 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
3176 /* Free any previously allocated psymbol lists. */
3178 if (objfile
->global_psymbols
.list
)
3180 xfree (objfile
->global_psymbols
.list
);
3182 if (objfile
->static_psymbols
.list
)
3184 xfree (objfile
->static_psymbols
.list
);
3187 /* Current best guess is that approximately a twentieth
3188 of the total symbols (in a debugging file) are global or static
3191 objfile
->global_psymbols
.size
= total_symbols
/ 10;
3192 objfile
->static_psymbols
.size
= total_symbols
/ 10;
3194 if (objfile
->global_psymbols
.size
> 0)
3196 objfile
->global_psymbols
.next
=
3197 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
3198 xmalloc ((objfile
->global_psymbols
.size
3199 * sizeof (struct partial_symbol
*)));
3201 if (objfile
->static_psymbols
.size
> 0)
3203 objfile
->static_psymbols
.next
=
3204 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
3205 xmalloc ((objfile
->static_psymbols
.size
3206 * sizeof (struct partial_symbol
*)));
3211 The following code implements an abstraction for debugging overlay sections.
3213 The target model is as follows:
3214 1) The gnu linker will permit multiple sections to be mapped into the
3215 same VMA, each with its own unique LMA (or load address).
3216 2) It is assumed that some runtime mechanism exists for mapping the
3217 sections, one by one, from the load address into the VMA address.
3218 3) This code provides a mechanism for gdb to keep track of which
3219 sections should be considered to be mapped from the VMA to the LMA.
3220 This information is used for symbol lookup, and memory read/write.
3221 For instance, if a section has been mapped then its contents
3222 should be read from the VMA, otherwise from the LMA.
3224 Two levels of debugger support for overlays are available. One is
3225 "manual", in which the debugger relies on the user to tell it which
3226 overlays are currently mapped. This level of support is
3227 implemented entirely in the core debugger, and the information about
3228 whether a section is mapped is kept in the objfile->obj_section table.
3230 The second level of support is "automatic", and is only available if
3231 the target-specific code provides functionality to read the target's
3232 overlay mapping table, and translate its contents for the debugger
3233 (by updating the mapped state information in the obj_section tables).
3235 The interface is as follows:
3237 overlay map <name> -- tell gdb to consider this section mapped
3238 overlay unmap <name> -- tell gdb to consider this section unmapped
3239 overlay list -- list the sections that GDB thinks are mapped
3240 overlay read-target -- get the target's state of what's mapped
3241 overlay off/manual/auto -- set overlay debugging state
3242 Functional interface:
3243 find_pc_mapped_section(pc): if the pc is in the range of a mapped
3244 section, return that section.
3245 find_pc_overlay(pc): find any overlay section that contains
3246 the pc, either in its VMA or its LMA
3247 section_is_mapped(sect): true if overlay is marked as mapped
3248 section_is_overlay(sect): true if section's VMA != LMA
3249 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
3250 pc_in_unmapped_range(...): true if pc belongs to section's LMA
3251 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
3252 overlay_mapped_address(...): map an address from section's LMA to VMA
3253 overlay_unmapped_address(...): map an address from section's VMA to LMA
3254 symbol_overlayed_address(...): Return a "current" address for symbol:
3255 either in VMA or LMA depending on whether
3256 the symbol's section is currently mapped
3259 /* Overlay debugging state: */
3261 enum overlay_debugging_state overlay_debugging
= ovly_off
;
3262 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
3264 /* Function: section_is_overlay (SECTION)
3265 Returns true if SECTION has VMA not equal to LMA, ie.
3266 SECTION is loaded at an address different from where it will "run". */
3269 section_is_overlay (struct obj_section
*section
)
3271 if (overlay_debugging
&& section
)
3273 bfd
*abfd
= section
->objfile
->obfd
;
3274 asection
*bfd_section
= section
->the_bfd_section
;
3276 if (bfd_section_lma (abfd
, bfd_section
) != 0
3277 && bfd_section_lma (abfd
, bfd_section
)
3278 != bfd_section_vma (abfd
, bfd_section
))
3285 /* Function: overlay_invalidate_all (void)
3286 Invalidate the mapped state of all overlay sections (mark it as stale). */
3289 overlay_invalidate_all (void)
3291 struct objfile
*objfile
;
3292 struct obj_section
*sect
;
3294 ALL_OBJSECTIONS (objfile
, sect
)
3295 if (section_is_overlay (sect
))
3296 sect
->ovly_mapped
= -1;
3299 /* Function: section_is_mapped (SECTION)
3300 Returns true if section is an overlay, and is currently mapped.
3302 Access to the ovly_mapped flag is restricted to this function, so
3303 that we can do automatic update. If the global flag
3304 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3305 overlay_invalidate_all. If the mapped state of the particular
3306 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3309 section_is_mapped (struct obj_section
*osect
)
3311 struct gdbarch
*gdbarch
;
3313 if (osect
== 0 || !section_is_overlay (osect
))
3316 switch (overlay_debugging
)
3320 return 0; /* overlay debugging off */
3321 case ovly_auto
: /* overlay debugging automatic */
3322 /* Unles there is a gdbarch_overlay_update function,
3323 there's really nothing useful to do here (can't really go auto) */
3324 gdbarch
= get_objfile_arch (osect
->objfile
);
3325 if (gdbarch_overlay_update_p (gdbarch
))
3327 if (overlay_cache_invalid
)
3329 overlay_invalidate_all ();
3330 overlay_cache_invalid
= 0;
3332 if (osect
->ovly_mapped
== -1)
3333 gdbarch_overlay_update (gdbarch
, osect
);
3335 /* fall thru to manual case */
3336 case ovly_on
: /* overlay debugging manual */
3337 return osect
->ovly_mapped
== 1;
3341 /* Function: pc_in_unmapped_range
3342 If PC falls into the lma range of SECTION, return true, else false. */
3345 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3347 if (section_is_overlay (section
))
3349 bfd
*abfd
= section
->objfile
->obfd
;
3350 asection
*bfd_section
= section
->the_bfd_section
;
3352 /* We assume the LMA is relocated by the same offset as the VMA. */
3353 bfd_vma size
= bfd_get_section_size (bfd_section
);
3354 CORE_ADDR offset
= obj_section_offset (section
);
3356 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3357 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3364 /* Function: pc_in_mapped_range
3365 If PC falls into the vma range of SECTION, return true, else false. */
3368 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3370 if (section_is_overlay (section
))
3372 if (obj_section_addr (section
) <= pc
3373 && pc
< obj_section_endaddr (section
))
3381 /* Return true if the mapped ranges of sections A and B overlap, false
3384 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3386 CORE_ADDR a_start
= obj_section_addr (a
);
3387 CORE_ADDR a_end
= obj_section_endaddr (a
);
3388 CORE_ADDR b_start
= obj_section_addr (b
);
3389 CORE_ADDR b_end
= obj_section_endaddr (b
);
3391 return (a_start
< b_end
&& b_start
< a_end
);
3394 /* Function: overlay_unmapped_address (PC, SECTION)
3395 Returns the address corresponding to PC in the unmapped (load) range.
3396 May be the same as PC. */
3399 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3401 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3403 bfd
*abfd
= section
->objfile
->obfd
;
3404 asection
*bfd_section
= section
->the_bfd_section
;
3406 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3407 - bfd_section_vma (abfd
, bfd_section
);
3413 /* Function: overlay_mapped_address (PC, SECTION)
3414 Returns the address corresponding to PC in the mapped (runtime) range.
3415 May be the same as PC. */
3418 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3420 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3422 bfd
*abfd
= section
->objfile
->obfd
;
3423 asection
*bfd_section
= section
->the_bfd_section
;
3425 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3426 - bfd_section_lma (abfd
, bfd_section
);
3433 /* Function: symbol_overlayed_address
3434 Return one of two addresses (relative to the VMA or to the LMA),
3435 depending on whether the section is mapped or not. */
3438 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3440 if (overlay_debugging
)
3442 /* If the symbol has no section, just return its regular address. */
3445 /* If the symbol's section is not an overlay, just return its address */
3446 if (!section_is_overlay (section
))
3448 /* If the symbol's section is mapped, just return its address */
3449 if (section_is_mapped (section
))
3452 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3453 * then return its LOADED address rather than its vma address!!
3455 return overlay_unmapped_address (address
, section
);
3460 /* Function: find_pc_overlay (PC)
3461 Return the best-match overlay section for PC:
3462 If PC matches a mapped overlay section's VMA, return that section.
3463 Else if PC matches an unmapped section's VMA, return that section.
3464 Else if PC matches an unmapped section's LMA, return that section. */
3466 struct obj_section
*
3467 find_pc_overlay (CORE_ADDR pc
)
3469 struct objfile
*objfile
;
3470 struct obj_section
*osect
, *best_match
= NULL
;
3472 if (overlay_debugging
)
3473 ALL_OBJSECTIONS (objfile
, osect
)
3474 if (section_is_overlay (osect
))
3476 if (pc_in_mapped_range (pc
, osect
))
3478 if (section_is_mapped (osect
))
3483 else if (pc_in_unmapped_range (pc
, osect
))
3489 /* Function: find_pc_mapped_section (PC)
3490 If PC falls into the VMA address range of an overlay section that is
3491 currently marked as MAPPED, return that section. Else return NULL. */
3493 struct obj_section
*
3494 find_pc_mapped_section (CORE_ADDR pc
)
3496 struct objfile
*objfile
;
3497 struct obj_section
*osect
;
3499 if (overlay_debugging
)
3500 ALL_OBJSECTIONS (objfile
, osect
)
3501 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3507 /* Function: list_overlays_command
3508 Print a list of mapped sections and their PC ranges */
3511 list_overlays_command (char *args
, int from_tty
)
3514 struct objfile
*objfile
;
3515 struct obj_section
*osect
;
3517 if (overlay_debugging
)
3518 ALL_OBJSECTIONS (objfile
, osect
)
3519 if (section_is_mapped (osect
))
3521 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3526 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3527 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3528 size
= bfd_get_section_size (osect
->the_bfd_section
);
3529 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3531 printf_filtered ("Section %s, loaded at ", name
);
3532 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3533 puts_filtered (" - ");
3534 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3535 printf_filtered (", mapped at ");
3536 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3537 puts_filtered (" - ");
3538 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3539 puts_filtered ("\n");
3544 printf_filtered (_("No sections are mapped.\n"));
3547 /* Function: map_overlay_command
3548 Mark the named section as mapped (ie. residing at its VMA address). */
3551 map_overlay_command (char *args
, int from_tty
)
3553 struct objfile
*objfile
, *objfile2
;
3554 struct obj_section
*sec
, *sec2
;
3556 if (!overlay_debugging
)
3558 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3559 the 'overlay manual' command."));
3561 if (args
== 0 || *args
== 0)
3562 error (_("Argument required: name of an overlay section"));
3564 /* First, find a section matching the user supplied argument */
3565 ALL_OBJSECTIONS (objfile
, sec
)
3566 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3568 /* Now, check to see if the section is an overlay. */
3569 if (!section_is_overlay (sec
))
3570 continue; /* not an overlay section */
3572 /* Mark the overlay as "mapped" */
3573 sec
->ovly_mapped
= 1;
3575 /* Next, make a pass and unmap any sections that are
3576 overlapped by this new section: */
3577 ALL_OBJSECTIONS (objfile2
, sec2
)
3578 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3581 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3582 bfd_section_name (objfile
->obfd
,
3583 sec2
->the_bfd_section
));
3584 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3588 error (_("No overlay section called %s"), args
);
3591 /* Function: unmap_overlay_command
3592 Mark the overlay section as unmapped
3593 (ie. resident in its LMA address range, rather than the VMA range). */
3596 unmap_overlay_command (char *args
, int from_tty
)
3598 struct objfile
*objfile
;
3599 struct obj_section
*sec
;
3601 if (!overlay_debugging
)
3603 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3604 the 'overlay manual' command."));
3606 if (args
== 0 || *args
== 0)
3607 error (_("Argument required: name of an overlay section"));
3609 /* First, find a section matching the user supplied argument */
3610 ALL_OBJSECTIONS (objfile
, sec
)
3611 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3613 if (!sec
->ovly_mapped
)
3614 error (_("Section %s is not mapped"), args
);
3615 sec
->ovly_mapped
= 0;
3618 error (_("No overlay section called %s"), args
);
3621 /* Function: overlay_auto_command
3622 A utility command to turn on overlay debugging.
3623 Possibly this should be done via a set/show command. */
3626 overlay_auto_command (char *args
, int from_tty
)
3628 overlay_debugging
= ovly_auto
;
3629 enable_overlay_breakpoints ();
3631 printf_unfiltered (_("Automatic overlay debugging enabled."));
3634 /* Function: overlay_manual_command
3635 A utility command to turn on overlay debugging.
3636 Possibly this should be done via a set/show command. */
3639 overlay_manual_command (char *args
, int from_tty
)
3641 overlay_debugging
= ovly_on
;
3642 disable_overlay_breakpoints ();
3644 printf_unfiltered (_("Overlay debugging enabled."));
3647 /* Function: overlay_off_command
3648 A utility command to turn on overlay debugging.
3649 Possibly this should be done via a set/show command. */
3652 overlay_off_command (char *args
, int from_tty
)
3654 overlay_debugging
= ovly_off
;
3655 disable_overlay_breakpoints ();
3657 printf_unfiltered (_("Overlay debugging disabled."));
3661 overlay_load_command (char *args
, int from_tty
)
3663 struct gdbarch
*gdbarch
= get_current_arch ();
3665 if (gdbarch_overlay_update_p (gdbarch
))
3666 gdbarch_overlay_update (gdbarch
, NULL
);
3668 error (_("This target does not know how to read its overlay state."));
3671 /* Function: overlay_command
3672 A place-holder for a mis-typed command */
3674 /* Command list chain containing all defined "overlay" subcommands. */
3675 struct cmd_list_element
*overlaylist
;
3678 overlay_command (char *args
, int from_tty
)
3681 ("\"overlay\" must be followed by the name of an overlay command.\n");
3682 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3686 /* Target Overlays for the "Simplest" overlay manager:
3688 This is GDB's default target overlay layer. It works with the
3689 minimal overlay manager supplied as an example by Cygnus. The
3690 entry point is via a function pointer "gdbarch_overlay_update",
3691 so targets that use a different runtime overlay manager can
3692 substitute their own overlay_update function and take over the
3695 The overlay_update function pokes around in the target's data structures
3696 to see what overlays are mapped, and updates GDB's overlay mapping with
3699 In this simple implementation, the target data structures are as follows:
3700 unsigned _novlys; /# number of overlay sections #/
3701 unsigned _ovly_table[_novlys][4] = {
3702 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3703 {..., ..., ..., ...},
3705 unsigned _novly_regions; /# number of overlay regions #/
3706 unsigned _ovly_region_table[_novly_regions][3] = {
3707 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3710 These functions will attempt to update GDB's mappedness state in the
3711 symbol section table, based on the target's mappedness state.
3713 To do this, we keep a cached copy of the target's _ovly_table, and
3714 attempt to detect when the cached copy is invalidated. The main
3715 entry point is "simple_overlay_update(SECT), which looks up SECT in
3716 the cached table and re-reads only the entry for that section from
3717 the target (whenever possible).
3720 /* Cached, dynamically allocated copies of the target data structures: */
3721 static unsigned (*cache_ovly_table
)[4] = 0;
3723 static unsigned (*cache_ovly_region_table
)[3] = 0;
3725 static unsigned cache_novlys
= 0;
3727 static unsigned cache_novly_regions
= 0;
3729 static CORE_ADDR cache_ovly_table_base
= 0;
3731 static CORE_ADDR cache_ovly_region_table_base
= 0;
3735 VMA
, SIZE
, LMA
, MAPPED
3738 /* Throw away the cached copy of _ovly_table */
3740 simple_free_overlay_table (void)
3742 if (cache_ovly_table
)
3743 xfree (cache_ovly_table
);
3745 cache_ovly_table
= NULL
;
3746 cache_ovly_table_base
= 0;
3750 /* Throw away the cached copy of _ovly_region_table */
3752 simple_free_overlay_region_table (void)
3754 if (cache_ovly_region_table
)
3755 xfree (cache_ovly_region_table
);
3756 cache_novly_regions
= 0;
3757 cache_ovly_region_table
= NULL
;
3758 cache_ovly_region_table_base
= 0;
3762 /* Read an array of ints of size SIZE from the target into a local buffer.
3763 Convert to host order. int LEN is number of ints */
3765 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3766 int len
, int size
, enum bfd_endian byte_order
)
3768 /* FIXME (alloca): Not safe if array is very large. */
3769 gdb_byte
*buf
= alloca (len
* size
);
3772 read_memory (memaddr
, buf
, len
* size
);
3773 for (i
= 0; i
< len
; i
++)
3774 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3777 /* Find and grab a copy of the target _ovly_table
3778 (and _novlys, which is needed for the table's size) */
3780 simple_read_overlay_table (void)
3782 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3783 struct gdbarch
*gdbarch
;
3785 enum bfd_endian byte_order
;
3787 simple_free_overlay_table ();
3788 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3791 error (_("Error reading inferior's overlay table: "
3792 "couldn't find `_novlys' variable\n"
3793 "in inferior. Use `overlay manual' mode."));
3797 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3798 if (! ovly_table_msym
)
3800 error (_("Error reading inferior's overlay table: couldn't find "
3801 "`_ovly_table' array\n"
3802 "in inferior. Use `overlay manual' mode."));
3806 gdbarch
= get_objfile_arch (msymbol_objfile (ovly_table_msym
));
3807 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3808 byte_order
= gdbarch_byte_order (gdbarch
);
3810 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
),
3813 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3814 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3815 read_target_long_array (cache_ovly_table_base
,
3816 (unsigned int *) cache_ovly_table
,
3817 cache_novlys
* 4, word_size
, byte_order
);
3819 return 1; /* SUCCESS */
3823 /* Find and grab a copy of the target _ovly_region_table
3824 (and _novly_regions, which is needed for the table's size) */
3826 simple_read_overlay_region_table (void)
3828 struct minimal_symbol
*msym
;
3829 struct gdbarch
*gdbarch
;
3831 enum bfd_endian byte_order
;
3833 simple_free_overlay_region_table ();
3834 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3836 return 0; /* failure */
3838 gdbarch
= get_objfile_arch (msymbol_objfile (msym
));
3839 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3840 byte_order
= gdbarch_byte_order (gdbarch
);
3842 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
),
3845 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3846 if (cache_ovly_region_table
!= NULL
)
3848 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3851 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3852 read_target_long_array (cache_ovly_region_table_base
,
3853 (unsigned int *) cache_ovly_region_table
,
3854 cache_novly_regions
* 3,
3855 word_size
, byte_order
);
3858 return 0; /* failure */
3861 return 0; /* failure */
3862 return 1; /* SUCCESS */
3866 /* Function: simple_overlay_update_1
3867 A helper function for simple_overlay_update. Assuming a cached copy
3868 of _ovly_table exists, look through it to find an entry whose vma,
3869 lma and size match those of OSECT. Re-read the entry and make sure
3870 it still matches OSECT (else the table may no longer be valid).
3871 Set OSECT's mapped state to match the entry. Return: 1 for
3872 success, 0 for failure. */
3875 simple_overlay_update_1 (struct obj_section
*osect
)
3878 bfd
*obfd
= osect
->objfile
->obfd
;
3879 asection
*bsect
= osect
->the_bfd_section
;
3880 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3881 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3882 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3884 size
= bfd_get_section_size (osect
->the_bfd_section
);
3885 for (i
= 0; i
< cache_novlys
; i
++)
3886 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3887 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3888 /* && cache_ovly_table[i][SIZE] == size */ )
3890 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3891 (unsigned int *) cache_ovly_table
[i
],
3892 4, word_size
, byte_order
);
3893 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3894 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3895 /* && cache_ovly_table[i][SIZE] == size */ )
3897 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3900 else /* Warning! Warning! Target's ovly table has changed! */
3906 /* Function: simple_overlay_update
3907 If OSECT is NULL, then update all sections' mapped state
3908 (after re-reading the entire target _ovly_table).
3909 If OSECT is non-NULL, then try to find a matching entry in the
3910 cached ovly_table and update only OSECT's mapped state.
3911 If a cached entry can't be found or the cache isn't valid, then
3912 re-read the entire cache, and go ahead and update all sections. */
3915 simple_overlay_update (struct obj_section
*osect
)
3917 struct objfile
*objfile
;
3919 /* Were we given an osect to look up? NULL means do all of them. */
3921 /* Have we got a cached copy of the target's overlay table? */
3922 if (cache_ovly_table
!= NULL
)
3923 /* Does its cached location match what's currently in the symtab? */
3924 if (cache_ovly_table_base
==
3925 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3926 /* Then go ahead and try to look up this single section in the cache */
3927 if (simple_overlay_update_1 (osect
))
3928 /* Found it! We're done. */
3931 /* Cached table no good: need to read the entire table anew.
3932 Or else we want all the sections, in which case it's actually
3933 more efficient to read the whole table in one block anyway. */
3935 if (! simple_read_overlay_table ())
3938 /* Now may as well update all sections, even if only one was requested. */
3939 ALL_OBJSECTIONS (objfile
, osect
)
3940 if (section_is_overlay (osect
))
3943 bfd
*obfd
= osect
->objfile
->obfd
;
3944 asection
*bsect
= osect
->the_bfd_section
;
3946 size
= bfd_get_section_size (bsect
);
3947 for (i
= 0; i
< cache_novlys
; i
++)
3948 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3949 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3950 /* && cache_ovly_table[i][SIZE] == size */ )
3951 { /* obj_section matches i'th entry in ovly_table */
3952 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3953 break; /* finished with inner for loop: break out */
3958 /* Set the output sections and output offsets for section SECTP in
3959 ABFD. The relocation code in BFD will read these offsets, so we
3960 need to be sure they're initialized. We map each section to itself,
3961 with no offset; this means that SECTP->vma will be honored. */
3964 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3966 sectp
->output_section
= sectp
;
3967 sectp
->output_offset
= 0;
3970 /* Relocate the contents of a debug section SECTP in ABFD. The
3971 contents are stored in BUF if it is non-NULL, or returned in a
3972 malloc'd buffer otherwise.
3974 For some platforms and debug info formats, shared libraries contain
3975 relocations against the debug sections (particularly for DWARF-2;
3976 one affected platform is PowerPC GNU/Linux, although it depends on
3977 the version of the linker in use). Also, ELF object files naturally
3978 have unresolved relocations for their debug sections. We need to apply
3979 the relocations in order to get the locations of symbols correct.
3980 Another example that may require relocation processing, is the
3981 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3985 symfile_relocate_debug_section (bfd
*abfd
, asection
*sectp
, bfd_byte
*buf
)
3987 /* We're only interested in sections with relocation
3989 if ((sectp
->flags
& SEC_RELOC
) == 0)
3992 /* We will handle section offsets properly elsewhere, so relocate as if
3993 all sections begin at 0. */
3994 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3996 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3999 struct symfile_segment_data
*
4000 get_symfile_segment_data (bfd
*abfd
)
4002 struct sym_fns
*sf
= find_sym_fns (abfd
);
4007 return sf
->sym_segments (abfd
);
4011 free_symfile_segment_data (struct symfile_segment_data
*data
)
4013 xfree (data
->segment_bases
);
4014 xfree (data
->segment_sizes
);
4015 xfree (data
->segment_info
);
4021 - DATA, containing segment addresses from the object file ABFD, and
4022 the mapping from ABFD's sections onto the segments that own them,
4024 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
4025 segment addresses reported by the target,
4026 store the appropriate offsets for each section in OFFSETS.
4028 If there are fewer entries in SEGMENT_BASES than there are segments
4029 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
4031 If there are more entries, then ignore the extra. The target may
4032 not be able to distinguish between an empty data segment and a
4033 missing data segment; a missing text segment is less plausible. */
4035 symfile_map_offsets_to_segments (bfd
*abfd
, struct symfile_segment_data
*data
,
4036 struct section_offsets
*offsets
,
4037 int num_segment_bases
,
4038 const CORE_ADDR
*segment_bases
)
4043 /* It doesn't make sense to call this function unless you have some
4044 segment base addresses. */
4045 gdb_assert (segment_bases
> 0);
4047 /* If we do not have segment mappings for the object file, we
4048 can not relocate it by segments. */
4049 gdb_assert (data
!= NULL
);
4050 gdb_assert (data
->num_segments
> 0);
4052 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
4054 int which
= data
->segment_info
[i
];
4056 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
4058 /* Don't bother computing offsets for sections that aren't
4059 loaded as part of any segment. */
4063 /* Use the last SEGMENT_BASES entry as the address of any extra
4064 segments mentioned in DATA->segment_info. */
4065 if (which
> num_segment_bases
)
4066 which
= num_segment_bases
;
4068 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
4069 - data
->segment_bases
[which
- 1]);
4076 symfile_find_segment_sections (struct objfile
*objfile
)
4078 bfd
*abfd
= objfile
->obfd
;
4081 struct symfile_segment_data
*data
;
4083 data
= get_symfile_segment_data (objfile
->obfd
);
4087 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
4089 free_symfile_segment_data (data
);
4093 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
4096 int which
= data
->segment_info
[i
];
4100 if (objfile
->sect_index_text
== -1)
4101 objfile
->sect_index_text
= sect
->index
;
4103 if (objfile
->sect_index_rodata
== -1)
4104 objfile
->sect_index_rodata
= sect
->index
;
4106 else if (which
== 2)
4108 if (objfile
->sect_index_data
== -1)
4109 objfile
->sect_index_data
= sect
->index
;
4111 if (objfile
->sect_index_bss
== -1)
4112 objfile
->sect_index_bss
= sect
->index
;
4116 free_symfile_segment_data (data
);
4120 _initialize_symfile (void)
4122 struct cmd_list_element
*c
;
4124 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
4125 Load symbol table from executable file FILE.\n\
4126 The `file' command can also load symbol tables, as well as setting the file\n\
4127 to execute."), &cmdlist
);
4128 set_cmd_completer (c
, filename_completer
);
4130 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
4131 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
4132 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
4133 ADDR is the starting address of the file's text.\n\
4134 The optional arguments are section-name section-address pairs and\n\
4135 should be specified if the data and bss segments are not contiguous\n\
4136 with the text. SECT is a section name to be loaded at SECT_ADDR."),
4138 set_cmd_completer (c
, filename_completer
);
4140 c
= add_cmd ("load", class_files
, load_command
, _("\
4141 Dynamically load FILE into the running program, and record its symbols\n\
4142 for access from GDB.\n\
4143 A load OFFSET may also be given."), &cmdlist
);
4144 set_cmd_completer (c
, filename_completer
);
4146 add_setshow_boolean_cmd ("symbol-reloading", class_support
,
4147 &symbol_reloading
, _("\
4148 Set dynamic symbol table reloading multiple times in one run."), _("\
4149 Show dynamic symbol table reloading multiple times in one run."), NULL
,
4151 show_symbol_reloading
,
4152 &setlist
, &showlist
);
4154 add_prefix_cmd ("overlay", class_support
, overlay_command
,
4155 _("Commands for debugging overlays."), &overlaylist
,
4156 "overlay ", 0, &cmdlist
);
4158 add_com_alias ("ovly", "overlay", class_alias
, 1);
4159 add_com_alias ("ov", "overlay", class_alias
, 1);
4161 add_cmd ("map-overlay", class_support
, map_overlay_command
,
4162 _("Assert that an overlay section is mapped."), &overlaylist
);
4164 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
4165 _("Assert that an overlay section is unmapped."), &overlaylist
);
4167 add_cmd ("list-overlays", class_support
, list_overlays_command
,
4168 _("List mappings of overlay sections."), &overlaylist
);
4170 add_cmd ("manual", class_support
, overlay_manual_command
,
4171 _("Enable overlay debugging."), &overlaylist
);
4172 add_cmd ("off", class_support
, overlay_off_command
,
4173 _("Disable overlay debugging."), &overlaylist
);
4174 add_cmd ("auto", class_support
, overlay_auto_command
,
4175 _("Enable automatic overlay debugging."), &overlaylist
);
4176 add_cmd ("load-target", class_support
, overlay_load_command
,
4177 _("Read the overlay mapping state from the target."), &overlaylist
);
4179 /* Filename extension to source language lookup table: */
4180 init_filename_language_table ();
4181 add_setshow_string_noescape_cmd ("extension-language", class_files
,
4183 Set mapping between filename extension and source language."), _("\
4184 Show mapping between filename extension and source language."), _("\
4185 Usage: set extension-language .foo bar"),
4186 set_ext_lang_command
,
4188 &setlist
, &showlist
);
4190 add_info ("extensions", info_ext_lang_command
,
4191 _("All filename extensions associated with a source language."));
4193 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
4194 &debug_file_directory
, _("\
4195 Set the directories where separate debug symbols are searched for."), _("\
4196 Show the directories where separate debug symbols are searched for."), _("\
4197 Separate debug symbols are first searched for in the same\n\
4198 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
4199 and lastly at the path of the directory of the binary with\n\
4200 each global debug-file-directory component prepended."),
4202 show_debug_file_directory
,
4203 &setlist
, &showlist
);