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, 2010
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
;
331 /* Build (allocate and populate) a section_addr_info struct from
332 an existing section table. */
334 extern struct section_addr_info
*
335 build_section_addr_info_from_section_table (const struct target_section
*start
,
336 const struct target_section
*end
)
338 struct section_addr_info
*sap
;
339 const struct target_section
*stp
;
342 sap
= alloc_section_addr_info (end
- start
);
344 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
346 if (bfd_get_section_flags (stp
->bfd
,
347 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
348 && oidx
< end
- start
)
350 sap
->other
[oidx
].addr
= stp
->addr
;
351 sap
->other
[oidx
].name
352 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
353 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
361 /* Create a section_addr_info from section offsets in OBJFILE. */
363 struct section_addr_info
*
364 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
366 struct section_addr_info
*sap
;
368 struct bfd_section
*sec
;
369 int addr_bit
= gdbarch_addr_bit (objfile
->gdbarch
);
370 CORE_ADDR mask
= CORE_ADDR_MAX
;
372 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
373 mask
= ((CORE_ADDR
) 1 << addr_bit
) - 1;
375 sap
= alloc_section_addr_info (objfile
->num_sections
);
376 for (i
= 0, sec
= objfile
->obfd
->sections
;
377 i
< objfile
->num_sections
;
378 i
++, sec
= sec
->next
)
380 gdb_assert (sec
!= NULL
);
381 sap
->other
[i
].addr
= (bfd_get_section_vma (objfile
->obfd
, sec
)
382 + objfile
->section_offsets
->offsets
[i
]) & mask
;
383 sap
->other
[i
].name
= xstrdup (bfd_get_section_name (objfile
->obfd
, sec
));
384 sap
->other
[i
].sectindex
= sec
->index
;
390 /* Free all memory allocated by build_section_addr_info_from_section_table. */
393 free_section_addr_info (struct section_addr_info
*sap
)
397 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
398 if (sap
->other
[idx
].name
)
399 xfree (sap
->other
[idx
].name
);
404 /* Initialize OBJFILE's sect_index_* members. */
406 init_objfile_sect_indices (struct objfile
*objfile
)
411 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
413 objfile
->sect_index_text
= sect
->index
;
415 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
417 objfile
->sect_index_data
= sect
->index
;
419 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
421 objfile
->sect_index_bss
= sect
->index
;
423 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
425 objfile
->sect_index_rodata
= sect
->index
;
427 /* This is where things get really weird... We MUST have valid
428 indices for the various sect_index_* members or gdb will abort.
429 So if for example, there is no ".text" section, we have to
430 accomodate that. First, check for a file with the standard
431 one or two segments. */
433 symfile_find_segment_sections (objfile
);
435 /* Except when explicitly adding symbol files at some address,
436 section_offsets contains nothing but zeros, so it doesn't matter
437 which slot in section_offsets the individual sect_index_* members
438 index into. So if they are all zero, it is safe to just point
439 all the currently uninitialized indices to the first slot. But
440 beware: if this is the main executable, it may be relocated
441 later, e.g. by the remote qOffsets packet, and then this will
442 be wrong! That's why we try segments first. */
444 for (i
= 0; i
< objfile
->num_sections
; i
++)
446 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
451 if (i
== objfile
->num_sections
)
453 if (objfile
->sect_index_text
== -1)
454 objfile
->sect_index_text
= 0;
455 if (objfile
->sect_index_data
== -1)
456 objfile
->sect_index_data
= 0;
457 if (objfile
->sect_index_bss
== -1)
458 objfile
->sect_index_bss
= 0;
459 if (objfile
->sect_index_rodata
== -1)
460 objfile
->sect_index_rodata
= 0;
464 /* The arguments to place_section. */
466 struct place_section_arg
468 struct section_offsets
*offsets
;
472 /* Find a unique offset to use for loadable section SECT if
473 the user did not provide an offset. */
476 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
478 struct place_section_arg
*arg
= obj
;
479 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
481 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
483 /* We are only interested in allocated sections. */
484 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
487 /* If the user specified an offset, honor it. */
488 if (offsets
[sect
->index
] != 0)
491 /* Otherwise, let's try to find a place for the section. */
492 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
499 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
501 int indx
= cur_sec
->index
;
502 CORE_ADDR cur_offset
;
504 /* We don't need to compare against ourself. */
508 /* We can only conflict with allocated sections. */
509 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
512 /* If the section offset is 0, either the section has not been placed
513 yet, or it was the lowest section placed (in which case LOWEST
514 will be past its end). */
515 if (offsets
[indx
] == 0)
518 /* If this section would overlap us, then we must move up. */
519 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
520 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
522 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
523 start_addr
= (start_addr
+ align
- 1) & -align
;
528 /* Otherwise, we appear to be OK. So far. */
533 offsets
[sect
->index
] = start_addr
;
534 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
537 /* Store struct section_addr_info as prepared (made relative and with SECTINDEX
538 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
542 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
544 struct section_addr_info
*addrs
)
548 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
550 /* Now calculate offsets for section that were specified by the caller. */
551 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
553 struct other_sections
*osp
;
555 osp
= &addrs
->other
[i
];
559 /* Record all sections in offsets */
560 /* The section_offsets in the objfile are here filled in using
562 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
566 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
567 also SECTINDEXes there. */
570 addr_info_make_relative (struct section_addr_info
*addrs
, bfd
*abfd
)
572 asection
*lower_sect
;
574 CORE_ADDR lower_offset
;
577 /* Find lowest loadable section to be used as starting point for
578 continguous sections. FIXME!! won't work without call to find
579 .text first, but this assumes text is lowest section. */
580 lower_sect
= bfd_get_section_by_name (abfd
, ".text");
581 if (lower_sect
== NULL
)
582 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
583 if (lower_sect
== NULL
)
585 warning (_("no loadable sections found in added symbol-file %s"),
586 bfd_get_filename (abfd
));
590 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
592 /* Calculate offsets for the loadable sections.
593 FIXME! Sections must be in order of increasing loadable section
594 so that contiguous sections can use the lower-offset!!!
596 Adjust offsets if the segments are not contiguous.
597 If the section is contiguous, its offset should be set to
598 the offset of the highest loadable section lower than it
599 (the loadable section directly below it in memory).
600 this_offset = lower_offset = lower_addr - lower_orig_addr */
602 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
604 if (addrs
->other
[i
].addr
!= 0)
606 sect
= bfd_get_section_by_name (abfd
, addrs
->other
[i
].name
);
609 addrs
->other
[i
].addr
-= bfd_section_vma (abfd
, sect
);
610 lower_offset
= addrs
->other
[i
].addr
;
611 /* This is the index used by BFD. */
612 addrs
->other
[i
].sectindex
= sect
->index
;
616 warning (_("section %s not found in %s"), addrs
->other
[i
].name
,
617 bfd_get_filename (abfd
));
618 addrs
->other
[i
].addr
= 0;
622 addrs
->other
[i
].addr
= lower_offset
;
626 /* Parse the user's idea of an offset for dynamic linking, into our idea
627 of how to represent it for fast symbol reading. This is the default
628 version of the sym_fns.sym_offsets function for symbol readers that
629 don't need to do anything special. It allocates a section_offsets table
630 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
633 default_symfile_offsets (struct objfile
*objfile
,
634 struct section_addr_info
*addrs
)
636 objfile
->num_sections
= bfd_count_sections (objfile
->obfd
);
637 objfile
->section_offsets
= (struct section_offsets
*)
638 obstack_alloc (&objfile
->objfile_obstack
,
639 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
640 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
641 objfile
->num_sections
, addrs
);
643 /* For relocatable files, all loadable sections will start at zero.
644 The zero is meaningless, so try to pick arbitrary addresses such
645 that no loadable sections overlap. This algorithm is quadratic,
646 but the number of sections in a single object file is generally
648 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
650 struct place_section_arg arg
;
651 bfd
*abfd
= objfile
->obfd
;
653 CORE_ADDR lowest
= 0;
655 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
656 /* We do not expect this to happen; just skip this step if the
657 relocatable file has a section with an assigned VMA. */
658 if (bfd_section_vma (abfd
, cur_sec
) != 0)
663 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
665 /* Pick non-overlapping offsets for sections the user did not
667 arg
.offsets
= objfile
->section_offsets
;
669 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
671 /* Correctly filling in the section offsets is not quite
672 enough. Relocatable files have two properties that
673 (most) shared objects do not:
675 - Their debug information will contain relocations. Some
676 shared libraries do also, but many do not, so this can not
679 - If there are multiple code sections they will be loaded
680 at different relative addresses in memory than they are
681 in the objfile, since all sections in the file will start
684 Because GDB has very limited ability to map from an
685 address in debug info to the correct code section,
686 it relies on adding SECT_OFF_TEXT to things which might be
687 code. If we clear all the section offsets, and set the
688 section VMAs instead, then symfile_relocate_debug_section
689 will return meaningful debug information pointing at the
692 GDB has too many different data structures for section
693 addresses - a bfd, objfile, and so_list all have section
694 tables, as does exec_ops. Some of these could probably
697 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
698 cur_sec
= cur_sec
->next
)
700 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
703 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
704 exec_set_section_address (bfd_get_filename (abfd
), cur_sec
->index
,
705 offsets
[cur_sec
->index
]);
706 offsets
[cur_sec
->index
] = 0;
711 /* Remember the bfd indexes for the .text, .data, .bss and
713 init_objfile_sect_indices (objfile
);
717 /* Divide the file into segments, which are individual relocatable units.
718 This is the default version of the sym_fns.sym_segments function for
719 symbol readers that do not have an explicit representation of segments.
720 It assumes that object files do not have segments, and fully linked
721 files have a single segment. */
723 struct symfile_segment_data
*
724 default_symfile_segments (bfd
*abfd
)
728 struct symfile_segment_data
*data
;
731 /* Relocatable files contain enough information to position each
732 loadable section independently; they should not be relocated
734 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
737 /* Make sure there is at least one loadable section in the file. */
738 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
740 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
748 low
= bfd_get_section_vma (abfd
, sect
);
749 high
= low
+ bfd_get_section_size (sect
);
751 data
= XZALLOC (struct symfile_segment_data
);
752 data
->num_segments
= 1;
753 data
->segment_bases
= XCALLOC (1, CORE_ADDR
);
754 data
->segment_sizes
= XCALLOC (1, CORE_ADDR
);
756 num_sections
= bfd_count_sections (abfd
);
757 data
->segment_info
= XCALLOC (num_sections
, int);
759 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
763 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
766 vma
= bfd_get_section_vma (abfd
, sect
);
769 if (vma
+ bfd_get_section_size (sect
) > high
)
770 high
= vma
+ bfd_get_section_size (sect
);
772 data
->segment_info
[i
] = 1;
775 data
->segment_bases
[0] = low
;
776 data
->segment_sizes
[0] = high
- low
;
781 /* Process a symbol file, as either the main file or as a dynamically
784 OBJFILE is where the symbols are to be read from.
786 ADDRS is the list of section load addresses. If the user has given
787 an 'add-symbol-file' command, then this is the list of offsets and
788 addresses he or she provided as arguments to the command; or, if
789 we're handling a shared library, these are the actual addresses the
790 sections are loaded at, according to the inferior's dynamic linker
791 (as gleaned by GDB's shared library code). We convert each address
792 into an offset from the section VMA's as it appears in the object
793 file, and then call the file's sym_offsets function to convert this
794 into a format-specific offset table --- a `struct section_offsets'.
795 If ADDRS is non-zero, OFFSETS must be zero.
797 OFFSETS is a table of section offsets already in the right
798 format-specific representation. NUM_OFFSETS is the number of
799 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
800 assume this is the proper table the call to sym_offsets described
801 above would produce. Instead of calling sym_offsets, we just dump
802 it right into objfile->section_offsets. (When we're re-reading
803 symbols from an objfile, we don't have the original load address
804 list any more; all we have is the section offset table.) If
805 OFFSETS is non-zero, ADDRS must be zero.
807 ADD_FLAGS encodes verbosity level, whether this is main symbol or
808 an extra symbol file such as dynamically loaded code, and wether
809 breakpoint reset should be deferred. */
812 syms_from_objfile (struct objfile
*objfile
,
813 struct section_addr_info
*addrs
,
814 struct section_offsets
*offsets
,
818 struct section_addr_info
*local_addr
= NULL
;
819 struct cleanup
*old_chain
;
820 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
822 gdb_assert (! (addrs
&& offsets
));
824 init_entry_point_info (objfile
);
825 objfile
->sf
= find_sym_fns (objfile
->obfd
);
827 if (objfile
->sf
== NULL
)
828 return; /* No symbols. */
830 /* Make sure that partially constructed symbol tables will be cleaned up
831 if an error occurs during symbol reading. */
832 old_chain
= make_cleanup_free_objfile (objfile
);
834 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
835 list. We now establish the convention that an addr of zero means
836 no load address was specified. */
837 if (! addrs
&& ! offsets
)
840 = alloc_section_addr_info (bfd_count_sections (objfile
->obfd
));
841 make_cleanup (xfree
, local_addr
);
845 /* Now either addrs or offsets is non-zero. */
849 /* We will modify the main symbol table, make sure that all its users
850 will be cleaned up if an error occurs during symbol reading. */
851 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
853 /* Since no error yet, throw away the old symbol table. */
855 if (symfile_objfile
!= NULL
)
857 free_objfile (symfile_objfile
);
858 gdb_assert (symfile_objfile
== NULL
);
861 /* Currently we keep symbols from the add-symbol-file command.
862 If the user wants to get rid of them, they should do "symbol-file"
863 without arguments first. Not sure this is the best behavior
866 (*objfile
->sf
->sym_new_init
) (objfile
);
869 /* Convert addr into an offset rather than an absolute address.
870 We find the lowest address of a loaded segment in the objfile,
871 and assume that <addr> is where that got loaded.
873 We no longer warn if the lowest section is not a text segment (as
874 happens for the PA64 port. */
875 if (addrs
&& addrs
->other
[0].name
)
876 addr_info_make_relative (addrs
, objfile
->obfd
);
878 /* Initialize symbol reading routines for this objfile, allow complaints to
879 appear for this new file, and record how verbose to be, then do the
880 initial symbol reading for this file. */
882 (*objfile
->sf
->sym_init
) (objfile
);
883 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
886 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
889 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
891 /* Just copy in the offset table directly as given to us. */
892 objfile
->num_sections
= num_offsets
;
893 objfile
->section_offsets
894 = ((struct section_offsets
*)
895 obstack_alloc (&objfile
->objfile_obstack
, size
));
896 memcpy (objfile
->section_offsets
, offsets
, size
);
898 init_objfile_sect_indices (objfile
);
901 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
903 /* Discard cleanups as symbol reading was successful. */
905 discard_cleanups (old_chain
);
909 /* Perform required actions after either reading in the initial
910 symbols for a new objfile, or mapping in the symbols from a reusable
914 new_symfile_objfile (struct objfile
*objfile
, int add_flags
)
917 /* If this is the main symbol file we have to clean up all users of the
918 old main symbol file. Otherwise it is sufficient to fixup all the
919 breakpoints that may have been redefined by this symbol file. */
920 if (add_flags
& SYMFILE_MAINLINE
)
922 /* OK, make it the "real" symbol file. */
923 symfile_objfile
= objfile
;
925 clear_symtab_users ();
927 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
929 breakpoint_re_set ();
932 /* We're done reading the symbol file; finish off complaints. */
933 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
936 /* Process a symbol file, as either the main file or as a dynamically
939 ABFD is a BFD already open on the file, as from symfile_bfd_open.
940 This BFD will be closed on error, and is always consumed by this function.
942 ADD_FLAGS encodes verbosity, whether this is main symbol file or
943 extra, such as dynamically loaded code, and what to do with breakpoins.
945 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
946 syms_from_objfile, above.
947 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
949 Upon success, returns a pointer to the objfile that was added.
950 Upon failure, jumps back to command level (never returns). */
952 static struct objfile
*
953 symbol_file_add_with_addrs_or_offsets (bfd
*abfd
,
955 struct section_addr_info
*addrs
,
956 struct section_offsets
*offsets
,
960 struct objfile
*objfile
;
961 struct partial_symtab
*psymtab
;
962 struct cleanup
*my_cleanups
;
963 const char *name
= bfd_get_filename (abfd
);
964 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
966 my_cleanups
= make_cleanup_bfd_close (abfd
);
968 /* Give user a chance to burp if we'd be
969 interactively wiping out any existing symbols. */
971 if ((have_full_symbols () || have_partial_symbols ())
972 && (add_flags
& SYMFILE_MAINLINE
)
974 && !query (_("Load new symbol table from \"%s\"? "), name
))
975 error (_("Not confirmed."));
977 objfile
= allocate_objfile (abfd
, flags
);
978 discard_cleanups (my_cleanups
);
980 /* We either created a new mapped symbol table, mapped an existing
981 symbol table file which has not had initial symbol reading
982 performed, or need to read an unmapped symbol table. */
983 if (from_tty
|| info_verbose
)
985 if (deprecated_pre_add_symbol_hook
)
986 deprecated_pre_add_symbol_hook (name
);
989 printf_unfiltered (_("Reading symbols from %s..."), name
);
991 gdb_flush (gdb_stdout
);
994 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
997 /* We now have at least a partial symbol table. Check to see if the
998 user requested that all symbols be read on initial access via either
999 the gdb startup command line or on a per symbol file basis. Expand
1000 all partial symbol tables for this objfile if so. */
1002 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
1004 if (from_tty
|| info_verbose
)
1006 printf_unfiltered (_("expanding to full symbols..."));
1008 gdb_flush (gdb_stdout
);
1011 for (psymtab
= objfile
->psymtabs
;
1013 psymtab
= psymtab
->next
)
1015 psymtab_to_symtab (psymtab
);
1019 if ((from_tty
|| info_verbose
)
1020 && !objfile_has_symbols (objfile
))
1023 printf_unfiltered (_("(no debugging symbols found)..."));
1027 if (from_tty
|| info_verbose
)
1029 if (deprecated_post_add_symbol_hook
)
1030 deprecated_post_add_symbol_hook ();
1032 printf_unfiltered (_("done.\n"));
1035 /* We print some messages regardless of whether 'from_tty ||
1036 info_verbose' is true, so make sure they go out at the right
1038 gdb_flush (gdb_stdout
);
1040 do_cleanups (my_cleanups
);
1042 if (objfile
->sf
== NULL
)
1044 observer_notify_new_objfile (objfile
);
1045 return objfile
; /* No symbols. */
1048 new_symfile_objfile (objfile
, add_flags
);
1050 observer_notify_new_objfile (objfile
);
1052 bfd_cache_close_all ();
1056 /* Add BFD as a separate debug file for OBJFILE. */
1059 symbol_file_add_separate (bfd
*bfd
, int symfile_flags
, struct objfile
*objfile
)
1061 struct objfile
*new_objfile
;
1062 struct section_addr_info
*sap
;
1063 struct cleanup
*my_cleanup
;
1065 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1066 because sections of BFD may not match sections of OBJFILE and because
1067 vma may have been modified by tools such as prelink. */
1068 sap
= build_section_addr_info_from_objfile (objfile
);
1069 my_cleanup
= make_cleanup_free_section_addr_info (sap
);
1071 new_objfile
= symbol_file_add_with_addrs_or_offsets
1072 (bfd
, symfile_flags
,
1074 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1075 | OBJF_USERLOADED
));
1077 do_cleanups (my_cleanup
);
1079 add_separate_debug_objfile (new_objfile
, objfile
);
1082 /* Process the symbol file ABFD, as either the main file or as a
1083 dynamically loaded file.
1085 See symbol_file_add_with_addrs_or_offsets's comments for
1088 symbol_file_add_from_bfd (bfd
*abfd
, int add_flags
,
1089 struct section_addr_info
*addrs
,
1092 return symbol_file_add_with_addrs_or_offsets (abfd
, add_flags
, addrs
, 0, 0,
1097 /* Process a symbol file, as either the main file or as a dynamically
1098 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1101 symbol_file_add (char *name
, int add_flags
, struct section_addr_info
*addrs
,
1104 return symbol_file_add_from_bfd (symfile_bfd_open (name
), add_flags
, addrs
,
1109 /* Call symbol_file_add() with default values and update whatever is
1110 affected by the loading of a new main().
1111 Used when the file is supplied in the gdb command line
1112 and by some targets with special loading requirements.
1113 The auxiliary function, symbol_file_add_main_1(), has the flags
1114 argument for the switches that can only be specified in the symbol_file
1118 symbol_file_add_main (char *args
, int from_tty
)
1120 symbol_file_add_main_1 (args
, from_tty
, 0);
1124 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1126 const int add_flags
= SYMFILE_MAINLINE
| (from_tty
? SYMFILE_VERBOSE
: 0);
1127 symbol_file_add (args
, add_flags
, NULL
, flags
);
1129 /* Getting new symbols may change our opinion about
1130 what is frameless. */
1131 reinit_frame_cache ();
1133 set_initial_language ();
1137 symbol_file_clear (int from_tty
)
1139 if ((have_full_symbols () || have_partial_symbols ())
1142 ? !query (_("Discard symbol table from `%s'? "),
1143 symfile_objfile
->name
)
1144 : !query (_("Discard symbol table? "))))
1145 error (_("Not confirmed."));
1147 free_all_objfiles ();
1149 /* solib descriptors may have handles to objfiles. Since their
1150 storage has just been released, we'd better wipe the solib
1151 descriptors as well. */
1152 no_shared_libraries (NULL
, from_tty
);
1154 gdb_assert (symfile_objfile
== NULL
);
1156 printf_unfiltered (_("No symbol file now.\n"));
1160 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1163 bfd_size_type debuglink_size
;
1164 unsigned long crc32
;
1169 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1174 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1176 contents
= xmalloc (debuglink_size
);
1177 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1178 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1180 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1181 crc_offset
= strlen (contents
) + 1;
1182 crc_offset
= (crc_offset
+ 3) & ~3;
1184 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1191 separate_debug_file_exists (const char *name
, unsigned long crc
,
1192 struct objfile
*parent_objfile
)
1194 unsigned long file_crc
= 0;
1196 gdb_byte buffer
[8*1024];
1198 struct stat parent_stat
, abfd_stat
;
1200 /* Find a separate debug info file as if symbols would be present in
1201 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1202 section can contain just the basename of PARENT_OBJFILE without any
1203 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1204 the separate debug infos with the same basename can exist. */
1206 if (strcmp (name
, parent_objfile
->name
) == 0)
1209 abfd
= bfd_open_maybe_remote (name
);
1214 /* Verify symlinks were not the cause of strcmp name difference above.
1216 Some operating systems, e.g. Windows, do not provide a meaningful
1217 st_ino; they always set it to zero. (Windows does provide a
1218 meaningful st_dev.) Do not indicate a duplicate library in that
1219 case. While there is no guarantee that a system that provides
1220 meaningful inode numbers will never set st_ino to zero, this is
1221 merely an optimization, so we do not need to worry about false
1224 if (bfd_stat (abfd
, &abfd_stat
) == 0
1225 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0
1226 && abfd_stat
.st_dev
== parent_stat
.st_dev
1227 && abfd_stat
.st_ino
== parent_stat
.st_ino
1228 && abfd_stat
.st_ino
!= 0)
1234 while ((count
= bfd_bread (buffer
, sizeof (buffer
), abfd
)) > 0)
1235 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1239 if (crc
!= file_crc
)
1241 warning (_("the debug information found in \"%s\""
1242 " does not match \"%s\" (CRC mismatch).\n"),
1243 name
, parent_objfile
->name
);
1250 char *debug_file_directory
= NULL
;
1252 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1253 struct cmd_list_element
*c
, const char *value
)
1255 fprintf_filtered (file
, _("\
1256 The directory where separate debug symbols are searched for is \"%s\".\n"),
1260 #if ! defined (DEBUG_SUBDIRECTORY)
1261 #define DEBUG_SUBDIRECTORY ".debug"
1265 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1268 char *basename
, *name_copy
, *debugdir
;
1270 char *debugfile
= NULL
;
1271 char *canon_name
= NULL
;
1272 bfd_size_type debuglink_size
;
1273 unsigned long crc32
;
1276 basename
= get_debug_link_info (objfile
, &crc32
);
1278 if (basename
== NULL
)
1279 /* There's no separate debug info, hence there's no way we could
1280 load it => no warning. */
1281 goto cleanup_return_debugfile
;
1283 dir
= xstrdup (objfile
->name
);
1285 /* Strip off the final filename part, leaving the directory name,
1286 followed by a slash. Objfile names should always be absolute and
1287 tilde-expanded, so there should always be a slash in there
1289 for (i
= strlen(dir
) - 1; i
>= 0; i
--)
1291 if (IS_DIR_SEPARATOR (dir
[i
]))
1294 gdb_assert (i
>= 0 && IS_DIR_SEPARATOR (dir
[i
]));
1297 /* Set I to max (strlen (canon_name), strlen (dir)). */
1298 canon_name
= lrealpath (dir
);
1300 if (canon_name
&& strlen (canon_name
) > i
)
1301 i
= strlen (canon_name
);
1303 debugfile
= xmalloc (strlen (debug_file_directory
) + 1
1305 + strlen (DEBUG_SUBDIRECTORY
)
1310 /* First try in the same directory as the original file. */
1311 strcpy (debugfile
, dir
);
1312 strcat (debugfile
, basename
);
1314 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1315 goto cleanup_return_debugfile
;
1317 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1318 strcpy (debugfile
, dir
);
1319 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1320 strcat (debugfile
, "/");
1321 strcat (debugfile
, basename
);
1323 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1324 goto cleanup_return_debugfile
;
1326 /* Then try in the global debugfile directories.
1328 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1329 cause "/..." lookups. */
1331 debugdir
= debug_file_directory
;
1336 while (*debugdir
== DIRNAME_SEPARATOR
)
1339 debugdir_end
= strchr (debugdir
, DIRNAME_SEPARATOR
);
1340 if (debugdir_end
== NULL
)
1341 debugdir_end
= &debugdir
[strlen (debugdir
)];
1343 memcpy (debugfile
, debugdir
, debugdir_end
- debugdir
);
1344 debugfile
[debugdir_end
- debugdir
] = 0;
1345 strcat (debugfile
, "/");
1346 strcat (debugfile
, dir
);
1347 strcat (debugfile
, basename
);
1349 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1350 goto cleanup_return_debugfile
;
1352 /* If the file is in the sysroot, try using its base path in the
1353 global debugfile directory. */
1355 && strncmp (canon_name
, gdb_sysroot
, strlen (gdb_sysroot
)) == 0
1356 && IS_DIR_SEPARATOR (canon_name
[strlen (gdb_sysroot
)]))
1358 memcpy (debugfile
, debugdir
, debugdir_end
- debugdir
);
1359 debugfile
[debugdir_end
- debugdir
] = 0;
1360 strcat (debugfile
, canon_name
+ strlen (gdb_sysroot
));
1361 strcat (debugfile
, "/");
1362 strcat (debugfile
, basename
);
1364 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1365 goto cleanup_return_debugfile
;
1368 debugdir
= debugdir_end
;
1370 while (*debugdir
!= 0);
1375 cleanup_return_debugfile
:
1383 /* This is the symbol-file command. Read the file, analyze its
1384 symbols, and add a struct symtab to a symtab list. The syntax of
1385 the command is rather bizarre:
1387 1. The function buildargv implements various quoting conventions
1388 which are undocumented and have little or nothing in common with
1389 the way things are quoted (or not quoted) elsewhere in GDB.
1391 2. Options are used, which are not generally used in GDB (perhaps
1392 "set mapped on", "set readnow on" would be better)
1394 3. The order of options matters, which is contrary to GNU
1395 conventions (because it is confusing and inconvenient). */
1398 symbol_file_command (char *args
, int from_tty
)
1404 symbol_file_clear (from_tty
);
1408 char **argv
= gdb_buildargv (args
);
1409 int flags
= OBJF_USERLOADED
;
1410 struct cleanup
*cleanups
;
1413 cleanups
= make_cleanup_freeargv (argv
);
1414 while (*argv
!= NULL
)
1416 if (strcmp (*argv
, "-readnow") == 0)
1417 flags
|= OBJF_READNOW
;
1418 else if (**argv
== '-')
1419 error (_("unknown option `%s'"), *argv
);
1422 symbol_file_add_main_1 (*argv
, from_tty
, flags
);
1430 error (_("no symbol file name was specified"));
1432 do_cleanups (cleanups
);
1436 /* Set the initial language.
1438 FIXME: A better solution would be to record the language in the
1439 psymtab when reading partial symbols, and then use it (if known) to
1440 set the language. This would be a win for formats that encode the
1441 language in an easily discoverable place, such as DWARF. For
1442 stabs, we can jump through hoops looking for specially named
1443 symbols or try to intuit the language from the specific type of
1444 stabs we find, but we can't do that until later when we read in
1448 set_initial_language (void)
1450 struct partial_symtab
*pst
;
1451 enum language lang
= language_unknown
;
1453 pst
= find_main_psymtab ();
1456 if (pst
->filename
!= NULL
)
1457 lang
= deduce_language_from_filename (pst
->filename
);
1459 if (lang
== language_unknown
)
1461 /* Make C the default language */
1465 set_language (lang
);
1466 expected_language
= current_language
; /* Don't warn the user. */
1470 /* If NAME is a remote name open the file using remote protocol, otherwise
1471 open it normally. */
1474 bfd_open_maybe_remote (const char *name
)
1476 if (remote_filename_p (name
))
1477 return remote_bfd_open (name
, gnutarget
);
1479 return bfd_openr (name
, gnutarget
);
1483 /* Open the file specified by NAME and hand it off to BFD for
1484 preliminary analysis. Return a newly initialized bfd *, which
1485 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1486 absolute). In case of trouble, error() is called. */
1489 symfile_bfd_open (char *name
)
1493 char *absolute_name
;
1495 if (remote_filename_p (name
))
1497 name
= xstrdup (name
);
1498 sym_bfd
= remote_bfd_open (name
, gnutarget
);
1501 make_cleanup (xfree
, name
);
1502 error (_("`%s': can't open to read symbols: %s."), name
,
1503 bfd_errmsg (bfd_get_error ()));
1506 if (!bfd_check_format (sym_bfd
, bfd_object
))
1508 bfd_close (sym_bfd
);
1509 make_cleanup (xfree
, name
);
1510 error (_("`%s': can't read symbols: %s."), name
,
1511 bfd_errmsg (bfd_get_error ()));
1517 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy. */
1519 /* Look down path for it, allocate 2nd new malloc'd copy. */
1520 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, name
,
1521 O_RDONLY
| O_BINARY
, &absolute_name
);
1522 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1525 char *exename
= alloca (strlen (name
) + 5);
1526 strcat (strcpy (exename
, name
), ".exe");
1527 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
1528 O_RDONLY
| O_BINARY
, &absolute_name
);
1533 make_cleanup (xfree
, name
);
1534 perror_with_name (name
);
1537 /* Free 1st new malloc'd copy, but keep the 2nd malloc'd copy in
1538 bfd. It'll be freed in free_objfile(). */
1540 name
= absolute_name
;
1542 sym_bfd
= bfd_fopen (name
, gnutarget
, FOPEN_RB
, desc
);
1546 make_cleanup (xfree
, name
);
1547 error (_("`%s': can't open to read symbols: %s."), name
,
1548 bfd_errmsg (bfd_get_error ()));
1550 bfd_set_cacheable (sym_bfd
, 1);
1552 if (!bfd_check_format (sym_bfd
, bfd_object
))
1554 /* FIXME: should be checking for errors from bfd_close (for one
1555 thing, on error it does not free all the storage associated
1557 bfd_close (sym_bfd
); /* This also closes desc. */
1558 make_cleanup (xfree
, name
);
1559 error (_("`%s': can't read symbols: %s."), name
,
1560 bfd_errmsg (bfd_get_error ()));
1563 /* bfd_usrdata exists for applications and libbfd must not touch it. */
1564 gdb_assert (bfd_usrdata (sym_bfd
) == NULL
);
1569 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1570 the section was not found. */
1573 get_section_index (struct objfile
*objfile
, char *section_name
)
1575 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1583 /* Link SF into the global symtab_fns list. Called on startup by the
1584 _initialize routine in each object file format reader, to register
1585 information about each format the the reader is prepared to
1589 add_symtab_fns (struct sym_fns
*sf
)
1591 sf
->next
= symtab_fns
;
1595 /* Initialize OBJFILE to read symbols from its associated BFD. It
1596 either returns or calls error(). The result is an initialized
1597 struct sym_fns in the objfile structure, that contains cached
1598 information about the symbol file. */
1600 static struct sym_fns
*
1601 find_sym_fns (bfd
*abfd
)
1604 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1606 if (our_flavour
== bfd_target_srec_flavour
1607 || our_flavour
== bfd_target_ihex_flavour
1608 || our_flavour
== bfd_target_tekhex_flavour
)
1609 return NULL
; /* No symbols. */
1611 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1612 if (our_flavour
== sf
->sym_flavour
)
1615 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1616 bfd_get_target (abfd
));
1620 /* This function runs the load command of our current target. */
1623 load_command (char *arg
, int from_tty
)
1625 /* The user might be reloading because the binary has changed. Take
1626 this opportunity to check. */
1627 reopen_exec_file ();
1635 parg
= arg
= get_exec_file (1);
1637 /* Count how many \ " ' tab space there are in the name. */
1638 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1646 /* We need to quote this string so buildargv can pull it apart. */
1647 char *temp
= xmalloc (strlen (arg
) + count
+ 1 );
1651 make_cleanup (xfree
, temp
);
1654 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1656 strncpy (ptemp
, prev
, parg
- prev
);
1657 ptemp
+= parg
- prev
;
1661 strcpy (ptemp
, prev
);
1667 target_load (arg
, from_tty
);
1669 /* After re-loading the executable, we don't really know which
1670 overlays are mapped any more. */
1671 overlay_cache_invalid
= 1;
1674 /* This version of "load" should be usable for any target. Currently
1675 it is just used for remote targets, not inftarg.c or core files,
1676 on the theory that only in that case is it useful.
1678 Avoiding xmodem and the like seems like a win (a) because we don't have
1679 to worry about finding it, and (b) On VMS, fork() is very slow and so
1680 we don't want to run a subprocess. On the other hand, I'm not sure how
1681 performance compares. */
1683 static int validate_download
= 0;
1685 /* Callback service function for generic_load (bfd_map_over_sections). */
1688 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1690 bfd_size_type
*sum
= data
;
1692 *sum
+= bfd_get_section_size (asec
);
1695 /* Opaque data for load_section_callback. */
1696 struct load_section_data
{
1697 unsigned long load_offset
;
1698 struct load_progress_data
*progress_data
;
1699 VEC(memory_write_request_s
) *requests
;
1702 /* Opaque data for load_progress. */
1703 struct load_progress_data
{
1704 /* Cumulative data. */
1705 unsigned long write_count
;
1706 unsigned long data_count
;
1707 bfd_size_type total_size
;
1710 /* Opaque data for load_progress for a single section. */
1711 struct load_progress_section_data
{
1712 struct load_progress_data
*cumulative
;
1714 /* Per-section data. */
1715 const char *section_name
;
1716 ULONGEST section_sent
;
1717 ULONGEST section_size
;
1722 /* Target write callback routine for progress reporting. */
1725 load_progress (ULONGEST bytes
, void *untyped_arg
)
1727 struct load_progress_section_data
*args
= untyped_arg
;
1728 struct load_progress_data
*totals
;
1731 /* Writing padding data. No easy way to get at the cumulative
1732 stats, so just ignore this. */
1735 totals
= args
->cumulative
;
1737 if (bytes
== 0 && args
->section_sent
== 0)
1739 /* The write is just starting. Let the user know we've started
1741 ui_out_message (uiout
, 0, "Loading section %s, size %s lma %s\n",
1742 args
->section_name
, hex_string (args
->section_size
),
1743 paddress (target_gdbarch
, args
->lma
));
1747 if (validate_download
)
1749 /* Broken memories and broken monitors manifest themselves here
1750 when bring new computers to life. This doubles already slow
1752 /* NOTE: cagney/1999-10-18: A more efficient implementation
1753 might add a verify_memory() method to the target vector and
1754 then use that. remote.c could implement that method using
1755 the ``qCRC'' packet. */
1756 gdb_byte
*check
= xmalloc (bytes
);
1757 struct cleanup
*verify_cleanups
= make_cleanup (xfree
, check
);
1759 if (target_read_memory (args
->lma
, check
, bytes
) != 0)
1760 error (_("Download verify read failed at %s"),
1761 paddress (target_gdbarch
, args
->lma
));
1762 if (memcmp (args
->buffer
, check
, bytes
) != 0)
1763 error (_("Download verify compare failed at %s"),
1764 paddress (target_gdbarch
, args
->lma
));
1765 do_cleanups (verify_cleanups
);
1767 totals
->data_count
+= bytes
;
1769 args
->buffer
+= bytes
;
1770 totals
->write_count
+= 1;
1771 args
->section_sent
+= bytes
;
1773 || (deprecated_ui_load_progress_hook
!= NULL
1774 && deprecated_ui_load_progress_hook (args
->section_name
,
1775 args
->section_sent
)))
1776 error (_("Canceled the download"));
1778 if (deprecated_show_load_progress
!= NULL
)
1779 deprecated_show_load_progress (args
->section_name
,
1783 totals
->total_size
);
1786 /* Callback service function for generic_load (bfd_map_over_sections). */
1789 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1791 struct memory_write_request
*new_request
;
1792 struct load_section_data
*args
= data
;
1793 struct load_progress_section_data
*section_data
;
1794 bfd_size_type size
= bfd_get_section_size (asec
);
1796 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1798 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1804 new_request
= VEC_safe_push (memory_write_request_s
,
1805 args
->requests
, NULL
);
1806 memset (new_request
, 0, sizeof (struct memory_write_request
));
1807 section_data
= xcalloc (1, sizeof (struct load_progress_section_data
));
1808 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1809 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size be in instead? */
1810 new_request
->data
= xmalloc (size
);
1811 new_request
->baton
= section_data
;
1813 buffer
= new_request
->data
;
1815 section_data
->cumulative
= args
->progress_data
;
1816 section_data
->section_name
= sect_name
;
1817 section_data
->section_size
= size
;
1818 section_data
->lma
= new_request
->begin
;
1819 section_data
->buffer
= buffer
;
1821 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1824 /* Clean up an entire memory request vector, including load
1825 data and progress records. */
1828 clear_memory_write_data (void *arg
)
1830 VEC(memory_write_request_s
) **vec_p
= arg
;
1831 VEC(memory_write_request_s
) *vec
= *vec_p
;
1833 struct memory_write_request
*mr
;
1835 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
1840 VEC_free (memory_write_request_s
, vec
);
1844 generic_load (char *args
, int from_tty
)
1847 struct timeval start_time
, end_time
;
1849 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, 0);
1850 struct load_section_data cbdata
;
1851 struct load_progress_data total_progress
;
1856 memset (&cbdata
, 0, sizeof (cbdata
));
1857 memset (&total_progress
, 0, sizeof (total_progress
));
1858 cbdata
.progress_data
= &total_progress
;
1860 make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
1863 error_no_arg (_("file to load"));
1865 argv
= gdb_buildargv (args
);
1866 make_cleanup_freeargv (argv
);
1868 filename
= tilde_expand (argv
[0]);
1869 make_cleanup (xfree
, filename
);
1871 if (argv
[1] != NULL
)
1875 cbdata
.load_offset
= strtoul (argv
[1], &endptr
, 0);
1877 /* If the last word was not a valid number then
1878 treat it as a file name with spaces in. */
1879 if (argv
[1] == endptr
)
1880 error (_("Invalid download offset:%s."), argv
[1]);
1882 if (argv
[2] != NULL
)
1883 error (_("Too many parameters."));
1886 /* Open the file for loading. */
1887 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1888 if (loadfile_bfd
== NULL
)
1890 perror_with_name (filename
);
1894 /* FIXME: should be checking for errors from bfd_close (for one thing,
1895 on error it does not free all the storage associated with the
1897 make_cleanup_bfd_close (loadfile_bfd
);
1899 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1901 error (_("\"%s\" is not an object file: %s"), filename
,
1902 bfd_errmsg (bfd_get_error ()));
1905 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1906 (void *) &total_progress
.total_size
);
1908 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1910 gettimeofday (&start_time
, NULL
);
1912 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
1913 load_progress
) != 0)
1914 error (_("Load failed"));
1916 gettimeofday (&end_time
, NULL
);
1918 entry
= bfd_get_start_address (loadfile_bfd
);
1919 ui_out_text (uiout
, "Start address ");
1920 ui_out_field_fmt (uiout
, "address", "%s", paddress (target_gdbarch
, entry
));
1921 ui_out_text (uiout
, ", load size ");
1922 ui_out_field_fmt (uiout
, "load-size", "%lu", total_progress
.data_count
);
1923 ui_out_text (uiout
, "\n");
1924 /* We were doing this in remote-mips.c, I suspect it is right
1925 for other targets too. */
1926 regcache_write_pc (get_current_regcache (), entry
);
1928 /* FIXME: are we supposed to call symbol_file_add or not? According
1929 to a comment from remote-mips.c (where a call to symbol_file_add
1930 was commented out), making the call confuses GDB if more than one
1931 file is loaded in. Some targets do (e.g., remote-vx.c) but
1932 others don't (or didn't - perhaps they have all been deleted). */
1934 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
1935 total_progress
.write_count
,
1936 &start_time
, &end_time
);
1938 do_cleanups (old_cleanups
);
1941 /* Report how fast the transfer went. */
1943 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1944 replaced by print_transfer_performance (with a very different
1945 function signature). */
1948 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1951 struct timeval start
, end
;
1953 start
.tv_sec
= start_time
;
1955 end
.tv_sec
= end_time
;
1958 print_transfer_performance (gdb_stdout
, data_count
, 0, &start
, &end
);
1962 print_transfer_performance (struct ui_file
*stream
,
1963 unsigned long data_count
,
1964 unsigned long write_count
,
1965 const struct timeval
*start_time
,
1966 const struct timeval
*end_time
)
1968 ULONGEST time_count
;
1970 /* Compute the elapsed time in milliseconds, as a tradeoff between
1971 accuracy and overflow. */
1972 time_count
= (end_time
->tv_sec
- start_time
->tv_sec
) * 1000;
1973 time_count
+= (end_time
->tv_usec
- start_time
->tv_usec
) / 1000;
1975 ui_out_text (uiout
, "Transfer rate: ");
1978 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / time_count
;
1980 if (ui_out_is_mi_like_p (uiout
))
1982 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
* 8);
1983 ui_out_text (uiout
, " bits/sec");
1985 else if (rate
< 1024)
1987 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
);
1988 ui_out_text (uiout
, " bytes/sec");
1992 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
/ 1024);
1993 ui_out_text (uiout
, " KB/sec");
1998 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
1999 ui_out_text (uiout
, " bits in <1 sec");
2001 if (write_count
> 0)
2003 ui_out_text (uiout
, ", ");
2004 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
2005 ui_out_text (uiout
, " bytes/write");
2007 ui_out_text (uiout
, ".\n");
2010 /* This function allows the addition of incrementally linked object files.
2011 It does not modify any state in the target, only in the debugger. */
2012 /* Note: ezannoni 2000-04-13 This function/command used to have a
2013 special case syntax for the rombug target (Rombug is the boot
2014 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2015 rombug case, the user doesn't need to supply a text address,
2016 instead a call to target_link() (in target.c) would supply the
2017 value to use. We are now discontinuing this type of ad hoc syntax. */
2020 add_symbol_file_command (char *args
, int from_tty
)
2022 struct gdbarch
*gdbarch
= get_current_arch ();
2023 char *filename
= NULL
;
2024 int flags
= OBJF_USERLOADED
;
2026 int expecting_option
= 0;
2027 int section_index
= 0;
2031 int expecting_sec_name
= 0;
2032 int expecting_sec_addr
= 0;
2041 struct section_addr_info
*section_addrs
;
2042 struct sect_opt
*sect_opts
= NULL
;
2043 size_t num_sect_opts
= 0;
2044 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2047 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
2048 * sizeof (struct sect_opt
));
2053 error (_("add-symbol-file takes a file name and an address"));
2055 argv
= gdb_buildargv (args
);
2056 make_cleanup_freeargv (argv
);
2058 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2060 /* Process the argument. */
2063 /* The first argument is the file name. */
2064 filename
= tilde_expand (arg
);
2065 make_cleanup (xfree
, filename
);
2070 /* The second argument is always the text address at which
2071 to load the program. */
2072 sect_opts
[section_index
].name
= ".text";
2073 sect_opts
[section_index
].value
= arg
;
2074 if (++section_index
>= num_sect_opts
)
2077 sect_opts
= ((struct sect_opt
*)
2078 xrealloc (sect_opts
,
2080 * sizeof (struct sect_opt
)));
2085 /* It's an option (starting with '-') or it's an argument
2090 if (strcmp (arg
, "-readnow") == 0)
2091 flags
|= OBJF_READNOW
;
2092 else if (strcmp (arg
, "-s") == 0)
2094 expecting_sec_name
= 1;
2095 expecting_sec_addr
= 1;
2100 if (expecting_sec_name
)
2102 sect_opts
[section_index
].name
= arg
;
2103 expecting_sec_name
= 0;
2106 if (expecting_sec_addr
)
2108 sect_opts
[section_index
].value
= arg
;
2109 expecting_sec_addr
= 0;
2110 if (++section_index
>= num_sect_opts
)
2113 sect_opts
= ((struct sect_opt
*)
2114 xrealloc (sect_opts
,
2116 * sizeof (struct sect_opt
)));
2120 error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
2125 /* This command takes at least two arguments. The first one is a
2126 filename, and the second is the address where this file has been
2127 loaded. Abort now if this address hasn't been provided by the
2129 if (section_index
< 1)
2130 error (_("The address where %s has been loaded is missing"), filename
);
2132 /* Print the prompt for the query below. And save the arguments into
2133 a sect_addr_info structure to be passed around to other
2134 functions. We have to split this up into separate print
2135 statements because hex_string returns a local static
2138 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
2139 section_addrs
= alloc_section_addr_info (section_index
);
2140 make_cleanup (xfree
, section_addrs
);
2141 for (i
= 0; i
< section_index
; i
++)
2144 char *val
= sect_opts
[i
].value
;
2145 char *sec
= sect_opts
[i
].name
;
2147 addr
= parse_and_eval_address (val
);
2149 /* Here we store the section offsets in the order they were
2150 entered on the command line. */
2151 section_addrs
->other
[sec_num
].name
= sec
;
2152 section_addrs
->other
[sec_num
].addr
= addr
;
2153 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2154 paddress (gdbarch
, addr
));
2157 /* The object's sections are initialized when a
2158 call is made to build_objfile_section_table (objfile).
2159 This happens in reread_symbols.
2160 At this point, we don't know what file type this is,
2161 so we can't determine what section names are valid. */
2164 if (from_tty
&& (!query ("%s", "")))
2165 error (_("Not confirmed."));
2167 symbol_file_add (filename
, from_tty
? SYMFILE_VERBOSE
: 0,
2168 section_addrs
, flags
);
2170 /* Getting new symbols may change our opinion about what is
2172 reinit_frame_cache ();
2173 do_cleanups (my_cleanups
);
2177 /* Re-read symbols if a symbol-file has changed. */
2179 reread_symbols (void)
2181 struct objfile
*objfile
;
2184 struct stat new_statbuf
;
2187 /* With the addition of shared libraries, this should be modified,
2188 the load time should be saved in the partial symbol tables, since
2189 different tables may come from different source files. FIXME.
2190 This routine should then walk down each partial symbol table
2191 and see if the symbol table that it originates from has been changed */
2193 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2195 /* solib-sunos.c creates one objfile with obfd. */
2196 if (objfile
->obfd
== NULL
)
2199 /* Separate debug objfiles are handled in the main objfile. */
2200 if (objfile
->separate_debug_objfile_backlink
)
2203 #ifdef DEPRECATED_IBM6000_TARGET
2204 /* If this object is from a shared library, then you should
2205 stat on the library name, not member name. */
2207 if (objfile
->obfd
->my_archive
)
2208 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2211 res
= stat (objfile
->name
, &new_statbuf
);
2214 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2215 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2219 new_modtime
= new_statbuf
.st_mtime
;
2220 if (new_modtime
!= objfile
->mtime
)
2222 struct cleanup
*old_cleanups
;
2223 struct section_offsets
*offsets
;
2225 char *obfd_filename
;
2227 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2230 /* There are various functions like symbol_file_add,
2231 symfile_bfd_open, syms_from_objfile, etc., which might
2232 appear to do what we want. But they have various other
2233 effects which we *don't* want. So we just do stuff
2234 ourselves. We don't worry about mapped files (for one thing,
2235 any mapped file will be out of date). */
2237 /* If we get an error, blow away this objfile (not sure if
2238 that is the correct response for things like shared
2240 old_cleanups
= make_cleanup_free_objfile (objfile
);
2241 /* We need to do this whenever any symbols go away. */
2242 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2244 if (exec_bfd
!= NULL
&& strcmp (bfd_get_filename (objfile
->obfd
),
2245 bfd_get_filename (exec_bfd
)) == 0)
2247 /* Reload EXEC_BFD without asking anything. */
2249 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2252 /* Clean up any state BFD has sitting around. We don't need
2253 to close the descriptor but BFD lacks a way of closing the
2254 BFD without closing the descriptor. */
2255 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2256 if (!bfd_close (objfile
->obfd
))
2257 error (_("Can't close BFD for %s: %s"), objfile
->name
,
2258 bfd_errmsg (bfd_get_error ()));
2259 objfile
->obfd
= bfd_open_maybe_remote (obfd_filename
);
2260 if (objfile
->obfd
== NULL
)
2261 error (_("Can't open %s to read symbols."), objfile
->name
);
2263 objfile
->obfd
= gdb_bfd_ref (objfile
->obfd
);
2264 /* bfd_openr sets cacheable to true, which is what we want. */
2265 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2266 error (_("Can't read symbols from %s: %s."), objfile
->name
,
2267 bfd_errmsg (bfd_get_error ()));
2269 /* Save the offsets, we will nuke them with the rest of the
2271 num_offsets
= objfile
->num_sections
;
2272 offsets
= ((struct section_offsets
*)
2273 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2274 memcpy (offsets
, objfile
->section_offsets
,
2275 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2277 /* Remove any references to this objfile in the global
2279 preserve_values (objfile
);
2281 /* Nuke all the state that we will re-read. Much of the following
2282 code which sets things to NULL really is necessary to tell
2283 other parts of GDB that there is nothing currently there.
2285 Try to keep the freeing order compatible with free_objfile. */
2287 if (objfile
->sf
!= NULL
)
2289 (*objfile
->sf
->sym_finish
) (objfile
);
2292 clear_objfile_data (objfile
);
2294 /* Free the separate debug objfiles. It will be
2295 automatically recreated by sym_read. */
2296 free_objfile_separate_debug (objfile
);
2298 /* FIXME: Do we have to free a whole linked list, or is this
2300 if (objfile
->global_psymbols
.list
)
2301 xfree (objfile
->global_psymbols
.list
);
2302 memset (&objfile
->global_psymbols
, 0,
2303 sizeof (objfile
->global_psymbols
));
2304 if (objfile
->static_psymbols
.list
)
2305 xfree (objfile
->static_psymbols
.list
);
2306 memset (&objfile
->static_psymbols
, 0,
2307 sizeof (objfile
->static_psymbols
));
2309 /* Free the obstacks for non-reusable objfiles */
2310 bcache_xfree (objfile
->psymbol_cache
);
2311 objfile
->psymbol_cache
= bcache_xmalloc ();
2312 bcache_xfree (objfile
->macro_cache
);
2313 objfile
->macro_cache
= bcache_xmalloc ();
2314 bcache_xfree (objfile
->filename_cache
);
2315 objfile
->filename_cache
= bcache_xmalloc ();
2316 if (objfile
->demangled_names_hash
!= NULL
)
2318 htab_delete (objfile
->demangled_names_hash
);
2319 objfile
->demangled_names_hash
= NULL
;
2321 obstack_free (&objfile
->objfile_obstack
, 0);
2322 objfile
->sections
= NULL
;
2323 objfile
->symtabs
= NULL
;
2324 objfile
->psymtabs
= NULL
;
2325 objfile
->psymtabs_addrmap
= NULL
;
2326 objfile
->free_psymtabs
= NULL
;
2327 objfile
->cp_namespace_symtab
= NULL
;
2328 objfile
->msymbols
= NULL
;
2329 objfile
->deprecated_sym_private
= NULL
;
2330 objfile
->minimal_symbol_count
= 0;
2331 memset (&objfile
->msymbol_hash
, 0,
2332 sizeof (objfile
->msymbol_hash
));
2333 memset (&objfile
->msymbol_demangled_hash
, 0,
2334 sizeof (objfile
->msymbol_demangled_hash
));
2336 objfile
->psymbol_cache
= bcache_xmalloc ();
2337 objfile
->macro_cache
= bcache_xmalloc ();
2338 objfile
->filename_cache
= bcache_xmalloc ();
2339 /* obstack_init also initializes the obstack so it is
2340 empty. We could use obstack_specify_allocation but
2341 gdb_obstack.h specifies the alloc/dealloc
2343 obstack_init (&objfile
->objfile_obstack
);
2344 if (build_objfile_section_table (objfile
))
2346 error (_("Can't find the file sections in `%s': %s"),
2347 objfile
->name
, bfd_errmsg (bfd_get_error ()));
2349 terminate_minimal_symbol_table (objfile
);
2351 /* We use the same section offsets as from last time. I'm not
2352 sure whether that is always correct for shared libraries. */
2353 objfile
->section_offsets
= (struct section_offsets
*)
2354 obstack_alloc (&objfile
->objfile_obstack
,
2355 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2356 memcpy (objfile
->section_offsets
, offsets
,
2357 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2358 objfile
->num_sections
= num_offsets
;
2360 /* What the hell is sym_new_init for, anyway? The concept of
2361 distinguishing between the main file and additional files
2362 in this way seems rather dubious. */
2363 if (objfile
== symfile_objfile
)
2365 (*objfile
->sf
->sym_new_init
) (objfile
);
2368 (*objfile
->sf
->sym_init
) (objfile
);
2369 clear_complaints (&symfile_complaints
, 1, 1);
2370 /* Do not set flags as this is safe and we don't want to be
2372 (*objfile
->sf
->sym_read
) (objfile
, 0);
2373 if (!objfile_has_symbols (objfile
))
2376 printf_unfiltered (_("(no debugging symbols found)\n"));
2380 /* We're done reading the symbol file; finish off complaints. */
2381 clear_complaints (&symfile_complaints
, 0, 1);
2383 /* Getting new symbols may change our opinion about what is
2386 reinit_frame_cache ();
2388 /* Discard cleanups as symbol reading was successful. */
2389 discard_cleanups (old_cleanups
);
2391 /* If the mtime has changed between the time we set new_modtime
2392 and now, we *want* this to be out of date, so don't call stat
2394 objfile
->mtime
= new_modtime
;
2396 init_entry_point_info (objfile
);
2402 /* Notify objfiles that we've modified objfile sections. */
2403 objfiles_changed ();
2405 clear_symtab_users ();
2406 /* At least one objfile has changed, so we can consider that
2407 the executable we're debugging has changed too. */
2408 observer_notify_executable_changed ();
2421 static filename_language
*filename_language_table
;
2422 static int fl_table_size
, fl_table_next
;
2425 add_filename_language (char *ext
, enum language lang
)
2427 if (fl_table_next
>= fl_table_size
)
2429 fl_table_size
+= 10;
2430 filename_language_table
=
2431 xrealloc (filename_language_table
,
2432 fl_table_size
* sizeof (*filename_language_table
));
2435 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2436 filename_language_table
[fl_table_next
].lang
= lang
;
2440 static char *ext_args
;
2442 show_ext_args (struct ui_file
*file
, int from_tty
,
2443 struct cmd_list_element
*c
, const char *value
)
2445 fprintf_filtered (file
, _("\
2446 Mapping between filename extension and source language is \"%s\".\n"),
2451 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2454 char *cp
= ext_args
;
2457 /* First arg is filename extension, starting with '.' */
2459 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2461 /* Find end of first arg. */
2462 while (*cp
&& !isspace (*cp
))
2466 error (_("'%s': two arguments required -- filename extension and language"),
2469 /* Null-terminate first arg */
2472 /* Find beginning of second arg, which should be a source language. */
2473 while (*cp
&& isspace (*cp
))
2477 error (_("'%s': two arguments required -- filename extension and language"),
2480 /* Lookup the language from among those we know. */
2481 lang
= language_enum (cp
);
2483 /* Now lookup the filename extension: do we already know it? */
2484 for (i
= 0; i
< fl_table_next
; i
++)
2485 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2488 if (i
>= fl_table_next
)
2490 /* new file extension */
2491 add_filename_language (ext_args
, lang
);
2495 /* redefining a previously known filename extension */
2498 /* query ("Really make files of type %s '%s'?", */
2499 /* ext_args, language_str (lang)); */
2501 xfree (filename_language_table
[i
].ext
);
2502 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2503 filename_language_table
[i
].lang
= lang
;
2508 info_ext_lang_command (char *args
, int from_tty
)
2512 printf_filtered (_("Filename extensions and the languages they represent:"));
2513 printf_filtered ("\n\n");
2514 for (i
= 0; i
< fl_table_next
; i
++)
2515 printf_filtered ("\t%s\t- %s\n",
2516 filename_language_table
[i
].ext
,
2517 language_str (filename_language_table
[i
].lang
));
2521 init_filename_language_table (void)
2523 if (fl_table_size
== 0) /* protect against repetition */
2527 filename_language_table
=
2528 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2529 add_filename_language (".c", language_c
);
2530 add_filename_language (".C", language_cplus
);
2531 add_filename_language (".cc", language_cplus
);
2532 add_filename_language (".cp", language_cplus
);
2533 add_filename_language (".cpp", language_cplus
);
2534 add_filename_language (".cxx", language_cplus
);
2535 add_filename_language (".c++", language_cplus
);
2536 add_filename_language (".java", language_java
);
2537 add_filename_language (".class", language_java
);
2538 add_filename_language (".m", language_objc
);
2539 add_filename_language (".f", language_fortran
);
2540 add_filename_language (".F", language_fortran
);
2541 add_filename_language (".s", language_asm
);
2542 add_filename_language (".sx", language_asm
);
2543 add_filename_language (".S", language_asm
);
2544 add_filename_language (".pas", language_pascal
);
2545 add_filename_language (".p", language_pascal
);
2546 add_filename_language (".pp", language_pascal
);
2547 add_filename_language (".adb", language_ada
);
2548 add_filename_language (".ads", language_ada
);
2549 add_filename_language (".a", language_ada
);
2550 add_filename_language (".ada", language_ada
);
2555 deduce_language_from_filename (char *filename
)
2560 if (filename
!= NULL
)
2561 if ((cp
= strrchr (filename
, '.')) != NULL
)
2562 for (i
= 0; i
< fl_table_next
; i
++)
2563 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2564 return filename_language_table
[i
].lang
;
2566 return language_unknown
;
2571 Allocate and partly initialize a new symbol table. Return a pointer
2572 to it. error() if no space.
2574 Caller must set these fields:
2580 possibly free_named_symtabs (symtab->filename);
2584 allocate_symtab (char *filename
, struct objfile
*objfile
)
2586 struct symtab
*symtab
;
2588 symtab
= (struct symtab
*)
2589 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2590 memset (symtab
, 0, sizeof (*symtab
));
2591 symtab
->filename
= (char *) bcache (filename
, strlen (filename
) + 1,
2592 objfile
->filename_cache
);
2593 symtab
->fullname
= NULL
;
2594 symtab
->language
= deduce_language_from_filename (filename
);
2595 symtab
->debugformat
= "unknown";
2597 /* Hook it to the objfile it comes from */
2599 symtab
->objfile
= objfile
;
2600 symtab
->next
= objfile
->symtabs
;
2601 objfile
->symtabs
= symtab
;
2606 struct partial_symtab
*
2607 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
2609 struct partial_symtab
*psymtab
;
2611 if (objfile
->free_psymtabs
)
2613 psymtab
= objfile
->free_psymtabs
;
2614 objfile
->free_psymtabs
= psymtab
->next
;
2617 psymtab
= (struct partial_symtab
*)
2618 obstack_alloc (&objfile
->objfile_obstack
,
2619 sizeof (struct partial_symtab
));
2621 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2622 psymtab
->filename
= (char *) bcache (filename
, strlen (filename
) + 1,
2623 objfile
->filename_cache
);
2624 psymtab
->symtab
= NULL
;
2626 /* Prepend it to the psymtab list for the objfile it belongs to.
2627 Psymtabs are searched in most recent inserted -> least recent
2630 psymtab
->objfile
= objfile
;
2631 psymtab
->next
= objfile
->psymtabs
;
2632 objfile
->psymtabs
= psymtab
;
2635 struct partial_symtab
**prev_pst
;
2636 psymtab
->objfile
= objfile
;
2637 psymtab
->next
= NULL
;
2638 prev_pst
= &(objfile
->psymtabs
);
2639 while ((*prev_pst
) != NULL
)
2640 prev_pst
= &((*prev_pst
)->next
);
2641 (*prev_pst
) = psymtab
;
2649 discard_psymtab (struct partial_symtab
*pst
)
2651 struct partial_symtab
**prev_pst
;
2654 Empty psymtabs happen as a result of header files which don't
2655 have any symbols in them. There can be a lot of them. But this
2656 check is wrong, in that a psymtab with N_SLINE entries but
2657 nothing else is not empty, but we don't realize that. Fixing
2658 that without slowing things down might be tricky. */
2660 /* First, snip it out of the psymtab chain */
2662 prev_pst
= &(pst
->objfile
->psymtabs
);
2663 while ((*prev_pst
) != pst
)
2664 prev_pst
= &((*prev_pst
)->next
);
2665 (*prev_pst
) = pst
->next
;
2667 /* Next, put it on a free list for recycling */
2669 pst
->next
= pst
->objfile
->free_psymtabs
;
2670 pst
->objfile
->free_psymtabs
= pst
;
2674 /* Reset all data structures in gdb which may contain references to symbol
2678 clear_symtab_users (void)
2680 /* Someday, we should do better than this, by only blowing away
2681 the things that really need to be blown. */
2683 /* Clear the "current" symtab first, because it is no longer valid.
2684 breakpoint_re_set may try to access the current symtab. */
2685 clear_current_source_symtab_and_line ();
2688 breakpoint_re_set ();
2689 set_default_breakpoint (0, NULL
, 0, 0, 0);
2690 clear_pc_function_cache ();
2691 observer_notify_new_objfile (NULL
);
2693 /* Clear globals which might have pointed into a removed objfile.
2694 FIXME: It's not clear which of these are supposed to persist
2695 between expressions and which ought to be reset each time. */
2696 expression_context_block
= NULL
;
2697 innermost_block
= NULL
;
2699 /* Varobj may refer to old symbols, perform a cleanup. */
2700 varobj_invalidate ();
2705 clear_symtab_users_cleanup (void *ignore
)
2707 clear_symtab_users ();
2710 /* clear_symtab_users_once:
2712 This function is run after symbol reading, or from a cleanup.
2713 If an old symbol table was obsoleted, the old symbol table
2714 has been blown away, but the other GDB data structures that may
2715 reference it have not yet been cleared or re-directed. (The old
2716 symtab was zapped, and the cleanup queued, in free_named_symtab()
2719 This function can be queued N times as a cleanup, or called
2720 directly; it will do all the work the first time, and then will be a
2721 no-op until the next time it is queued. This works by bumping a
2722 counter at queueing time. Much later when the cleanup is run, or at
2723 the end of symbol processing (in case the cleanup is discarded), if
2724 the queued count is greater than the "done-count", we do the work
2725 and set the done-count to the queued count. If the queued count is
2726 less than or equal to the done-count, we just ignore the call. This
2727 is needed because reading a single .o file will often replace many
2728 symtabs (one per .h file, for example), and we don't want to reset
2729 the breakpoints N times in the user's face.
2731 The reason we both queue a cleanup, and call it directly after symbol
2732 reading, is because the cleanup protects us in case of errors, but is
2733 discarded if symbol reading is successful. */
2736 /* FIXME: As free_named_symtabs is currently a big noop this function
2737 is no longer needed. */
2738 static void clear_symtab_users_once (void);
2740 static int clear_symtab_users_queued
;
2741 static int clear_symtab_users_done
;
2744 clear_symtab_users_once (void)
2746 /* Enforce once-per-`do_cleanups'-semantics */
2747 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2749 clear_symtab_users_done
= clear_symtab_users_queued
;
2751 clear_symtab_users ();
2755 /* Delete the specified psymtab, and any others that reference it. */
2758 cashier_psymtab (struct partial_symtab
*pst
)
2760 struct partial_symtab
*ps
, *pprev
= NULL
;
2763 /* Find its previous psymtab in the chain */
2764 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2773 /* Unhook it from the chain. */
2774 if (ps
== pst
->objfile
->psymtabs
)
2775 pst
->objfile
->psymtabs
= ps
->next
;
2777 pprev
->next
= ps
->next
;
2779 /* FIXME, we can't conveniently deallocate the entries in the
2780 partial_symbol lists (global_psymbols/static_psymbols) that
2781 this psymtab points to. These just take up space until all
2782 the psymtabs are reclaimed. Ditto the dependencies list and
2783 filename, which are all in the objfile_obstack. */
2785 /* We need to cashier any psymtab that has this one as a dependency... */
2787 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2789 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2791 if (ps
->dependencies
[i
] == pst
)
2793 cashier_psymtab (ps
);
2794 goto again
; /* Must restart, chain has been munged. */
2801 /* If a symtab or psymtab for filename NAME is found, free it along
2802 with any dependent breakpoints, displays, etc.
2803 Used when loading new versions of object modules with the "add-file"
2804 command. This is only called on the top-level symtab or psymtab's name;
2805 it is not called for subsidiary files such as .h files.
2807 Return value is 1 if we blew away the environment, 0 if not.
2808 FIXME. The return value appears to never be used.
2810 FIXME. I think this is not the best way to do this. We should
2811 work on being gentler to the environment while still cleaning up
2812 all stray pointers into the freed symtab. */
2815 free_named_symtabs (char *name
)
2818 /* FIXME: With the new method of each objfile having it's own
2819 psymtab list, this function needs serious rethinking. In particular,
2820 why was it ever necessary to toss psymtabs with specific compilation
2821 unit filenames, as opposed to all psymtabs from a particular symbol
2823 Well, the answer is that some systems permit reloading of particular
2824 compilation units. We want to blow away any old info about these
2825 compilation units, regardless of which objfiles they arrived in. --gnu. */
2828 struct symtab
*prev
;
2829 struct partial_symtab
*ps
;
2830 struct blockvector
*bv
;
2833 /* We only wack things if the symbol-reload switch is set. */
2834 if (!symbol_reloading
)
2837 /* Some symbol formats have trouble providing file names... */
2838 if (name
== 0 || *name
== '\0')
2841 /* Look for a psymtab with the specified name. */
2844 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2846 if (strcmp (name
, ps
->filename
) == 0)
2848 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2849 goto again2
; /* Must restart, chain has been munged */
2853 /* Look for a symtab with the specified name. */
2855 for (s
= symtab_list
; s
; s
= s
->next
)
2857 if (strcmp (name
, s
->filename
) == 0)
2864 if (s
== symtab_list
)
2865 symtab_list
= s
->next
;
2867 prev
->next
= s
->next
;
2869 /* For now, queue a delete for all breakpoints, displays, etc., whether
2870 or not they depend on the symtab being freed. This should be
2871 changed so that only those data structures affected are deleted. */
2873 /* But don't delete anything if the symtab is empty.
2874 This test is necessary due to a bug in "dbxread.c" that
2875 causes empty symtabs to be created for N_SO symbols that
2876 contain the pathname of the object file. (This problem
2877 has been fixed in GDB 3.9x). */
2879 bv
= BLOCKVECTOR (s
);
2880 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2881 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2882 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2884 complaint (&symfile_complaints
, _("Replacing old symbols for `%s'"),
2886 clear_symtab_users_queued
++;
2887 make_cleanup (clear_symtab_users_once
, 0);
2891 complaint (&symfile_complaints
, _("Empty symbol table found for `%s'"),
2898 /* It is still possible that some breakpoints will be affected
2899 even though no symtab was found, since the file might have
2900 been compiled without debugging, and hence not be associated
2901 with a symtab. In order to handle this correctly, we would need
2902 to keep a list of text address ranges for undebuggable files.
2903 For now, we do nothing, since this is a fairly obscure case. */
2907 /* FIXME, what about the minimal symbol table? */
2914 /* Allocate and partially fill a partial symtab. It will be
2915 completely filled at the end of the symbol list.
2917 FILENAME is the name of the symbol-file we are reading from. */
2919 struct partial_symtab
*
2920 start_psymtab_common (struct objfile
*objfile
,
2921 struct section_offsets
*section_offsets
,
2922 const char *filename
,
2923 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2924 struct partial_symbol
**static_syms
)
2926 struct partial_symtab
*psymtab
;
2928 psymtab
= allocate_psymtab (filename
, objfile
);
2929 psymtab
->section_offsets
= section_offsets
;
2930 psymtab
->textlow
= textlow
;
2931 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2932 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2933 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2937 /* Helper function, initialises partial symbol structure and stashes
2938 it into objfile's bcache. Note that our caching mechanism will
2939 use all fields of struct partial_symbol to determine hash value of the
2940 structure. In other words, having two symbols with the same name but
2941 different domain (or address) is possible and correct. */
2943 static const struct partial_symbol
*
2944 add_psymbol_to_bcache (char *name
, int namelength
, int copy_name
,
2946 enum address_class
class,
2947 long val
, /* Value as a long */
2948 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2949 enum language language
, struct objfile
*objfile
,
2952 /* psymbol is static so that there will be no uninitialized gaps in the
2953 structure which might contain random data, causing cache misses in
2955 static struct partial_symbol psymbol
;
2957 /* However, we must ensure that the entire 'value' field has been
2958 zeroed before assigning to it, because an assignment may not
2959 write the entire field. */
2960 memset (&psymbol
.ginfo
.value
, 0, sizeof (psymbol
.ginfo
.value
));
2961 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2964 SYMBOL_VALUE (&psymbol
) = val
;
2968 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2970 SYMBOL_SECTION (&psymbol
) = 0;
2971 SYMBOL_LANGUAGE (&psymbol
) = language
;
2972 PSYMBOL_DOMAIN (&psymbol
) = domain
;
2973 PSYMBOL_CLASS (&psymbol
) = class;
2975 SYMBOL_SET_NAMES (&psymbol
, name
, namelength
, copy_name
, objfile
);
2977 /* Stash the partial symbol away in the cache */
2978 return bcache_full (&psymbol
, sizeof (struct partial_symbol
),
2979 objfile
->psymbol_cache
, added
);
2982 /* Helper function, adds partial symbol to the given partial symbol
2986 append_psymbol_to_list (struct psymbol_allocation_list
*list
,
2987 const struct partial_symbol
*psym
,
2988 struct objfile
*objfile
)
2990 if (list
->next
>= list
->list
+ list
->size
)
2991 extend_psymbol_list (list
, objfile
);
2992 *list
->next
++ = (struct partial_symbol
*) psym
;
2993 OBJSTAT (objfile
, n_psyms
++);
2996 /* Add a symbol with a long value to a psymtab.
2997 Since one arg is a struct, we pass in a ptr and deref it (sigh).
2998 Return the partial symbol that has been added. */
3000 /* NOTE: carlton/2003-09-11: The reason why we return the partial
3001 symbol is so that callers can get access to the symbol's demangled
3002 name, which they don't have any cheap way to determine otherwise.
3003 (Currenly, dwarf2read.c is the only file who uses that information,
3004 though it's possible that other readers might in the future.)
3005 Elena wasn't thrilled about that, and I don't blame her, but we
3006 couldn't come up with a better way to get that information. If
3007 it's needed in other situations, we could consider breaking up
3008 SYMBOL_SET_NAMES to provide access to the demangled name lookup
3011 const struct partial_symbol
*
3012 add_psymbol_to_list (char *name
, int namelength
, int copy_name
,
3014 enum address_class
class,
3015 struct psymbol_allocation_list
*list
,
3016 long val
, /* Value as a long */
3017 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
3018 enum language language
, struct objfile
*objfile
)
3020 const struct partial_symbol
*psym
;
3024 /* Stash the partial symbol away in the cache */
3025 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, class,
3026 val
, coreaddr
, language
, objfile
, &added
);
3028 /* Do not duplicate global partial symbols. */
3029 if (list
== &objfile
->global_psymbols
3033 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
3034 append_psymbol_to_list (list
, psym
, objfile
);
3038 /* Initialize storage for partial symbols. */
3041 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
3043 /* Free any previously allocated psymbol lists. */
3045 if (objfile
->global_psymbols
.list
)
3047 xfree (objfile
->global_psymbols
.list
);
3049 if (objfile
->static_psymbols
.list
)
3051 xfree (objfile
->static_psymbols
.list
);
3054 /* Current best guess is that approximately a twentieth
3055 of the total symbols (in a debugging file) are global or static
3058 objfile
->global_psymbols
.size
= total_symbols
/ 10;
3059 objfile
->static_psymbols
.size
= total_symbols
/ 10;
3061 if (objfile
->global_psymbols
.size
> 0)
3063 objfile
->global_psymbols
.next
=
3064 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
3065 xmalloc ((objfile
->global_psymbols
.size
3066 * sizeof (struct partial_symbol
*)));
3068 if (objfile
->static_psymbols
.size
> 0)
3070 objfile
->static_psymbols
.next
=
3071 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
3072 xmalloc ((objfile
->static_psymbols
.size
3073 * sizeof (struct partial_symbol
*)));
3078 The following code implements an abstraction for debugging overlay sections.
3080 The target model is as follows:
3081 1) The gnu linker will permit multiple sections to be mapped into the
3082 same VMA, each with its own unique LMA (or load address).
3083 2) It is assumed that some runtime mechanism exists for mapping the
3084 sections, one by one, from the load address into the VMA address.
3085 3) This code provides a mechanism for gdb to keep track of which
3086 sections should be considered to be mapped from the VMA to the LMA.
3087 This information is used for symbol lookup, and memory read/write.
3088 For instance, if a section has been mapped then its contents
3089 should be read from the VMA, otherwise from the LMA.
3091 Two levels of debugger support for overlays are available. One is
3092 "manual", in which the debugger relies on the user to tell it which
3093 overlays are currently mapped. This level of support is
3094 implemented entirely in the core debugger, and the information about
3095 whether a section is mapped is kept in the objfile->obj_section table.
3097 The second level of support is "automatic", and is only available if
3098 the target-specific code provides functionality to read the target's
3099 overlay mapping table, and translate its contents for the debugger
3100 (by updating the mapped state information in the obj_section tables).
3102 The interface is as follows:
3104 overlay map <name> -- tell gdb to consider this section mapped
3105 overlay unmap <name> -- tell gdb to consider this section unmapped
3106 overlay list -- list the sections that GDB thinks are mapped
3107 overlay read-target -- get the target's state of what's mapped
3108 overlay off/manual/auto -- set overlay debugging state
3109 Functional interface:
3110 find_pc_mapped_section(pc): if the pc is in the range of a mapped
3111 section, return that section.
3112 find_pc_overlay(pc): find any overlay section that contains
3113 the pc, either in its VMA or its LMA
3114 section_is_mapped(sect): true if overlay is marked as mapped
3115 section_is_overlay(sect): true if section's VMA != LMA
3116 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
3117 pc_in_unmapped_range(...): true if pc belongs to section's LMA
3118 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
3119 overlay_mapped_address(...): map an address from section's LMA to VMA
3120 overlay_unmapped_address(...): map an address from section's VMA to LMA
3121 symbol_overlayed_address(...): Return a "current" address for symbol:
3122 either in VMA or LMA depending on whether
3123 the symbol's section is currently mapped
3126 /* Overlay debugging state: */
3128 enum overlay_debugging_state overlay_debugging
= ovly_off
;
3129 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
3131 /* Function: section_is_overlay (SECTION)
3132 Returns true if SECTION has VMA not equal to LMA, ie.
3133 SECTION is loaded at an address different from where it will "run". */
3136 section_is_overlay (struct obj_section
*section
)
3138 if (overlay_debugging
&& section
)
3140 bfd
*abfd
= section
->objfile
->obfd
;
3141 asection
*bfd_section
= section
->the_bfd_section
;
3143 if (bfd_section_lma (abfd
, bfd_section
) != 0
3144 && bfd_section_lma (abfd
, bfd_section
)
3145 != bfd_section_vma (abfd
, bfd_section
))
3152 /* Function: overlay_invalidate_all (void)
3153 Invalidate the mapped state of all overlay sections (mark it as stale). */
3156 overlay_invalidate_all (void)
3158 struct objfile
*objfile
;
3159 struct obj_section
*sect
;
3161 ALL_OBJSECTIONS (objfile
, sect
)
3162 if (section_is_overlay (sect
))
3163 sect
->ovly_mapped
= -1;
3166 /* Function: section_is_mapped (SECTION)
3167 Returns true if section is an overlay, and is currently mapped.
3169 Access to the ovly_mapped flag is restricted to this function, so
3170 that we can do automatic update. If the global flag
3171 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3172 overlay_invalidate_all. If the mapped state of the particular
3173 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3176 section_is_mapped (struct obj_section
*osect
)
3178 struct gdbarch
*gdbarch
;
3180 if (osect
== 0 || !section_is_overlay (osect
))
3183 switch (overlay_debugging
)
3187 return 0; /* overlay debugging off */
3188 case ovly_auto
: /* overlay debugging automatic */
3189 /* Unles there is a gdbarch_overlay_update function,
3190 there's really nothing useful to do here (can't really go auto) */
3191 gdbarch
= get_objfile_arch (osect
->objfile
);
3192 if (gdbarch_overlay_update_p (gdbarch
))
3194 if (overlay_cache_invalid
)
3196 overlay_invalidate_all ();
3197 overlay_cache_invalid
= 0;
3199 if (osect
->ovly_mapped
== -1)
3200 gdbarch_overlay_update (gdbarch
, osect
);
3202 /* fall thru to manual case */
3203 case ovly_on
: /* overlay debugging manual */
3204 return osect
->ovly_mapped
== 1;
3208 /* Function: pc_in_unmapped_range
3209 If PC falls into the lma range of SECTION, return true, else false. */
3212 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3214 if (section_is_overlay (section
))
3216 bfd
*abfd
= section
->objfile
->obfd
;
3217 asection
*bfd_section
= section
->the_bfd_section
;
3219 /* We assume the LMA is relocated by the same offset as the VMA. */
3220 bfd_vma size
= bfd_get_section_size (bfd_section
);
3221 CORE_ADDR offset
= obj_section_offset (section
);
3223 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3224 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3231 /* Function: pc_in_mapped_range
3232 If PC falls into the vma range of SECTION, return true, else false. */
3235 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3237 if (section_is_overlay (section
))
3239 if (obj_section_addr (section
) <= pc
3240 && pc
< obj_section_endaddr (section
))
3248 /* Return true if the mapped ranges of sections A and B overlap, false
3251 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3253 CORE_ADDR a_start
= obj_section_addr (a
);
3254 CORE_ADDR a_end
= obj_section_endaddr (a
);
3255 CORE_ADDR b_start
= obj_section_addr (b
);
3256 CORE_ADDR b_end
= obj_section_endaddr (b
);
3258 return (a_start
< b_end
&& b_start
< a_end
);
3261 /* Function: overlay_unmapped_address (PC, SECTION)
3262 Returns the address corresponding to PC in the unmapped (load) range.
3263 May be the same as PC. */
3266 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3268 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3270 bfd
*abfd
= section
->objfile
->obfd
;
3271 asection
*bfd_section
= section
->the_bfd_section
;
3273 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3274 - bfd_section_vma (abfd
, bfd_section
);
3280 /* Function: overlay_mapped_address (PC, SECTION)
3281 Returns the address corresponding to PC in the mapped (runtime) range.
3282 May be the same as PC. */
3285 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3287 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3289 bfd
*abfd
= section
->objfile
->obfd
;
3290 asection
*bfd_section
= section
->the_bfd_section
;
3292 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3293 - bfd_section_lma (abfd
, bfd_section
);
3300 /* Function: symbol_overlayed_address
3301 Return one of two addresses (relative to the VMA or to the LMA),
3302 depending on whether the section is mapped or not. */
3305 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3307 if (overlay_debugging
)
3309 /* If the symbol has no section, just return its regular address. */
3312 /* If the symbol's section is not an overlay, just return its address */
3313 if (!section_is_overlay (section
))
3315 /* If the symbol's section is mapped, just return its address */
3316 if (section_is_mapped (section
))
3319 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3320 * then return its LOADED address rather than its vma address!!
3322 return overlay_unmapped_address (address
, section
);
3327 /* Function: find_pc_overlay (PC)
3328 Return the best-match overlay section for PC:
3329 If PC matches a mapped overlay section's VMA, return that section.
3330 Else if PC matches an unmapped section's VMA, return that section.
3331 Else if PC matches an unmapped section's LMA, return that section. */
3333 struct obj_section
*
3334 find_pc_overlay (CORE_ADDR pc
)
3336 struct objfile
*objfile
;
3337 struct obj_section
*osect
, *best_match
= NULL
;
3339 if (overlay_debugging
)
3340 ALL_OBJSECTIONS (objfile
, osect
)
3341 if (section_is_overlay (osect
))
3343 if (pc_in_mapped_range (pc
, osect
))
3345 if (section_is_mapped (osect
))
3350 else if (pc_in_unmapped_range (pc
, osect
))
3356 /* Function: find_pc_mapped_section (PC)
3357 If PC falls into the VMA address range of an overlay section that is
3358 currently marked as MAPPED, return that section. Else return NULL. */
3360 struct obj_section
*
3361 find_pc_mapped_section (CORE_ADDR pc
)
3363 struct objfile
*objfile
;
3364 struct obj_section
*osect
;
3366 if (overlay_debugging
)
3367 ALL_OBJSECTIONS (objfile
, osect
)
3368 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3374 /* Function: list_overlays_command
3375 Print a list of mapped sections and their PC ranges */
3378 list_overlays_command (char *args
, int from_tty
)
3381 struct objfile
*objfile
;
3382 struct obj_section
*osect
;
3384 if (overlay_debugging
)
3385 ALL_OBJSECTIONS (objfile
, osect
)
3386 if (section_is_mapped (osect
))
3388 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3393 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3394 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3395 size
= bfd_get_section_size (osect
->the_bfd_section
);
3396 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3398 printf_filtered ("Section %s, loaded at ", name
);
3399 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3400 puts_filtered (" - ");
3401 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3402 printf_filtered (", mapped at ");
3403 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3404 puts_filtered (" - ");
3405 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3406 puts_filtered ("\n");
3411 printf_filtered (_("No sections are mapped.\n"));
3414 /* Function: map_overlay_command
3415 Mark the named section as mapped (ie. residing at its VMA address). */
3418 map_overlay_command (char *args
, int from_tty
)
3420 struct objfile
*objfile
, *objfile2
;
3421 struct obj_section
*sec
, *sec2
;
3423 if (!overlay_debugging
)
3425 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3426 the 'overlay manual' command."));
3428 if (args
== 0 || *args
== 0)
3429 error (_("Argument required: name of an overlay section"));
3431 /* First, find a section matching the user supplied argument */
3432 ALL_OBJSECTIONS (objfile
, sec
)
3433 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3435 /* Now, check to see if the section is an overlay. */
3436 if (!section_is_overlay (sec
))
3437 continue; /* not an overlay section */
3439 /* Mark the overlay as "mapped" */
3440 sec
->ovly_mapped
= 1;
3442 /* Next, make a pass and unmap any sections that are
3443 overlapped by this new section: */
3444 ALL_OBJSECTIONS (objfile2
, sec2
)
3445 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3448 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3449 bfd_section_name (objfile
->obfd
,
3450 sec2
->the_bfd_section
));
3451 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3455 error (_("No overlay section called %s"), args
);
3458 /* Function: unmap_overlay_command
3459 Mark the overlay section as unmapped
3460 (ie. resident in its LMA address range, rather than the VMA range). */
3463 unmap_overlay_command (char *args
, int from_tty
)
3465 struct objfile
*objfile
;
3466 struct obj_section
*sec
;
3468 if (!overlay_debugging
)
3470 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3471 the 'overlay manual' command."));
3473 if (args
== 0 || *args
== 0)
3474 error (_("Argument required: name of an overlay section"));
3476 /* First, find a section matching the user supplied argument */
3477 ALL_OBJSECTIONS (objfile
, sec
)
3478 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3480 if (!sec
->ovly_mapped
)
3481 error (_("Section %s is not mapped"), args
);
3482 sec
->ovly_mapped
= 0;
3485 error (_("No overlay section called %s"), args
);
3488 /* Function: overlay_auto_command
3489 A utility command to turn on overlay debugging.
3490 Possibly this should be done via a set/show command. */
3493 overlay_auto_command (char *args
, int from_tty
)
3495 overlay_debugging
= ovly_auto
;
3496 enable_overlay_breakpoints ();
3498 printf_unfiltered (_("Automatic overlay debugging enabled."));
3501 /* Function: overlay_manual_command
3502 A utility command to turn on overlay debugging.
3503 Possibly this should be done via a set/show command. */
3506 overlay_manual_command (char *args
, int from_tty
)
3508 overlay_debugging
= ovly_on
;
3509 disable_overlay_breakpoints ();
3511 printf_unfiltered (_("Overlay debugging enabled."));
3514 /* Function: overlay_off_command
3515 A utility command to turn on overlay debugging.
3516 Possibly this should be done via a set/show command. */
3519 overlay_off_command (char *args
, int from_tty
)
3521 overlay_debugging
= ovly_off
;
3522 disable_overlay_breakpoints ();
3524 printf_unfiltered (_("Overlay debugging disabled."));
3528 overlay_load_command (char *args
, int from_tty
)
3530 struct gdbarch
*gdbarch
= get_current_arch ();
3532 if (gdbarch_overlay_update_p (gdbarch
))
3533 gdbarch_overlay_update (gdbarch
, NULL
);
3535 error (_("This target does not know how to read its overlay state."));
3538 /* Function: overlay_command
3539 A place-holder for a mis-typed command */
3541 /* Command list chain containing all defined "overlay" subcommands. */
3542 struct cmd_list_element
*overlaylist
;
3545 overlay_command (char *args
, int from_tty
)
3548 ("\"overlay\" must be followed by the name of an overlay command.\n");
3549 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3553 /* Target Overlays for the "Simplest" overlay manager:
3555 This is GDB's default target overlay layer. It works with the
3556 minimal overlay manager supplied as an example by Cygnus. The
3557 entry point is via a function pointer "gdbarch_overlay_update",
3558 so targets that use a different runtime overlay manager can
3559 substitute their own overlay_update function and take over the
3562 The overlay_update function pokes around in the target's data structures
3563 to see what overlays are mapped, and updates GDB's overlay mapping with
3566 In this simple implementation, the target data structures are as follows:
3567 unsigned _novlys; /# number of overlay sections #/
3568 unsigned _ovly_table[_novlys][4] = {
3569 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3570 {..., ..., ..., ...},
3572 unsigned _novly_regions; /# number of overlay regions #/
3573 unsigned _ovly_region_table[_novly_regions][3] = {
3574 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3577 These functions will attempt to update GDB's mappedness state in the
3578 symbol section table, based on the target's mappedness state.
3580 To do this, we keep a cached copy of the target's _ovly_table, and
3581 attempt to detect when the cached copy is invalidated. The main
3582 entry point is "simple_overlay_update(SECT), which looks up SECT in
3583 the cached table and re-reads only the entry for that section from
3584 the target (whenever possible).
3587 /* Cached, dynamically allocated copies of the target data structures: */
3588 static unsigned (*cache_ovly_table
)[4] = 0;
3590 static unsigned (*cache_ovly_region_table
)[3] = 0;
3592 static unsigned cache_novlys
= 0;
3594 static unsigned cache_novly_regions
= 0;
3596 static CORE_ADDR cache_ovly_table_base
= 0;
3598 static CORE_ADDR cache_ovly_region_table_base
= 0;
3602 VMA
, SIZE
, LMA
, MAPPED
3605 /* Throw away the cached copy of _ovly_table */
3607 simple_free_overlay_table (void)
3609 if (cache_ovly_table
)
3610 xfree (cache_ovly_table
);
3612 cache_ovly_table
= NULL
;
3613 cache_ovly_table_base
= 0;
3617 /* Throw away the cached copy of _ovly_region_table */
3619 simple_free_overlay_region_table (void)
3621 if (cache_ovly_region_table
)
3622 xfree (cache_ovly_region_table
);
3623 cache_novly_regions
= 0;
3624 cache_ovly_region_table
= NULL
;
3625 cache_ovly_region_table_base
= 0;
3629 /* Read an array of ints of size SIZE from the target into a local buffer.
3630 Convert to host order. int LEN is number of ints */
3632 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3633 int len
, int size
, enum bfd_endian byte_order
)
3635 /* FIXME (alloca): Not safe if array is very large. */
3636 gdb_byte
*buf
= alloca (len
* size
);
3639 read_memory (memaddr
, buf
, len
* size
);
3640 for (i
= 0; i
< len
; i
++)
3641 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3644 /* Find and grab a copy of the target _ovly_table
3645 (and _novlys, which is needed for the table's size) */
3647 simple_read_overlay_table (void)
3649 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3650 struct gdbarch
*gdbarch
;
3652 enum bfd_endian byte_order
;
3654 simple_free_overlay_table ();
3655 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3658 error (_("Error reading inferior's overlay table: "
3659 "couldn't find `_novlys' variable\n"
3660 "in inferior. Use `overlay manual' mode."));
3664 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3665 if (! ovly_table_msym
)
3667 error (_("Error reading inferior's overlay table: couldn't find "
3668 "`_ovly_table' array\n"
3669 "in inferior. Use `overlay manual' mode."));
3673 gdbarch
= get_objfile_arch (msymbol_objfile (ovly_table_msym
));
3674 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3675 byte_order
= gdbarch_byte_order (gdbarch
);
3677 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
),
3680 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3681 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3682 read_target_long_array (cache_ovly_table_base
,
3683 (unsigned int *) cache_ovly_table
,
3684 cache_novlys
* 4, word_size
, byte_order
);
3686 return 1; /* SUCCESS */
3690 /* Find and grab a copy of the target _ovly_region_table
3691 (and _novly_regions, which is needed for the table's size) */
3693 simple_read_overlay_region_table (void)
3695 struct minimal_symbol
*msym
;
3696 struct gdbarch
*gdbarch
;
3698 enum bfd_endian byte_order
;
3700 simple_free_overlay_region_table ();
3701 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3703 return 0; /* failure */
3705 gdbarch
= get_objfile_arch (msymbol_objfile (msym
));
3706 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3707 byte_order
= gdbarch_byte_order (gdbarch
);
3709 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
),
3712 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3713 if (cache_ovly_region_table
!= NULL
)
3715 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3718 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3719 read_target_long_array (cache_ovly_region_table_base
,
3720 (unsigned int *) cache_ovly_region_table
,
3721 cache_novly_regions
* 3,
3722 word_size
, byte_order
);
3725 return 0; /* failure */
3728 return 0; /* failure */
3729 return 1; /* SUCCESS */
3733 /* Function: simple_overlay_update_1
3734 A helper function for simple_overlay_update. Assuming a cached copy
3735 of _ovly_table exists, look through it to find an entry whose vma,
3736 lma and size match those of OSECT. Re-read the entry and make sure
3737 it still matches OSECT (else the table may no longer be valid).
3738 Set OSECT's mapped state to match the entry. Return: 1 for
3739 success, 0 for failure. */
3742 simple_overlay_update_1 (struct obj_section
*osect
)
3745 bfd
*obfd
= osect
->objfile
->obfd
;
3746 asection
*bsect
= osect
->the_bfd_section
;
3747 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3748 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3749 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3751 size
= bfd_get_section_size (osect
->the_bfd_section
);
3752 for (i
= 0; i
< cache_novlys
; i
++)
3753 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3754 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3755 /* && cache_ovly_table[i][SIZE] == size */ )
3757 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3758 (unsigned int *) cache_ovly_table
[i
],
3759 4, word_size
, byte_order
);
3760 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3761 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3762 /* && cache_ovly_table[i][SIZE] == size */ )
3764 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3767 else /* Warning! Warning! Target's ovly table has changed! */
3773 /* Function: simple_overlay_update
3774 If OSECT is NULL, then update all sections' mapped state
3775 (after re-reading the entire target _ovly_table).
3776 If OSECT is non-NULL, then try to find a matching entry in the
3777 cached ovly_table and update only OSECT's mapped state.
3778 If a cached entry can't be found or the cache isn't valid, then
3779 re-read the entire cache, and go ahead and update all sections. */
3782 simple_overlay_update (struct obj_section
*osect
)
3784 struct objfile
*objfile
;
3786 /* Were we given an osect to look up? NULL means do all of them. */
3788 /* Have we got a cached copy of the target's overlay table? */
3789 if (cache_ovly_table
!= NULL
)
3790 /* Does its cached location match what's currently in the symtab? */
3791 if (cache_ovly_table_base
==
3792 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3793 /* Then go ahead and try to look up this single section in the cache */
3794 if (simple_overlay_update_1 (osect
))
3795 /* Found it! We're done. */
3798 /* Cached table no good: need to read the entire table anew.
3799 Or else we want all the sections, in which case it's actually
3800 more efficient to read the whole table in one block anyway. */
3802 if (! simple_read_overlay_table ())
3805 /* Now may as well update all sections, even if only one was requested. */
3806 ALL_OBJSECTIONS (objfile
, osect
)
3807 if (section_is_overlay (osect
))
3810 bfd
*obfd
= osect
->objfile
->obfd
;
3811 asection
*bsect
= osect
->the_bfd_section
;
3813 size
= bfd_get_section_size (bsect
);
3814 for (i
= 0; i
< cache_novlys
; i
++)
3815 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3816 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3817 /* && cache_ovly_table[i][SIZE] == size */ )
3818 { /* obj_section matches i'th entry in ovly_table */
3819 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3820 break; /* finished with inner for loop: break out */
3825 /* Set the output sections and output offsets for section SECTP in
3826 ABFD. The relocation code in BFD will read these offsets, so we
3827 need to be sure they're initialized. We map each section to itself,
3828 with no offset; this means that SECTP->vma will be honored. */
3831 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3833 sectp
->output_section
= sectp
;
3834 sectp
->output_offset
= 0;
3837 /* Relocate the contents of a debug section SECTP in ABFD. The
3838 contents are stored in BUF if it is non-NULL, or returned in a
3839 malloc'd buffer otherwise.
3841 For some platforms and debug info formats, shared libraries contain
3842 relocations against the debug sections (particularly for DWARF-2;
3843 one affected platform is PowerPC GNU/Linux, although it depends on
3844 the version of the linker in use). Also, ELF object files naturally
3845 have unresolved relocations for their debug sections. We need to apply
3846 the relocations in order to get the locations of symbols correct.
3847 Another example that may require relocation processing, is the
3848 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3852 symfile_relocate_debug_section (bfd
*abfd
, asection
*sectp
, bfd_byte
*buf
)
3854 /* We're only interested in sections with relocation
3856 if ((sectp
->flags
& SEC_RELOC
) == 0)
3859 /* We will handle section offsets properly elsewhere, so relocate as if
3860 all sections begin at 0. */
3861 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3863 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3866 struct symfile_segment_data
*
3867 get_symfile_segment_data (bfd
*abfd
)
3869 struct sym_fns
*sf
= find_sym_fns (abfd
);
3874 return sf
->sym_segments (abfd
);
3878 free_symfile_segment_data (struct symfile_segment_data
*data
)
3880 xfree (data
->segment_bases
);
3881 xfree (data
->segment_sizes
);
3882 xfree (data
->segment_info
);
3888 - DATA, containing segment addresses from the object file ABFD, and
3889 the mapping from ABFD's sections onto the segments that own them,
3891 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3892 segment addresses reported by the target,
3893 store the appropriate offsets for each section in OFFSETS.
3895 If there are fewer entries in SEGMENT_BASES than there are segments
3896 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3898 If there are more entries, then ignore the extra. The target may
3899 not be able to distinguish between an empty data segment and a
3900 missing data segment; a missing text segment is less plausible. */
3902 symfile_map_offsets_to_segments (bfd
*abfd
, struct symfile_segment_data
*data
,
3903 struct section_offsets
*offsets
,
3904 int num_segment_bases
,
3905 const CORE_ADDR
*segment_bases
)
3910 /* It doesn't make sense to call this function unless you have some
3911 segment base addresses. */
3912 gdb_assert (segment_bases
> 0);
3914 /* If we do not have segment mappings for the object file, we
3915 can not relocate it by segments. */
3916 gdb_assert (data
!= NULL
);
3917 gdb_assert (data
->num_segments
> 0);
3919 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3921 int which
= data
->segment_info
[i
];
3923 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3925 /* Don't bother computing offsets for sections that aren't
3926 loaded as part of any segment. */
3930 /* Use the last SEGMENT_BASES entry as the address of any extra
3931 segments mentioned in DATA->segment_info. */
3932 if (which
> num_segment_bases
)
3933 which
= num_segment_bases
;
3935 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3936 - data
->segment_bases
[which
- 1]);
3943 symfile_find_segment_sections (struct objfile
*objfile
)
3945 bfd
*abfd
= objfile
->obfd
;
3948 struct symfile_segment_data
*data
;
3950 data
= get_symfile_segment_data (objfile
->obfd
);
3954 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3956 free_symfile_segment_data (data
);
3960 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3963 int which
= data
->segment_info
[i
];
3967 if (objfile
->sect_index_text
== -1)
3968 objfile
->sect_index_text
= sect
->index
;
3970 if (objfile
->sect_index_rodata
== -1)
3971 objfile
->sect_index_rodata
= sect
->index
;
3973 else if (which
== 2)
3975 if (objfile
->sect_index_data
== -1)
3976 objfile
->sect_index_data
= sect
->index
;
3978 if (objfile
->sect_index_bss
== -1)
3979 objfile
->sect_index_bss
= sect
->index
;
3983 free_symfile_segment_data (data
);
3987 _initialize_symfile (void)
3989 struct cmd_list_element
*c
;
3991 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
3992 Load symbol table from executable file FILE.\n\
3993 The `file' command can also load symbol tables, as well as setting the file\n\
3994 to execute."), &cmdlist
);
3995 set_cmd_completer (c
, filename_completer
);
3997 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
3998 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
3999 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
4000 ADDR is the starting address of the file's text.\n\
4001 The optional arguments are section-name section-address pairs and\n\
4002 should be specified if the data and bss segments are not contiguous\n\
4003 with the text. SECT is a section name to be loaded at SECT_ADDR."),
4005 set_cmd_completer (c
, filename_completer
);
4007 c
= add_cmd ("load", class_files
, load_command
, _("\
4008 Dynamically load FILE into the running program, and record its symbols\n\
4009 for access from GDB.\n\
4010 A load OFFSET may also be given."), &cmdlist
);
4011 set_cmd_completer (c
, filename_completer
);
4013 add_setshow_boolean_cmd ("symbol-reloading", class_support
,
4014 &symbol_reloading
, _("\
4015 Set dynamic symbol table reloading multiple times in one run."), _("\
4016 Show dynamic symbol table reloading multiple times in one run."), NULL
,
4018 show_symbol_reloading
,
4019 &setlist
, &showlist
);
4021 add_prefix_cmd ("overlay", class_support
, overlay_command
,
4022 _("Commands for debugging overlays."), &overlaylist
,
4023 "overlay ", 0, &cmdlist
);
4025 add_com_alias ("ovly", "overlay", class_alias
, 1);
4026 add_com_alias ("ov", "overlay", class_alias
, 1);
4028 add_cmd ("map-overlay", class_support
, map_overlay_command
,
4029 _("Assert that an overlay section is mapped."), &overlaylist
);
4031 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
4032 _("Assert that an overlay section is unmapped."), &overlaylist
);
4034 add_cmd ("list-overlays", class_support
, list_overlays_command
,
4035 _("List mappings of overlay sections."), &overlaylist
);
4037 add_cmd ("manual", class_support
, overlay_manual_command
,
4038 _("Enable overlay debugging."), &overlaylist
);
4039 add_cmd ("off", class_support
, overlay_off_command
,
4040 _("Disable overlay debugging."), &overlaylist
);
4041 add_cmd ("auto", class_support
, overlay_auto_command
,
4042 _("Enable automatic overlay debugging."), &overlaylist
);
4043 add_cmd ("load-target", class_support
, overlay_load_command
,
4044 _("Read the overlay mapping state from the target."), &overlaylist
);
4046 /* Filename extension to source language lookup table: */
4047 init_filename_language_table ();
4048 add_setshow_string_noescape_cmd ("extension-language", class_files
,
4050 Set mapping between filename extension and source language."), _("\
4051 Show mapping between filename extension and source language."), _("\
4052 Usage: set extension-language .foo bar"),
4053 set_ext_lang_command
,
4055 &setlist
, &showlist
);
4057 add_info ("extensions", info_ext_lang_command
,
4058 _("All filename extensions associated with a source language."));
4060 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
4061 &debug_file_directory
, _("\
4062 Set the directories where separate debug symbols are searched for."), _("\
4063 Show the directories where separate debug symbols are searched for."), _("\
4064 Separate debug symbols are first searched for in the same\n\
4065 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
4066 and lastly at the path of the directory of the binary with\n\
4067 each global debug-file-directory component prepended."),
4069 show_debug_file_directory
,
4070 &setlist
, &showlist
);