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
;
332 /* Return a freshly allocated copy of ADDRS. The section names, if
333 any, are also freshly allocated copies of those in ADDRS. */
334 struct section_addr_info
*
335 copy_section_addr_info (struct section_addr_info
*addrs
)
337 struct section_addr_info
*copy
338 = alloc_section_addr_info (addrs
->num_sections
);
341 copy
->num_sections
= addrs
->num_sections
;
342 for (i
= 0; i
< addrs
->num_sections
; i
++)
344 copy
->other
[i
].addr
= addrs
->other
[i
].addr
;
345 if (addrs
->other
[i
].name
)
346 copy
->other
[i
].name
= xstrdup (addrs
->other
[i
].name
);
348 copy
->other
[i
].name
= NULL
;
349 copy
->other
[i
].sectindex
= addrs
->other
[i
].sectindex
;
357 /* Build (allocate and populate) a section_addr_info struct from
358 an existing section table. */
360 extern struct section_addr_info
*
361 build_section_addr_info_from_section_table (const struct target_section
*start
,
362 const struct target_section
*end
)
364 struct section_addr_info
*sap
;
365 const struct target_section
*stp
;
368 sap
= alloc_section_addr_info (end
- start
);
370 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
372 if (bfd_get_section_flags (stp
->bfd
,
373 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
374 && oidx
< end
- start
)
376 sap
->other
[oidx
].addr
= stp
->addr
;
377 sap
->other
[oidx
].name
378 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
379 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
387 /* Create a section_addr_info from section offsets in OBJFILE. */
389 static struct section_addr_info
*
390 build_section_addr_info_from_objfile (const struct objfile
*objfile
)
392 struct section_addr_info
*sap
;
394 struct bfd_section
*sec
;
396 sap
= alloc_section_addr_info (objfile
->num_sections
);
397 for (i
= 0, sec
= objfile
->obfd
->sections
;
398 i
< objfile
->num_sections
;
399 i
++, sec
= sec
->next
)
401 gdb_assert (sec
!= NULL
);
402 sap
->other
[i
].addr
= (bfd_get_section_vma (objfile
->obfd
, sec
)
403 + objfile
->section_offsets
->offsets
[i
]);
404 sap
->other
[i
].name
= xstrdup (bfd_get_section_name (objfile
->obfd
, sec
));
405 sap
->other
[i
].sectindex
= sec
->index
;
411 /* Free all memory allocated by build_section_addr_info_from_section_table. */
414 free_section_addr_info (struct section_addr_info
*sap
)
418 for (idx
= 0; idx
< sap
->num_sections
; idx
++)
419 if (sap
->other
[idx
].name
)
420 xfree (sap
->other
[idx
].name
);
425 /* Initialize OBJFILE's sect_index_* members. */
427 init_objfile_sect_indices (struct objfile
*objfile
)
432 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
434 objfile
->sect_index_text
= sect
->index
;
436 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
438 objfile
->sect_index_data
= sect
->index
;
440 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
442 objfile
->sect_index_bss
= sect
->index
;
444 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
446 objfile
->sect_index_rodata
= sect
->index
;
448 /* This is where things get really weird... We MUST have valid
449 indices for the various sect_index_* members or gdb will abort.
450 So if for example, there is no ".text" section, we have to
451 accomodate that. First, check for a file with the standard
452 one or two segments. */
454 symfile_find_segment_sections (objfile
);
456 /* Except when explicitly adding symbol files at some address,
457 section_offsets contains nothing but zeros, so it doesn't matter
458 which slot in section_offsets the individual sect_index_* members
459 index into. So if they are all zero, it is safe to just point
460 all the currently uninitialized indices to the first slot. But
461 beware: if this is the main executable, it may be relocated
462 later, e.g. by the remote qOffsets packet, and then this will
463 be wrong! That's why we try segments first. */
465 for (i
= 0; i
< objfile
->num_sections
; i
++)
467 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
472 if (i
== objfile
->num_sections
)
474 if (objfile
->sect_index_text
== -1)
475 objfile
->sect_index_text
= 0;
476 if (objfile
->sect_index_data
== -1)
477 objfile
->sect_index_data
= 0;
478 if (objfile
->sect_index_bss
== -1)
479 objfile
->sect_index_bss
= 0;
480 if (objfile
->sect_index_rodata
== -1)
481 objfile
->sect_index_rodata
= 0;
485 /* The arguments to place_section. */
487 struct place_section_arg
489 struct section_offsets
*offsets
;
493 /* Find a unique offset to use for loadable section SECT if
494 the user did not provide an offset. */
497 place_section (bfd
*abfd
, asection
*sect
, void *obj
)
499 struct place_section_arg
*arg
= obj
;
500 CORE_ADDR
*offsets
= arg
->offsets
->offsets
, start_addr
;
502 ULONGEST align
= ((ULONGEST
) 1) << bfd_get_section_alignment (abfd
, sect
);
504 /* We are only interested in allocated sections. */
505 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
508 /* If the user specified an offset, honor it. */
509 if (offsets
[sect
->index
] != 0)
512 /* Otherwise, let's try to find a place for the section. */
513 start_addr
= (arg
->lowest
+ align
- 1) & -align
;
520 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
522 int indx
= cur_sec
->index
;
523 CORE_ADDR cur_offset
;
525 /* We don't need to compare against ourself. */
529 /* We can only conflict with allocated sections. */
530 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
533 /* If the section offset is 0, either the section has not been placed
534 yet, or it was the lowest section placed (in which case LOWEST
535 will be past its end). */
536 if (offsets
[indx
] == 0)
539 /* If this section would overlap us, then we must move up. */
540 if (start_addr
+ bfd_get_section_size (sect
) > offsets
[indx
]
541 && start_addr
< offsets
[indx
] + bfd_get_section_size (cur_sec
))
543 start_addr
= offsets
[indx
] + bfd_get_section_size (cur_sec
);
544 start_addr
= (start_addr
+ align
- 1) & -align
;
549 /* Otherwise, we appear to be OK. So far. */
554 offsets
[sect
->index
] = start_addr
;
555 arg
->lowest
= start_addr
+ bfd_get_section_size (sect
);
558 /* Store struct section_addr_info as prepared (made relative and with SECTINDEX
559 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS
563 relative_addr_info_to_section_offsets (struct section_offsets
*section_offsets
,
565 struct section_addr_info
*addrs
)
569 memset (section_offsets
, 0, SIZEOF_N_SECTION_OFFSETS (num_sections
));
571 /* Now calculate offsets for section that were specified by the caller. */
572 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
574 struct other_sections
*osp
;
576 osp
= &addrs
->other
[i
];
580 /* Record all sections in offsets */
581 /* The section_offsets in the objfile are here filled in using
583 section_offsets
->offsets
[osp
->sectindex
] = osp
->addr
;
587 /* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
588 also SECTINDEXes there. */
591 addr_info_make_relative (struct section_addr_info
*addrs
, bfd
*abfd
)
593 asection
*lower_sect
;
595 CORE_ADDR lower_offset
;
598 /* Find lowest loadable section to be used as starting point for
599 continguous sections. FIXME!! won't work without call to find
600 .text first, but this assumes text is lowest section. */
601 lower_sect
= bfd_get_section_by_name (abfd
, ".text");
602 if (lower_sect
== NULL
)
603 bfd_map_over_sections (abfd
, find_lowest_section
, &lower_sect
);
604 if (lower_sect
== NULL
)
606 warning (_("no loadable sections found in added symbol-file %s"),
607 bfd_get_filename (abfd
));
611 lower_offset
= bfd_section_vma (bfd_get_filename (abfd
), lower_sect
);
613 /* Calculate offsets for the loadable sections.
614 FIXME! Sections must be in order of increasing loadable section
615 so that contiguous sections can use the lower-offset!!!
617 Adjust offsets if the segments are not contiguous.
618 If the section is contiguous, its offset should be set to
619 the offset of the highest loadable section lower than it
620 (the loadable section directly below it in memory).
621 this_offset = lower_offset = lower_addr - lower_orig_addr */
623 for (i
= 0; i
< addrs
->num_sections
&& addrs
->other
[i
].name
; i
++)
625 if (addrs
->other
[i
].addr
!= 0)
627 sect
= bfd_get_section_by_name (abfd
, addrs
->other
[i
].name
);
630 addrs
->other
[i
].addr
-= bfd_section_vma (abfd
, sect
);
631 lower_offset
= addrs
->other
[i
].addr
;
632 /* This is the index used by BFD. */
633 addrs
->other
[i
].sectindex
= sect
->index
;
637 warning (_("section %s not found in %s"), addrs
->other
[i
].name
,
638 bfd_get_filename (abfd
));
639 addrs
->other
[i
].addr
= 0;
643 addrs
->other
[i
].addr
= lower_offset
;
647 /* Parse the user's idea of an offset for dynamic linking, into our idea
648 of how to represent it for fast symbol reading. This is the default
649 version of the sym_fns.sym_offsets function for symbol readers that
650 don't need to do anything special. It allocates a section_offsets table
651 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
654 default_symfile_offsets (struct objfile
*objfile
,
655 struct section_addr_info
*addrs
)
657 objfile
->num_sections
= bfd_count_sections (objfile
->obfd
);
658 objfile
->section_offsets
= (struct section_offsets
*)
659 obstack_alloc (&objfile
->objfile_obstack
,
660 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
661 relative_addr_info_to_section_offsets (objfile
->section_offsets
,
662 objfile
->num_sections
, addrs
);
664 /* For relocatable files, all loadable sections will start at zero.
665 The zero is meaningless, so try to pick arbitrary addresses such
666 that no loadable sections overlap. This algorithm is quadratic,
667 but the number of sections in a single object file is generally
669 if ((bfd_get_file_flags (objfile
->obfd
) & (EXEC_P
| DYNAMIC
)) == 0)
671 struct place_section_arg arg
;
672 bfd
*abfd
= objfile
->obfd
;
674 CORE_ADDR lowest
= 0;
676 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
; cur_sec
= cur_sec
->next
)
677 /* We do not expect this to happen; just skip this step if the
678 relocatable file has a section with an assigned VMA. */
679 if (bfd_section_vma (abfd
, cur_sec
) != 0)
684 CORE_ADDR
*offsets
= objfile
->section_offsets
->offsets
;
686 /* Pick non-overlapping offsets for sections the user did not
688 arg
.offsets
= objfile
->section_offsets
;
690 bfd_map_over_sections (objfile
->obfd
, place_section
, &arg
);
692 /* Correctly filling in the section offsets is not quite
693 enough. Relocatable files have two properties that
694 (most) shared objects do not:
696 - Their debug information will contain relocations. Some
697 shared libraries do also, but many do not, so this can not
700 - If there are multiple code sections they will be loaded
701 at different relative addresses in memory than they are
702 in the objfile, since all sections in the file will start
705 Because GDB has very limited ability to map from an
706 address in debug info to the correct code section,
707 it relies on adding SECT_OFF_TEXT to things which might be
708 code. If we clear all the section offsets, and set the
709 section VMAs instead, then symfile_relocate_debug_section
710 will return meaningful debug information pointing at the
713 GDB has too many different data structures for section
714 addresses - a bfd, objfile, and so_list all have section
715 tables, as does exec_ops. Some of these could probably
718 for (cur_sec
= abfd
->sections
; cur_sec
!= NULL
;
719 cur_sec
= cur_sec
->next
)
721 if ((bfd_get_section_flags (abfd
, cur_sec
) & SEC_ALLOC
) == 0)
724 bfd_set_section_vma (abfd
, cur_sec
, offsets
[cur_sec
->index
]);
725 exec_set_section_address (bfd_get_filename (abfd
), cur_sec
->index
,
726 offsets
[cur_sec
->index
]);
727 offsets
[cur_sec
->index
] = 0;
732 /* Remember the bfd indexes for the .text, .data, .bss and
734 init_objfile_sect_indices (objfile
);
738 /* Divide the file into segments, which are individual relocatable units.
739 This is the default version of the sym_fns.sym_segments function for
740 symbol readers that do not have an explicit representation of segments.
741 It assumes that object files do not have segments, and fully linked
742 files have a single segment. */
744 struct symfile_segment_data
*
745 default_symfile_segments (bfd
*abfd
)
749 struct symfile_segment_data
*data
;
752 /* Relocatable files contain enough information to position each
753 loadable section independently; they should not be relocated
755 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) == 0)
758 /* Make sure there is at least one loadable section in the file. */
759 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
761 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
769 low
= bfd_get_section_vma (abfd
, sect
);
770 high
= low
+ bfd_get_section_size (sect
);
772 data
= XZALLOC (struct symfile_segment_data
);
773 data
->num_segments
= 1;
774 data
->segment_bases
= XCALLOC (1, CORE_ADDR
);
775 data
->segment_sizes
= XCALLOC (1, CORE_ADDR
);
777 num_sections
= bfd_count_sections (abfd
);
778 data
->segment_info
= XCALLOC (num_sections
, int);
780 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
784 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
787 vma
= bfd_get_section_vma (abfd
, sect
);
790 if (vma
+ bfd_get_section_size (sect
) > high
)
791 high
= vma
+ bfd_get_section_size (sect
);
793 data
->segment_info
[i
] = 1;
796 data
->segment_bases
[0] = low
;
797 data
->segment_sizes
[0] = high
- low
;
802 /* Process a symbol file, as either the main file or as a dynamically
805 OBJFILE is where the symbols are to be read from.
807 ADDRS is the list of section load addresses. If the user has given
808 an 'add-symbol-file' command, then this is the list of offsets and
809 addresses he or she provided as arguments to the command; or, if
810 we're handling a shared library, these are the actual addresses the
811 sections are loaded at, according to the inferior's dynamic linker
812 (as gleaned by GDB's shared library code). We convert each address
813 into an offset from the section VMA's as it appears in the object
814 file, and then call the file's sym_offsets function to convert this
815 into a format-specific offset table --- a `struct section_offsets'.
816 If ADDRS is non-zero, OFFSETS must be zero.
818 OFFSETS is a table of section offsets already in the right
819 format-specific representation. NUM_OFFSETS is the number of
820 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
821 assume this is the proper table the call to sym_offsets described
822 above would produce. Instead of calling sym_offsets, we just dump
823 it right into objfile->section_offsets. (When we're re-reading
824 symbols from an objfile, we don't have the original load address
825 list any more; all we have is the section offset table.) If
826 OFFSETS is non-zero, ADDRS must be zero.
828 ADD_FLAGS encodes verbosity level, whether this is main symbol or
829 an extra symbol file such as dynamically loaded code, and wether
830 breakpoint reset should be deferred. */
833 syms_from_objfile (struct objfile
*objfile
,
834 struct section_addr_info
*addrs
,
835 struct section_offsets
*offsets
,
839 struct section_addr_info
*local_addr
= NULL
;
840 struct cleanup
*old_chain
;
841 const int mainline
= add_flags
& SYMFILE_MAINLINE
;
843 gdb_assert (! (addrs
&& offsets
));
845 init_entry_point_info (objfile
);
846 objfile
->sf
= find_sym_fns (objfile
->obfd
);
848 if (objfile
->sf
== NULL
)
849 return; /* No symbols. */
851 /* Make sure that partially constructed symbol tables will be cleaned up
852 if an error occurs during symbol reading. */
853 old_chain
= make_cleanup_free_objfile (objfile
);
855 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
856 list. We now establish the convention that an addr of zero means
857 no load address was specified. */
858 if (! addrs
&& ! offsets
)
861 = alloc_section_addr_info (bfd_count_sections (objfile
->obfd
));
862 make_cleanup (xfree
, local_addr
);
866 /* Now either addrs or offsets is non-zero. */
870 /* We will modify the main symbol table, make sure that all its users
871 will be cleaned up if an error occurs during symbol reading. */
872 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
874 /* Since no error yet, throw away the old symbol table. */
876 if (symfile_objfile
!= NULL
)
878 free_objfile (symfile_objfile
);
879 gdb_assert (symfile_objfile
== NULL
);
882 /* Currently we keep symbols from the add-symbol-file command.
883 If the user wants to get rid of them, they should do "symbol-file"
884 without arguments first. Not sure this is the best behavior
887 (*objfile
->sf
->sym_new_init
) (objfile
);
890 /* Convert addr into an offset rather than an absolute address.
891 We find the lowest address of a loaded segment in the objfile,
892 and assume that <addr> is where that got loaded.
894 We no longer warn if the lowest section is not a text segment (as
895 happens for the PA64 port. */
896 if (addrs
&& addrs
->other
[0].name
)
897 addr_info_make_relative (addrs
, objfile
->obfd
);
899 /* Initialize symbol reading routines for this objfile, allow complaints to
900 appear for this new file, and record how verbose to be, then do the
901 initial symbol reading for this file. */
903 (*objfile
->sf
->sym_init
) (objfile
);
904 clear_complaints (&symfile_complaints
, 1, add_flags
& SYMFILE_VERBOSE
);
907 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
910 size_t size
= SIZEOF_N_SECTION_OFFSETS (num_offsets
);
912 /* Just copy in the offset table directly as given to us. */
913 objfile
->num_sections
= num_offsets
;
914 objfile
->section_offsets
915 = ((struct section_offsets
*)
916 obstack_alloc (&objfile
->objfile_obstack
, size
));
917 memcpy (objfile
->section_offsets
, offsets
, size
);
919 init_objfile_sect_indices (objfile
);
922 (*objfile
->sf
->sym_read
) (objfile
, add_flags
);
924 /* Discard cleanups as symbol reading was successful. */
926 discard_cleanups (old_chain
);
930 /* Perform required actions after either reading in the initial
931 symbols for a new objfile, or mapping in the symbols from a reusable
935 new_symfile_objfile (struct objfile
*objfile
, int add_flags
)
938 /* If this is the main symbol file we have to clean up all users of the
939 old main symbol file. Otherwise it is sufficient to fixup all the
940 breakpoints that may have been redefined by this symbol file. */
941 if (add_flags
& SYMFILE_MAINLINE
)
943 /* OK, make it the "real" symbol file. */
944 symfile_objfile
= objfile
;
946 clear_symtab_users ();
948 else if ((add_flags
& SYMFILE_DEFER_BP_RESET
) == 0)
950 breakpoint_re_set ();
953 /* We're done reading the symbol file; finish off complaints. */
954 clear_complaints (&symfile_complaints
, 0, add_flags
& SYMFILE_VERBOSE
);
957 /* Process a symbol file, as either the main file or as a dynamically
960 ABFD is a BFD already open on the file, as from symfile_bfd_open.
961 This BFD will be closed on error, and is always consumed by this function.
963 ADD_FLAGS encodes verbosity, whether this is main symbol file or
964 extra, such as dynamically loaded code, and what to do with breakpoins.
966 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
967 syms_from_objfile, above.
968 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
970 Upon success, returns a pointer to the objfile that was added.
971 Upon failure, jumps back to command level (never returns). */
973 static struct objfile
*
974 symbol_file_add_with_addrs_or_offsets (bfd
*abfd
,
976 struct section_addr_info
*addrs
,
977 struct section_offsets
*offsets
,
981 struct objfile
*objfile
;
982 struct partial_symtab
*psymtab
;
983 struct cleanup
*my_cleanups
;
984 const char *name
= bfd_get_filename (abfd
);
985 const int from_tty
= add_flags
& SYMFILE_VERBOSE
;
987 my_cleanups
= make_cleanup_bfd_close (abfd
);
989 /* Give user a chance to burp if we'd be
990 interactively wiping out any existing symbols. */
992 if ((have_full_symbols () || have_partial_symbols ())
993 && (add_flags
& SYMFILE_MAINLINE
)
995 && !query (_("Load new symbol table from \"%s\"? "), name
))
996 error (_("Not confirmed."));
998 objfile
= allocate_objfile (abfd
, flags
);
999 discard_cleanups (my_cleanups
);
1001 /* We either created a new mapped symbol table, mapped an existing
1002 symbol table file which has not had initial symbol reading
1003 performed, or need to read an unmapped symbol table. */
1004 if (from_tty
|| info_verbose
)
1006 if (deprecated_pre_add_symbol_hook
)
1007 deprecated_pre_add_symbol_hook (name
);
1010 printf_unfiltered (_("Reading symbols from %s..."), name
);
1012 gdb_flush (gdb_stdout
);
1015 syms_from_objfile (objfile
, addrs
, offsets
, num_offsets
,
1018 /* We now have at least a partial symbol table. Check to see if the
1019 user requested that all symbols be read on initial access via either
1020 the gdb startup command line or on a per symbol file basis. Expand
1021 all partial symbol tables for this objfile if so. */
1023 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
1025 if (from_tty
|| info_verbose
)
1027 printf_unfiltered (_("expanding to full symbols..."));
1029 gdb_flush (gdb_stdout
);
1032 for (psymtab
= objfile
->psymtabs
;
1034 psymtab
= psymtab
->next
)
1036 psymtab_to_symtab (psymtab
);
1040 if ((from_tty
|| info_verbose
)
1041 && !objfile_has_symbols (objfile
))
1044 printf_unfiltered (_("(no debugging symbols found)..."));
1048 if (from_tty
|| info_verbose
)
1050 if (deprecated_post_add_symbol_hook
)
1051 deprecated_post_add_symbol_hook ();
1053 printf_unfiltered (_("done.\n"));
1056 /* We print some messages regardless of whether 'from_tty ||
1057 info_verbose' is true, so make sure they go out at the right
1059 gdb_flush (gdb_stdout
);
1061 do_cleanups (my_cleanups
);
1063 if (objfile
->sf
== NULL
)
1065 observer_notify_new_objfile (objfile
);
1066 return objfile
; /* No symbols. */
1069 new_symfile_objfile (objfile
, add_flags
);
1071 observer_notify_new_objfile (objfile
);
1073 bfd_cache_close_all ();
1077 /* Add BFD as a separate debug file for OBJFILE. */
1080 symbol_file_add_separate (bfd
*bfd
, int symfile_flags
, struct objfile
*objfile
)
1082 struct objfile
*new_objfile
;
1083 struct section_addr_info
*sap
;
1084 struct cleanup
*my_cleanup
;
1086 /* Create section_addr_info. We can't directly use offsets from OBJFILE
1087 because sections of BFD may not match sections of OBJFILE and because
1088 vma may have been modified by tools such as prelink. */
1089 sap
= build_section_addr_info_from_objfile (objfile
);
1090 my_cleanup
= make_cleanup_free_section_addr_info (sap
);
1092 new_objfile
= symbol_file_add_with_addrs_or_offsets
1093 (bfd
, symfile_flags
,
1095 objfile
->flags
& (OBJF_REORDERED
| OBJF_SHARED
| OBJF_READNOW
1096 | OBJF_USERLOADED
));
1098 do_cleanups (my_cleanup
);
1100 add_separate_debug_objfile (new_objfile
, objfile
);
1103 /* Process the symbol file ABFD, as either the main file or as a
1104 dynamically loaded file.
1106 See symbol_file_add_with_addrs_or_offsets's comments for
1109 symbol_file_add_from_bfd (bfd
*abfd
, int add_flags
,
1110 struct section_addr_info
*addrs
,
1113 return symbol_file_add_with_addrs_or_offsets (abfd
, add_flags
, addrs
, 0, 0,
1118 /* Process a symbol file, as either the main file or as a dynamically
1119 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
1122 symbol_file_add (char *name
, int add_flags
, struct section_addr_info
*addrs
,
1125 return symbol_file_add_from_bfd (symfile_bfd_open (name
), add_flags
, addrs
,
1130 /* Call symbol_file_add() with default values and update whatever is
1131 affected by the loading of a new main().
1132 Used when the file is supplied in the gdb command line
1133 and by some targets with special loading requirements.
1134 The auxiliary function, symbol_file_add_main_1(), has the flags
1135 argument for the switches that can only be specified in the symbol_file
1139 symbol_file_add_main (char *args
, int from_tty
)
1141 symbol_file_add_main_1 (args
, from_tty
, 0);
1145 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
1147 const int add_flags
= SYMFILE_MAINLINE
| (from_tty
? SYMFILE_VERBOSE
: 0);
1148 symbol_file_add (args
, add_flags
, NULL
, flags
);
1150 /* Getting new symbols may change our opinion about
1151 what is frameless. */
1152 reinit_frame_cache ();
1154 set_initial_language ();
1158 symbol_file_clear (int from_tty
)
1160 if ((have_full_symbols () || have_partial_symbols ())
1163 ? !query (_("Discard symbol table from `%s'? "),
1164 symfile_objfile
->name
)
1165 : !query (_("Discard symbol table? "))))
1166 error (_("Not confirmed."));
1168 free_all_objfiles ();
1170 /* solib descriptors may have handles to objfiles. Since their
1171 storage has just been released, we'd better wipe the solib
1172 descriptors as well. */
1173 no_shared_libraries (NULL
, from_tty
);
1175 gdb_assert (symfile_objfile
== NULL
);
1177 printf_unfiltered (_("No symbol file now.\n"));
1181 get_debug_link_info (struct objfile
*objfile
, unsigned long *crc32_out
)
1184 bfd_size_type debuglink_size
;
1185 unsigned long crc32
;
1190 sect
= bfd_get_section_by_name (objfile
->obfd
, ".gnu_debuglink");
1195 debuglink_size
= bfd_section_size (objfile
->obfd
, sect
);
1197 contents
= xmalloc (debuglink_size
);
1198 bfd_get_section_contents (objfile
->obfd
, sect
, contents
,
1199 (file_ptr
)0, (bfd_size_type
)debuglink_size
);
1201 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1202 crc_offset
= strlen (contents
) + 1;
1203 crc_offset
= (crc_offset
+ 3) & ~3;
1205 crc32
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) (contents
+ crc_offset
));
1212 separate_debug_file_exists (const char *name
, unsigned long crc
,
1213 struct objfile
*parent_objfile
)
1215 unsigned long file_crc
= 0;
1217 gdb_byte buffer
[8*1024];
1219 struct stat parent_stat
, abfd_stat
;
1221 /* Find a separate debug info file as if symbols would be present in
1222 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
1223 section can contain just the basename of PARENT_OBJFILE without any
1224 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
1225 the separate debug infos with the same basename can exist. */
1227 if (strcmp (name
, parent_objfile
->name
) == 0)
1230 abfd
= bfd_open_maybe_remote (name
);
1235 /* Verify symlinks were not the cause of strcmp name difference above.
1237 Some operating systems, e.g. Windows, do not provide a meaningful
1238 st_ino; they always set it to zero. (Windows does provide a
1239 meaningful st_dev.) Do not indicate a duplicate library in that
1240 case. While there is no guarantee that a system that provides
1241 meaningful inode numbers will never set st_ino to zero, this is
1242 merely an optimization, so we do not need to worry about false
1245 if (bfd_stat (abfd
, &abfd_stat
) == 0
1246 && bfd_stat (parent_objfile
->obfd
, &parent_stat
) == 0
1247 && abfd_stat
.st_dev
== parent_stat
.st_dev
1248 && abfd_stat
.st_ino
== parent_stat
.st_ino
1249 && abfd_stat
.st_ino
!= 0)
1255 while ((count
= bfd_bread (buffer
, sizeof (buffer
), abfd
)) > 0)
1256 file_crc
= gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1260 if (crc
!= file_crc
)
1262 warning (_("the debug information found in \"%s\""
1263 " does not match \"%s\" (CRC mismatch).\n"),
1264 name
, parent_objfile
->name
);
1271 char *debug_file_directory
= NULL
;
1273 show_debug_file_directory (struct ui_file
*file
, int from_tty
,
1274 struct cmd_list_element
*c
, const char *value
)
1276 fprintf_filtered (file
, _("\
1277 The directory where separate debug symbols are searched for is \"%s\".\n"),
1281 #if ! defined (DEBUG_SUBDIRECTORY)
1282 #define DEBUG_SUBDIRECTORY ".debug"
1286 find_separate_debug_file_by_debuglink (struct objfile
*objfile
)
1289 char *basename
, *name_copy
, *debugdir
;
1291 char *debugfile
= NULL
;
1292 char *canon_name
= NULL
;
1293 bfd_size_type debuglink_size
;
1294 unsigned long crc32
;
1297 basename
= get_debug_link_info (objfile
, &crc32
);
1299 if (basename
== NULL
)
1300 /* There's no separate debug info, hence there's no way we could
1301 load it => no warning. */
1302 goto cleanup_return_debugfile
;
1304 dir
= xstrdup (objfile
->name
);
1306 /* Strip off the final filename part, leaving the directory name,
1307 followed by a slash. Objfile names should always be absolute and
1308 tilde-expanded, so there should always be a slash in there
1310 for (i
= strlen(dir
) - 1; i
>= 0; i
--)
1312 if (IS_DIR_SEPARATOR (dir
[i
]))
1315 gdb_assert (i
>= 0 && IS_DIR_SEPARATOR (dir
[i
]));
1318 /* Set I to max (strlen (canon_name), strlen (dir)). */
1319 canon_name
= lrealpath (dir
);
1321 if (canon_name
&& strlen (canon_name
) > i
)
1322 i
= strlen (canon_name
);
1324 debugfile
= xmalloc (strlen (debug_file_directory
) + 1
1326 + strlen (DEBUG_SUBDIRECTORY
)
1331 /* First try in the same directory as the original file. */
1332 strcpy (debugfile
, dir
);
1333 strcat (debugfile
, basename
);
1335 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1336 goto cleanup_return_debugfile
;
1338 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1339 strcpy (debugfile
, dir
);
1340 strcat (debugfile
, DEBUG_SUBDIRECTORY
);
1341 strcat (debugfile
, "/");
1342 strcat (debugfile
, basename
);
1344 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1345 goto cleanup_return_debugfile
;
1347 /* Then try in the global debugfile directories.
1349 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1350 cause "/..." lookups. */
1352 debugdir
= debug_file_directory
;
1357 while (*debugdir
== DIRNAME_SEPARATOR
)
1360 debugdir_end
= strchr (debugdir
, DIRNAME_SEPARATOR
);
1361 if (debugdir_end
== NULL
)
1362 debugdir_end
= &debugdir
[strlen (debugdir
)];
1364 memcpy (debugfile
, debugdir
, debugdir_end
- debugdir
);
1365 debugfile
[debugdir_end
- debugdir
] = 0;
1366 strcat (debugfile
, "/");
1367 strcat (debugfile
, dir
);
1368 strcat (debugfile
, basename
);
1370 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1371 goto cleanup_return_debugfile
;
1373 /* If the file is in the sysroot, try using its base path in the
1374 global debugfile directory. */
1376 && strncmp (canon_name
, gdb_sysroot
, strlen (gdb_sysroot
)) == 0
1377 && IS_DIR_SEPARATOR (canon_name
[strlen (gdb_sysroot
)]))
1379 memcpy (debugfile
, debugdir
, debugdir_end
- debugdir
);
1380 debugfile
[debugdir_end
- debugdir
] = 0;
1381 strcat (debugfile
, canon_name
+ strlen (gdb_sysroot
));
1382 strcat (debugfile
, "/");
1383 strcat (debugfile
, basename
);
1385 if (separate_debug_file_exists (debugfile
, crc32
, objfile
))
1386 goto cleanup_return_debugfile
;
1389 debugdir
= debugdir_end
;
1391 while (*debugdir
!= 0);
1396 cleanup_return_debugfile
:
1404 /* This is the symbol-file command. Read the file, analyze its
1405 symbols, and add a struct symtab to a symtab list. The syntax of
1406 the command is rather bizarre:
1408 1. The function buildargv implements various quoting conventions
1409 which are undocumented and have little or nothing in common with
1410 the way things are quoted (or not quoted) elsewhere in GDB.
1412 2. Options are used, which are not generally used in GDB (perhaps
1413 "set mapped on", "set readnow on" would be better)
1415 3. The order of options matters, which is contrary to GNU
1416 conventions (because it is confusing and inconvenient). */
1419 symbol_file_command (char *args
, int from_tty
)
1425 symbol_file_clear (from_tty
);
1429 char **argv
= gdb_buildargv (args
);
1430 int flags
= OBJF_USERLOADED
;
1431 struct cleanup
*cleanups
;
1434 cleanups
= make_cleanup_freeargv (argv
);
1435 while (*argv
!= NULL
)
1437 if (strcmp (*argv
, "-readnow") == 0)
1438 flags
|= OBJF_READNOW
;
1439 else if (**argv
== '-')
1440 error (_("unknown option `%s'"), *argv
);
1443 symbol_file_add_main_1 (*argv
, from_tty
, flags
);
1451 error (_("no symbol file name was specified"));
1453 do_cleanups (cleanups
);
1457 /* Set the initial language.
1459 FIXME: A better solution would be to record the language in the
1460 psymtab when reading partial symbols, and then use it (if known) to
1461 set the language. This would be a win for formats that encode the
1462 language in an easily discoverable place, such as DWARF. For
1463 stabs, we can jump through hoops looking for specially named
1464 symbols or try to intuit the language from the specific type of
1465 stabs we find, but we can't do that until later when we read in
1469 set_initial_language (void)
1471 struct partial_symtab
*pst
;
1472 enum language lang
= language_unknown
;
1474 pst
= find_main_psymtab ();
1477 if (pst
->filename
!= NULL
)
1478 lang
= deduce_language_from_filename (pst
->filename
);
1480 if (lang
== language_unknown
)
1482 /* Make C the default language */
1486 set_language (lang
);
1487 expected_language
= current_language
; /* Don't warn the user. */
1491 /* If NAME is a remote name open the file using remote protocol, otherwise
1492 open it normally. */
1495 bfd_open_maybe_remote (const char *name
)
1497 if (remote_filename_p (name
))
1498 return remote_bfd_open (name
, gnutarget
);
1500 return bfd_openr (name
, gnutarget
);
1504 /* Open the file specified by NAME and hand it off to BFD for
1505 preliminary analysis. Return a newly initialized bfd *, which
1506 includes a newly malloc'd` copy of NAME (tilde-expanded and made
1507 absolute). In case of trouble, error() is called. */
1510 symfile_bfd_open (char *name
)
1514 char *absolute_name
;
1516 if (remote_filename_p (name
))
1518 name
= xstrdup (name
);
1519 sym_bfd
= remote_bfd_open (name
, gnutarget
);
1522 make_cleanup (xfree
, name
);
1523 error (_("`%s': can't open to read symbols: %s."), name
,
1524 bfd_errmsg (bfd_get_error ()));
1527 if (!bfd_check_format (sym_bfd
, bfd_object
))
1529 bfd_close (sym_bfd
);
1530 make_cleanup (xfree
, name
);
1531 error (_("`%s': can't read symbols: %s."), name
,
1532 bfd_errmsg (bfd_get_error ()));
1538 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy. */
1540 /* Look down path for it, allocate 2nd new malloc'd copy. */
1541 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, name
,
1542 O_RDONLY
| O_BINARY
, &absolute_name
);
1543 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1546 char *exename
= alloca (strlen (name
) + 5);
1547 strcat (strcpy (exename
, name
), ".exe");
1548 desc
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
1549 O_RDONLY
| O_BINARY
, &absolute_name
);
1554 make_cleanup (xfree
, name
);
1555 perror_with_name (name
);
1558 /* Free 1st new malloc'd copy, but keep the 2nd malloc'd copy in
1559 bfd. It'll be freed in free_objfile(). */
1561 name
= absolute_name
;
1563 sym_bfd
= bfd_fopen (name
, gnutarget
, FOPEN_RB
, desc
);
1567 make_cleanup (xfree
, name
);
1568 error (_("`%s': can't open to read symbols: %s."), name
,
1569 bfd_errmsg (bfd_get_error ()));
1571 bfd_set_cacheable (sym_bfd
, 1);
1573 if (!bfd_check_format (sym_bfd
, bfd_object
))
1575 /* FIXME: should be checking for errors from bfd_close (for one
1576 thing, on error it does not free all the storage associated
1578 bfd_close (sym_bfd
); /* This also closes desc. */
1579 make_cleanup (xfree
, name
);
1580 error (_("`%s': can't read symbols: %s."), name
,
1581 bfd_errmsg (bfd_get_error ()));
1584 /* bfd_usrdata exists for applications and libbfd must not touch it. */
1585 gdb_assert (bfd_usrdata (sym_bfd
) == NULL
);
1590 /* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
1591 the section was not found. */
1594 get_section_index (struct objfile
*objfile
, char *section_name
)
1596 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1604 /* Link SF into the global symtab_fns list. Called on startup by the
1605 _initialize routine in each object file format reader, to register
1606 information about each format the the reader is prepared to
1610 add_symtab_fns (struct sym_fns
*sf
)
1612 sf
->next
= symtab_fns
;
1616 /* Initialize OBJFILE to read symbols from its associated BFD. It
1617 either returns or calls error(). The result is an initialized
1618 struct sym_fns in the objfile structure, that contains cached
1619 information about the symbol file. */
1621 static struct sym_fns
*
1622 find_sym_fns (bfd
*abfd
)
1625 enum bfd_flavour our_flavour
= bfd_get_flavour (abfd
);
1627 if (our_flavour
== bfd_target_srec_flavour
1628 || our_flavour
== bfd_target_ihex_flavour
1629 || our_flavour
== bfd_target_tekhex_flavour
)
1630 return NULL
; /* No symbols. */
1632 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1633 if (our_flavour
== sf
->sym_flavour
)
1636 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
1637 bfd_get_target (abfd
));
1641 /* This function runs the load command of our current target. */
1644 load_command (char *arg
, int from_tty
)
1646 /* The user might be reloading because the binary has changed. Take
1647 this opportunity to check. */
1648 reopen_exec_file ();
1656 parg
= arg
= get_exec_file (1);
1658 /* Count how many \ " ' tab space there are in the name. */
1659 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1667 /* We need to quote this string so buildargv can pull it apart. */
1668 char *temp
= xmalloc (strlen (arg
) + count
+ 1 );
1672 make_cleanup (xfree
, temp
);
1675 while ((parg
= strpbrk (parg
, "\\\"'\t ")))
1677 strncpy (ptemp
, prev
, parg
- prev
);
1678 ptemp
+= parg
- prev
;
1682 strcpy (ptemp
, prev
);
1688 target_load (arg
, from_tty
);
1690 /* After re-loading the executable, we don't really know which
1691 overlays are mapped any more. */
1692 overlay_cache_invalid
= 1;
1695 /* This version of "load" should be usable for any target. Currently
1696 it is just used for remote targets, not inftarg.c or core files,
1697 on the theory that only in that case is it useful.
1699 Avoiding xmodem and the like seems like a win (a) because we don't have
1700 to worry about finding it, and (b) On VMS, fork() is very slow and so
1701 we don't want to run a subprocess. On the other hand, I'm not sure how
1702 performance compares. */
1704 static int validate_download
= 0;
1706 /* Callback service function for generic_load (bfd_map_over_sections). */
1709 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1711 bfd_size_type
*sum
= data
;
1713 *sum
+= bfd_get_section_size (asec
);
1716 /* Opaque data for load_section_callback. */
1717 struct load_section_data
{
1718 unsigned long load_offset
;
1719 struct load_progress_data
*progress_data
;
1720 VEC(memory_write_request_s
) *requests
;
1723 /* Opaque data for load_progress. */
1724 struct load_progress_data
{
1725 /* Cumulative data. */
1726 unsigned long write_count
;
1727 unsigned long data_count
;
1728 bfd_size_type total_size
;
1731 /* Opaque data for load_progress for a single section. */
1732 struct load_progress_section_data
{
1733 struct load_progress_data
*cumulative
;
1735 /* Per-section data. */
1736 const char *section_name
;
1737 ULONGEST section_sent
;
1738 ULONGEST section_size
;
1743 /* Target write callback routine for progress reporting. */
1746 load_progress (ULONGEST bytes
, void *untyped_arg
)
1748 struct load_progress_section_data
*args
= untyped_arg
;
1749 struct load_progress_data
*totals
;
1752 /* Writing padding data. No easy way to get at the cumulative
1753 stats, so just ignore this. */
1756 totals
= args
->cumulative
;
1758 if (bytes
== 0 && args
->section_sent
== 0)
1760 /* The write is just starting. Let the user know we've started
1762 ui_out_message (uiout
, 0, "Loading section %s, size %s lma %s\n",
1763 args
->section_name
, hex_string (args
->section_size
),
1764 paddress (target_gdbarch
, args
->lma
));
1768 if (validate_download
)
1770 /* Broken memories and broken monitors manifest themselves here
1771 when bring new computers to life. This doubles already slow
1773 /* NOTE: cagney/1999-10-18: A more efficient implementation
1774 might add a verify_memory() method to the target vector and
1775 then use that. remote.c could implement that method using
1776 the ``qCRC'' packet. */
1777 gdb_byte
*check
= xmalloc (bytes
);
1778 struct cleanup
*verify_cleanups
= make_cleanup (xfree
, check
);
1780 if (target_read_memory (args
->lma
, check
, bytes
) != 0)
1781 error (_("Download verify read failed at %s"),
1782 paddress (target_gdbarch
, args
->lma
));
1783 if (memcmp (args
->buffer
, check
, bytes
) != 0)
1784 error (_("Download verify compare failed at %s"),
1785 paddress (target_gdbarch
, args
->lma
));
1786 do_cleanups (verify_cleanups
);
1788 totals
->data_count
+= bytes
;
1790 args
->buffer
+= bytes
;
1791 totals
->write_count
+= 1;
1792 args
->section_sent
+= bytes
;
1794 || (deprecated_ui_load_progress_hook
!= NULL
1795 && deprecated_ui_load_progress_hook (args
->section_name
,
1796 args
->section_sent
)))
1797 error (_("Canceled the download"));
1799 if (deprecated_show_load_progress
!= NULL
)
1800 deprecated_show_load_progress (args
->section_name
,
1804 totals
->total_size
);
1807 /* Callback service function for generic_load (bfd_map_over_sections). */
1810 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1812 struct memory_write_request
*new_request
;
1813 struct load_section_data
*args
= data
;
1814 struct load_progress_section_data
*section_data
;
1815 bfd_size_type size
= bfd_get_section_size (asec
);
1817 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1819 if ((bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
) == 0)
1825 new_request
= VEC_safe_push (memory_write_request_s
,
1826 args
->requests
, NULL
);
1827 memset (new_request
, 0, sizeof (struct memory_write_request
));
1828 section_data
= xcalloc (1, sizeof (struct load_progress_section_data
));
1829 new_request
->begin
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1830 new_request
->end
= new_request
->begin
+ size
; /* FIXME Should size be in instead? */
1831 new_request
->data
= xmalloc (size
);
1832 new_request
->baton
= section_data
;
1834 buffer
= new_request
->data
;
1836 section_data
->cumulative
= args
->progress_data
;
1837 section_data
->section_name
= sect_name
;
1838 section_data
->section_size
= size
;
1839 section_data
->lma
= new_request
->begin
;
1840 section_data
->buffer
= buffer
;
1842 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1845 /* Clean up an entire memory request vector, including load
1846 data and progress records. */
1849 clear_memory_write_data (void *arg
)
1851 VEC(memory_write_request_s
) **vec_p
= arg
;
1852 VEC(memory_write_request_s
) *vec
= *vec_p
;
1854 struct memory_write_request
*mr
;
1856 for (i
= 0; VEC_iterate (memory_write_request_s
, vec
, i
, mr
); ++i
)
1861 VEC_free (memory_write_request_s
, vec
);
1865 generic_load (char *args
, int from_tty
)
1868 struct timeval start_time
, end_time
;
1870 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, 0);
1871 struct load_section_data cbdata
;
1872 struct load_progress_data total_progress
;
1877 memset (&cbdata
, 0, sizeof (cbdata
));
1878 memset (&total_progress
, 0, sizeof (total_progress
));
1879 cbdata
.progress_data
= &total_progress
;
1881 make_cleanup (clear_memory_write_data
, &cbdata
.requests
);
1884 error_no_arg (_("file to load"));
1886 argv
= gdb_buildargv (args
);
1887 make_cleanup_freeargv (argv
);
1889 filename
= tilde_expand (argv
[0]);
1890 make_cleanup (xfree
, filename
);
1892 if (argv
[1] != NULL
)
1896 cbdata
.load_offset
= strtoul (argv
[1], &endptr
, 0);
1898 /* If the last word was not a valid number then
1899 treat it as a file name with spaces in. */
1900 if (argv
[1] == endptr
)
1901 error (_("Invalid download offset:%s."), argv
[1]);
1903 if (argv
[2] != NULL
)
1904 error (_("Too many parameters."));
1907 /* Open the file for loading. */
1908 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1909 if (loadfile_bfd
== NULL
)
1911 perror_with_name (filename
);
1915 /* FIXME: should be checking for errors from bfd_close (for one thing,
1916 on error it does not free all the storage associated with the
1918 make_cleanup_bfd_close (loadfile_bfd
);
1920 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1922 error (_("\"%s\" is not an object file: %s"), filename
,
1923 bfd_errmsg (bfd_get_error ()));
1926 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1927 (void *) &total_progress
.total_size
);
1929 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1931 gettimeofday (&start_time
, NULL
);
1933 if (target_write_memory_blocks (cbdata
.requests
, flash_discard
,
1934 load_progress
) != 0)
1935 error (_("Load failed"));
1937 gettimeofday (&end_time
, NULL
);
1939 entry
= bfd_get_start_address (loadfile_bfd
);
1940 ui_out_text (uiout
, "Start address ");
1941 ui_out_field_fmt (uiout
, "address", "%s", paddress (target_gdbarch
, entry
));
1942 ui_out_text (uiout
, ", load size ");
1943 ui_out_field_fmt (uiout
, "load-size", "%lu", total_progress
.data_count
);
1944 ui_out_text (uiout
, "\n");
1945 /* We were doing this in remote-mips.c, I suspect it is right
1946 for other targets too. */
1947 regcache_write_pc (get_current_regcache (), entry
);
1949 /* FIXME: are we supposed to call symbol_file_add or not? According
1950 to a comment from remote-mips.c (where a call to symbol_file_add
1951 was commented out), making the call confuses GDB if more than one
1952 file is loaded in. Some targets do (e.g., remote-vx.c) but
1953 others don't (or didn't - perhaps they have all been deleted). */
1955 print_transfer_performance (gdb_stdout
, total_progress
.data_count
,
1956 total_progress
.write_count
,
1957 &start_time
, &end_time
);
1959 do_cleanups (old_cleanups
);
1962 /* Report how fast the transfer went. */
1964 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1965 replaced by print_transfer_performance (with a very different
1966 function signature). */
1969 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1972 struct timeval start
, end
;
1974 start
.tv_sec
= start_time
;
1976 end
.tv_sec
= end_time
;
1979 print_transfer_performance (gdb_stdout
, data_count
, 0, &start
, &end
);
1983 print_transfer_performance (struct ui_file
*stream
,
1984 unsigned long data_count
,
1985 unsigned long write_count
,
1986 const struct timeval
*start_time
,
1987 const struct timeval
*end_time
)
1989 ULONGEST time_count
;
1991 /* Compute the elapsed time in milliseconds, as a tradeoff between
1992 accuracy and overflow. */
1993 time_count
= (end_time
->tv_sec
- start_time
->tv_sec
) * 1000;
1994 time_count
+= (end_time
->tv_usec
- start_time
->tv_usec
) / 1000;
1996 ui_out_text (uiout
, "Transfer rate: ");
1999 unsigned long rate
= ((ULONGEST
) data_count
* 1000) / time_count
;
2001 if (ui_out_is_mi_like_p (uiout
))
2003 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
* 8);
2004 ui_out_text (uiout
, " bits/sec");
2006 else if (rate
< 1024)
2008 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
);
2009 ui_out_text (uiout
, " bytes/sec");
2013 ui_out_field_fmt (uiout
, "transfer-rate", "%lu", rate
/ 1024);
2014 ui_out_text (uiout
, " KB/sec");
2019 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
2020 ui_out_text (uiout
, " bits in <1 sec");
2022 if (write_count
> 0)
2024 ui_out_text (uiout
, ", ");
2025 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
2026 ui_out_text (uiout
, " bytes/write");
2028 ui_out_text (uiout
, ".\n");
2031 /* This function allows the addition of incrementally linked object files.
2032 It does not modify any state in the target, only in the debugger. */
2033 /* Note: ezannoni 2000-04-13 This function/command used to have a
2034 special case syntax for the rombug target (Rombug is the boot
2035 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
2036 rombug case, the user doesn't need to supply a text address,
2037 instead a call to target_link() (in target.c) would supply the
2038 value to use. We are now discontinuing this type of ad hoc syntax. */
2041 add_symbol_file_command (char *args
, int from_tty
)
2043 struct gdbarch
*gdbarch
= get_current_arch ();
2044 char *filename
= NULL
;
2045 int flags
= OBJF_USERLOADED
;
2047 int expecting_option
= 0;
2048 int section_index
= 0;
2052 int expecting_sec_name
= 0;
2053 int expecting_sec_addr
= 0;
2062 struct section_addr_info
*section_addrs
;
2063 struct sect_opt
*sect_opts
= NULL
;
2064 size_t num_sect_opts
= 0;
2065 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
2068 sect_opts
= (struct sect_opt
*) xmalloc (num_sect_opts
2069 * sizeof (struct sect_opt
));
2074 error (_("add-symbol-file takes a file name and an address"));
2076 argv
= gdb_buildargv (args
);
2077 make_cleanup_freeargv (argv
);
2079 for (arg
= argv
[0], argcnt
= 0; arg
!= NULL
; arg
= argv
[++argcnt
])
2081 /* Process the argument. */
2084 /* The first argument is the file name. */
2085 filename
= tilde_expand (arg
);
2086 make_cleanup (xfree
, filename
);
2091 /* The second argument is always the text address at which
2092 to load the program. */
2093 sect_opts
[section_index
].name
= ".text";
2094 sect_opts
[section_index
].value
= arg
;
2095 if (++section_index
>= num_sect_opts
)
2098 sect_opts
= ((struct sect_opt
*)
2099 xrealloc (sect_opts
,
2101 * sizeof (struct sect_opt
)));
2106 /* It's an option (starting with '-') or it's an argument
2111 if (strcmp (arg
, "-readnow") == 0)
2112 flags
|= OBJF_READNOW
;
2113 else if (strcmp (arg
, "-s") == 0)
2115 expecting_sec_name
= 1;
2116 expecting_sec_addr
= 1;
2121 if (expecting_sec_name
)
2123 sect_opts
[section_index
].name
= arg
;
2124 expecting_sec_name
= 0;
2127 if (expecting_sec_addr
)
2129 sect_opts
[section_index
].value
= arg
;
2130 expecting_sec_addr
= 0;
2131 if (++section_index
>= num_sect_opts
)
2134 sect_opts
= ((struct sect_opt
*)
2135 xrealloc (sect_opts
,
2137 * sizeof (struct sect_opt
)));
2141 error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
2146 /* This command takes at least two arguments. The first one is a
2147 filename, and the second is the address where this file has been
2148 loaded. Abort now if this address hasn't been provided by the
2150 if (section_index
< 1)
2151 error (_("The address where %s has been loaded is missing"), filename
);
2153 /* Print the prompt for the query below. And save the arguments into
2154 a sect_addr_info structure to be passed around to other
2155 functions. We have to split this up into separate print
2156 statements because hex_string returns a local static
2159 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename
);
2160 section_addrs
= alloc_section_addr_info (section_index
);
2161 make_cleanup (xfree
, section_addrs
);
2162 for (i
= 0; i
< section_index
; i
++)
2165 char *val
= sect_opts
[i
].value
;
2166 char *sec
= sect_opts
[i
].name
;
2168 addr
= parse_and_eval_address (val
);
2170 /* Here we store the section offsets in the order they were
2171 entered on the command line. */
2172 section_addrs
->other
[sec_num
].name
= sec
;
2173 section_addrs
->other
[sec_num
].addr
= addr
;
2174 printf_unfiltered ("\t%s_addr = %s\n", sec
,
2175 paddress (gdbarch
, addr
));
2178 /* The object's sections are initialized when a
2179 call is made to build_objfile_section_table (objfile).
2180 This happens in reread_symbols.
2181 At this point, we don't know what file type this is,
2182 so we can't determine what section names are valid. */
2185 if (from_tty
&& (!query ("%s", "")))
2186 error (_("Not confirmed."));
2188 symbol_file_add (filename
, from_tty
? SYMFILE_VERBOSE
: 0,
2189 section_addrs
, flags
);
2191 /* Getting new symbols may change our opinion about what is
2193 reinit_frame_cache ();
2194 do_cleanups (my_cleanups
);
2198 /* Re-read symbols if a symbol-file has changed. */
2200 reread_symbols (void)
2202 struct objfile
*objfile
;
2205 struct stat new_statbuf
;
2208 /* With the addition of shared libraries, this should be modified,
2209 the load time should be saved in the partial symbol tables, since
2210 different tables may come from different source files. FIXME.
2211 This routine should then walk down each partial symbol table
2212 and see if the symbol table that it originates from has been changed */
2214 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2216 /* solib-sunos.c creates one objfile with obfd. */
2217 if (objfile
->obfd
== NULL
)
2220 /* Separate debug objfiles are handled in the main objfile. */
2221 if (objfile
->separate_debug_objfile_backlink
)
2224 #ifdef DEPRECATED_IBM6000_TARGET
2225 /* If this object is from a shared library, then you should
2226 stat on the library name, not member name. */
2228 if (objfile
->obfd
->my_archive
)
2229 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
2232 res
= stat (objfile
->name
, &new_statbuf
);
2235 /* FIXME, should use print_sys_errmsg but it's not filtered. */
2236 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
2240 new_modtime
= new_statbuf
.st_mtime
;
2241 if (new_modtime
!= objfile
->mtime
)
2243 struct cleanup
*old_cleanups
;
2244 struct section_offsets
*offsets
;
2246 char *obfd_filename
;
2248 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
2251 /* There are various functions like symbol_file_add,
2252 symfile_bfd_open, syms_from_objfile, etc., which might
2253 appear to do what we want. But they have various other
2254 effects which we *don't* want. So we just do stuff
2255 ourselves. We don't worry about mapped files (for one thing,
2256 any mapped file will be out of date). */
2258 /* If we get an error, blow away this objfile (not sure if
2259 that is the correct response for things like shared
2261 old_cleanups
= make_cleanup_free_objfile (objfile
);
2262 /* We need to do this whenever any symbols go away. */
2263 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
2265 if (exec_bfd
!= NULL
&& strcmp (bfd_get_filename (objfile
->obfd
),
2266 bfd_get_filename (exec_bfd
)) == 0)
2268 /* Reload EXEC_BFD without asking anything. */
2270 exec_file_attach (bfd_get_filename (objfile
->obfd
), 0);
2273 /* Clean up any state BFD has sitting around. We don't need
2274 to close the descriptor but BFD lacks a way of closing the
2275 BFD without closing the descriptor. */
2276 obfd_filename
= bfd_get_filename (objfile
->obfd
);
2277 if (!bfd_close (objfile
->obfd
))
2278 error (_("Can't close BFD for %s: %s"), objfile
->name
,
2279 bfd_errmsg (bfd_get_error ()));
2280 objfile
->obfd
= bfd_open_maybe_remote (obfd_filename
);
2281 if (objfile
->obfd
== NULL
)
2282 error (_("Can't open %s to read symbols."), objfile
->name
);
2284 objfile
->obfd
= gdb_bfd_ref (objfile
->obfd
);
2285 /* bfd_openr sets cacheable to true, which is what we want. */
2286 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
2287 error (_("Can't read symbols from %s: %s."), objfile
->name
,
2288 bfd_errmsg (bfd_get_error ()));
2290 /* Save the offsets, we will nuke them with the rest of the
2292 num_offsets
= objfile
->num_sections
;
2293 offsets
= ((struct section_offsets
*)
2294 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets
)));
2295 memcpy (offsets
, objfile
->section_offsets
,
2296 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2298 /* Remove any references to this objfile in the global
2300 preserve_values (objfile
);
2302 /* Nuke all the state that we will re-read. Much of the following
2303 code which sets things to NULL really is necessary to tell
2304 other parts of GDB that there is nothing currently there.
2306 Try to keep the freeing order compatible with free_objfile. */
2308 if (objfile
->sf
!= NULL
)
2310 (*objfile
->sf
->sym_finish
) (objfile
);
2313 clear_objfile_data (objfile
);
2315 /* Free the separate debug objfiles. It will be
2316 automatically recreated by sym_read. */
2317 free_objfile_separate_debug (objfile
);
2319 /* FIXME: Do we have to free a whole linked list, or is this
2321 if (objfile
->global_psymbols
.list
)
2322 xfree (objfile
->global_psymbols
.list
);
2323 memset (&objfile
->global_psymbols
, 0,
2324 sizeof (objfile
->global_psymbols
));
2325 if (objfile
->static_psymbols
.list
)
2326 xfree (objfile
->static_psymbols
.list
);
2327 memset (&objfile
->static_psymbols
, 0,
2328 sizeof (objfile
->static_psymbols
));
2330 /* Free the obstacks for non-reusable objfiles */
2331 bcache_xfree (objfile
->psymbol_cache
);
2332 objfile
->psymbol_cache
= bcache_xmalloc ();
2333 bcache_xfree (objfile
->macro_cache
);
2334 objfile
->macro_cache
= bcache_xmalloc ();
2335 bcache_xfree (objfile
->filename_cache
);
2336 objfile
->filename_cache
= bcache_xmalloc ();
2337 if (objfile
->demangled_names_hash
!= NULL
)
2339 htab_delete (objfile
->demangled_names_hash
);
2340 objfile
->demangled_names_hash
= NULL
;
2342 obstack_free (&objfile
->objfile_obstack
, 0);
2343 objfile
->sections
= NULL
;
2344 objfile
->symtabs
= NULL
;
2345 objfile
->psymtabs
= NULL
;
2346 objfile
->psymtabs_addrmap
= NULL
;
2347 objfile
->free_psymtabs
= NULL
;
2348 objfile
->cp_namespace_symtab
= NULL
;
2349 objfile
->msymbols
= NULL
;
2350 objfile
->deprecated_sym_private
= NULL
;
2351 objfile
->minimal_symbol_count
= 0;
2352 memset (&objfile
->msymbol_hash
, 0,
2353 sizeof (objfile
->msymbol_hash
));
2354 memset (&objfile
->msymbol_demangled_hash
, 0,
2355 sizeof (objfile
->msymbol_demangled_hash
));
2357 objfile
->psymbol_cache
= bcache_xmalloc ();
2358 objfile
->macro_cache
= bcache_xmalloc ();
2359 objfile
->filename_cache
= bcache_xmalloc ();
2360 /* obstack_init also initializes the obstack so it is
2361 empty. We could use obstack_specify_allocation but
2362 gdb_obstack.h specifies the alloc/dealloc
2364 obstack_init (&objfile
->objfile_obstack
);
2365 if (build_objfile_section_table (objfile
))
2367 error (_("Can't find the file sections in `%s': %s"),
2368 objfile
->name
, bfd_errmsg (bfd_get_error ()));
2370 terminate_minimal_symbol_table (objfile
);
2372 /* We use the same section offsets as from last time. I'm not
2373 sure whether that is always correct for shared libraries. */
2374 objfile
->section_offsets
= (struct section_offsets
*)
2375 obstack_alloc (&objfile
->objfile_obstack
,
2376 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2377 memcpy (objfile
->section_offsets
, offsets
,
2378 SIZEOF_N_SECTION_OFFSETS (num_offsets
));
2379 objfile
->num_sections
= num_offsets
;
2381 /* What the hell is sym_new_init for, anyway? The concept of
2382 distinguishing between the main file and additional files
2383 in this way seems rather dubious. */
2384 if (objfile
== symfile_objfile
)
2386 (*objfile
->sf
->sym_new_init
) (objfile
);
2389 (*objfile
->sf
->sym_init
) (objfile
);
2390 clear_complaints (&symfile_complaints
, 1, 1);
2391 /* Do not set flags as this is safe and we don't want to be
2393 (*objfile
->sf
->sym_read
) (objfile
, 0);
2394 if (!objfile_has_symbols (objfile
))
2397 printf_unfiltered (_("(no debugging symbols found)\n"));
2401 /* We're done reading the symbol file; finish off complaints. */
2402 clear_complaints (&symfile_complaints
, 0, 1);
2404 /* Getting new symbols may change our opinion about what is
2407 reinit_frame_cache ();
2409 /* Discard cleanups as symbol reading was successful. */
2410 discard_cleanups (old_cleanups
);
2412 /* If the mtime has changed between the time we set new_modtime
2413 and now, we *want* this to be out of date, so don't call stat
2415 objfile
->mtime
= new_modtime
;
2417 init_entry_point_info (objfile
);
2423 /* Notify objfiles that we've modified objfile sections. */
2424 objfiles_changed ();
2426 clear_symtab_users ();
2427 /* At least one objfile has changed, so we can consider that
2428 the executable we're debugging has changed too. */
2429 observer_notify_executable_changed ();
2442 static filename_language
*filename_language_table
;
2443 static int fl_table_size
, fl_table_next
;
2446 add_filename_language (char *ext
, enum language lang
)
2448 if (fl_table_next
>= fl_table_size
)
2450 fl_table_size
+= 10;
2451 filename_language_table
=
2452 xrealloc (filename_language_table
,
2453 fl_table_size
* sizeof (*filename_language_table
));
2456 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
2457 filename_language_table
[fl_table_next
].lang
= lang
;
2461 static char *ext_args
;
2463 show_ext_args (struct ui_file
*file
, int from_tty
,
2464 struct cmd_list_element
*c
, const char *value
)
2466 fprintf_filtered (file
, _("\
2467 Mapping between filename extension and source language is \"%s\".\n"),
2472 set_ext_lang_command (char *args
, int from_tty
, struct cmd_list_element
*e
)
2475 char *cp
= ext_args
;
2478 /* First arg is filename extension, starting with '.' */
2480 error (_("'%s': Filename extension must begin with '.'"), ext_args
);
2482 /* Find end of first arg. */
2483 while (*cp
&& !isspace (*cp
))
2487 error (_("'%s': two arguments required -- filename extension and language"),
2490 /* Null-terminate first arg */
2493 /* Find beginning of second arg, which should be a source language. */
2494 while (*cp
&& isspace (*cp
))
2498 error (_("'%s': two arguments required -- filename extension and language"),
2501 /* Lookup the language from among those we know. */
2502 lang
= language_enum (cp
);
2504 /* Now lookup the filename extension: do we already know it? */
2505 for (i
= 0; i
< fl_table_next
; i
++)
2506 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
2509 if (i
>= fl_table_next
)
2511 /* new file extension */
2512 add_filename_language (ext_args
, lang
);
2516 /* redefining a previously known filename extension */
2519 /* query ("Really make files of type %s '%s'?", */
2520 /* ext_args, language_str (lang)); */
2522 xfree (filename_language_table
[i
].ext
);
2523 filename_language_table
[i
].ext
= xstrdup (ext_args
);
2524 filename_language_table
[i
].lang
= lang
;
2529 info_ext_lang_command (char *args
, int from_tty
)
2533 printf_filtered (_("Filename extensions and the languages they represent:"));
2534 printf_filtered ("\n\n");
2535 for (i
= 0; i
< fl_table_next
; i
++)
2536 printf_filtered ("\t%s\t- %s\n",
2537 filename_language_table
[i
].ext
,
2538 language_str (filename_language_table
[i
].lang
));
2542 init_filename_language_table (void)
2544 if (fl_table_size
== 0) /* protect against repetition */
2548 filename_language_table
=
2549 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
2550 add_filename_language (".c", language_c
);
2551 add_filename_language (".C", language_cplus
);
2552 add_filename_language (".cc", language_cplus
);
2553 add_filename_language (".cp", language_cplus
);
2554 add_filename_language (".cpp", language_cplus
);
2555 add_filename_language (".cxx", language_cplus
);
2556 add_filename_language (".c++", language_cplus
);
2557 add_filename_language (".java", language_java
);
2558 add_filename_language (".class", language_java
);
2559 add_filename_language (".m", language_objc
);
2560 add_filename_language (".f", language_fortran
);
2561 add_filename_language (".F", language_fortran
);
2562 add_filename_language (".s", language_asm
);
2563 add_filename_language (".sx", language_asm
);
2564 add_filename_language (".S", language_asm
);
2565 add_filename_language (".pas", language_pascal
);
2566 add_filename_language (".p", language_pascal
);
2567 add_filename_language (".pp", language_pascal
);
2568 add_filename_language (".adb", language_ada
);
2569 add_filename_language (".ads", language_ada
);
2570 add_filename_language (".a", language_ada
);
2571 add_filename_language (".ada", language_ada
);
2576 deduce_language_from_filename (char *filename
)
2581 if (filename
!= NULL
)
2582 if ((cp
= strrchr (filename
, '.')) != NULL
)
2583 for (i
= 0; i
< fl_table_next
; i
++)
2584 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
2585 return filename_language_table
[i
].lang
;
2587 return language_unknown
;
2592 Allocate and partly initialize a new symbol table. Return a pointer
2593 to it. error() if no space.
2595 Caller must set these fields:
2601 possibly free_named_symtabs (symtab->filename);
2605 allocate_symtab (char *filename
, struct objfile
*objfile
)
2607 struct symtab
*symtab
;
2609 symtab
= (struct symtab
*)
2610 obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct symtab
));
2611 memset (symtab
, 0, sizeof (*symtab
));
2612 symtab
->filename
= (char *) bcache (filename
, strlen (filename
) + 1,
2613 objfile
->filename_cache
);
2614 symtab
->fullname
= NULL
;
2615 symtab
->language
= deduce_language_from_filename (filename
);
2616 symtab
->debugformat
= "unknown";
2618 /* Hook it to the objfile it comes from */
2620 symtab
->objfile
= objfile
;
2621 symtab
->next
= objfile
->symtabs
;
2622 objfile
->symtabs
= symtab
;
2627 struct partial_symtab
*
2628 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
2630 struct partial_symtab
*psymtab
;
2632 if (objfile
->free_psymtabs
)
2634 psymtab
= objfile
->free_psymtabs
;
2635 objfile
->free_psymtabs
= psymtab
->next
;
2638 psymtab
= (struct partial_symtab
*)
2639 obstack_alloc (&objfile
->objfile_obstack
,
2640 sizeof (struct partial_symtab
));
2642 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2643 psymtab
->filename
= (char *) bcache (filename
, strlen (filename
) + 1,
2644 objfile
->filename_cache
);
2645 psymtab
->symtab
= NULL
;
2647 /* Prepend it to the psymtab list for the objfile it belongs to.
2648 Psymtabs are searched in most recent inserted -> least recent
2651 psymtab
->objfile
= objfile
;
2652 psymtab
->next
= objfile
->psymtabs
;
2653 objfile
->psymtabs
= psymtab
;
2656 struct partial_symtab
**prev_pst
;
2657 psymtab
->objfile
= objfile
;
2658 psymtab
->next
= NULL
;
2659 prev_pst
= &(objfile
->psymtabs
);
2660 while ((*prev_pst
) != NULL
)
2661 prev_pst
= &((*prev_pst
)->next
);
2662 (*prev_pst
) = psymtab
;
2670 discard_psymtab (struct partial_symtab
*pst
)
2672 struct partial_symtab
**prev_pst
;
2675 Empty psymtabs happen as a result of header files which don't
2676 have any symbols in them. There can be a lot of them. But this
2677 check is wrong, in that a psymtab with N_SLINE entries but
2678 nothing else is not empty, but we don't realize that. Fixing
2679 that without slowing things down might be tricky. */
2681 /* First, snip it out of the psymtab chain */
2683 prev_pst
= &(pst
->objfile
->psymtabs
);
2684 while ((*prev_pst
) != pst
)
2685 prev_pst
= &((*prev_pst
)->next
);
2686 (*prev_pst
) = pst
->next
;
2688 /* Next, put it on a free list for recycling */
2690 pst
->next
= pst
->objfile
->free_psymtabs
;
2691 pst
->objfile
->free_psymtabs
= pst
;
2695 /* Reset all data structures in gdb which may contain references to symbol
2699 clear_symtab_users (void)
2701 /* Someday, we should do better than this, by only blowing away
2702 the things that really need to be blown. */
2704 /* Clear the "current" symtab first, because it is no longer valid.
2705 breakpoint_re_set may try to access the current symtab. */
2706 clear_current_source_symtab_and_line ();
2709 breakpoint_re_set ();
2710 set_default_breakpoint (0, NULL
, 0, 0, 0);
2711 clear_pc_function_cache ();
2712 observer_notify_new_objfile (NULL
);
2714 /* Clear globals which might have pointed into a removed objfile.
2715 FIXME: It's not clear which of these are supposed to persist
2716 between expressions and which ought to be reset each time. */
2717 expression_context_block
= NULL
;
2718 innermost_block
= NULL
;
2720 /* Varobj may refer to old symbols, perform a cleanup. */
2721 varobj_invalidate ();
2726 clear_symtab_users_cleanup (void *ignore
)
2728 clear_symtab_users ();
2731 /* clear_symtab_users_once:
2733 This function is run after symbol reading, or from a cleanup.
2734 If an old symbol table was obsoleted, the old symbol table
2735 has been blown away, but the other GDB data structures that may
2736 reference it have not yet been cleared or re-directed. (The old
2737 symtab was zapped, and the cleanup queued, in free_named_symtab()
2740 This function can be queued N times as a cleanup, or called
2741 directly; it will do all the work the first time, and then will be a
2742 no-op until the next time it is queued. This works by bumping a
2743 counter at queueing time. Much later when the cleanup is run, or at
2744 the end of symbol processing (in case the cleanup is discarded), if
2745 the queued count is greater than the "done-count", we do the work
2746 and set the done-count to the queued count. If the queued count is
2747 less than or equal to the done-count, we just ignore the call. This
2748 is needed because reading a single .o file will often replace many
2749 symtabs (one per .h file, for example), and we don't want to reset
2750 the breakpoints N times in the user's face.
2752 The reason we both queue a cleanup, and call it directly after symbol
2753 reading, is because the cleanup protects us in case of errors, but is
2754 discarded if symbol reading is successful. */
2757 /* FIXME: As free_named_symtabs is currently a big noop this function
2758 is no longer needed. */
2759 static void clear_symtab_users_once (void);
2761 static int clear_symtab_users_queued
;
2762 static int clear_symtab_users_done
;
2765 clear_symtab_users_once (void)
2767 /* Enforce once-per-`do_cleanups'-semantics */
2768 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2770 clear_symtab_users_done
= clear_symtab_users_queued
;
2772 clear_symtab_users ();
2776 /* Delete the specified psymtab, and any others that reference it. */
2779 cashier_psymtab (struct partial_symtab
*pst
)
2781 struct partial_symtab
*ps
, *pprev
= NULL
;
2784 /* Find its previous psymtab in the chain */
2785 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2794 /* Unhook it from the chain. */
2795 if (ps
== pst
->objfile
->psymtabs
)
2796 pst
->objfile
->psymtabs
= ps
->next
;
2798 pprev
->next
= ps
->next
;
2800 /* FIXME, we can't conveniently deallocate the entries in the
2801 partial_symbol lists (global_psymbols/static_psymbols) that
2802 this psymtab points to. These just take up space until all
2803 the psymtabs are reclaimed. Ditto the dependencies list and
2804 filename, which are all in the objfile_obstack. */
2806 /* We need to cashier any psymtab that has this one as a dependency... */
2808 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2810 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2812 if (ps
->dependencies
[i
] == pst
)
2814 cashier_psymtab (ps
);
2815 goto again
; /* Must restart, chain has been munged. */
2822 /* If a symtab or psymtab for filename NAME is found, free it along
2823 with any dependent breakpoints, displays, etc.
2824 Used when loading new versions of object modules with the "add-file"
2825 command. This is only called on the top-level symtab or psymtab's name;
2826 it is not called for subsidiary files such as .h files.
2828 Return value is 1 if we blew away the environment, 0 if not.
2829 FIXME. The return value appears to never be used.
2831 FIXME. I think this is not the best way to do this. We should
2832 work on being gentler to the environment while still cleaning up
2833 all stray pointers into the freed symtab. */
2836 free_named_symtabs (char *name
)
2839 /* FIXME: With the new method of each objfile having it's own
2840 psymtab list, this function needs serious rethinking. In particular,
2841 why was it ever necessary to toss psymtabs with specific compilation
2842 unit filenames, as opposed to all psymtabs from a particular symbol
2844 Well, the answer is that some systems permit reloading of particular
2845 compilation units. We want to blow away any old info about these
2846 compilation units, regardless of which objfiles they arrived in. --gnu. */
2849 struct symtab
*prev
;
2850 struct partial_symtab
*ps
;
2851 struct blockvector
*bv
;
2854 /* We only wack things if the symbol-reload switch is set. */
2855 if (!symbol_reloading
)
2858 /* Some symbol formats have trouble providing file names... */
2859 if (name
== 0 || *name
== '\0')
2862 /* Look for a psymtab with the specified name. */
2865 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2867 if (strcmp (name
, ps
->filename
) == 0)
2869 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2870 goto again2
; /* Must restart, chain has been munged */
2874 /* Look for a symtab with the specified name. */
2876 for (s
= symtab_list
; s
; s
= s
->next
)
2878 if (strcmp (name
, s
->filename
) == 0)
2885 if (s
== symtab_list
)
2886 symtab_list
= s
->next
;
2888 prev
->next
= s
->next
;
2890 /* For now, queue a delete for all breakpoints, displays, etc., whether
2891 or not they depend on the symtab being freed. This should be
2892 changed so that only those data structures affected are deleted. */
2894 /* But don't delete anything if the symtab is empty.
2895 This test is necessary due to a bug in "dbxread.c" that
2896 causes empty symtabs to be created for N_SO symbols that
2897 contain the pathname of the object file. (This problem
2898 has been fixed in GDB 3.9x). */
2900 bv
= BLOCKVECTOR (s
);
2901 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2902 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2903 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2905 complaint (&symfile_complaints
, _("Replacing old symbols for `%s'"),
2907 clear_symtab_users_queued
++;
2908 make_cleanup (clear_symtab_users_once
, 0);
2912 complaint (&symfile_complaints
, _("Empty symbol table found for `%s'"),
2919 /* It is still possible that some breakpoints will be affected
2920 even though no symtab was found, since the file might have
2921 been compiled without debugging, and hence not be associated
2922 with a symtab. In order to handle this correctly, we would need
2923 to keep a list of text address ranges for undebuggable files.
2924 For now, we do nothing, since this is a fairly obscure case. */
2928 /* FIXME, what about the minimal symbol table? */
2935 /* Allocate and partially fill a partial symtab. It will be
2936 completely filled at the end of the symbol list.
2938 FILENAME is the name of the symbol-file we are reading from. */
2940 struct partial_symtab
*
2941 start_psymtab_common (struct objfile
*objfile
,
2942 struct section_offsets
*section_offsets
,
2943 const char *filename
,
2944 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2945 struct partial_symbol
**static_syms
)
2947 struct partial_symtab
*psymtab
;
2949 psymtab
= allocate_psymtab (filename
, objfile
);
2950 psymtab
->section_offsets
= section_offsets
;
2951 psymtab
->textlow
= textlow
;
2952 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2953 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2954 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2958 /* Helper function, initialises partial symbol structure and stashes
2959 it into objfile's bcache. Note that our caching mechanism will
2960 use all fields of struct partial_symbol to determine hash value of the
2961 structure. In other words, having two symbols with the same name but
2962 different domain (or address) is possible and correct. */
2964 static const struct partial_symbol
*
2965 add_psymbol_to_bcache (char *name
, int namelength
, int copy_name
,
2967 enum address_class
class,
2968 long val
, /* Value as a long */
2969 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2970 enum language language
, struct objfile
*objfile
,
2973 /* psymbol is static so that there will be no uninitialized gaps in the
2974 structure which might contain random data, causing cache misses in
2976 static struct partial_symbol psymbol
;
2978 /* However, we must ensure that the entire 'value' field has been
2979 zeroed before assigning to it, because an assignment may not
2980 write the entire field. */
2981 memset (&psymbol
.ginfo
.value
, 0, sizeof (psymbol
.ginfo
.value
));
2982 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2985 SYMBOL_VALUE (&psymbol
) = val
;
2989 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2991 SYMBOL_SECTION (&psymbol
) = 0;
2992 SYMBOL_LANGUAGE (&psymbol
) = language
;
2993 PSYMBOL_DOMAIN (&psymbol
) = domain
;
2994 PSYMBOL_CLASS (&psymbol
) = class;
2996 SYMBOL_SET_NAMES (&psymbol
, name
, namelength
, copy_name
, objfile
);
2998 /* Stash the partial symbol away in the cache */
2999 return bcache_full (&psymbol
, sizeof (struct partial_symbol
),
3000 objfile
->psymbol_cache
, added
);
3003 /* Helper function, adds partial symbol to the given partial symbol
3007 append_psymbol_to_list (struct psymbol_allocation_list
*list
,
3008 const struct partial_symbol
*psym
,
3009 struct objfile
*objfile
)
3011 if (list
->next
>= list
->list
+ list
->size
)
3012 extend_psymbol_list (list
, objfile
);
3013 *list
->next
++ = (struct partial_symbol
*) psym
;
3014 OBJSTAT (objfile
, n_psyms
++);
3017 /* Add a symbol with a long value to a psymtab.
3018 Since one arg is a struct, we pass in a ptr and deref it (sigh).
3019 Return the partial symbol that has been added. */
3021 /* NOTE: carlton/2003-09-11: The reason why we return the partial
3022 symbol is so that callers can get access to the symbol's demangled
3023 name, which they don't have any cheap way to determine otherwise.
3024 (Currenly, dwarf2read.c is the only file who uses that information,
3025 though it's possible that other readers might in the future.)
3026 Elena wasn't thrilled about that, and I don't blame her, but we
3027 couldn't come up with a better way to get that information. If
3028 it's needed in other situations, we could consider breaking up
3029 SYMBOL_SET_NAMES to provide access to the demangled name lookup
3032 const struct partial_symbol
*
3033 add_psymbol_to_list (char *name
, int namelength
, int copy_name
,
3035 enum address_class
class,
3036 struct psymbol_allocation_list
*list
,
3037 long val
, /* Value as a long */
3038 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
3039 enum language language
, struct objfile
*objfile
)
3041 const struct partial_symbol
*psym
;
3045 /* Stash the partial symbol away in the cache */
3046 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, class,
3047 val
, coreaddr
, language
, objfile
, &added
);
3049 /* Do not duplicate global partial symbols. */
3050 if (list
== &objfile
->global_psymbols
3054 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
3055 append_psymbol_to_list (list
, psym
, objfile
);
3059 /* Initialize storage for partial symbols. */
3062 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
3064 /* Free any previously allocated psymbol lists. */
3066 if (objfile
->global_psymbols
.list
)
3068 xfree (objfile
->global_psymbols
.list
);
3070 if (objfile
->static_psymbols
.list
)
3072 xfree (objfile
->static_psymbols
.list
);
3075 /* Current best guess is that approximately a twentieth
3076 of the total symbols (in a debugging file) are global or static
3079 objfile
->global_psymbols
.size
= total_symbols
/ 10;
3080 objfile
->static_psymbols
.size
= total_symbols
/ 10;
3082 if (objfile
->global_psymbols
.size
> 0)
3084 objfile
->global_psymbols
.next
=
3085 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
3086 xmalloc ((objfile
->global_psymbols
.size
3087 * sizeof (struct partial_symbol
*)));
3089 if (objfile
->static_psymbols
.size
> 0)
3091 objfile
->static_psymbols
.next
=
3092 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
3093 xmalloc ((objfile
->static_psymbols
.size
3094 * sizeof (struct partial_symbol
*)));
3099 The following code implements an abstraction for debugging overlay sections.
3101 The target model is as follows:
3102 1) The gnu linker will permit multiple sections to be mapped into the
3103 same VMA, each with its own unique LMA (or load address).
3104 2) It is assumed that some runtime mechanism exists for mapping the
3105 sections, one by one, from the load address into the VMA address.
3106 3) This code provides a mechanism for gdb to keep track of which
3107 sections should be considered to be mapped from the VMA to the LMA.
3108 This information is used for symbol lookup, and memory read/write.
3109 For instance, if a section has been mapped then its contents
3110 should be read from the VMA, otherwise from the LMA.
3112 Two levels of debugger support for overlays are available. One is
3113 "manual", in which the debugger relies on the user to tell it which
3114 overlays are currently mapped. This level of support is
3115 implemented entirely in the core debugger, and the information about
3116 whether a section is mapped is kept in the objfile->obj_section table.
3118 The second level of support is "automatic", and is only available if
3119 the target-specific code provides functionality to read the target's
3120 overlay mapping table, and translate its contents for the debugger
3121 (by updating the mapped state information in the obj_section tables).
3123 The interface is as follows:
3125 overlay map <name> -- tell gdb to consider this section mapped
3126 overlay unmap <name> -- tell gdb to consider this section unmapped
3127 overlay list -- list the sections that GDB thinks are mapped
3128 overlay read-target -- get the target's state of what's mapped
3129 overlay off/manual/auto -- set overlay debugging state
3130 Functional interface:
3131 find_pc_mapped_section(pc): if the pc is in the range of a mapped
3132 section, return that section.
3133 find_pc_overlay(pc): find any overlay section that contains
3134 the pc, either in its VMA or its LMA
3135 section_is_mapped(sect): true if overlay is marked as mapped
3136 section_is_overlay(sect): true if section's VMA != LMA
3137 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
3138 pc_in_unmapped_range(...): true if pc belongs to section's LMA
3139 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
3140 overlay_mapped_address(...): map an address from section's LMA to VMA
3141 overlay_unmapped_address(...): map an address from section's VMA to LMA
3142 symbol_overlayed_address(...): Return a "current" address for symbol:
3143 either in VMA or LMA depending on whether
3144 the symbol's section is currently mapped
3147 /* Overlay debugging state: */
3149 enum overlay_debugging_state overlay_debugging
= ovly_off
;
3150 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
3152 /* Function: section_is_overlay (SECTION)
3153 Returns true if SECTION has VMA not equal to LMA, ie.
3154 SECTION is loaded at an address different from where it will "run". */
3157 section_is_overlay (struct obj_section
*section
)
3159 if (overlay_debugging
&& section
)
3161 bfd
*abfd
= section
->objfile
->obfd
;
3162 asection
*bfd_section
= section
->the_bfd_section
;
3164 if (bfd_section_lma (abfd
, bfd_section
) != 0
3165 && bfd_section_lma (abfd
, bfd_section
)
3166 != bfd_section_vma (abfd
, bfd_section
))
3173 /* Function: overlay_invalidate_all (void)
3174 Invalidate the mapped state of all overlay sections (mark it as stale). */
3177 overlay_invalidate_all (void)
3179 struct objfile
*objfile
;
3180 struct obj_section
*sect
;
3182 ALL_OBJSECTIONS (objfile
, sect
)
3183 if (section_is_overlay (sect
))
3184 sect
->ovly_mapped
= -1;
3187 /* Function: section_is_mapped (SECTION)
3188 Returns true if section is an overlay, and is currently mapped.
3190 Access to the ovly_mapped flag is restricted to this function, so
3191 that we can do automatic update. If the global flag
3192 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
3193 overlay_invalidate_all. If the mapped state of the particular
3194 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
3197 section_is_mapped (struct obj_section
*osect
)
3199 struct gdbarch
*gdbarch
;
3201 if (osect
== 0 || !section_is_overlay (osect
))
3204 switch (overlay_debugging
)
3208 return 0; /* overlay debugging off */
3209 case ovly_auto
: /* overlay debugging automatic */
3210 /* Unles there is a gdbarch_overlay_update function,
3211 there's really nothing useful to do here (can't really go auto) */
3212 gdbarch
= get_objfile_arch (osect
->objfile
);
3213 if (gdbarch_overlay_update_p (gdbarch
))
3215 if (overlay_cache_invalid
)
3217 overlay_invalidate_all ();
3218 overlay_cache_invalid
= 0;
3220 if (osect
->ovly_mapped
== -1)
3221 gdbarch_overlay_update (gdbarch
, osect
);
3223 /* fall thru to manual case */
3224 case ovly_on
: /* overlay debugging manual */
3225 return osect
->ovly_mapped
== 1;
3229 /* Function: pc_in_unmapped_range
3230 If PC falls into the lma range of SECTION, return true, else false. */
3233 pc_in_unmapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3235 if (section_is_overlay (section
))
3237 bfd
*abfd
= section
->objfile
->obfd
;
3238 asection
*bfd_section
= section
->the_bfd_section
;
3240 /* We assume the LMA is relocated by the same offset as the VMA. */
3241 bfd_vma size
= bfd_get_section_size (bfd_section
);
3242 CORE_ADDR offset
= obj_section_offset (section
);
3244 if (bfd_get_section_lma (abfd
, bfd_section
) + offset
<= pc
3245 && pc
< bfd_get_section_lma (abfd
, bfd_section
) + offset
+ size
)
3252 /* Function: pc_in_mapped_range
3253 If PC falls into the vma range of SECTION, return true, else false. */
3256 pc_in_mapped_range (CORE_ADDR pc
, struct obj_section
*section
)
3258 if (section_is_overlay (section
))
3260 if (obj_section_addr (section
) <= pc
3261 && pc
< obj_section_endaddr (section
))
3269 /* Return true if the mapped ranges of sections A and B overlap, false
3272 sections_overlap (struct obj_section
*a
, struct obj_section
*b
)
3274 CORE_ADDR a_start
= obj_section_addr (a
);
3275 CORE_ADDR a_end
= obj_section_endaddr (a
);
3276 CORE_ADDR b_start
= obj_section_addr (b
);
3277 CORE_ADDR b_end
= obj_section_endaddr (b
);
3279 return (a_start
< b_end
&& b_start
< a_end
);
3282 /* Function: overlay_unmapped_address (PC, SECTION)
3283 Returns the address corresponding to PC in the unmapped (load) range.
3284 May be the same as PC. */
3287 overlay_unmapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3289 if (section_is_overlay (section
) && pc_in_mapped_range (pc
, section
))
3291 bfd
*abfd
= section
->objfile
->obfd
;
3292 asection
*bfd_section
= section
->the_bfd_section
;
3294 return pc
+ bfd_section_lma (abfd
, bfd_section
)
3295 - bfd_section_vma (abfd
, bfd_section
);
3301 /* Function: overlay_mapped_address (PC, SECTION)
3302 Returns the address corresponding to PC in the mapped (runtime) range.
3303 May be the same as PC. */
3306 overlay_mapped_address (CORE_ADDR pc
, struct obj_section
*section
)
3308 if (section_is_overlay (section
) && pc_in_unmapped_range (pc
, section
))
3310 bfd
*abfd
= section
->objfile
->obfd
;
3311 asection
*bfd_section
= section
->the_bfd_section
;
3313 return pc
+ bfd_section_vma (abfd
, bfd_section
)
3314 - bfd_section_lma (abfd
, bfd_section
);
3321 /* Function: symbol_overlayed_address
3322 Return one of two addresses (relative to the VMA or to the LMA),
3323 depending on whether the section is mapped or not. */
3326 symbol_overlayed_address (CORE_ADDR address
, struct obj_section
*section
)
3328 if (overlay_debugging
)
3330 /* If the symbol has no section, just return its regular address. */
3333 /* If the symbol's section is not an overlay, just return its address */
3334 if (!section_is_overlay (section
))
3336 /* If the symbol's section is mapped, just return its address */
3337 if (section_is_mapped (section
))
3340 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3341 * then return its LOADED address rather than its vma address!!
3343 return overlay_unmapped_address (address
, section
);
3348 /* Function: find_pc_overlay (PC)
3349 Return the best-match overlay section for PC:
3350 If PC matches a mapped overlay section's VMA, return that section.
3351 Else if PC matches an unmapped section's VMA, return that section.
3352 Else if PC matches an unmapped section's LMA, return that section. */
3354 struct obj_section
*
3355 find_pc_overlay (CORE_ADDR pc
)
3357 struct objfile
*objfile
;
3358 struct obj_section
*osect
, *best_match
= NULL
;
3360 if (overlay_debugging
)
3361 ALL_OBJSECTIONS (objfile
, osect
)
3362 if (section_is_overlay (osect
))
3364 if (pc_in_mapped_range (pc
, osect
))
3366 if (section_is_mapped (osect
))
3371 else if (pc_in_unmapped_range (pc
, osect
))
3377 /* Function: find_pc_mapped_section (PC)
3378 If PC falls into the VMA address range of an overlay section that is
3379 currently marked as MAPPED, return that section. Else return NULL. */
3381 struct obj_section
*
3382 find_pc_mapped_section (CORE_ADDR pc
)
3384 struct objfile
*objfile
;
3385 struct obj_section
*osect
;
3387 if (overlay_debugging
)
3388 ALL_OBJSECTIONS (objfile
, osect
)
3389 if (pc_in_mapped_range (pc
, osect
) && section_is_mapped (osect
))
3395 /* Function: list_overlays_command
3396 Print a list of mapped sections and their PC ranges */
3399 list_overlays_command (char *args
, int from_tty
)
3402 struct objfile
*objfile
;
3403 struct obj_section
*osect
;
3405 if (overlay_debugging
)
3406 ALL_OBJSECTIONS (objfile
, osect
)
3407 if (section_is_mapped (osect
))
3409 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3414 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
3415 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
3416 size
= bfd_get_section_size (osect
->the_bfd_section
);
3417 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
3419 printf_filtered ("Section %s, loaded at ", name
);
3420 fputs_filtered (paddress (gdbarch
, lma
), gdb_stdout
);
3421 puts_filtered (" - ");
3422 fputs_filtered (paddress (gdbarch
, lma
+ size
), gdb_stdout
);
3423 printf_filtered (", mapped at ");
3424 fputs_filtered (paddress (gdbarch
, vma
), gdb_stdout
);
3425 puts_filtered (" - ");
3426 fputs_filtered (paddress (gdbarch
, vma
+ size
), gdb_stdout
);
3427 puts_filtered ("\n");
3432 printf_filtered (_("No sections are mapped.\n"));
3435 /* Function: map_overlay_command
3436 Mark the named section as mapped (ie. residing at its VMA address). */
3439 map_overlay_command (char *args
, int from_tty
)
3441 struct objfile
*objfile
, *objfile2
;
3442 struct obj_section
*sec
, *sec2
;
3444 if (!overlay_debugging
)
3446 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3447 the 'overlay manual' command."));
3449 if (args
== 0 || *args
== 0)
3450 error (_("Argument required: name of an overlay section"));
3452 /* First, find a section matching the user supplied argument */
3453 ALL_OBJSECTIONS (objfile
, sec
)
3454 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3456 /* Now, check to see if the section is an overlay. */
3457 if (!section_is_overlay (sec
))
3458 continue; /* not an overlay section */
3460 /* Mark the overlay as "mapped" */
3461 sec
->ovly_mapped
= 1;
3463 /* Next, make a pass and unmap any sections that are
3464 overlapped by this new section: */
3465 ALL_OBJSECTIONS (objfile2
, sec2
)
3466 if (sec2
->ovly_mapped
&& sec
!= sec2
&& sections_overlap (sec
, sec2
))
3469 printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
3470 bfd_section_name (objfile
->obfd
,
3471 sec2
->the_bfd_section
));
3472 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
3476 error (_("No overlay section called %s"), args
);
3479 /* Function: unmap_overlay_command
3480 Mark the overlay section as unmapped
3481 (ie. resident in its LMA address range, rather than the VMA range). */
3484 unmap_overlay_command (char *args
, int from_tty
)
3486 struct objfile
*objfile
;
3487 struct obj_section
*sec
;
3489 if (!overlay_debugging
)
3491 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3492 the 'overlay manual' command."));
3494 if (args
== 0 || *args
== 0)
3495 error (_("Argument required: name of an overlay section"));
3497 /* First, find a section matching the user supplied argument */
3498 ALL_OBJSECTIONS (objfile
, sec
)
3499 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
3501 if (!sec
->ovly_mapped
)
3502 error (_("Section %s is not mapped"), args
);
3503 sec
->ovly_mapped
= 0;
3506 error (_("No overlay section called %s"), args
);
3509 /* Function: overlay_auto_command
3510 A utility command to turn on overlay debugging.
3511 Possibly this should be done via a set/show command. */
3514 overlay_auto_command (char *args
, int from_tty
)
3516 overlay_debugging
= ovly_auto
;
3517 enable_overlay_breakpoints ();
3519 printf_unfiltered (_("Automatic overlay debugging enabled."));
3522 /* Function: overlay_manual_command
3523 A utility command to turn on overlay debugging.
3524 Possibly this should be done via a set/show command. */
3527 overlay_manual_command (char *args
, int from_tty
)
3529 overlay_debugging
= ovly_on
;
3530 disable_overlay_breakpoints ();
3532 printf_unfiltered (_("Overlay debugging enabled."));
3535 /* Function: overlay_off_command
3536 A utility command to turn on overlay debugging.
3537 Possibly this should be done via a set/show command. */
3540 overlay_off_command (char *args
, int from_tty
)
3542 overlay_debugging
= ovly_off
;
3543 disable_overlay_breakpoints ();
3545 printf_unfiltered (_("Overlay debugging disabled."));
3549 overlay_load_command (char *args
, int from_tty
)
3551 struct gdbarch
*gdbarch
= get_current_arch ();
3553 if (gdbarch_overlay_update_p (gdbarch
))
3554 gdbarch_overlay_update (gdbarch
, NULL
);
3556 error (_("This target does not know how to read its overlay state."));
3559 /* Function: overlay_command
3560 A place-holder for a mis-typed command */
3562 /* Command list chain containing all defined "overlay" subcommands. */
3563 struct cmd_list_element
*overlaylist
;
3566 overlay_command (char *args
, int from_tty
)
3569 ("\"overlay\" must be followed by the name of an overlay command.\n");
3570 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3574 /* Target Overlays for the "Simplest" overlay manager:
3576 This is GDB's default target overlay layer. It works with the
3577 minimal overlay manager supplied as an example by Cygnus. The
3578 entry point is via a function pointer "gdbarch_overlay_update",
3579 so targets that use a different runtime overlay manager can
3580 substitute their own overlay_update function and take over the
3583 The overlay_update function pokes around in the target's data structures
3584 to see what overlays are mapped, and updates GDB's overlay mapping with
3587 In this simple implementation, the target data structures are as follows:
3588 unsigned _novlys; /# number of overlay sections #/
3589 unsigned _ovly_table[_novlys][4] = {
3590 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3591 {..., ..., ..., ...},
3593 unsigned _novly_regions; /# number of overlay regions #/
3594 unsigned _ovly_region_table[_novly_regions][3] = {
3595 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3598 These functions will attempt to update GDB's mappedness state in the
3599 symbol section table, based on the target's mappedness state.
3601 To do this, we keep a cached copy of the target's _ovly_table, and
3602 attempt to detect when the cached copy is invalidated. The main
3603 entry point is "simple_overlay_update(SECT), which looks up SECT in
3604 the cached table and re-reads only the entry for that section from
3605 the target (whenever possible).
3608 /* Cached, dynamically allocated copies of the target data structures: */
3609 static unsigned (*cache_ovly_table
)[4] = 0;
3611 static unsigned (*cache_ovly_region_table
)[3] = 0;
3613 static unsigned cache_novlys
= 0;
3615 static unsigned cache_novly_regions
= 0;
3617 static CORE_ADDR cache_ovly_table_base
= 0;
3619 static CORE_ADDR cache_ovly_region_table_base
= 0;
3623 VMA
, SIZE
, LMA
, MAPPED
3626 /* Throw away the cached copy of _ovly_table */
3628 simple_free_overlay_table (void)
3630 if (cache_ovly_table
)
3631 xfree (cache_ovly_table
);
3633 cache_ovly_table
= NULL
;
3634 cache_ovly_table_base
= 0;
3638 /* Throw away the cached copy of _ovly_region_table */
3640 simple_free_overlay_region_table (void)
3642 if (cache_ovly_region_table
)
3643 xfree (cache_ovly_region_table
);
3644 cache_novly_regions
= 0;
3645 cache_ovly_region_table
= NULL
;
3646 cache_ovly_region_table_base
= 0;
3650 /* Read an array of ints of size SIZE from the target into a local buffer.
3651 Convert to host order. int LEN is number of ints */
3653 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
,
3654 int len
, int size
, enum bfd_endian byte_order
)
3656 /* FIXME (alloca): Not safe if array is very large. */
3657 gdb_byte
*buf
= alloca (len
* size
);
3660 read_memory (memaddr
, buf
, len
* size
);
3661 for (i
= 0; i
< len
; i
++)
3662 myaddr
[i
] = extract_unsigned_integer (size
* i
+ buf
, size
, byte_order
);
3665 /* Find and grab a copy of the target _ovly_table
3666 (and _novlys, which is needed for the table's size) */
3668 simple_read_overlay_table (void)
3670 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3671 struct gdbarch
*gdbarch
;
3673 enum bfd_endian byte_order
;
3675 simple_free_overlay_table ();
3676 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3679 error (_("Error reading inferior's overlay table: "
3680 "couldn't find `_novlys' variable\n"
3681 "in inferior. Use `overlay manual' mode."));
3685 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3686 if (! ovly_table_msym
)
3688 error (_("Error reading inferior's overlay table: couldn't find "
3689 "`_ovly_table' array\n"
3690 "in inferior. Use `overlay manual' mode."));
3694 gdbarch
= get_objfile_arch (msymbol_objfile (ovly_table_msym
));
3695 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3696 byte_order
= gdbarch_byte_order (gdbarch
);
3698 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
),
3701 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3702 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3703 read_target_long_array (cache_ovly_table_base
,
3704 (unsigned int *) cache_ovly_table
,
3705 cache_novlys
* 4, word_size
, byte_order
);
3707 return 1; /* SUCCESS */
3711 /* Find and grab a copy of the target _ovly_region_table
3712 (and _novly_regions, which is needed for the table's size) */
3714 simple_read_overlay_region_table (void)
3716 struct minimal_symbol
*msym
;
3717 struct gdbarch
*gdbarch
;
3719 enum bfd_endian byte_order
;
3721 simple_free_overlay_region_table ();
3722 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3724 return 0; /* failure */
3726 gdbarch
= get_objfile_arch (msymbol_objfile (msym
));
3727 word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3728 byte_order
= gdbarch_byte_order (gdbarch
);
3730 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
),
3733 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3734 if (cache_ovly_region_table
!= NULL
)
3736 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3739 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3740 read_target_long_array (cache_ovly_region_table_base
,
3741 (unsigned int *) cache_ovly_region_table
,
3742 cache_novly_regions
* 3,
3743 word_size
, byte_order
);
3746 return 0; /* failure */
3749 return 0; /* failure */
3750 return 1; /* SUCCESS */
3754 /* Function: simple_overlay_update_1
3755 A helper function for simple_overlay_update. Assuming a cached copy
3756 of _ovly_table exists, look through it to find an entry whose vma,
3757 lma and size match those of OSECT. Re-read the entry and make sure
3758 it still matches OSECT (else the table may no longer be valid).
3759 Set OSECT's mapped state to match the entry. Return: 1 for
3760 success, 0 for failure. */
3763 simple_overlay_update_1 (struct obj_section
*osect
)
3766 bfd
*obfd
= osect
->objfile
->obfd
;
3767 asection
*bsect
= osect
->the_bfd_section
;
3768 struct gdbarch
*gdbarch
= get_objfile_arch (osect
->objfile
);
3769 int word_size
= gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
3770 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3772 size
= bfd_get_section_size (osect
->the_bfd_section
);
3773 for (i
= 0; i
< cache_novlys
; i
++)
3774 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3775 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3776 /* && cache_ovly_table[i][SIZE] == size */ )
3778 read_target_long_array (cache_ovly_table_base
+ i
* word_size
,
3779 (unsigned int *) cache_ovly_table
[i
],
3780 4, word_size
, byte_order
);
3781 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3782 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3783 /* && cache_ovly_table[i][SIZE] == size */ )
3785 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3788 else /* Warning! Warning! Target's ovly table has changed! */
3794 /* Function: simple_overlay_update
3795 If OSECT is NULL, then update all sections' mapped state
3796 (after re-reading the entire target _ovly_table).
3797 If OSECT is non-NULL, then try to find a matching entry in the
3798 cached ovly_table and update only OSECT's mapped state.
3799 If a cached entry can't be found or the cache isn't valid, then
3800 re-read the entire cache, and go ahead and update all sections. */
3803 simple_overlay_update (struct obj_section
*osect
)
3805 struct objfile
*objfile
;
3807 /* Were we given an osect to look up? NULL means do all of them. */
3809 /* Have we got a cached copy of the target's overlay table? */
3810 if (cache_ovly_table
!= NULL
)
3811 /* Does its cached location match what's currently in the symtab? */
3812 if (cache_ovly_table_base
==
3813 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3814 /* Then go ahead and try to look up this single section in the cache */
3815 if (simple_overlay_update_1 (osect
))
3816 /* Found it! We're done. */
3819 /* Cached table no good: need to read the entire table anew.
3820 Or else we want all the sections, in which case it's actually
3821 more efficient to read the whole table in one block anyway. */
3823 if (! simple_read_overlay_table ())
3826 /* Now may as well update all sections, even if only one was requested. */
3827 ALL_OBJSECTIONS (objfile
, osect
)
3828 if (section_is_overlay (osect
))
3831 bfd
*obfd
= osect
->objfile
->obfd
;
3832 asection
*bsect
= osect
->the_bfd_section
;
3834 size
= bfd_get_section_size (bsect
);
3835 for (i
= 0; i
< cache_novlys
; i
++)
3836 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3837 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3838 /* && cache_ovly_table[i][SIZE] == size */ )
3839 { /* obj_section matches i'th entry in ovly_table */
3840 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3841 break; /* finished with inner for loop: break out */
3846 /* Set the output sections and output offsets for section SECTP in
3847 ABFD. The relocation code in BFD will read these offsets, so we
3848 need to be sure they're initialized. We map each section to itself,
3849 with no offset; this means that SECTP->vma will be honored. */
3852 symfile_dummy_outputs (bfd
*abfd
, asection
*sectp
, void *dummy
)
3854 sectp
->output_section
= sectp
;
3855 sectp
->output_offset
= 0;
3858 /* Relocate the contents of a debug section SECTP in ABFD. The
3859 contents are stored in BUF if it is non-NULL, or returned in a
3860 malloc'd buffer otherwise.
3862 For some platforms and debug info formats, shared libraries contain
3863 relocations against the debug sections (particularly for DWARF-2;
3864 one affected platform is PowerPC GNU/Linux, although it depends on
3865 the version of the linker in use). Also, ELF object files naturally
3866 have unresolved relocations for their debug sections. We need to apply
3867 the relocations in order to get the locations of symbols correct.
3868 Another example that may require relocation processing, is the
3869 DWARF-2 .eh_frame section in .o files, although it isn't strictly a
3873 symfile_relocate_debug_section (bfd
*abfd
, asection
*sectp
, bfd_byte
*buf
)
3875 /* We're only interested in sections with relocation
3877 if ((sectp
->flags
& SEC_RELOC
) == 0)
3880 /* We will handle section offsets properly elsewhere, so relocate as if
3881 all sections begin at 0. */
3882 bfd_map_over_sections (abfd
, symfile_dummy_outputs
, NULL
);
3884 return bfd_simple_get_relocated_section_contents (abfd
, sectp
, buf
, NULL
);
3887 struct symfile_segment_data
*
3888 get_symfile_segment_data (bfd
*abfd
)
3890 struct sym_fns
*sf
= find_sym_fns (abfd
);
3895 return sf
->sym_segments (abfd
);
3899 free_symfile_segment_data (struct symfile_segment_data
*data
)
3901 xfree (data
->segment_bases
);
3902 xfree (data
->segment_sizes
);
3903 xfree (data
->segment_info
);
3909 - DATA, containing segment addresses from the object file ABFD, and
3910 the mapping from ABFD's sections onto the segments that own them,
3912 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
3913 segment addresses reported by the target,
3914 store the appropriate offsets for each section in OFFSETS.
3916 If there are fewer entries in SEGMENT_BASES than there are segments
3917 in DATA, then apply SEGMENT_BASES' last entry to all the segments.
3919 If there are more entries, then ignore the extra. The target may
3920 not be able to distinguish between an empty data segment and a
3921 missing data segment; a missing text segment is less plausible. */
3923 symfile_map_offsets_to_segments (bfd
*abfd
, struct symfile_segment_data
*data
,
3924 struct section_offsets
*offsets
,
3925 int num_segment_bases
,
3926 const CORE_ADDR
*segment_bases
)
3931 /* It doesn't make sense to call this function unless you have some
3932 segment base addresses. */
3933 gdb_assert (segment_bases
> 0);
3935 /* If we do not have segment mappings for the object file, we
3936 can not relocate it by segments. */
3937 gdb_assert (data
!= NULL
);
3938 gdb_assert (data
->num_segments
> 0);
3940 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3942 int which
= data
->segment_info
[i
];
3944 gdb_assert (0 <= which
&& which
<= data
->num_segments
);
3946 /* Don't bother computing offsets for sections that aren't
3947 loaded as part of any segment. */
3951 /* Use the last SEGMENT_BASES entry as the address of any extra
3952 segments mentioned in DATA->segment_info. */
3953 if (which
> num_segment_bases
)
3954 which
= num_segment_bases
;
3956 offsets
->offsets
[i
] = (segment_bases
[which
- 1]
3957 - data
->segment_bases
[which
- 1]);
3964 symfile_find_segment_sections (struct objfile
*objfile
)
3966 bfd
*abfd
= objfile
->obfd
;
3969 struct symfile_segment_data
*data
;
3971 data
= get_symfile_segment_data (objfile
->obfd
);
3975 if (data
->num_segments
!= 1 && data
->num_segments
!= 2)
3977 free_symfile_segment_data (data
);
3981 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
3984 int which
= data
->segment_info
[i
];
3988 if (objfile
->sect_index_text
== -1)
3989 objfile
->sect_index_text
= sect
->index
;
3991 if (objfile
->sect_index_rodata
== -1)
3992 objfile
->sect_index_rodata
= sect
->index
;
3994 else if (which
== 2)
3996 if (objfile
->sect_index_data
== -1)
3997 objfile
->sect_index_data
= sect
->index
;
3999 if (objfile
->sect_index_bss
== -1)
4000 objfile
->sect_index_bss
= sect
->index
;
4004 free_symfile_segment_data (data
);
4008 _initialize_symfile (void)
4010 struct cmd_list_element
*c
;
4012 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
, _("\
4013 Load symbol table from executable file FILE.\n\
4014 The `file' command can also load symbol tables, as well as setting the file\n\
4015 to execute."), &cmdlist
);
4016 set_cmd_completer (c
, filename_completer
);
4018 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
, _("\
4019 Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
4020 Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
4021 ADDR is the starting address of the file's text.\n\
4022 The optional arguments are section-name section-address pairs and\n\
4023 should be specified if the data and bss segments are not contiguous\n\
4024 with the text. SECT is a section name to be loaded at SECT_ADDR."),
4026 set_cmd_completer (c
, filename_completer
);
4028 c
= add_cmd ("load", class_files
, load_command
, _("\
4029 Dynamically load FILE into the running program, and record its symbols\n\
4030 for access from GDB.\n\
4031 A load OFFSET may also be given."), &cmdlist
);
4032 set_cmd_completer (c
, filename_completer
);
4034 add_setshow_boolean_cmd ("symbol-reloading", class_support
,
4035 &symbol_reloading
, _("\
4036 Set dynamic symbol table reloading multiple times in one run."), _("\
4037 Show dynamic symbol table reloading multiple times in one run."), NULL
,
4039 show_symbol_reloading
,
4040 &setlist
, &showlist
);
4042 add_prefix_cmd ("overlay", class_support
, overlay_command
,
4043 _("Commands for debugging overlays."), &overlaylist
,
4044 "overlay ", 0, &cmdlist
);
4046 add_com_alias ("ovly", "overlay", class_alias
, 1);
4047 add_com_alias ("ov", "overlay", class_alias
, 1);
4049 add_cmd ("map-overlay", class_support
, map_overlay_command
,
4050 _("Assert that an overlay section is mapped."), &overlaylist
);
4052 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
4053 _("Assert that an overlay section is unmapped."), &overlaylist
);
4055 add_cmd ("list-overlays", class_support
, list_overlays_command
,
4056 _("List mappings of overlay sections."), &overlaylist
);
4058 add_cmd ("manual", class_support
, overlay_manual_command
,
4059 _("Enable overlay debugging."), &overlaylist
);
4060 add_cmd ("off", class_support
, overlay_off_command
,
4061 _("Disable overlay debugging."), &overlaylist
);
4062 add_cmd ("auto", class_support
, overlay_auto_command
,
4063 _("Enable automatic overlay debugging."), &overlaylist
);
4064 add_cmd ("load-target", class_support
, overlay_load_command
,
4065 _("Read the overlay mapping state from the target."), &overlaylist
);
4067 /* Filename extension to source language lookup table: */
4068 init_filename_language_table ();
4069 add_setshow_string_noescape_cmd ("extension-language", class_files
,
4071 Set mapping between filename extension and source language."), _("\
4072 Show mapping between filename extension and source language."), _("\
4073 Usage: set extension-language .foo bar"),
4074 set_ext_lang_command
,
4076 &setlist
, &showlist
);
4078 add_info ("extensions", info_ext_lang_command
,
4079 _("All filename extensions associated with a source language."));
4081 add_setshow_optional_filename_cmd ("debug-file-directory", class_support
,
4082 &debug_file_directory
, _("\
4083 Set the directories where separate debug symbols are searched for."), _("\
4084 Show the directories where separate debug symbols are searched for."), _("\
4085 Separate debug symbols are first searched for in the same\n\
4086 directory as the binary, then in the `" DEBUG_SUBDIRECTORY
"' subdirectory,\n\
4087 and lastly at the path of the directory of the binary with\n\
4088 each global debug-file-directory component prepended."),
4090 show_debug_file_directory
,
4091 &setlist
, &showlist
);