1 /* Generic symbol file reading for the GNU debugger, GDB.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
6 Contributed by Cygnus Support, using pieces from other GDB modules.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
35 #include "breakpoint.h"
37 #include "complaints.h"
39 #include "inferior.h" /* for write_pc */
40 #include "gdb-stabs.h"
42 #include "completer.h"
45 #include <sys/types.h>
47 #include "gdb_string.h"
58 /* Some HP-UX related globals to clear when a new "main"
59 symbol file is loaded. HP-specific. */
61 extern int hp_som_som_object_present
;
62 extern int hp_cxx_exception_support_initialized
;
63 #define RESET_HP_UX_GLOBALS() do {\
64 hp_som_som_object_present = 0; /* indicates HP-compiled code */ \
65 hp_cxx_exception_support_initialized = 0; /* must reinitialize exception stuff */ \
69 int (*ui_load_progress_hook
) (const char *section
, unsigned long num
);
70 void (*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 (*pre_add_symbol_hook
) (char *);
76 void (*post_add_symbol_hook
) (void);
77 void (*target_new_objfile_hook
) (struct objfile
*);
79 static void clear_symtab_users_cleanup (void *ignore
);
81 /* Global variables owned by this file */
82 int readnow_symbol_files
; /* Read full symbols immediately */
84 struct complaint oldsyms_complaint
=
86 "Replacing old symbols for `%s'", 0, 0
89 struct complaint empty_symtab_complaint
=
91 "Empty symbol table found for `%s'", 0, 0
94 struct complaint unknown_option_complaint
=
96 "Unknown option `%s' ignored", 0, 0
99 /* External variables and functions referenced. */
101 extern void report_transfer_performance (unsigned long, time_t, time_t);
103 /* Functions this file defines */
106 static int simple_read_overlay_region_table (void);
107 static void simple_free_overlay_region_table (void);
110 static void set_initial_language (void);
112 static void load_command (char *, int);
114 static void symbol_file_add_main_1 (char *args
, int from_tty
, int flags
);
116 static void add_symbol_file_command (char *, int);
118 static void add_shared_symbol_files_command (char *, int);
120 static void cashier_psymtab (struct partial_symtab
*);
122 bfd
*symfile_bfd_open (char *);
124 int get_section_index (struct objfile
*, char *);
126 static void find_sym_fns (struct objfile
*);
128 static void decrement_reading_symtab (void *);
130 static void overlay_invalidate_all (void);
132 static int overlay_is_mapped (struct obj_section
*);
134 void list_overlays_command (char *, int);
136 void map_overlay_command (char *, int);
138 void unmap_overlay_command (char *, int);
140 static void overlay_auto_command (char *, int);
142 static void overlay_manual_command (char *, int);
144 static void overlay_off_command (char *, int);
146 static void overlay_load_command (char *, int);
148 static void overlay_command (char *, int);
150 static void simple_free_overlay_table (void);
152 static void read_target_long_array (CORE_ADDR
, unsigned int *, int);
154 static int simple_read_overlay_table (void);
156 static int simple_overlay_update_1 (struct obj_section
*);
158 static void add_filename_language (char *ext
, enum language lang
);
160 static void set_ext_lang_command (char *args
, int from_tty
);
162 static void info_ext_lang_command (char *args
, int from_tty
);
164 static void init_filename_language_table (void);
166 void _initialize_symfile (void);
168 /* List of all available sym_fns. On gdb startup, each object file reader
169 calls add_symtab_fns() to register information on each format it is
172 static struct sym_fns
*symtab_fns
= NULL
;
174 /* Flag for whether user will be reloading symbols multiple times.
175 Defaults to ON for VxWorks, otherwise OFF. */
177 #ifdef SYMBOL_RELOADING_DEFAULT
178 int symbol_reloading
= SYMBOL_RELOADING_DEFAULT
;
180 int symbol_reloading
= 0;
183 /* If non-zero, shared library symbols will be added automatically
184 when the inferior is created, new libraries are loaded, or when
185 attaching to the inferior. This is almost always what users will
186 want to have happen; but for very large programs, the startup time
187 will be excessive, and so if this is a problem, the user can clear
188 this flag and then add the shared library symbols as needed. Note
189 that there is a potential for confusion, since if the shared
190 library symbols are not loaded, commands like "info fun" will *not*
191 report all the functions that are actually present. */
193 int auto_solib_add
= 1;
195 /* For systems that support it, a threshold size in megabytes. If
196 automatically adding a new library's symbol table to those already
197 known to the debugger would cause the total shared library symbol
198 size to exceed this threshhold, then the shlib's symbols are not
199 added. The threshold is ignored if the user explicitly asks for a
200 shlib to be added, such as when using the "sharedlibrary"
203 int auto_solib_limit
;
206 /* Since this function is called from within qsort, in an ANSI environment
207 it must conform to the prototype for qsort, which specifies that the
208 comparison function takes two "void *" pointers. */
211 compare_symbols (const void *s1p
, const void *s2p
)
213 register struct symbol
**s1
, **s2
;
215 s1
= (struct symbol
**) s1p
;
216 s2
= (struct symbol
**) s2p
;
217 return (strcmp (SYMBOL_SOURCE_NAME (*s1
), SYMBOL_SOURCE_NAME (*s2
)));
224 compare_psymbols -- compare two partial symbols by name
228 Given pointers to pointers to two partial symbol table entries,
229 compare them by name and return -N, 0, or +N (ala strcmp).
230 Typically used by sorting routines like qsort().
234 Does direct compare of first two characters before punting
235 and passing to strcmp for longer compares. Note that the
236 original version had a bug whereby two null strings or two
237 identically named one character strings would return the
238 comparison of memory following the null byte.
243 compare_psymbols (const void *s1p
, const void *s2p
)
245 register struct partial_symbol
**s1
, **s2
;
246 register char *st1
, *st2
;
248 s1
= (struct partial_symbol
**) s1p
;
249 s2
= (struct partial_symbol
**) s2p
;
250 st1
= SYMBOL_SOURCE_NAME (*s1
);
251 st2
= SYMBOL_SOURCE_NAME (*s2
);
254 if ((st1
[0] - st2
[0]) || !st1
[0])
256 return (st1
[0] - st2
[0]);
258 else if ((st1
[1] - st2
[1]) || !st1
[1])
260 return (st1
[1] - st2
[1]);
264 return (strcmp (st1
, st2
));
269 sort_pst_symbols (struct partial_symtab
*pst
)
271 /* Sort the global list; don't sort the static list */
273 qsort (pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
,
274 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
278 /* Call sort_block_syms to sort alphabetically the symbols of one block. */
281 sort_block_syms (register struct block
*b
)
283 qsort (&BLOCK_SYM (b
, 0), BLOCK_NSYMS (b
),
284 sizeof (struct symbol
*), compare_symbols
);
287 /* Call sort_symtab_syms to sort alphabetically
288 the symbols of each block of one symtab. */
291 sort_symtab_syms (register struct symtab
*s
)
293 register struct blockvector
*bv
;
296 register struct block
*b
;
300 bv
= BLOCKVECTOR (s
);
301 nbl
= BLOCKVECTOR_NBLOCKS (bv
);
302 for (i
= 0; i
< nbl
; i
++)
304 b
= BLOCKVECTOR_BLOCK (bv
, i
);
305 if (BLOCK_SHOULD_SORT (b
))
310 /* Make a null terminated copy of the string at PTR with SIZE characters in
311 the obstack pointed to by OBSTACKP . Returns the address of the copy.
312 Note that the string at PTR does not have to be null terminated, I.E. it
313 may be part of a larger string and we are only saving a substring. */
316 obsavestring (char *ptr
, int size
, struct obstack
*obstackp
)
318 register char *p
= (char *) obstack_alloc (obstackp
, size
+ 1);
319 /* Open-coded memcpy--saves function call time. These strings are usually
320 short. FIXME: Is this really still true with a compiler that can
323 register char *p1
= ptr
;
324 register char *p2
= p
;
325 char *end
= ptr
+ size
;
333 /* Concatenate strings S1, S2 and S3; return the new string. Space is found
334 in the obstack pointed to by OBSTACKP. */
337 obconcat (struct obstack
*obstackp
, const char *s1
, const char *s2
,
340 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
341 register char *val
= (char *) obstack_alloc (obstackp
, len
);
348 /* True if we are nested inside psymtab_to_symtab. */
350 int currently_reading_symtab
= 0;
353 decrement_reading_symtab (void *dummy
)
355 currently_reading_symtab
--;
358 /* Get the symbol table that corresponds to a partial_symtab.
359 This is fast after the first time you do it. In fact, there
360 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
364 psymtab_to_symtab (register struct partial_symtab
*pst
)
366 /* If it's been looked up before, return it. */
370 /* If it has not yet been read in, read it. */
373 struct cleanup
*back_to
= make_cleanup (decrement_reading_symtab
, NULL
);
374 currently_reading_symtab
++;
375 (*pst
->read_symtab
) (pst
);
376 do_cleanups (back_to
);
382 /* Initialize entry point information for this objfile. */
385 init_entry_point_info (struct objfile
*objfile
)
387 /* Save startup file's range of PC addresses to help blockframe.c
388 decide where the bottom of the stack is. */
390 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
392 /* Executable file -- record its entry point so we'll recognize
393 the startup file because it contains the entry point. */
394 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
398 /* Examination of non-executable.o files. Short-circuit this stuff. */
399 objfile
->ei
.entry_point
= INVALID_ENTRY_POINT
;
401 objfile
->ei
.entry_file_lowpc
= INVALID_ENTRY_LOWPC
;
402 objfile
->ei
.entry_file_highpc
= INVALID_ENTRY_HIGHPC
;
403 objfile
->ei
.entry_func_lowpc
= INVALID_ENTRY_LOWPC
;
404 objfile
->ei
.entry_func_highpc
= INVALID_ENTRY_HIGHPC
;
405 objfile
->ei
.main_func_lowpc
= INVALID_ENTRY_LOWPC
;
406 objfile
->ei
.main_func_highpc
= INVALID_ENTRY_HIGHPC
;
409 /* Get current entry point address. */
412 entry_point_address (void)
414 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
417 /* Remember the lowest-addressed loadable section we've seen.
418 This function is called via bfd_map_over_sections.
420 In case of equal vmas, the section with the largest size becomes the
421 lowest-addressed loadable section.
423 If the vmas and sizes are equal, the last section is considered the
424 lowest-addressed loadable section. */
427 find_lowest_section (bfd
*abfd
, asection
*sect
, PTR obj
)
429 asection
**lowest
= (asection
**) obj
;
431 if (0 == (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
))
434 *lowest
= sect
; /* First loadable section */
435 else if (bfd_section_vma (abfd
, *lowest
) > bfd_section_vma (abfd
, sect
))
436 *lowest
= sect
; /* A lower loadable section */
437 else if (bfd_section_vma (abfd
, *lowest
) == bfd_section_vma (abfd
, sect
)
438 && (bfd_section_size (abfd
, (*lowest
))
439 <= bfd_section_size (abfd
, sect
)))
444 /* Build (allocate and populate) a section_addr_info struct from
445 an existing section table. */
447 extern struct section_addr_info
*
448 build_section_addr_info_from_section_table (const struct section_table
*start
,
449 const struct section_table
*end
)
451 struct section_addr_info
*sap
;
452 const struct section_table
*stp
;
455 sap
= xmalloc (sizeof (struct section_addr_info
));
456 memset (sap
, 0, sizeof (struct section_addr_info
));
458 for (stp
= start
, oidx
= 0; stp
!= end
; stp
++)
460 if (bfd_get_section_flags (stp
->bfd
,
461 stp
->the_bfd_section
) & (SEC_ALLOC
| SEC_LOAD
)
462 && oidx
< MAX_SECTIONS
)
464 sap
->other
[oidx
].addr
= stp
->addr
;
465 sap
->other
[oidx
].name
466 = xstrdup (bfd_section_name (stp
->bfd
, stp
->the_bfd_section
));
467 sap
->other
[oidx
].sectindex
= stp
->the_bfd_section
->index
;
476 /* Free all memory allocated by build_section_addr_info_from_section_table. */
479 free_section_addr_info (struct section_addr_info
*sap
)
483 for (idx
= 0; idx
< MAX_SECTIONS
; idx
++)
484 if (sap
->other
[idx
].name
)
485 xfree (sap
->other
[idx
].name
);
490 /* Parse the user's idea of an offset for dynamic linking, into our idea
491 of how to represent it for fast symbol reading. This is the default
492 version of the sym_fns.sym_offsets function for symbol readers that
493 don't need to do anything special. It allocates a section_offsets table
494 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
497 default_symfile_offsets (struct objfile
*objfile
,
498 struct section_addr_info
*addrs
)
501 asection
*sect
= NULL
;
503 objfile
->num_sections
= SECT_OFF_MAX
;
504 objfile
->section_offsets
= (struct section_offsets
*)
505 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
506 memset (objfile
->section_offsets
, 0, SIZEOF_SECTION_OFFSETS
);
508 /* Now calculate offsets for section that were specified by the
510 for (i
= 0; i
< MAX_SECTIONS
&& addrs
->other
[i
].name
; i
++)
512 struct other_sections
*osp
;
514 osp
= &addrs
->other
[i
] ;
518 /* Record all sections in offsets */
519 /* The section_offsets in the objfile are here filled in using
521 (objfile
->section_offsets
)->offsets
[osp
->sectindex
] = osp
->addr
;
524 /* Remember the bfd indexes for the .text, .data, .bss and
527 sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
529 objfile
->sect_index_text
= sect
->index
;
531 sect
= bfd_get_section_by_name (objfile
->obfd
, ".data");
533 objfile
->sect_index_data
= sect
->index
;
535 sect
= bfd_get_section_by_name (objfile
->obfd
, ".bss");
537 objfile
->sect_index_bss
= sect
->index
;
539 sect
= bfd_get_section_by_name (objfile
->obfd
, ".rodata");
541 objfile
->sect_index_rodata
= sect
->index
;
543 /* This is where things get really weird... We MUST have valid
544 indices for the various sect_index_* members or gdb will abort.
545 So if for example, there is no ".text" section, we have to
546 accomodate that. Except when explicitly adding symbol files at
547 some address, section_offsets contains nothing but zeros, so it
548 doesn't matter which slot in section_offsets the individual
549 sect_index_* members index into. So if they are all zero, it is
550 safe to just point all the currently uninitialized indices to the
553 for (i
= 0; i
< objfile
->num_sections
; i
++)
555 if (ANOFFSET (objfile
->section_offsets
, i
) != 0)
560 if (i
== objfile
->num_sections
)
562 if (objfile
->sect_index_text
== -1)
563 objfile
->sect_index_text
= 0;
564 if (objfile
->sect_index_data
== -1)
565 objfile
->sect_index_data
= 0;
566 if (objfile
->sect_index_bss
== -1)
567 objfile
->sect_index_bss
= 0;
568 if (objfile
->sect_index_rodata
== -1)
569 objfile
->sect_index_rodata
= 0;
573 /* Process a symbol file, as either the main file or as a dynamically
576 OBJFILE is where the symbols are to be read from.
578 ADDR is the address where the text segment was loaded, unless the
579 objfile is the main symbol file, in which case it is zero.
581 MAINLINE is nonzero if this is the main symbol file, or zero if
582 it's an extra symbol file such as dynamically loaded code.
584 VERBO is nonzero if the caller has printed a verbose message about
585 the symbol reading (and complaints can be more terse about it). */
588 syms_from_objfile (struct objfile
*objfile
, struct section_addr_info
*addrs
,
589 int mainline
, int verbo
)
591 asection
*lower_sect
;
593 CORE_ADDR lower_offset
;
594 struct section_addr_info local_addr
;
595 struct cleanup
*old_chain
;
598 /* If ADDRS is NULL, initialize the local section_addr_info struct and
599 point ADDRS to it. We now establish the convention that an addr of
600 zero means no load address was specified. */
604 memset (&local_addr
, 0, sizeof (local_addr
));
608 init_entry_point_info (objfile
);
609 find_sym_fns (objfile
);
611 if (objfile
->sf
== NULL
)
612 return; /* No symbols. */
614 /* Make sure that partially constructed symbol tables will be cleaned up
615 if an error occurs during symbol reading. */
616 old_chain
= make_cleanup_free_objfile (objfile
);
620 /* We will modify the main symbol table, make sure that all its users
621 will be cleaned up if an error occurs during symbol reading. */
622 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
624 /* Since no error yet, throw away the old symbol table. */
626 if (symfile_objfile
!= NULL
)
628 free_objfile (symfile_objfile
);
629 symfile_objfile
= NULL
;
632 /* Currently we keep symbols from the add-symbol-file command.
633 If the user wants to get rid of them, they should do "symbol-file"
634 without arguments first. Not sure this is the best behavior
637 (*objfile
->sf
->sym_new_init
) (objfile
);
640 /* Convert addr into an offset rather than an absolute address.
641 We find the lowest address of a loaded segment in the objfile,
642 and assume that <addr> is where that got loaded.
644 We no longer warn if the lowest section is not a text segment (as
645 happens for the PA64 port. */
648 /* Find lowest loadable section to be used as starting point for
649 continguous sections. FIXME!! won't work without call to find
650 .text first, but this assumes text is lowest section. */
651 lower_sect
= bfd_get_section_by_name (objfile
->obfd
, ".text");
652 if (lower_sect
== NULL
)
653 bfd_map_over_sections (objfile
->obfd
, find_lowest_section
,
655 if (lower_sect
== NULL
)
656 warning ("no loadable sections found in added symbol-file %s",
659 if ((bfd_get_section_flags (objfile
->obfd
, lower_sect
) & SEC_CODE
) == 0)
660 warning ("Lowest section in %s is %s at %s",
662 bfd_section_name (objfile
->obfd
, lower_sect
),
663 paddr (bfd_section_vma (objfile
->obfd
, lower_sect
)));
664 if (lower_sect
!= NULL
)
665 lower_offset
= bfd_section_vma (objfile
->obfd
, lower_sect
);
669 /* Calculate offsets for the loadable sections.
670 FIXME! Sections must be in order of increasing loadable section
671 so that contiguous sections can use the lower-offset!!!
673 Adjust offsets if the segments are not contiguous.
674 If the section is contiguous, its offset should be set to
675 the offset of the highest loadable section lower than it
676 (the loadable section directly below it in memory).
677 this_offset = lower_offset = lower_addr - lower_orig_addr */
679 /* Calculate offsets for sections. */
680 for (i
=0 ; i
< MAX_SECTIONS
&& addrs
->other
[i
].name
; i
++)
682 if (addrs
->other
[i
].addr
!= 0)
684 sect
= bfd_get_section_by_name (objfile
->obfd
, addrs
->other
[i
].name
);
687 addrs
->other
[i
].addr
-= bfd_section_vma (objfile
->obfd
, sect
);
688 lower_offset
= addrs
->other
[i
].addr
;
689 /* This is the index used by BFD. */
690 addrs
->other
[i
].sectindex
= sect
->index
;
694 warning ("section %s not found in %s", addrs
->other
[i
].name
,
696 addrs
->other
[i
].addr
= 0;
700 addrs
->other
[i
].addr
= lower_offset
;
704 /* Initialize symbol reading routines for this objfile, allow complaints to
705 appear for this new file, and record how verbose to be, then do the
706 initial symbol reading for this file. */
708 (*objfile
->sf
->sym_init
) (objfile
);
709 clear_complaints (1, verbo
);
711 (*objfile
->sf
->sym_offsets
) (objfile
, addrs
);
713 #ifndef IBM6000_TARGET
714 /* This is a SVR4/SunOS specific hack, I think. In any event, it
715 screws RS/6000. sym_offsets should be doing this sort of thing,
716 because it knows the mapping between bfd sections and
718 /* This is a hack. As far as I can tell, section offsets are not
719 target dependent. They are all set to addr with a couple of
720 exceptions. The exceptions are sysvr4 shared libraries, whose
721 offsets are kept in solib structures anyway and rs6000 xcoff
722 which handles shared libraries in a completely unique way.
724 Section offsets are built similarly, except that they are built
725 by adding addr in all cases because there is no clear mapping
726 from section_offsets into actual sections. Note that solib.c
727 has a different algorithm for finding section offsets.
729 These should probably all be collapsed into some target
730 independent form of shared library support. FIXME. */
734 struct obj_section
*s
;
736 /* Map section offsets in "addr" back to the object's
737 sections by comparing the section names with bfd's
738 section names. Then adjust the section address by
739 the offset. */ /* for gdb/13815 */
741 ALL_OBJFILE_OSECTIONS (objfile
, s
)
743 CORE_ADDR s_addr
= 0;
747 !s_addr
&& i
< MAX_SECTIONS
&& addrs
->other
[i
].name
;
749 if (strcmp (bfd_section_name (s
->objfile
->obfd
,
751 addrs
->other
[i
].name
) == 0)
752 s_addr
= addrs
->other
[i
].addr
; /* end added for gdb/13815 */
754 s
->addr
-= s
->offset
;
756 s
->endaddr
-= s
->offset
;
757 s
->endaddr
+= s_addr
;
761 #endif /* not IBM6000_TARGET */
763 (*objfile
->sf
->sym_read
) (objfile
, mainline
);
765 if (!have_partial_symbols () && !have_full_symbols ())
768 printf_filtered ("(no debugging symbols found)...");
772 /* Don't allow char * to have a typename (else would get caddr_t).
773 Ditto void *. FIXME: Check whether this is now done by all the
774 symbol readers themselves (many of them now do), and if so remove
777 TYPE_NAME (lookup_pointer_type (builtin_type_char
)) = 0;
778 TYPE_NAME (lookup_pointer_type (builtin_type_void
)) = 0;
780 /* Mark the objfile has having had initial symbol read attempted. Note
781 that this does not mean we found any symbols... */
783 objfile
->flags
|= OBJF_SYMS
;
785 /* Discard cleanups as symbol reading was successful. */
787 discard_cleanups (old_chain
);
789 /* Call this after reading in a new symbol table to give target
790 dependent code a crack at the new symbols. For instance, this
791 could be used to update the values of target-specific symbols GDB
792 needs to keep track of (such as _sigtramp, or whatever). */
794 TARGET_SYMFILE_POSTREAD (objfile
);
797 /* Perform required actions after either reading in the initial
798 symbols for a new objfile, or mapping in the symbols from a reusable
802 new_symfile_objfile (struct objfile
*objfile
, int mainline
, int verbo
)
805 /* If this is the main symbol file we have to clean up all users of the
806 old main symbol file. Otherwise it is sufficient to fixup all the
807 breakpoints that may have been redefined by this symbol file. */
810 /* OK, make it the "real" symbol file. */
811 symfile_objfile
= objfile
;
813 clear_symtab_users ();
817 breakpoint_re_set ();
820 /* We're done reading the symbol file; finish off complaints. */
821 clear_complaints (0, verbo
);
824 /* Process a symbol file, as either the main file or as a dynamically
827 NAME is the file name (which will be tilde-expanded and made
828 absolute herein) (but we don't free or modify NAME itself).
829 FROM_TTY says how verbose to be. MAINLINE specifies whether this
830 is the main symbol file, or whether it's an extra symbol file such
831 as dynamically loaded code. If !mainline, ADDR is the address
832 where the text segment was loaded.
834 Upon success, returns a pointer to the objfile that was added.
835 Upon failure, jumps back to command level (never returns). */
838 symbol_file_add (char *name
, int from_tty
, struct section_addr_info
*addrs
,
839 int mainline
, int flags
)
841 struct objfile
*objfile
;
842 struct partial_symtab
*psymtab
;
845 /* Open a bfd for the file, and give user a chance to burp if we'd be
846 interactively wiping out any existing symbols. */
848 abfd
= symfile_bfd_open (name
);
850 if ((have_full_symbols () || have_partial_symbols ())
853 && !query ("Load new symbol table from \"%s\"? ", name
))
854 error ("Not confirmed.");
856 objfile
= allocate_objfile (abfd
, flags
);
858 /* If the objfile uses a mapped symbol file, and we have a psymtab for
859 it, then skip reading any symbols at this time. */
861 if ((objfile
->flags
& OBJF_MAPPED
) && (objfile
->flags
& OBJF_SYMS
))
863 /* We mapped in an existing symbol table file that already has had
864 initial symbol reading performed, so we can skip that part. Notify
865 the user that instead of reading the symbols, they have been mapped.
867 if (from_tty
|| info_verbose
)
869 printf_filtered ("Mapped symbols for %s...", name
);
871 gdb_flush (gdb_stdout
);
873 init_entry_point_info (objfile
);
874 find_sym_fns (objfile
);
878 /* We either created a new mapped symbol table, mapped an existing
879 symbol table file which has not had initial symbol reading
880 performed, or need to read an unmapped symbol table. */
881 if (from_tty
|| info_verbose
)
883 if (pre_add_symbol_hook
)
884 pre_add_symbol_hook (name
);
887 printf_filtered ("Reading symbols from %s...", name
);
889 gdb_flush (gdb_stdout
);
892 syms_from_objfile (objfile
, addrs
, mainline
, from_tty
);
895 /* We now have at least a partial symbol table. Check to see if the
896 user requested that all symbols be read on initial access via either
897 the gdb startup command line or on a per symbol file basis. Expand
898 all partial symbol tables for this objfile if so. */
900 if ((flags
& OBJF_READNOW
) || readnow_symbol_files
)
902 if (from_tty
|| info_verbose
)
904 printf_filtered ("expanding to full symbols...");
906 gdb_flush (gdb_stdout
);
909 for (psymtab
= objfile
->psymtabs
;
911 psymtab
= psymtab
->next
)
913 psymtab_to_symtab (psymtab
);
917 if (from_tty
|| info_verbose
)
919 if (post_add_symbol_hook
)
920 post_add_symbol_hook ();
923 printf_filtered ("done.\n");
924 gdb_flush (gdb_stdout
);
928 if (objfile
->sf
== NULL
)
929 return objfile
; /* No symbols. */
931 new_symfile_objfile (objfile
, mainline
, from_tty
);
933 if (target_new_objfile_hook
)
934 target_new_objfile_hook (objfile
);
939 /* Call symbol_file_add() with default values and update whatever is
940 affected by the loading of a new main().
941 Used when the file is supplied in the gdb command line
942 and by some targets with special loading requirements.
943 The auxiliary function, symbol_file_add_main_1(), has the flags
944 argument for the switches that can only be specified in the symbol_file
948 symbol_file_add_main (char *args
, int from_tty
)
950 symbol_file_add_main_1 (args
, from_tty
, 0);
954 symbol_file_add_main_1 (char *args
, int from_tty
, int flags
)
956 symbol_file_add (args
, from_tty
, NULL
, 1, flags
);
959 RESET_HP_UX_GLOBALS ();
962 /* Getting new symbols may change our opinion about
963 what is frameless. */
964 reinit_frame_cache ();
966 set_initial_language ();
970 symbol_file_clear (int from_tty
)
972 if ((have_full_symbols () || have_partial_symbols ())
974 && !query ("Discard symbol table from `%s'? ",
975 symfile_objfile
->name
))
976 error ("Not confirmed.");
977 free_all_objfiles ();
979 /* solib descriptors may have handles to objfiles. Since their
980 storage has just been released, we'd better wipe the solib
983 #if defined(SOLIB_RESTART)
987 symfile_objfile
= NULL
;
989 printf_unfiltered ("No symbol file now.\n");
991 RESET_HP_UX_GLOBALS ();
995 /* This is the symbol-file command. Read the file, analyze its
996 symbols, and add a struct symtab to a symtab list. The syntax of
997 the command is rather bizarre--(1) buildargv implements various
998 quoting conventions which are undocumented and have little or
999 nothing in common with the way things are quoted (or not quoted)
1000 elsewhere in GDB, (2) options are used, which are not generally
1001 used in GDB (perhaps "set mapped on", "set readnow on" would be
1002 better), (3) the order of options matters, which is contrary to GNU
1003 conventions (because it is confusing and inconvenient). */
1004 /* Note: ezannoni 2000-04-17. This function used to have support for
1005 rombug (see remote-os9k.c). It consisted of a call to target_link()
1006 (target.c) to get the address of the text segment from the target,
1007 and pass that to symbol_file_add(). This is no longer supported. */
1010 symbol_file_command (char *args
, int from_tty
)
1014 struct cleanup
*cleanups
;
1015 int flags
= OBJF_USERLOADED
;
1021 symbol_file_clear (from_tty
);
1025 if ((argv
= buildargv (args
)) == NULL
)
1029 cleanups
= make_cleanup_freeargv (argv
);
1030 while (*argv
!= NULL
)
1032 if (STREQ (*argv
, "-mapped"))
1033 flags
|= OBJF_MAPPED
;
1035 if (STREQ (*argv
, "-readnow"))
1036 flags
|= OBJF_READNOW
;
1039 error ("unknown option `%s'", *argv
);
1044 symbol_file_add_main_1 (name
, from_tty
, flags
);
1051 error ("no symbol file name was specified");
1053 do_cleanups (cleanups
);
1057 /* Set the initial language.
1059 A better solution would be to record the language in the psymtab when reading
1060 partial symbols, and then use it (if known) to set the language. This would
1061 be a win for formats that encode the language in an easily discoverable place,
1062 such as DWARF. For stabs, we can jump through hoops looking for specially
1063 named symbols or try to intuit the language from the specific type of stabs
1064 we find, but we can't do that until later when we read in full symbols.
1068 set_initial_language (void)
1070 struct partial_symtab
*pst
;
1071 enum language lang
= language_unknown
;
1073 pst
= find_main_psymtab ();
1076 if (pst
->filename
!= NULL
)
1078 lang
= deduce_language_from_filename (pst
->filename
);
1080 if (lang
== language_unknown
)
1082 /* Make C the default language */
1085 set_language (lang
);
1086 expected_language
= current_language
; /* Don't warn the user */
1090 /* Open file specified by NAME and hand it off to BFD for preliminary
1091 analysis. Result is a newly initialized bfd *, which includes a newly
1092 malloc'd` copy of NAME (tilde-expanded and made absolute).
1093 In case of trouble, error() is called. */
1096 symfile_bfd_open (char *name
)
1100 char *absolute_name
;
1104 name
= tilde_expand (name
); /* Returns 1st new malloc'd copy */
1106 /* Look down path for it, allocate 2nd new malloc'd copy. */
1107 desc
= openp (getenv ("PATH"), 1, name
, O_RDONLY
| O_BINARY
, 0, &absolute_name
);
1108 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1111 char *exename
= alloca (strlen (name
) + 5);
1112 strcat (strcpy (exename
, name
), ".exe");
1113 desc
= openp (getenv ("PATH"), 1, exename
, O_RDONLY
| O_BINARY
,
1119 make_cleanup (xfree
, name
);
1120 perror_with_name (name
);
1122 xfree (name
); /* Free 1st new malloc'd copy */
1123 name
= absolute_name
; /* Keep 2nd malloc'd copy in bfd */
1124 /* It'll be freed in free_objfile(). */
1126 sym_bfd
= bfd_fdopenr (name
, gnutarget
, desc
);
1130 make_cleanup (xfree
, name
);
1131 error ("\"%s\": can't open to read symbols: %s.", name
,
1132 bfd_errmsg (bfd_get_error ()));
1134 sym_bfd
->cacheable
= 1;
1136 if (!bfd_check_format (sym_bfd
, bfd_object
))
1138 /* FIXME: should be checking for errors from bfd_close (for one thing,
1139 on error it does not free all the storage associated with the
1141 bfd_close (sym_bfd
); /* This also closes desc */
1142 make_cleanup (xfree
, name
);
1143 error ("\"%s\": can't read symbols: %s.", name
,
1144 bfd_errmsg (bfd_get_error ()));
1149 /* Return the section index for the given section name. Return -1 if
1150 the section was not found. */
1152 get_section_index (struct objfile
*objfile
, char *section_name
)
1154 asection
*sect
= bfd_get_section_by_name (objfile
->obfd
, section_name
);
1161 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb
1162 startup by the _initialize routine in each object file format reader,
1163 to register information about each format the the reader is prepared
1167 add_symtab_fns (struct sym_fns
*sf
)
1169 sf
->next
= symtab_fns
;
1174 /* Initialize to read symbols from the symbol file sym_bfd. It either
1175 returns or calls error(). The result is an initialized struct sym_fns
1176 in the objfile structure, that contains cached information about the
1180 find_sym_fns (struct objfile
*objfile
)
1183 enum bfd_flavour our_flavour
= bfd_get_flavour (objfile
->obfd
);
1184 char *our_target
= bfd_get_target (objfile
->obfd
);
1186 if (our_flavour
== bfd_target_srec_flavour
1187 || our_flavour
== bfd_target_ihex_flavour
1188 || our_flavour
== bfd_target_tekhex_flavour
)
1189 return; /* No symbols. */
1191 /* Special kludge for apollo. See dstread.c. */
1192 if (STREQN (our_target
, "apollo", 6))
1193 our_flavour
= (enum bfd_flavour
) -2;
1195 for (sf
= symtab_fns
; sf
!= NULL
; sf
= sf
->next
)
1197 if (our_flavour
== sf
->sym_flavour
)
1203 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
1204 bfd_get_target (objfile
->obfd
));
1207 /* This function runs the load command of our current target. */
1210 load_command (char *arg
, int from_tty
)
1213 arg
= get_exec_file (1);
1214 target_load (arg
, from_tty
);
1216 /* After re-loading the executable, we don't really know which
1217 overlays are mapped any more. */
1218 overlay_cache_invalid
= 1;
1221 /* This version of "load" should be usable for any target. Currently
1222 it is just used for remote targets, not inftarg.c or core files,
1223 on the theory that only in that case is it useful.
1225 Avoiding xmodem and the like seems like a win (a) because we don't have
1226 to worry about finding it, and (b) On VMS, fork() is very slow and so
1227 we don't want to run a subprocess. On the other hand, I'm not sure how
1228 performance compares. */
1230 static int download_write_size
= 512;
1231 static int validate_download
= 0;
1233 /* Callback service function for generic_load (bfd_map_over_sections). */
1236 add_section_size_callback (bfd
*abfd
, asection
*asec
, void *data
)
1238 bfd_size_type
*sum
= data
;
1240 *sum
+= bfd_get_section_size_before_reloc (asec
);
1243 /* Opaque data for load_section_callback. */
1244 struct load_section_data
{
1245 unsigned long load_offset
;
1246 unsigned long write_count
;
1247 unsigned long data_count
;
1248 bfd_size_type total_size
;
1251 /* Callback service function for generic_load (bfd_map_over_sections). */
1254 load_section_callback (bfd
*abfd
, asection
*asec
, void *data
)
1256 struct load_section_data
*args
= data
;
1258 if (bfd_get_section_flags (abfd
, asec
) & SEC_LOAD
)
1260 bfd_size_type size
= bfd_get_section_size_before_reloc (asec
);
1264 struct cleanup
*old_chain
;
1265 CORE_ADDR lma
= bfd_section_lma (abfd
, asec
) + args
->load_offset
;
1266 bfd_size_type block_size
;
1268 const char *sect_name
= bfd_get_section_name (abfd
, asec
);
1271 if (download_write_size
> 0 && size
> download_write_size
)
1272 block_size
= download_write_size
;
1276 buffer
= xmalloc (size
);
1277 old_chain
= make_cleanup (xfree
, buffer
);
1279 /* Is this really necessary? I guess it gives the user something
1280 to look at during a long download. */
1281 ui_out_message (uiout
, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1282 sect_name
, paddr_nz (size
), paddr_nz (lma
));
1284 bfd_get_section_contents (abfd
, asec
, buffer
, 0, size
);
1290 bfd_size_type this_transfer
= size
- sent
;
1292 if (this_transfer
>= block_size
)
1293 this_transfer
= block_size
;
1294 len
= target_write_memory_partial (lma
, buffer
,
1295 this_transfer
, &err
);
1298 if (validate_download
)
1300 /* Broken memories and broken monitors manifest
1301 themselves here when bring new computers to
1302 life. This doubles already slow downloads. */
1303 /* NOTE: cagney/1999-10-18: A more efficient
1304 implementation might add a verify_memory()
1305 method to the target vector and then use
1306 that. remote.c could implement that method
1307 using the ``qCRC'' packet. */
1308 char *check
= xmalloc (len
);
1309 struct cleanup
*verify_cleanups
=
1310 make_cleanup (xfree
, check
);
1312 if (target_read_memory (lma
, check
, len
) != 0)
1313 error ("Download verify read failed at 0x%s",
1315 if (memcmp (buffer
, check
, len
) != 0)
1316 error ("Download verify compare failed at 0x%s",
1318 do_cleanups (verify_cleanups
);
1320 args
->data_count
+= len
;
1323 args
->write_count
+= 1;
1326 || (ui_load_progress_hook
!= NULL
1327 && ui_load_progress_hook (sect_name
, sent
)))
1328 error ("Canceled the download");
1330 if (show_load_progress
!= NULL
)
1331 show_load_progress (sect_name
, sent
, size
,
1332 args
->data_count
, args
->total_size
);
1334 while (sent
< size
);
1337 error ("Memory access error while loading section %s.", sect_name
);
1339 do_cleanups (old_chain
);
1345 generic_load (char *args
, int from_tty
)
1349 time_t start_time
, end_time
; /* Start and end times of download */
1351 struct cleanup
*old_cleanups
;
1353 struct load_section_data cbdata
;
1356 cbdata
.load_offset
= 0; /* Offset to add to vma for each section. */
1357 cbdata
.write_count
= 0; /* Number of writes needed. */
1358 cbdata
.data_count
= 0; /* Number of bytes written to target memory. */
1359 cbdata
.total_size
= 0; /* Total size of all bfd sectors. */
1361 /* Parse the input argument - the user can specify a load offset as
1362 a second argument. */
1363 filename
= xmalloc (strlen (args
) + 1);
1364 old_cleanups
= make_cleanup (xfree
, filename
);
1365 strcpy (filename
, args
);
1366 offptr
= strchr (filename
, ' ');
1371 cbdata
.load_offset
= strtoul (offptr
, &endptr
, 0);
1372 if (offptr
== endptr
)
1373 error ("Invalid download offset:%s\n", offptr
);
1377 cbdata
.load_offset
= 0;
1379 /* Open the file for loading. */
1380 loadfile_bfd
= bfd_openr (filename
, gnutarget
);
1381 if (loadfile_bfd
== NULL
)
1383 perror_with_name (filename
);
1387 /* FIXME: should be checking for errors from bfd_close (for one thing,
1388 on error it does not free all the storage associated with the
1390 make_cleanup_bfd_close (loadfile_bfd
);
1392 if (!bfd_check_format (loadfile_bfd
, bfd_object
))
1394 error ("\"%s\" is not an object file: %s", filename
,
1395 bfd_errmsg (bfd_get_error ()));
1398 bfd_map_over_sections (loadfile_bfd
, add_section_size_callback
,
1399 (void *) &cbdata
.total_size
);
1401 start_time
= time (NULL
);
1403 bfd_map_over_sections (loadfile_bfd
, load_section_callback
, &cbdata
);
1405 end_time
= time (NULL
);
1407 entry
= bfd_get_start_address (loadfile_bfd
);
1408 ui_out_text (uiout
, "Start address ");
1409 ui_out_field_fmt (uiout
, "address", "0x%s", paddr_nz (entry
));
1410 ui_out_text (uiout
, ", load size ");
1411 ui_out_field_fmt (uiout
, "load-size", "%lu", cbdata
.data_count
);
1412 ui_out_text (uiout
, "\n");
1413 /* We were doing this in remote-mips.c, I suspect it is right
1414 for other targets too. */
1417 /* FIXME: are we supposed to call symbol_file_add or not? According to
1418 a comment from remote-mips.c (where a call to symbol_file_add was
1419 commented out), making the call confuses GDB if more than one file is
1420 loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
1423 print_transfer_performance (gdb_stdout
, cbdata
.data_count
,
1424 cbdata
.write_count
, end_time
- start_time
);
1426 do_cleanups (old_cleanups
);
1429 /* Report how fast the transfer went. */
1431 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1432 replaced by print_transfer_performance (with a very different
1433 function signature). */
1436 report_transfer_performance (unsigned long data_count
, time_t start_time
,
1439 print_transfer_performance (gdb_stdout
, data_count
,
1440 end_time
- start_time
, 0);
1444 print_transfer_performance (struct ui_file
*stream
,
1445 unsigned long data_count
,
1446 unsigned long write_count
,
1447 unsigned long time_count
)
1449 ui_out_text (uiout
, "Transfer rate: ");
1452 ui_out_field_fmt (uiout
, "transfer-rate", "%lu",
1453 (data_count
* 8) / time_count
);
1454 ui_out_text (uiout
, " bits/sec");
1458 ui_out_field_fmt (uiout
, "transferred-bits", "%lu", (data_count
* 8));
1459 ui_out_text (uiout
, " bits in <1 sec");
1461 if (write_count
> 0)
1463 ui_out_text (uiout
, ", ");
1464 ui_out_field_fmt (uiout
, "write-rate", "%lu", data_count
/ write_count
);
1465 ui_out_text (uiout
, " bytes/write");
1467 ui_out_text (uiout
, ".\n");
1470 /* This function allows the addition of incrementally linked object files.
1471 It does not modify any state in the target, only in the debugger. */
1472 /* Note: ezannoni 2000-04-13 This function/command used to have a
1473 special case syntax for the rombug target (Rombug is the boot
1474 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1475 rombug case, the user doesn't need to supply a text address,
1476 instead a call to target_link() (in target.c) would supply the
1477 value to use. We are now discontinuing this type of ad hoc syntax. */
1481 add_symbol_file_command (char *args
, int from_tty
)
1483 char *filename
= NULL
;
1484 int flags
= OBJF_USERLOADED
;
1486 int expecting_option
= 0;
1487 int section_index
= 0;
1491 int expecting_sec_name
= 0;
1492 int expecting_sec_addr
= 0;
1498 } sect_opts
[SECT_OFF_MAX
];
1500 struct section_addr_info section_addrs
;
1501 struct cleanup
*my_cleanups
= make_cleanup (null_cleanup
, NULL
);
1506 error ("add-symbol-file takes a file name and an address");
1508 /* Make a copy of the string that we can safely write into. */
1509 args
= xstrdup (args
);
1511 /* Ensure section_addrs is initialized */
1512 memset (§ion_addrs
, 0, sizeof (section_addrs
));
1514 while (*args
!= '\000')
1516 /* Any leading spaces? */
1517 while (isspace (*args
))
1520 /* Point arg to the beginning of the argument. */
1523 /* Move args pointer over the argument. */
1524 while ((*args
!= '\000') && !isspace (*args
))
1527 /* If there are more arguments, terminate arg and
1529 if (*args
!= '\000')
1532 /* Now process the argument. */
1535 /* The first argument is the file name. */
1536 filename
= tilde_expand (arg
);
1537 make_cleanup (xfree
, filename
);
1542 /* The second argument is always the text address at which
1543 to load the program. */
1544 sect_opts
[section_index
].name
= ".text";
1545 sect_opts
[section_index
].value
= arg
;
1550 /* It's an option (starting with '-') or it's an argument
1555 if (strcmp (arg
, "-mapped") == 0)
1556 flags
|= OBJF_MAPPED
;
1558 if (strcmp (arg
, "-readnow") == 0)
1559 flags
|= OBJF_READNOW
;
1561 if (strcmp (arg
, "-s") == 0)
1563 if (section_index
>= SECT_OFF_MAX
)
1564 error ("Too many sections specified.");
1565 expecting_sec_name
= 1;
1566 expecting_sec_addr
= 1;
1571 if (expecting_sec_name
)
1573 sect_opts
[section_index
].name
= arg
;
1574 expecting_sec_name
= 0;
1577 if (expecting_sec_addr
)
1579 sect_opts
[section_index
].value
= arg
;
1580 expecting_sec_addr
= 0;
1584 error ("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*");
1590 /* Print the prompt for the query below. And save the arguments into
1591 a sect_addr_info structure to be passed around to other
1592 functions. We have to split this up into separate print
1593 statements because local_hex_string returns a local static
1596 printf_filtered ("add symbol table from file \"%s\" at\n", filename
);
1597 for (i
= 0; i
< section_index
; i
++)
1600 char *val
= sect_opts
[i
].value
;
1601 char *sec
= sect_opts
[i
].name
;
1603 val
= sect_opts
[i
].value
;
1604 if (val
[0] == '0' && val
[1] == 'x')
1605 addr
= strtoul (val
+2, NULL
, 16);
1607 addr
= strtoul (val
, NULL
, 10);
1609 /* Here we store the section offsets in the order they were
1610 entered on the command line. */
1611 section_addrs
.other
[sec_num
].name
= sec
;
1612 section_addrs
.other
[sec_num
].addr
= addr
;
1613 printf_filtered ("\t%s_addr = %s\n",
1615 local_hex_string ((unsigned long)addr
));
1618 /* The object's sections are initialized when a
1619 call is made to build_objfile_section_table (objfile).
1620 This happens in reread_symbols.
1621 At this point, we don't know what file type this is,
1622 so we can't determine what section names are valid. */
1625 if (from_tty
&& (!query ("%s", "")))
1626 error ("Not confirmed.");
1628 symbol_file_add (filename
, from_tty
, §ion_addrs
, 0, flags
);
1630 /* Getting new symbols may change our opinion about what is
1632 reinit_frame_cache ();
1633 do_cleanups (my_cleanups
);
1637 add_shared_symbol_files_command (char *args
, int from_tty
)
1639 #ifdef ADD_SHARED_SYMBOL_FILES
1640 ADD_SHARED_SYMBOL_FILES (args
, from_tty
);
1642 error ("This command is not available in this configuration of GDB.");
1646 /* Re-read symbols if a symbol-file has changed. */
1648 reread_symbols (void)
1650 struct objfile
*objfile
;
1653 struct stat new_statbuf
;
1656 /* With the addition of shared libraries, this should be modified,
1657 the load time should be saved in the partial symbol tables, since
1658 different tables may come from different source files. FIXME.
1659 This routine should then walk down each partial symbol table
1660 and see if the symbol table that it originates from has been changed */
1662 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
1666 #ifdef IBM6000_TARGET
1667 /* If this object is from a shared library, then you should
1668 stat on the library name, not member name. */
1670 if (objfile
->obfd
->my_archive
)
1671 res
= stat (objfile
->obfd
->my_archive
->filename
, &new_statbuf
);
1674 res
= stat (objfile
->name
, &new_statbuf
);
1677 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1678 printf_filtered ("`%s' has disappeared; keeping its symbols.\n",
1682 new_modtime
= new_statbuf
.st_mtime
;
1683 if (new_modtime
!= objfile
->mtime
)
1685 struct cleanup
*old_cleanups
;
1686 struct section_offsets
*offsets
;
1688 char *obfd_filename
;
1690 printf_filtered ("`%s' has changed; re-reading symbols.\n",
1693 /* There are various functions like symbol_file_add,
1694 symfile_bfd_open, syms_from_objfile, etc., which might
1695 appear to do what we want. But they have various other
1696 effects which we *don't* want. So we just do stuff
1697 ourselves. We don't worry about mapped files (for one thing,
1698 any mapped file will be out of date). */
1700 /* If we get an error, blow away this objfile (not sure if
1701 that is the correct response for things like shared
1703 old_cleanups
= make_cleanup_free_objfile (objfile
);
1704 /* We need to do this whenever any symbols go away. */
1705 make_cleanup (clear_symtab_users_cleanup
, 0 /*ignore*/);
1707 /* Clean up any state BFD has sitting around. We don't need
1708 to close the descriptor but BFD lacks a way of closing the
1709 BFD without closing the descriptor. */
1710 obfd_filename
= bfd_get_filename (objfile
->obfd
);
1711 if (!bfd_close (objfile
->obfd
))
1712 error ("Can't close BFD for %s: %s", objfile
->name
,
1713 bfd_errmsg (bfd_get_error ()));
1714 objfile
->obfd
= bfd_openr (obfd_filename
, gnutarget
);
1715 if (objfile
->obfd
== NULL
)
1716 error ("Can't open %s to read symbols.", objfile
->name
);
1717 /* bfd_openr sets cacheable to true, which is what we want. */
1718 if (!bfd_check_format (objfile
->obfd
, bfd_object
))
1719 error ("Can't read symbols from %s: %s.", objfile
->name
,
1720 bfd_errmsg (bfd_get_error ()));
1722 /* Save the offsets, we will nuke them with the rest of the
1724 num_offsets
= objfile
->num_sections
;
1725 offsets
= (struct section_offsets
*) alloca (SIZEOF_SECTION_OFFSETS
);
1726 memcpy (offsets
, objfile
->section_offsets
, SIZEOF_SECTION_OFFSETS
);
1728 /* Nuke all the state that we will re-read. Much of the following
1729 code which sets things to NULL really is necessary to tell
1730 other parts of GDB that there is nothing currently there. */
1732 /* FIXME: Do we have to free a whole linked list, or is this
1734 if (objfile
->global_psymbols
.list
)
1735 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
1736 memset (&objfile
->global_psymbols
, 0,
1737 sizeof (objfile
->global_psymbols
));
1738 if (objfile
->static_psymbols
.list
)
1739 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
1740 memset (&objfile
->static_psymbols
, 0,
1741 sizeof (objfile
->static_psymbols
));
1743 /* Free the obstacks for non-reusable objfiles */
1744 bcache_xfree (objfile
->psymbol_cache
);
1745 objfile
->psymbol_cache
= bcache_xmalloc ();
1746 bcache_xfree (objfile
->macro_cache
);
1747 objfile
->macro_cache
= bcache_xmalloc ();
1748 obstack_free (&objfile
->psymbol_obstack
, 0);
1749 obstack_free (&objfile
->symbol_obstack
, 0);
1750 obstack_free (&objfile
->type_obstack
, 0);
1751 objfile
->sections
= NULL
;
1752 objfile
->symtabs
= NULL
;
1753 objfile
->psymtabs
= NULL
;
1754 objfile
->free_psymtabs
= NULL
;
1755 objfile
->msymbols
= NULL
;
1756 objfile
->minimal_symbol_count
= 0;
1757 memset (&objfile
->msymbol_hash
, 0,
1758 sizeof (objfile
->msymbol_hash
));
1759 memset (&objfile
->msymbol_demangled_hash
, 0,
1760 sizeof (objfile
->msymbol_demangled_hash
));
1761 objfile
->fundamental_types
= NULL
;
1762 if (objfile
->sf
!= NULL
)
1764 (*objfile
->sf
->sym_finish
) (objfile
);
1767 /* We never make this a mapped file. */
1769 /* obstack_specify_allocation also initializes the obstack so
1771 objfile
->psymbol_cache
= bcache_xmalloc ();
1772 objfile
->macro_cache
= bcache_xmalloc ();
1773 obstack_specify_allocation (&objfile
->psymbol_obstack
, 0, 0,
1775 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0,
1777 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0,
1779 if (build_objfile_section_table (objfile
))
1781 error ("Can't find the file sections in `%s': %s",
1782 objfile
->name
, bfd_errmsg (bfd_get_error ()));
1785 /* We use the same section offsets as from last time. I'm not
1786 sure whether that is always correct for shared libraries. */
1787 objfile
->section_offsets
= (struct section_offsets
*)
1788 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
1789 memcpy (objfile
->section_offsets
, offsets
, SIZEOF_SECTION_OFFSETS
);
1790 objfile
->num_sections
= num_offsets
;
1792 /* What the hell is sym_new_init for, anyway? The concept of
1793 distinguishing between the main file and additional files
1794 in this way seems rather dubious. */
1795 if (objfile
== symfile_objfile
)
1797 (*objfile
->sf
->sym_new_init
) (objfile
);
1799 RESET_HP_UX_GLOBALS ();
1803 (*objfile
->sf
->sym_init
) (objfile
);
1804 clear_complaints (1, 1);
1805 /* The "mainline" parameter is a hideous hack; I think leaving it
1806 zero is OK since dbxread.c also does what it needs to do if
1807 objfile->global_psymbols.size is 0. */
1808 (*objfile
->sf
->sym_read
) (objfile
, 0);
1809 if (!have_partial_symbols () && !have_full_symbols ())
1812 printf_filtered ("(no debugging symbols found)\n");
1815 objfile
->flags
|= OBJF_SYMS
;
1817 /* We're done reading the symbol file; finish off complaints. */
1818 clear_complaints (0, 1);
1820 /* Getting new symbols may change our opinion about what is
1823 reinit_frame_cache ();
1825 /* Discard cleanups as symbol reading was successful. */
1826 discard_cleanups (old_cleanups
);
1828 /* If the mtime has changed between the time we set new_modtime
1829 and now, we *want* this to be out of date, so don't call stat
1831 objfile
->mtime
= new_modtime
;
1834 /* Call this after reading in a new symbol table to give target
1835 dependent code a crack at the new symbols. For instance, this
1836 could be used to update the values of target-specific symbols GDB
1837 needs to keep track of (such as _sigtramp, or whatever). */
1839 TARGET_SYMFILE_POSTREAD (objfile
);
1845 clear_symtab_users ();
1857 static filename_language
*filename_language_table
;
1858 static int fl_table_size
, fl_table_next
;
1861 add_filename_language (char *ext
, enum language lang
)
1863 if (fl_table_next
>= fl_table_size
)
1865 fl_table_size
+= 10;
1866 filename_language_table
=
1867 xrealloc (filename_language_table
,
1868 fl_table_size
* sizeof (*filename_language_table
));
1871 filename_language_table
[fl_table_next
].ext
= xstrdup (ext
);
1872 filename_language_table
[fl_table_next
].lang
= lang
;
1876 static char *ext_args
;
1879 set_ext_lang_command (char *args
, int from_tty
)
1882 char *cp
= ext_args
;
1885 /* First arg is filename extension, starting with '.' */
1887 error ("'%s': Filename extension must begin with '.'", ext_args
);
1889 /* Find end of first arg. */
1890 while (*cp
&& !isspace (*cp
))
1894 error ("'%s': two arguments required -- filename extension and language",
1897 /* Null-terminate first arg */
1900 /* Find beginning of second arg, which should be a source language. */
1901 while (*cp
&& isspace (*cp
))
1905 error ("'%s': two arguments required -- filename extension and language",
1908 /* Lookup the language from among those we know. */
1909 lang
= language_enum (cp
);
1911 /* Now lookup the filename extension: do we already know it? */
1912 for (i
= 0; i
< fl_table_next
; i
++)
1913 if (0 == strcmp (ext_args
, filename_language_table
[i
].ext
))
1916 if (i
>= fl_table_next
)
1918 /* new file extension */
1919 add_filename_language (ext_args
, lang
);
1923 /* redefining a previously known filename extension */
1926 /* query ("Really make files of type %s '%s'?", */
1927 /* ext_args, language_str (lang)); */
1929 xfree (filename_language_table
[i
].ext
);
1930 filename_language_table
[i
].ext
= xstrdup (ext_args
);
1931 filename_language_table
[i
].lang
= lang
;
1936 info_ext_lang_command (char *args
, int from_tty
)
1940 printf_filtered ("Filename extensions and the languages they represent:");
1941 printf_filtered ("\n\n");
1942 for (i
= 0; i
< fl_table_next
; i
++)
1943 printf_filtered ("\t%s\t- %s\n",
1944 filename_language_table
[i
].ext
,
1945 language_str (filename_language_table
[i
].lang
));
1949 init_filename_language_table (void)
1951 if (fl_table_size
== 0) /* protect against repetition */
1955 filename_language_table
=
1956 xmalloc (fl_table_size
* sizeof (*filename_language_table
));
1957 add_filename_language (".c", language_c
);
1958 add_filename_language (".C", language_cplus
);
1959 add_filename_language (".cc", language_cplus
);
1960 add_filename_language (".cp", language_cplus
);
1961 add_filename_language (".cpp", language_cplus
);
1962 add_filename_language (".cxx", language_cplus
);
1963 add_filename_language (".c++", language_cplus
);
1964 add_filename_language (".java", language_java
);
1965 add_filename_language (".class", language_java
);
1966 add_filename_language (".ch", language_chill
);
1967 add_filename_language (".c186", language_chill
);
1968 add_filename_language (".c286", language_chill
);
1969 add_filename_language (".f", language_fortran
);
1970 add_filename_language (".F", language_fortran
);
1971 add_filename_language (".s", language_asm
);
1972 add_filename_language (".S", language_asm
);
1973 add_filename_language (".pas", language_pascal
);
1974 add_filename_language (".p", language_pascal
);
1975 add_filename_language (".pp", language_pascal
);
1980 deduce_language_from_filename (char *filename
)
1985 if (filename
!= NULL
)
1986 if ((cp
= strrchr (filename
, '.')) != NULL
)
1987 for (i
= 0; i
< fl_table_next
; i
++)
1988 if (strcmp (cp
, filename_language_table
[i
].ext
) == 0)
1989 return filename_language_table
[i
].lang
;
1991 return language_unknown
;
1996 Allocate and partly initialize a new symbol table. Return a pointer
1997 to it. error() if no space.
1999 Caller must set these fields:
2005 possibly free_named_symtabs (symtab->filename);
2009 allocate_symtab (char *filename
, struct objfile
*objfile
)
2011 register struct symtab
*symtab
;
2013 symtab
= (struct symtab
*)
2014 obstack_alloc (&objfile
->symbol_obstack
, sizeof (struct symtab
));
2015 memset (symtab
, 0, sizeof (*symtab
));
2016 symtab
->filename
= obsavestring (filename
, strlen (filename
),
2017 &objfile
->symbol_obstack
);
2018 symtab
->fullname
= NULL
;
2019 symtab
->language
= deduce_language_from_filename (filename
);
2020 symtab
->debugformat
= obsavestring ("unknown", 7,
2021 &objfile
->symbol_obstack
);
2023 /* Hook it to the objfile it comes from */
2025 symtab
->objfile
= objfile
;
2026 symtab
->next
= objfile
->symtabs
;
2027 objfile
->symtabs
= symtab
;
2029 /* FIXME: This should go away. It is only defined for the Z8000,
2030 and the Z8000 definition of this macro doesn't have anything to
2031 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
2032 here for convenience. */
2033 #ifdef INIT_EXTRA_SYMTAB_INFO
2034 INIT_EXTRA_SYMTAB_INFO (symtab
);
2040 struct partial_symtab
*
2041 allocate_psymtab (char *filename
, struct objfile
*objfile
)
2043 struct partial_symtab
*psymtab
;
2045 if (objfile
->free_psymtabs
)
2047 psymtab
= objfile
->free_psymtabs
;
2048 objfile
->free_psymtabs
= psymtab
->next
;
2051 psymtab
= (struct partial_symtab
*)
2052 obstack_alloc (&objfile
->psymbol_obstack
,
2053 sizeof (struct partial_symtab
));
2055 memset (psymtab
, 0, sizeof (struct partial_symtab
));
2056 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
2057 &objfile
->psymbol_obstack
);
2058 psymtab
->symtab
= NULL
;
2060 /* Prepend it to the psymtab list for the objfile it belongs to.
2061 Psymtabs are searched in most recent inserted -> least recent
2064 psymtab
->objfile
= objfile
;
2065 psymtab
->next
= objfile
->psymtabs
;
2066 objfile
->psymtabs
= psymtab
;
2069 struct partial_symtab
**prev_pst
;
2070 psymtab
->objfile
= objfile
;
2071 psymtab
->next
= NULL
;
2072 prev_pst
= &(objfile
->psymtabs
);
2073 while ((*prev_pst
) != NULL
)
2074 prev_pst
= &((*prev_pst
)->next
);
2075 (*prev_pst
) = psymtab
;
2083 discard_psymtab (struct partial_symtab
*pst
)
2085 struct partial_symtab
**prev_pst
;
2088 Empty psymtabs happen as a result of header files which don't
2089 have any symbols in them. There can be a lot of them. But this
2090 check is wrong, in that a psymtab with N_SLINE entries but
2091 nothing else is not empty, but we don't realize that. Fixing
2092 that without slowing things down might be tricky. */
2094 /* First, snip it out of the psymtab chain */
2096 prev_pst
= &(pst
->objfile
->psymtabs
);
2097 while ((*prev_pst
) != pst
)
2098 prev_pst
= &((*prev_pst
)->next
);
2099 (*prev_pst
) = pst
->next
;
2101 /* Next, put it on a free list for recycling */
2103 pst
->next
= pst
->objfile
->free_psymtabs
;
2104 pst
->objfile
->free_psymtabs
= pst
;
2108 /* Reset all data structures in gdb which may contain references to symbol
2112 clear_symtab_users (void)
2114 /* Someday, we should do better than this, by only blowing away
2115 the things that really need to be blown. */
2116 clear_value_history ();
2118 clear_internalvars ();
2119 breakpoint_re_set ();
2120 set_default_breakpoint (0, 0, 0, 0);
2121 current_source_symtab
= 0;
2122 current_source_line
= 0;
2123 clear_pc_function_cache ();
2124 if (target_new_objfile_hook
)
2125 target_new_objfile_hook (NULL
);
2129 clear_symtab_users_cleanup (void *ignore
)
2131 clear_symtab_users ();
2134 /* clear_symtab_users_once:
2136 This function is run after symbol reading, or from a cleanup.
2137 If an old symbol table was obsoleted, the old symbol table
2138 has been blown away, but the other GDB data structures that may
2139 reference it have not yet been cleared or re-directed. (The old
2140 symtab was zapped, and the cleanup queued, in free_named_symtab()
2143 This function can be queued N times as a cleanup, or called
2144 directly; it will do all the work the first time, and then will be a
2145 no-op until the next time it is queued. This works by bumping a
2146 counter at queueing time. Much later when the cleanup is run, or at
2147 the end of symbol processing (in case the cleanup is discarded), if
2148 the queued count is greater than the "done-count", we do the work
2149 and set the done-count to the queued count. If the queued count is
2150 less than or equal to the done-count, we just ignore the call. This
2151 is needed because reading a single .o file will often replace many
2152 symtabs (one per .h file, for example), and we don't want to reset
2153 the breakpoints N times in the user's face.
2155 The reason we both queue a cleanup, and call it directly after symbol
2156 reading, is because the cleanup protects us in case of errors, but is
2157 discarded if symbol reading is successful. */
2160 /* FIXME: As free_named_symtabs is currently a big noop this function
2161 is no longer needed. */
2162 static void clear_symtab_users_once (void);
2164 static int clear_symtab_users_queued
;
2165 static int clear_symtab_users_done
;
2168 clear_symtab_users_once (void)
2170 /* Enforce once-per-`do_cleanups'-semantics */
2171 if (clear_symtab_users_queued
<= clear_symtab_users_done
)
2173 clear_symtab_users_done
= clear_symtab_users_queued
;
2175 clear_symtab_users ();
2179 /* Delete the specified psymtab, and any others that reference it. */
2182 cashier_psymtab (struct partial_symtab
*pst
)
2184 struct partial_symtab
*ps
, *pprev
= NULL
;
2187 /* Find its previous psymtab in the chain */
2188 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2197 /* Unhook it from the chain. */
2198 if (ps
== pst
->objfile
->psymtabs
)
2199 pst
->objfile
->psymtabs
= ps
->next
;
2201 pprev
->next
= ps
->next
;
2203 /* FIXME, we can't conveniently deallocate the entries in the
2204 partial_symbol lists (global_psymbols/static_psymbols) that
2205 this psymtab points to. These just take up space until all
2206 the psymtabs are reclaimed. Ditto the dependencies list and
2207 filename, which are all in the psymbol_obstack. */
2209 /* We need to cashier any psymtab that has this one as a dependency... */
2211 for (ps
= pst
->objfile
->psymtabs
; ps
; ps
= ps
->next
)
2213 for (i
= 0; i
< ps
->number_of_dependencies
; i
++)
2215 if (ps
->dependencies
[i
] == pst
)
2217 cashier_psymtab (ps
);
2218 goto again
; /* Must restart, chain has been munged. */
2225 /* If a symtab or psymtab for filename NAME is found, free it along
2226 with any dependent breakpoints, displays, etc.
2227 Used when loading new versions of object modules with the "add-file"
2228 command. This is only called on the top-level symtab or psymtab's name;
2229 it is not called for subsidiary files such as .h files.
2231 Return value is 1 if we blew away the environment, 0 if not.
2232 FIXME. The return value appears to never be used.
2234 FIXME. I think this is not the best way to do this. We should
2235 work on being gentler to the environment while still cleaning up
2236 all stray pointers into the freed symtab. */
2239 free_named_symtabs (char *name
)
2242 /* FIXME: With the new method of each objfile having it's own
2243 psymtab list, this function needs serious rethinking. In particular,
2244 why was it ever necessary to toss psymtabs with specific compilation
2245 unit filenames, as opposed to all psymtabs from a particular symbol
2247 Well, the answer is that some systems permit reloading of particular
2248 compilation units. We want to blow away any old info about these
2249 compilation units, regardless of which objfiles they arrived in. --gnu. */
2251 register struct symtab
*s
;
2252 register struct symtab
*prev
;
2253 register struct partial_symtab
*ps
;
2254 struct blockvector
*bv
;
2257 /* We only wack things if the symbol-reload switch is set. */
2258 if (!symbol_reloading
)
2261 /* Some symbol formats have trouble providing file names... */
2262 if (name
== 0 || *name
== '\0')
2265 /* Look for a psymtab with the specified name. */
2268 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
2270 if (STREQ (name
, ps
->filename
))
2272 cashier_psymtab (ps
); /* Blow it away...and its little dog, too. */
2273 goto again2
; /* Must restart, chain has been munged */
2277 /* Look for a symtab with the specified name. */
2279 for (s
= symtab_list
; s
; s
= s
->next
)
2281 if (STREQ (name
, s
->filename
))
2288 if (s
== symtab_list
)
2289 symtab_list
= s
->next
;
2291 prev
->next
= s
->next
;
2293 /* For now, queue a delete for all breakpoints, displays, etc., whether
2294 or not they depend on the symtab being freed. This should be
2295 changed so that only those data structures affected are deleted. */
2297 /* But don't delete anything if the symtab is empty.
2298 This test is necessary due to a bug in "dbxread.c" that
2299 causes empty symtabs to be created for N_SO symbols that
2300 contain the pathname of the object file. (This problem
2301 has been fixed in GDB 3.9x). */
2303 bv
= BLOCKVECTOR (s
);
2304 if (BLOCKVECTOR_NBLOCKS (bv
) > 2
2305 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
2306 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)))
2308 complain (&oldsyms_complaint
, name
);
2310 clear_symtab_users_queued
++;
2311 make_cleanup (clear_symtab_users_once
, 0);
2316 complain (&empty_symtab_complaint
, name
);
2323 /* It is still possible that some breakpoints will be affected
2324 even though no symtab was found, since the file might have
2325 been compiled without debugging, and hence not be associated
2326 with a symtab. In order to handle this correctly, we would need
2327 to keep a list of text address ranges for undebuggable files.
2328 For now, we do nothing, since this is a fairly obscure case. */
2332 /* FIXME, what about the minimal symbol table? */
2339 /* Allocate and partially fill a partial symtab. It will be
2340 completely filled at the end of the symbol list.
2342 FILENAME is the name of the symbol-file we are reading from. */
2344 struct partial_symtab
*
2345 start_psymtab_common (struct objfile
*objfile
,
2346 struct section_offsets
*section_offsets
, char *filename
,
2347 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
2348 struct partial_symbol
**static_syms
)
2350 struct partial_symtab
*psymtab
;
2352 psymtab
= allocate_psymtab (filename
, objfile
);
2353 psymtab
->section_offsets
= section_offsets
;
2354 psymtab
->textlow
= textlow
;
2355 psymtab
->texthigh
= psymtab
->textlow
; /* default */
2356 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
2357 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
2361 /* Add a symbol with a long value to a psymtab.
2362 Since one arg is a struct, we pass in a ptr and deref it (sigh). */
2365 add_psymbol_to_list (char *name
, int namelength
, namespace_enum
namespace,
2366 enum address_class
class,
2367 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2368 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2369 enum language language
, struct objfile
*objfile
)
2371 register struct partial_symbol
*psym
;
2372 char *buf
= alloca (namelength
+ 1);
2373 /* psymbol is static so that there will be no uninitialized gaps in the
2374 structure which might contain random data, causing cache misses in
2376 static struct partial_symbol psymbol
;
2378 /* Create local copy of the partial symbol */
2379 memcpy (buf
, name
, namelength
);
2380 buf
[namelength
] = '\0';
2381 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, objfile
->psymbol_cache
);
2382 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2385 SYMBOL_VALUE (&psymbol
) = val
;
2389 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2391 SYMBOL_SECTION (&psymbol
) = 0;
2392 SYMBOL_LANGUAGE (&psymbol
) = language
;
2393 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2394 PSYMBOL_CLASS (&psymbol
) = class;
2395 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2397 /* Stash the partial symbol away in the cache */
2398 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), objfile
->psymbol_cache
);
2400 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2401 if (list
->next
>= list
->list
+ list
->size
)
2403 extend_psymbol_list (list
, objfile
);
2405 *list
->next
++ = psym
;
2406 OBJSTAT (objfile
, n_psyms
++);
2409 /* Add a symbol with a long value to a psymtab. This differs from
2410 * add_psymbol_to_list above in taking both a mangled and a demangled
2414 add_psymbol_with_dem_name_to_list (char *name
, int namelength
, char *dem_name
,
2415 int dem_namelength
, namespace_enum
namespace,
2416 enum address_class
class,
2417 struct psymbol_allocation_list
*list
, long val
, /* Value as a long */
2418 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
2419 enum language language
,
2420 struct objfile
*objfile
)
2422 register struct partial_symbol
*psym
;
2423 char *buf
= alloca (namelength
+ 1);
2424 /* psymbol is static so that there will be no uninitialized gaps in the
2425 structure which might contain random data, causing cache misses in
2427 static struct partial_symbol psymbol
;
2429 /* Create local copy of the partial symbol */
2431 memcpy (buf
, name
, namelength
);
2432 buf
[namelength
] = '\0';
2433 SYMBOL_NAME (&psymbol
) = bcache (buf
, namelength
+ 1, objfile
->psymbol_cache
);
2435 buf
= alloca (dem_namelength
+ 1);
2436 memcpy (buf
, dem_name
, dem_namelength
);
2437 buf
[dem_namelength
] = '\0';
2442 case language_cplus
:
2443 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol
) =
2444 bcache (buf
, dem_namelength
+ 1, objfile
->psymbol_cache
);
2446 case language_chill
:
2447 SYMBOL_CHILL_DEMANGLED_NAME (&psymbol
) =
2448 bcache (buf
, dem_namelength
+ 1, objfile
->psymbol_cache
);
2450 /* FIXME What should be done for the default case? Ignoring for now. */
2453 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2456 SYMBOL_VALUE (&psymbol
) = val
;
2460 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
2462 SYMBOL_SECTION (&psymbol
) = 0;
2463 SYMBOL_LANGUAGE (&psymbol
) = language
;
2464 PSYMBOL_NAMESPACE (&psymbol
) = namespace;
2465 PSYMBOL_CLASS (&psymbol
) = class;
2466 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol
, language
);
2468 /* Stash the partial symbol away in the cache */
2469 psym
= bcache (&psymbol
, sizeof (struct partial_symbol
), objfile
->psymbol_cache
);
2471 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2472 if (list
->next
>= list
->list
+ list
->size
)
2474 extend_psymbol_list (list
, objfile
);
2476 *list
->next
++ = psym
;
2477 OBJSTAT (objfile
, n_psyms
++);
2480 /* Initialize storage for partial symbols. */
2483 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
2485 /* Free any previously allocated psymbol lists. */
2487 if (objfile
->global_psymbols
.list
)
2489 xmfree (objfile
->md
, (PTR
) objfile
->global_psymbols
.list
);
2491 if (objfile
->static_psymbols
.list
)
2493 xmfree (objfile
->md
, (PTR
) objfile
->static_psymbols
.list
);
2496 /* Current best guess is that approximately a twentieth
2497 of the total symbols (in a debugging file) are global or static
2500 objfile
->global_psymbols
.size
= total_symbols
/ 10;
2501 objfile
->static_psymbols
.size
= total_symbols
/ 10;
2503 if (objfile
->global_psymbols
.size
> 0)
2505 objfile
->global_psymbols
.next
=
2506 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
2507 xmmalloc (objfile
->md
, (objfile
->global_psymbols
.size
2508 * sizeof (struct partial_symbol
*)));
2510 if (objfile
->static_psymbols
.size
> 0)
2512 objfile
->static_psymbols
.next
=
2513 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
2514 xmmalloc (objfile
->md
, (objfile
->static_psymbols
.size
2515 * sizeof (struct partial_symbol
*)));
2520 The following code implements an abstraction for debugging overlay sections.
2522 The target model is as follows:
2523 1) The gnu linker will permit multiple sections to be mapped into the
2524 same VMA, each with its own unique LMA (or load address).
2525 2) It is assumed that some runtime mechanism exists for mapping the
2526 sections, one by one, from the load address into the VMA address.
2527 3) This code provides a mechanism for gdb to keep track of which
2528 sections should be considered to be mapped from the VMA to the LMA.
2529 This information is used for symbol lookup, and memory read/write.
2530 For instance, if a section has been mapped then its contents
2531 should be read from the VMA, otherwise from the LMA.
2533 Two levels of debugger support for overlays are available. One is
2534 "manual", in which the debugger relies on the user to tell it which
2535 overlays are currently mapped. This level of support is
2536 implemented entirely in the core debugger, and the information about
2537 whether a section is mapped is kept in the objfile->obj_section table.
2539 The second level of support is "automatic", and is only available if
2540 the target-specific code provides functionality to read the target's
2541 overlay mapping table, and translate its contents for the debugger
2542 (by updating the mapped state information in the obj_section tables).
2544 The interface is as follows:
2546 overlay map <name> -- tell gdb to consider this section mapped
2547 overlay unmap <name> -- tell gdb to consider this section unmapped
2548 overlay list -- list the sections that GDB thinks are mapped
2549 overlay read-target -- get the target's state of what's mapped
2550 overlay off/manual/auto -- set overlay debugging state
2551 Functional interface:
2552 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2553 section, return that section.
2554 find_pc_overlay(pc): find any overlay section that contains
2555 the pc, either in its VMA or its LMA
2556 overlay_is_mapped(sect): true if overlay is marked as mapped
2557 section_is_overlay(sect): true if section's VMA != LMA
2558 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2559 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2560 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2561 overlay_mapped_address(...): map an address from section's LMA to VMA
2562 overlay_unmapped_address(...): map an address from section's VMA to LMA
2563 symbol_overlayed_address(...): Return a "current" address for symbol:
2564 either in VMA or LMA depending on whether
2565 the symbol's section is currently mapped
2568 /* Overlay debugging state: */
2570 enum overlay_debugging_state overlay_debugging
= ovly_off
;
2571 int overlay_cache_invalid
= 0; /* True if need to refresh mapped state */
2573 /* Target vector for refreshing overlay mapped state */
2574 static void simple_overlay_update (struct obj_section
*);
2575 void (*target_overlay_update
) (struct obj_section
*) = simple_overlay_update
;
2577 /* Function: section_is_overlay (SECTION)
2578 Returns true if SECTION has VMA not equal to LMA, ie.
2579 SECTION is loaded at an address different from where it will "run". */
2582 section_is_overlay (asection
*section
)
2584 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2586 if (overlay_debugging
)
2587 if (section
&& section
->lma
!= 0 &&
2588 section
->vma
!= section
->lma
)
2594 /* Function: overlay_invalidate_all (void)
2595 Invalidate the mapped state of all overlay sections (mark it as stale). */
2598 overlay_invalidate_all (void)
2600 struct objfile
*objfile
;
2601 struct obj_section
*sect
;
2603 ALL_OBJSECTIONS (objfile
, sect
)
2604 if (section_is_overlay (sect
->the_bfd_section
))
2605 sect
->ovly_mapped
= -1;
2608 /* Function: overlay_is_mapped (SECTION)
2609 Returns true if section is an overlay, and is currently mapped.
2610 Private: public access is thru function section_is_mapped.
2612 Access to the ovly_mapped flag is restricted to this function, so
2613 that we can do automatic update. If the global flag
2614 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2615 overlay_invalidate_all. If the mapped state of the particular
2616 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2619 overlay_is_mapped (struct obj_section
*osect
)
2621 if (osect
== 0 || !section_is_overlay (osect
->the_bfd_section
))
2624 switch (overlay_debugging
)
2628 return 0; /* overlay debugging off */
2629 case ovly_auto
: /* overlay debugging automatic */
2630 /* Unles there is a target_overlay_update function,
2631 there's really nothing useful to do here (can't really go auto) */
2632 if (target_overlay_update
)
2634 if (overlay_cache_invalid
)
2636 overlay_invalidate_all ();
2637 overlay_cache_invalid
= 0;
2639 if (osect
->ovly_mapped
== -1)
2640 (*target_overlay_update
) (osect
);
2642 /* fall thru to manual case */
2643 case ovly_on
: /* overlay debugging manual */
2644 return osect
->ovly_mapped
== 1;
2648 /* Function: section_is_mapped
2649 Returns true if section is an overlay, and is currently mapped. */
2652 section_is_mapped (asection
*section
)
2654 struct objfile
*objfile
;
2655 struct obj_section
*osect
;
2657 if (overlay_debugging
)
2658 if (section
&& section_is_overlay (section
))
2659 ALL_OBJSECTIONS (objfile
, osect
)
2660 if (osect
->the_bfd_section
== section
)
2661 return overlay_is_mapped (osect
);
2666 /* Function: pc_in_unmapped_range
2667 If PC falls into the lma range of SECTION, return true, else false. */
2670 pc_in_unmapped_range (CORE_ADDR pc
, asection
*section
)
2672 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2676 if (overlay_debugging
)
2677 if (section
&& section_is_overlay (section
))
2679 size
= bfd_get_section_size_before_reloc (section
);
2680 if (section
->lma
<= pc
&& pc
< section
->lma
+ size
)
2686 /* Function: pc_in_mapped_range
2687 If PC falls into the vma range of SECTION, return true, else false. */
2690 pc_in_mapped_range (CORE_ADDR pc
, asection
*section
)
2692 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2696 if (overlay_debugging
)
2697 if (section
&& section_is_overlay (section
))
2699 size
= bfd_get_section_size_before_reloc (section
);
2700 if (section
->vma
<= pc
&& pc
< section
->vma
+ size
)
2707 /* Return true if the mapped ranges of sections A and B overlap, false
2710 sections_overlap (asection
*a
, asection
*b
)
2712 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2714 CORE_ADDR a_start
= a
->vma
;
2715 CORE_ADDR a_end
= a
->vma
+ bfd_get_section_size_before_reloc (a
);
2716 CORE_ADDR b_start
= b
->vma
;
2717 CORE_ADDR b_end
= b
->vma
+ bfd_get_section_size_before_reloc (b
);
2719 return (a_start
< b_end
&& b_start
< a_end
);
2722 /* Function: overlay_unmapped_address (PC, SECTION)
2723 Returns the address corresponding to PC in the unmapped (load) range.
2724 May be the same as PC. */
2727 overlay_unmapped_address (CORE_ADDR pc
, asection
*section
)
2729 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2731 if (overlay_debugging
)
2732 if (section
&& section_is_overlay (section
) &&
2733 pc_in_mapped_range (pc
, section
))
2734 return pc
+ section
->lma
- section
->vma
;
2739 /* Function: overlay_mapped_address (PC, SECTION)
2740 Returns the address corresponding to PC in the mapped (runtime) range.
2741 May be the same as PC. */
2744 overlay_mapped_address (CORE_ADDR pc
, asection
*section
)
2746 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2748 if (overlay_debugging
)
2749 if (section
&& section_is_overlay (section
) &&
2750 pc_in_unmapped_range (pc
, section
))
2751 return pc
+ section
->vma
- section
->lma
;
2757 /* Function: symbol_overlayed_address
2758 Return one of two addresses (relative to the VMA or to the LMA),
2759 depending on whether the section is mapped or not. */
2762 symbol_overlayed_address (CORE_ADDR address
, asection
*section
)
2764 if (overlay_debugging
)
2766 /* If the symbol has no section, just return its regular address. */
2769 /* If the symbol's section is not an overlay, just return its address */
2770 if (!section_is_overlay (section
))
2772 /* If the symbol's section is mapped, just return its address */
2773 if (section_is_mapped (section
))
2776 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
2777 * then return its LOADED address rather than its vma address!!
2779 return overlay_unmapped_address (address
, section
);
2784 /* Function: find_pc_overlay (PC)
2785 Return the best-match overlay section for PC:
2786 If PC matches a mapped overlay section's VMA, return that section.
2787 Else if PC matches an unmapped section's VMA, return that section.
2788 Else if PC matches an unmapped section's LMA, return that section. */
2791 find_pc_overlay (CORE_ADDR pc
)
2793 struct objfile
*objfile
;
2794 struct obj_section
*osect
, *best_match
= NULL
;
2796 if (overlay_debugging
)
2797 ALL_OBJSECTIONS (objfile
, osect
)
2798 if (section_is_overlay (osect
->the_bfd_section
))
2800 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
))
2802 if (overlay_is_mapped (osect
))
2803 return osect
->the_bfd_section
;
2807 else if (pc_in_unmapped_range (pc
, osect
->the_bfd_section
))
2810 return best_match
? best_match
->the_bfd_section
: NULL
;
2813 /* Function: find_pc_mapped_section (PC)
2814 If PC falls into the VMA address range of an overlay section that is
2815 currently marked as MAPPED, return that section. Else return NULL. */
2818 find_pc_mapped_section (CORE_ADDR pc
)
2820 struct objfile
*objfile
;
2821 struct obj_section
*osect
;
2823 if (overlay_debugging
)
2824 ALL_OBJSECTIONS (objfile
, osect
)
2825 if (pc_in_mapped_range (pc
, osect
->the_bfd_section
) &&
2826 overlay_is_mapped (osect
))
2827 return osect
->the_bfd_section
;
2832 /* Function: list_overlays_command
2833 Print a list of mapped sections and their PC ranges */
2836 list_overlays_command (char *args
, int from_tty
)
2839 struct objfile
*objfile
;
2840 struct obj_section
*osect
;
2842 if (overlay_debugging
)
2843 ALL_OBJSECTIONS (objfile
, osect
)
2844 if (overlay_is_mapped (osect
))
2850 vma
= bfd_section_vma (objfile
->obfd
, osect
->the_bfd_section
);
2851 lma
= bfd_section_lma (objfile
->obfd
, osect
->the_bfd_section
);
2852 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
2853 name
= bfd_section_name (objfile
->obfd
, osect
->the_bfd_section
);
2855 printf_filtered ("Section %s, loaded at ", name
);
2856 print_address_numeric (lma
, 1, gdb_stdout
);
2857 puts_filtered (" - ");
2858 print_address_numeric (lma
+ size
, 1, gdb_stdout
);
2859 printf_filtered (", mapped at ");
2860 print_address_numeric (vma
, 1, gdb_stdout
);
2861 puts_filtered (" - ");
2862 print_address_numeric (vma
+ size
, 1, gdb_stdout
);
2863 puts_filtered ("\n");
2868 printf_filtered ("No sections are mapped.\n");
2871 /* Function: map_overlay_command
2872 Mark the named section as mapped (ie. residing at its VMA address). */
2875 map_overlay_command (char *args
, int from_tty
)
2877 struct objfile
*objfile
, *objfile2
;
2878 struct obj_section
*sec
, *sec2
;
2881 if (!overlay_debugging
)
2883 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
2884 the 'overlay manual' command.");
2886 if (args
== 0 || *args
== 0)
2887 error ("Argument required: name of an overlay section");
2889 /* First, find a section matching the user supplied argument */
2890 ALL_OBJSECTIONS (objfile
, sec
)
2891 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
2893 /* Now, check to see if the section is an overlay. */
2894 bfdsec
= sec
->the_bfd_section
;
2895 if (!section_is_overlay (bfdsec
))
2896 continue; /* not an overlay section */
2898 /* Mark the overlay as "mapped" */
2899 sec
->ovly_mapped
= 1;
2901 /* Next, make a pass and unmap any sections that are
2902 overlapped by this new section: */
2903 ALL_OBJSECTIONS (objfile2
, sec2
)
2904 if (sec2
->ovly_mapped
2906 && sec
->the_bfd_section
!= sec2
->the_bfd_section
2907 && sections_overlap (sec
->the_bfd_section
,
2908 sec2
->the_bfd_section
))
2911 printf_filtered ("Note: section %s unmapped by overlap\n",
2912 bfd_section_name (objfile
->obfd
,
2913 sec2
->the_bfd_section
));
2914 sec2
->ovly_mapped
= 0; /* sec2 overlaps sec: unmap sec2 */
2918 error ("No overlay section called %s", args
);
2921 /* Function: unmap_overlay_command
2922 Mark the overlay section as unmapped
2923 (ie. resident in its LMA address range, rather than the VMA range). */
2926 unmap_overlay_command (char *args
, int from_tty
)
2928 struct objfile
*objfile
;
2929 struct obj_section
*sec
;
2931 if (!overlay_debugging
)
2933 Overlay debugging not enabled. Use either the 'overlay auto' or\n\
2934 the 'overlay manual' command.");
2936 if (args
== 0 || *args
== 0)
2937 error ("Argument required: name of an overlay section");
2939 /* First, find a section matching the user supplied argument */
2940 ALL_OBJSECTIONS (objfile
, sec
)
2941 if (!strcmp (bfd_section_name (objfile
->obfd
, sec
->the_bfd_section
), args
))
2943 if (!sec
->ovly_mapped
)
2944 error ("Section %s is not mapped", args
);
2945 sec
->ovly_mapped
= 0;
2948 error ("No overlay section called %s", args
);
2951 /* Function: overlay_auto_command
2952 A utility command to turn on overlay debugging.
2953 Possibly this should be done via a set/show command. */
2956 overlay_auto_command (char *args
, int from_tty
)
2958 overlay_debugging
= ovly_auto
;
2959 enable_overlay_breakpoints ();
2961 printf_filtered ("Automatic overlay debugging enabled.");
2964 /* Function: overlay_manual_command
2965 A utility command to turn on overlay debugging.
2966 Possibly this should be done via a set/show command. */
2969 overlay_manual_command (char *args
, int from_tty
)
2971 overlay_debugging
= ovly_on
;
2972 disable_overlay_breakpoints ();
2974 printf_filtered ("Overlay debugging enabled.");
2977 /* Function: overlay_off_command
2978 A utility command to turn on overlay debugging.
2979 Possibly this should be done via a set/show command. */
2982 overlay_off_command (char *args
, int from_tty
)
2984 overlay_debugging
= ovly_off
;
2985 disable_overlay_breakpoints ();
2987 printf_filtered ("Overlay debugging disabled.");
2991 overlay_load_command (char *args
, int from_tty
)
2993 if (target_overlay_update
)
2994 (*target_overlay_update
) (NULL
);
2996 error ("This target does not know how to read its overlay state.");
2999 /* Function: overlay_command
3000 A place-holder for a mis-typed command */
3002 /* Command list chain containing all defined "overlay" subcommands. */
3003 struct cmd_list_element
*overlaylist
;
3006 overlay_command (char *args
, int from_tty
)
3009 ("\"overlay\" must be followed by the name of an overlay command.\n");
3010 help_list (overlaylist
, "overlay ", -1, gdb_stdout
);
3014 /* Target Overlays for the "Simplest" overlay manager:
3016 This is GDB's default target overlay layer. It works with the
3017 minimal overlay manager supplied as an example by Cygnus. The
3018 entry point is via a function pointer "target_overlay_update",
3019 so targets that use a different runtime overlay manager can
3020 substitute their own overlay_update function and take over the
3023 The overlay_update function pokes around in the target's data structures
3024 to see what overlays are mapped, and updates GDB's overlay mapping with
3027 In this simple implementation, the target data structures are as follows:
3028 unsigned _novlys; /# number of overlay sections #/
3029 unsigned _ovly_table[_novlys][4] = {
3030 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3031 {..., ..., ..., ...},
3033 unsigned _novly_regions; /# number of overlay regions #/
3034 unsigned _ovly_region_table[_novly_regions][3] = {
3035 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3038 These functions will attempt to update GDB's mappedness state in the
3039 symbol section table, based on the target's mappedness state.
3041 To do this, we keep a cached copy of the target's _ovly_table, and
3042 attempt to detect when the cached copy is invalidated. The main
3043 entry point is "simple_overlay_update(SECT), which looks up SECT in
3044 the cached table and re-reads only the entry for that section from
3045 the target (whenever possible).
3048 /* Cached, dynamically allocated copies of the target data structures: */
3049 static unsigned (*cache_ovly_table
)[4] = 0;
3051 static unsigned (*cache_ovly_region_table
)[3] = 0;
3053 static unsigned cache_novlys
= 0;
3055 static unsigned cache_novly_regions
= 0;
3057 static CORE_ADDR cache_ovly_table_base
= 0;
3059 static CORE_ADDR cache_ovly_region_table_base
= 0;
3063 VMA
, SIZE
, LMA
, MAPPED
3065 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
3067 /* Throw away the cached copy of _ovly_table */
3069 simple_free_overlay_table (void)
3071 if (cache_ovly_table
)
3072 xfree (cache_ovly_table
);
3074 cache_ovly_table
= NULL
;
3075 cache_ovly_table_base
= 0;
3079 /* Throw away the cached copy of _ovly_region_table */
3081 simple_free_overlay_region_table (void)
3083 if (cache_ovly_region_table
)
3084 xfree (cache_ovly_region_table
);
3085 cache_novly_regions
= 0;
3086 cache_ovly_region_table
= NULL
;
3087 cache_ovly_region_table_base
= 0;
3091 /* Read an array of ints from the target into a local buffer.
3092 Convert to host order. int LEN is number of ints */
3094 read_target_long_array (CORE_ADDR memaddr
, unsigned int *myaddr
, int len
)
3096 /* FIXME (alloca): Not safe if array is very large. */
3097 char *buf
= alloca (len
* TARGET_LONG_BYTES
);
3100 read_memory (memaddr
, buf
, len
* TARGET_LONG_BYTES
);
3101 for (i
= 0; i
< len
; i
++)
3102 myaddr
[i
] = extract_unsigned_integer (TARGET_LONG_BYTES
* i
+ buf
,
3106 /* Find and grab a copy of the target _ovly_table
3107 (and _novlys, which is needed for the table's size) */
3109 simple_read_overlay_table (void)
3111 struct minimal_symbol
*novlys_msym
, *ovly_table_msym
;
3113 simple_free_overlay_table ();
3114 novlys_msym
= lookup_minimal_symbol ("_novlys", NULL
, NULL
);
3117 error ("Error reading inferior's overlay table: "
3118 "couldn't find `_novlys' variable\n"
3119 "in inferior. Use `overlay manual' mode.");
3123 ovly_table_msym
= lookup_minimal_symbol ("_ovly_table", NULL
, NULL
);
3124 if (! ovly_table_msym
)
3126 error ("Error reading inferior's overlay table: couldn't find "
3127 "`_ovly_table' array\n"
3128 "in inferior. Use `overlay manual' mode.");
3132 cache_novlys
= read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym
), 4);
3134 = (void *) xmalloc (cache_novlys
* sizeof (*cache_ovly_table
));
3135 cache_ovly_table_base
= SYMBOL_VALUE_ADDRESS (ovly_table_msym
);
3136 read_target_long_array (cache_ovly_table_base
,
3137 (int *) cache_ovly_table
,
3140 return 1; /* SUCCESS */
3144 /* Find and grab a copy of the target _ovly_region_table
3145 (and _novly_regions, which is needed for the table's size) */
3147 simple_read_overlay_region_table (void)
3149 struct minimal_symbol
*msym
;
3151 simple_free_overlay_region_table ();
3152 msym
= lookup_minimal_symbol ("_novly_regions", NULL
, NULL
);
3154 cache_novly_regions
= read_memory_integer (SYMBOL_VALUE_ADDRESS (msym
), 4);
3156 return 0; /* failure */
3157 cache_ovly_region_table
= (void *) xmalloc (cache_novly_regions
* 12);
3158 if (cache_ovly_region_table
!= NULL
)
3160 msym
= lookup_minimal_symbol ("_ovly_region_table", NULL
, NULL
);
3163 cache_ovly_region_table_base
= SYMBOL_VALUE_ADDRESS (msym
);
3164 read_target_long_array (cache_ovly_region_table_base
,
3165 (int *) cache_ovly_region_table
,
3166 cache_novly_regions
* 3);
3169 return 0; /* failure */
3172 return 0; /* failure */
3173 return 1; /* SUCCESS */
3177 /* Function: simple_overlay_update_1
3178 A helper function for simple_overlay_update. Assuming a cached copy
3179 of _ovly_table exists, look through it to find an entry whose vma,
3180 lma and size match those of OSECT. Re-read the entry and make sure
3181 it still matches OSECT (else the table may no longer be valid).
3182 Set OSECT's mapped state to match the entry. Return: 1 for
3183 success, 0 for failure. */
3186 simple_overlay_update_1 (struct obj_section
*osect
)
3189 bfd
*obfd
= osect
->objfile
->obfd
;
3190 asection
*bsect
= osect
->the_bfd_section
;
3192 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3193 for (i
= 0; i
< cache_novlys
; i
++)
3194 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3195 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3196 /* && cache_ovly_table[i][SIZE] == size */ )
3198 read_target_long_array (cache_ovly_table_base
+ i
* TARGET_LONG_BYTES
,
3199 (int *) cache_ovly_table
[i
], 4);
3200 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3201 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3202 /* && cache_ovly_table[i][SIZE] == size */ )
3204 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3207 else /* Warning! Warning! Target's ovly table has changed! */
3213 /* Function: simple_overlay_update
3214 If OSECT is NULL, then update all sections' mapped state
3215 (after re-reading the entire target _ovly_table).
3216 If OSECT is non-NULL, then try to find a matching entry in the
3217 cached ovly_table and update only OSECT's mapped state.
3218 If a cached entry can't be found or the cache isn't valid, then
3219 re-read the entire cache, and go ahead and update all sections. */
3222 simple_overlay_update (struct obj_section
*osect
)
3224 struct objfile
*objfile
;
3226 /* Were we given an osect to look up? NULL means do all of them. */
3228 /* Have we got a cached copy of the target's overlay table? */
3229 if (cache_ovly_table
!= NULL
)
3230 /* Does its cached location match what's currently in the symtab? */
3231 if (cache_ovly_table_base
==
3232 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL
, NULL
)))
3233 /* Then go ahead and try to look up this single section in the cache */
3234 if (simple_overlay_update_1 (osect
))
3235 /* Found it! We're done. */
3238 /* Cached table no good: need to read the entire table anew.
3239 Or else we want all the sections, in which case it's actually
3240 more efficient to read the whole table in one block anyway. */
3242 if (! simple_read_overlay_table ())
3245 /* Now may as well update all sections, even if only one was requested. */
3246 ALL_OBJSECTIONS (objfile
, osect
)
3247 if (section_is_overlay (osect
->the_bfd_section
))
3250 bfd
*obfd
= osect
->objfile
->obfd
;
3251 asection
*bsect
= osect
->the_bfd_section
;
3253 size
= bfd_get_section_size_before_reloc (osect
->the_bfd_section
);
3254 for (i
= 0; i
< cache_novlys
; i
++)
3255 if (cache_ovly_table
[i
][VMA
] == bfd_section_vma (obfd
, bsect
)
3256 && cache_ovly_table
[i
][LMA
] == bfd_section_lma (obfd
, bsect
)
3257 /* && cache_ovly_table[i][SIZE] == size */ )
3258 { /* obj_section matches i'th entry in ovly_table */
3259 osect
->ovly_mapped
= cache_ovly_table
[i
][MAPPED
];
3260 break; /* finished with inner for loop: break out */
3267 _initialize_symfile (void)
3269 struct cmd_list_element
*c
;
3271 c
= add_cmd ("symbol-file", class_files
, symbol_file_command
,
3272 "Load symbol table from executable file FILE.\n\
3273 The `file' command can also load symbol tables, as well as setting the file\n\
3274 to execute.", &cmdlist
);
3275 set_cmd_completer (c
, filename_completer
);
3277 c
= add_cmd ("add-symbol-file", class_files
, add_symbol_file_command
,
3278 "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3279 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
3280 ADDR is the starting address of the file's text.\n\
3281 The optional arguments are section-name section-address pairs and\n\
3282 should be specified if the data and bss segments are not contiguous\n\
3283 with the text. SECT is a section name to be loaded at SECT_ADDR.",
3285 set_cmd_completer (c
, filename_completer
);
3287 c
= add_cmd ("add-shared-symbol-files", class_files
,
3288 add_shared_symbol_files_command
,
3289 "Load the symbols from shared objects in the dynamic linker's link map.",
3291 c
= add_alias_cmd ("assf", "add-shared-symbol-files", class_files
, 1,
3294 c
= add_cmd ("load", class_files
, load_command
,
3295 "Dynamically load FILE into the running program, and record its symbols\n\
3296 for access from GDB.", &cmdlist
);
3297 set_cmd_completer (c
, filename_completer
);
3300 (add_set_cmd ("symbol-reloading", class_support
, var_boolean
,
3301 (char *) &symbol_reloading
,
3302 "Set dynamic symbol table reloading multiple times in one run.",
3306 add_prefix_cmd ("overlay", class_support
, overlay_command
,
3307 "Commands for debugging overlays.", &overlaylist
,
3308 "overlay ", 0, &cmdlist
);
3310 add_com_alias ("ovly", "overlay", class_alias
, 1);
3311 add_com_alias ("ov", "overlay", class_alias
, 1);
3313 add_cmd ("map-overlay", class_support
, map_overlay_command
,
3314 "Assert that an overlay section is mapped.", &overlaylist
);
3316 add_cmd ("unmap-overlay", class_support
, unmap_overlay_command
,
3317 "Assert that an overlay section is unmapped.", &overlaylist
);
3319 add_cmd ("list-overlays", class_support
, list_overlays_command
,
3320 "List mappings of overlay sections.", &overlaylist
);
3322 add_cmd ("manual", class_support
, overlay_manual_command
,
3323 "Enable overlay debugging.", &overlaylist
);
3324 add_cmd ("off", class_support
, overlay_off_command
,
3325 "Disable overlay debugging.", &overlaylist
);
3326 add_cmd ("auto", class_support
, overlay_auto_command
,
3327 "Enable automatic overlay debugging.", &overlaylist
);
3328 add_cmd ("load-target", class_support
, overlay_load_command
,
3329 "Read the overlay mapping state from the target.", &overlaylist
);
3331 /* Filename extension to source language lookup table: */
3332 init_filename_language_table ();
3333 c
= add_set_cmd ("extension-language", class_files
, var_string_noescape
,
3335 "Set mapping between filename extension and source language.\n\
3336 Usage: set extension-language .foo bar",
3338 set_cmd_cfunc (c
, set_ext_lang_command
);
3340 add_info ("extensions", info_ext_lang_command
,
3341 "All filename extensions associated with a source language.");
3344 (add_set_cmd ("download-write-size", class_obscure
,
3345 var_integer
, (char *) &download_write_size
,
3346 "Set the write size used when downloading a program.\n"
3347 "Only used when downloading a program onto a remote\n"
3348 "target. Specify zero, or a negative value, to disable\n"
3349 "blocked writes. The actual size of each transfer is also\n"
3350 "limited by the size of the target packet and the memory\n"