Bug Summary

File:src/gnu/usr.bin/binutils/gdb/symfile.c
Warning:line 3563, column 3
Value stored to 'c' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name symfile.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -resource-dir /usr/local/lib/clang/13.0.0 -D PIE_DEFAULT=1 -I . -I /usr/src/gnu/usr.bin/binutils/gdb -I /usr/src/gnu/usr.bin/binutils/gdb/config -D LOCALEDIR="/usr/share/locale" -D HAVE_CONFIG_H -I /usr/src/gnu/usr.bin/binutils/gdb/../include/opcode -I ../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../include -I ../intl -I /usr/src/gnu/usr.bin/binutils/gdb/../intl -D MI_OUT=1 -D TUI=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -fcommon -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils/gdb/symfile.c
1/* Generic symbol file reading for the GNU debugger, GDB.
2
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5
6 Contributed by Cygnus Support, using pieces from other GDB modules.
7
8 This file is part of GDB.
9
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.
14
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.
19
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. */
24
25#include "defs.h"
26#include "bfdlink.h"
27#include "symtab.h"
28#include "gdbtypes.h"
29#include "gdbcore.h"
30#include "frame.h"
31#include "target.h"
32#include "value.h"
33#include "symfile.h"
34#include "objfiles.h"
35#include "source.h"
36#include "gdbcmd.h"
37#include "breakpoint.h"
38#include "language.h"
39#include "complaints.h"
40#include "demangle.h"
41#include "inferior.h" /* for write_pc */
42#include "filenames.h" /* for DOSish file names */
43#include "gdb-stabs.h"
44#include "gdb_obstack.h"
45#include "completer.h"
46#include "bcache.h"
47#include "hashtab.h"
48#include "readline/readline.h"
49#include "gdb_assert.h"
50#include "block.h"
51#include "varobj.h"
52
53#include <sys/types.h>
54#include <fcntl.h>
55#include "gdb_string.h"
56#include "gdb_stat.h"
57#include <ctype.h>
58#include <time.h>
59
60#ifndef O_BINARY0
61#define O_BINARY0 0
62#endif
63
64int (*deprecated_ui_load_progress_hook) (const char *section, unsigned long num);
65void (*deprecated_show_load_progress) (const char *section,
66 unsigned long section_sent,
67 unsigned long section_size,
68 unsigned long total_sent,
69 unsigned long total_size);
70void (*deprecated_pre_add_symbol_hook) (const char *);
71void (*deprecated_post_add_symbol_hook) (void);
72void (*deprecated_target_new_objfile_hook) (struct objfile *);
73
74static void clear_symtab_users_cleanup (void *ignore);
75
76/* Global variables owned by this file */
77int readnow_symbol_files; /* Read full symbols immediately */
78
79/* External variables and functions referenced. */
80
81extern void report_transfer_performance (unsigned long, time_t, time_t);
82
83/* Functions this file defines */
84
85#if 0
86static int simple_read_overlay_region_table (void);
87static void simple_free_overlay_region_table (void);
88#endif
89
90static void set_initial_language (void);
91
92static void load_command (char *, int);
93
94static void symbol_file_add_main_1 (char *args, int from_tty, int flags);
95
96static void add_symbol_file_command (char *, int);
97
98static void add_shared_symbol_files_command (char *, int);
99
100static void reread_separate_symbols (struct objfile *objfile);
101
102static void cashier_psymtab (struct partial_symtab *);
103
104bfd *symfile_bfd_open (char *);
105
106int get_section_index (struct objfile *, char *);
107
108static void find_sym_fns (struct objfile *);
109
110static void decrement_reading_symtab (void *);
111
112static void overlay_invalidate_all (void);
113
114static int overlay_is_mapped (struct obj_section *);
115
116void list_overlays_command (char *, int);
117
118void map_overlay_command (char *, int);
119
120void unmap_overlay_command (char *, int);
121
122static void overlay_auto_command (char *, int);
123
124static void overlay_manual_command (char *, int);
125
126static void overlay_off_command (char *, int);
127
128static void overlay_load_command (char *, int);
129
130static void overlay_command (char *, int);
131
132static void simple_free_overlay_table (void);
133
134static void read_target_long_array (CORE_ADDR, unsigned int *, int);
135
136static int simple_read_overlay_table (void);
137
138static int simple_overlay_update_1 (struct obj_section *);
139
140static void add_filename_language (char *ext, enum language lang);
141
142static void set_ext_lang_command (char *args, int from_tty);
143
144static void info_ext_lang_command (char *args, int from_tty);
145
146static char *find_separate_debug_file (struct objfile *objfile);
147
148static void init_filename_language_table (void);
149
150void _initialize_symfile (void);
151
152/* List of all available sym_fns. On gdb startup, each object file reader
153 calls add_symtab_fns() to register information on each format it is
154 prepared to read. */
155
156static struct sym_fns *symtab_fns = NULL((void*)0);
157
158/* Flag for whether user will be reloading symbols multiple times.
159 Defaults to ON for VxWorks, otherwise OFF. */
160
161#ifdef SYMBOL_RELOADING_DEFAULT
162int symbol_reloading = SYMBOL_RELOADING_DEFAULT;
163#else
164int symbol_reloading = 0;
165#endif
166
167/* If non-zero, shared library symbols will be added automatically
168 when the inferior is created, new libraries are loaded, or when
169 attaching to the inferior. This is almost always what users will
170 want to have happen; but for very large programs, the startup time
171 will be excessive, and so if this is a problem, the user can clear
172 this flag and then add the shared library symbols as needed. Note
173 that there is a potential for confusion, since if the shared
174 library symbols are not loaded, commands like "info fun" will *not*
175 report all the functions that are actually present. */
176
177int auto_solib_add = 1;
178
179/* For systems that support it, a threshold size in megabytes. If
180 automatically adding a new library's symbol table to those already
181 known to the debugger would cause the total shared library symbol
182 size to exceed this threshhold, then the shlib's symbols are not
183 added. The threshold is ignored if the user explicitly asks for a
184 shlib to be added, such as when using the "sharedlibrary"
185 command. */
186
187int auto_solib_limit;
188
189
190/* This compares two partial symbols by names, using strcmp_iw_ordered
191 for the comparison. */
192
193static int
194compare_psymbols (const void *s1p, const void *s2p)
195{
196 struct partial_symbol *const *s1 = s1p;
197 struct partial_symbol *const *s2 = s2p;
198
199 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1)(symbol_search_name (&(*s1)->ginfo)),
200 SYMBOL_SEARCH_NAME (*s2)(symbol_search_name (&(*s2)->ginfo)));
201}
202
203void
204sort_pst_symbols (struct partial_symtab *pst)
205{
206 /* Sort the global list; don't sort the static list */
207
208 qsort (pst->objfile->global_psymbols.list + pst->globals_offset,
209 pst->n_global_syms, sizeof (struct partial_symbol *),
210 compare_psymbols);
211}
212
213/* Make a null terminated copy of the string at PTR with SIZE characters in
214 the obstack pointed to by OBSTACKP . Returns the address of the copy.
215 Note that the string at PTR does not have to be null terminated, I.E. it
216 may be part of a larger string and we are only saving a substring. */
217
218char *
219obsavestring (const char *ptr, int size, struct obstack *obstackp)
220{
221 char *p = (char *) obstack_alloc (obstackp, size + 1)__extension__ ({ struct obstack *__h = (obstackp); __extension__
({ struct obstack *__o = (__h); int __len = ((size + 1)); if
(__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
(__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
value = (void *) __o1->object_base; if (__o1->next_free
== value) __o1->maybe_empty_object = 1; __o1->next_free
= (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
(char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); })
;
222 /* Open-coded memcpy--saves function call time. These strings are usually
223 short. FIXME: Is this really still true with a compiler that can
224 inline memcpy? */
225 {
226 const char *p1 = ptr;
227 char *p2 = p;
228 const char *end = ptr + size;
229 while (p1 != end)
230 *p2++ = *p1++;
231 }
232 p[size] = 0;
233 return p;
234}
235
236/* Concatenate strings S1, S2 and S3; return the new string. Space is found
237 in the obstack pointed to by OBSTACKP. */
238
239char *
240obconcat (struct obstack *obstackp, const char *s1, const char *s2,
241 const char *s3)
242{
243 int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
244 char *val = (char *) obstack_alloc (obstackp, len)__extension__ ({ struct obstack *__h = (obstackp); __extension__
({ struct obstack *__o = (__h); int __len = ((len)); if (__o
->chunk_limit - __o->next_free < __len) _obstack_newchunk
(__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
value = (void *) __o1->object_base; if (__o1->next_free
== value) __o1->maybe_empty_object = 1; __o1->next_free
= (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
(char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); })
;
245 strcpy (val, s1);
246 strcat (val, s2);
247 strcat (val, s3);
248 return val;
249}
250
251/* True if we are nested inside psymtab_to_symtab. */
252
253int currently_reading_symtab = 0;
254
255static void
256decrement_reading_symtab (void *dummy)
257{
258 currently_reading_symtab--;
259}
260
261/* Get the symbol table that corresponds to a partial_symtab.
262 This is fast after the first time you do it. In fact, there
263 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
264 case inline. */
265
266struct symtab *
267psymtab_to_symtab (struct partial_symtab *pst)
268{
269 /* If it's been looked up before, return it. */
270 if (pst->symtab)
271 return pst->symtab;
272
273 /* If it has not yet been read in, read it. */
274 if (!pst->readin)
275 {
276 struct cleanup *back_to = make_cleanup (decrement_reading_symtab, NULL((void*)0));
277 currently_reading_symtab++;
278 (*pst->read_symtab) (pst);
279 do_cleanups (back_to);
280 }
281
282 return pst->symtab;
283}
284
285/* Remember the lowest-addressed loadable section we've seen.
286 This function is called via bfd_map_over_sections.
287
288 In case of equal vmas, the section with the largest size becomes the
289 lowest-addressed loadable section.
290
291 If the vmas and sizes are equal, the last section is considered the
292 lowest-addressed loadable section. */
293
294void
295find_lowest_section (bfd *abfd, asection *sect, void *obj)
296{
297 asection **lowest = (asection **) obj;
298
299 if (0 == (bfd_get_section_flags (abfd, sect)((sect)->flags + 0) & SEC_LOAD0x002))
300 return;
301 if (!*lowest)
302 *lowest = sect; /* First loadable section */
303 else if (bfd_section_vma (abfd, *lowest)((*lowest)->vma) > bfd_section_vma (abfd, sect)((sect)->vma))
304 *lowest = sect; /* A lower loadable section */
305 else if (bfd_section_vma (abfd, *lowest)((*lowest)->vma) == bfd_section_vma (abfd, sect)((sect)->vma)
306 && (bfd_section_size (abfd, (*lowest))(((*lowest))->_raw_size)
307 <= bfd_section_size (abfd, sect)((sect)->_raw_size)))
308 *lowest = sect;
309}
310
311/* Create a new section_addr_info, with room for NUM_SECTIONS. */
312
313struct section_addr_info *
314alloc_section_addr_info (size_t num_sections)
315{
316 struct section_addr_info *sap;
317 size_t size;
318
319 size = (sizeof (struct section_addr_info)
320 + sizeof (struct other_sections) * (num_sections - 1));
321 sap = (struct section_addr_info *) xmalloc (size);
322 memset (sap, 0, size);
323 sap->num_sections = num_sections;
324
325 return sap;
326}
327
328
329/* Return a freshly allocated copy of ADDRS. The section names, if
330 any, are also freshly allocated copies of those in ADDRS. */
331struct section_addr_info *
332copy_section_addr_info (struct section_addr_info *addrs)
333{
334 struct section_addr_info *copy
335 = alloc_section_addr_info (addrs->num_sections);
336 int i;
337
338 copy->num_sections = addrs->num_sections;
339 for (i = 0; i < addrs->num_sections; i++)
340 {
341 copy->other[i].addr = addrs->other[i].addr;
342 if (addrs->other[i].name)
343 copy->other[i].name = xstrdup (addrs->other[i].name);
344 else
345 copy->other[i].name = NULL((void*)0);
346 copy->other[i].sectindex = addrs->other[i].sectindex;
347 }
348
349 return copy;
350}
351
352
353
354/* Build (allocate and populate) a section_addr_info struct from
355 an existing section table. */
356
357extern struct section_addr_info *
358build_section_addr_info_from_section_table (const struct section_table *start,
359 const struct section_table *end)
360{
361 struct section_addr_info *sap;
362 const struct section_table *stp;
363 int oidx;
364
365 sap = alloc_section_addr_info (end - start);
366
367 for (stp = start, oidx = 0; stp != end; stp++)
368 {
369 if (bfd_get_section_flags (stp->bfd,((stp->the_bfd_section)->flags + 0)
370 stp->the_bfd_section)((stp->the_bfd_section)->flags + 0) & (SEC_ALLOC0x001 | SEC_LOAD0x002)
371 && oidx < end - start)
372 {
373 sap->other[oidx].addr = stp->addr;
374 sap->other[oidx].name
375 = xstrdup (bfd_section_name (stp->bfd, stp->the_bfd_section)((stp->the_bfd_section)->name));
376 sap->other[oidx].sectindex = stp->the_bfd_section->index;
377 oidx++;
378 }
379 }
380
381 return sap;
382}
383
384
385/* Free all memory allocated by build_section_addr_info_from_section_table. */
386
387extern void
388free_section_addr_info (struct section_addr_info *sap)
389{
390 int idx;
391
392 for (idx = 0; idx < sap->num_sections; idx++)
393 if (sap->other[idx].name)
394 xfree (sap->other[idx].name);
395 xfree (sap);
396}
397
398
399/* Initialize OBJFILE's sect_index_* members. */
400static void
401init_objfile_sect_indices (struct objfile *objfile)
402{
403 asection *sect;
404 int i;
405
406 sect = bfd_get_section_by_name (objfile->obfd, ".text");
407 if (sect)
408 objfile->sect_index_text = sect->index;
409
410 sect = bfd_get_section_by_name (objfile->obfd, ".data");
411 if (sect)
412 objfile->sect_index_data = sect->index;
413
414 sect = bfd_get_section_by_name (objfile->obfd, ".bss");
415 if (sect)
416 objfile->sect_index_bss = sect->index;
417
418 sect = bfd_get_section_by_name (objfile->obfd, ".rodata");
419 if (sect)
420 objfile->sect_index_rodata = sect->index;
421
422 /* This is where things get really weird... We MUST have valid
423 indices for the various sect_index_* members or gdb will abort.
424 So if for example, there is no ".text" section, we have to
425 accomodate that. Except when explicitly adding symbol files at
426 some address, section_offsets contains nothing but zeros, so it
427 doesn't matter which slot in section_offsets the individual
428 sect_index_* members index into. So if they are all zero, it is
429 safe to just point all the currently uninitialized indices to the
430 first slot. */
431
432 for (i = 0; i < objfile->num_sections; i++)
433 {
434 if (ANOFFSET (objfile->section_offsets, i)((i == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/symfile.c"
, 434, "Section index is uninitialized"), -1) : objfile->section_offsets
->offsets[i])
!= 0)
435 {
436 break;
437 }
438 }
439 if (i == objfile->num_sections)
440 {
441 if (objfile->sect_index_text == -1)
442 objfile->sect_index_text = 0;
443 if (objfile->sect_index_data == -1)
444 objfile->sect_index_data = 0;
445 if (objfile->sect_index_bss == -1)
446 objfile->sect_index_bss = 0;
447 if (objfile->sect_index_rodata == -1)
448 objfile->sect_index_rodata = 0;
449 }
450}
451
452
453/* Parse the user's idea of an offset for dynamic linking, into our idea
454 of how to represent it for fast symbol reading. This is the default
455 version of the sym_fns.sym_offsets function for symbol readers that
456 don't need to do anything special. It allocates a section_offsets table
457 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
458
459void
460default_symfile_offsets (struct objfile *objfile,
461 struct section_addr_info *addrs)
462{
463 int i;
464
465 objfile->num_sections = bfd_count_sections (objfile->obfd)((objfile->obfd)->section_count);
466 objfile->section_offsets = (struct section_offsets *)
467 obstack_alloc (&objfile->objfile_obstack,__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
((sizeof (struct section_offsets) + sizeof (((struct section_offsets
*) 0)->offsets) * ((objfile->num_sections)-1)))); if (
__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
(__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
value = (void *) __o1->object_base; if (__o1->next_free
== value) __o1->maybe_empty_object = 1; __o1->next_free
= (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
(char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); })
468 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections))__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
((sizeof (struct section_offsets) + sizeof (((struct section_offsets
*) 0)->offsets) * ((objfile->num_sections)-1)))); if (
__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
(__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
value = (void *) __o1->object_base; if (__o1->next_free
== value) __o1->maybe_empty_object = 1; __o1->next_free
= (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
(char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); })
;
469 memset (objfile->section_offsets, 0,
470 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)(sizeof (struct section_offsets) + sizeof (((struct section_offsets
*) 0)->offsets) * ((objfile->num_sections)-1))
);
471
472 /* Now calculate offsets for section that were specified by the
473 caller. */
474 for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
475 {
476 struct other_sections *osp ;
477
478 osp = &addrs->other[i] ;
479 if (osp->addr == 0)
480 continue;
481
482 /* Record all sections in offsets */
483 /* The section_offsets in the objfile are here filled in using
484 the BFD index. */
485 (objfile->section_offsets)->offsets[osp->sectindex] = osp->addr;
486 }
487
488 /* Remember the bfd indexes for the .text, .data, .bss and
489 .rodata sections. */
490 init_objfile_sect_indices (objfile);
491}
492
493
494/* Process a symbol file, as either the main file or as a dynamically
495 loaded file.
496
497 OBJFILE is where the symbols are to be read from.
498
499 ADDRS is the list of section load addresses. If the user has given
500 an 'add-symbol-file' command, then this is the list of offsets and
501 addresses he or she provided as arguments to the command; or, if
502 we're handling a shared library, these are the actual addresses the
503 sections are loaded at, according to the inferior's dynamic linker
504 (as gleaned by GDB's shared library code). We convert each address
505 into an offset from the section VMA's as it appears in the object
506 file, and then call the file's sym_offsets function to convert this
507 into a format-specific offset table --- a `struct section_offsets'.
508 If ADDRS is non-zero, OFFSETS must be zero.
509
510 OFFSETS is a table of section offsets already in the right
511 format-specific representation. NUM_OFFSETS is the number of
512 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
513 assume this is the proper table the call to sym_offsets described
514 above would produce. Instead of calling sym_offsets, we just dump
515 it right into objfile->section_offsets. (When we're re-reading
516 symbols from an objfile, we don't have the original load address
517 list any more; all we have is the section offset table.) If
518 OFFSETS is non-zero, ADDRS must be zero.
519
520 MAINLINE is nonzero if this is the main symbol file, or zero if
521 it's an extra symbol file such as dynamically loaded code.
522
523 VERBO is nonzero if the caller has printed a verbose message about
524 the symbol reading (and complaints can be more terse about it). */
525
526void
527syms_from_objfile (struct objfile *objfile,
528 struct section_addr_info *addrs,
529 struct section_offsets *offsets,
530 int num_offsets,
531 int mainline,
532 int verbo)
533{
534 struct section_addr_info *local_addr = NULL((void*)0);
535 struct cleanup *old_chain;
536
537 gdb_assert (! (addrs && offsets))((void) ((! (addrs && offsets)) ? 0 : (internal_error
("/usr/src/gnu/usr.bin/binutils/gdb/symfile.c", 537, "%s: Assertion `%s' failed."
, __PRETTY_FUNCTION__, "! (addrs && offsets)"), 0)))
;
538
539 init_entry_point_info (objfile);
540 find_sym_fns (objfile);
541
542 if (objfile->sf == NULL((void*)0))
543 return; /* No symbols. */
544
545 /* Make sure that partially constructed symbol tables will be cleaned up
546 if an error occurs during symbol reading. */
547 old_chain = make_cleanup_free_objfile (objfile);
548
549 /* If ADDRS and OFFSETS are both NULL, put together a dummy address
550 list. We now establish the convention that an addr of zero means
551 no load address was specified. */
552 if (! addrs && ! offsets)
553 {
554 local_addr
555 = alloc_section_addr_info (bfd_count_sections (objfile->obfd)((objfile->obfd)->section_count));
556 make_cleanup (xfree, local_addr);
557 addrs = local_addr;
558 }
559
560 /* Now either addrs or offsets is non-zero. */
561
562 if (mainline)
563 {
564 /* We will modify the main symbol table, make sure that all its users
565 will be cleaned up if an error occurs during symbol reading. */
566 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
567
568 /* Since no error yet, throw away the old symbol table. */
569
570 if (symfile_objfile != NULL((void*)0))
571 {
572 free_objfile (symfile_objfile);
573 symfile_objfile = NULL((void*)0);
574 }
575
576 /* Currently we keep symbols from the add-symbol-file command.
577 If the user wants to get rid of them, they should do "symbol-file"
578 without arguments first. Not sure this is the best behavior
579 (PR 2207). */
580
581 (*objfile->sf->sym_new_init) (objfile);
582 }
583
584 /* Convert addr into an offset rather than an absolute address.
585 We find the lowest address of a loaded segment in the objfile,
586 and assume that <addr> is where that got loaded.
587
588 We no longer warn if the lowest section is not a text segment (as
589 happens for the PA64 port. */
590 if (addrs && addrs->other[0].name)
591 {
592 asection *lower_sect;
593 asection *sect;
594 CORE_ADDR lower_offset;
595 int i;
596
597 /* Find lowest loadable section to be used as starting point for
598 continguous sections. FIXME!! won't work without call to find
599 .text first, but this assumes text is lowest section. */
600 lower_sect = bfd_get_section_by_name (objfile->obfd, ".text");
601 if (lower_sect == NULL((void*)0))
602 bfd_map_over_sections (objfile->obfd, find_lowest_section,
603 &lower_sect);
604 if (lower_sect == NULL((void*)0))
605 warning ("no loadable sections found in added symbol-file %s",
606 objfile->name);
607 else
608 if ((bfd_get_section_flags (objfile->obfd, lower_sect)((lower_sect)->flags + 0) & SEC_CODE0x020) == 0)
609 warning ("Lowest section in %s is %s at %s",
610 objfile->name,
611 bfd_section_name (objfile->obfd, lower_sect)((lower_sect)->name),
612 paddr (bfd_section_vma (objfile->obfd, lower_sect)((lower_sect)->vma)));
613 if (lower_sect != NULL((void*)0))
614 lower_offset = bfd_section_vma (objfile->obfd, lower_sect)((lower_sect)->vma);
615 else
616 lower_offset = 0;
617
618 /* Calculate offsets for the loadable sections.
619 FIXME! Sections must be in order of increasing loadable section
620 so that contiguous sections can use the lower-offset!!!
621
622 Adjust offsets if the segments are not contiguous.
623 If the section is contiguous, its offset should be set to
624 the offset of the highest loadable section lower than it
625 (the loadable section directly below it in memory).
626 this_offset = lower_offset = lower_addr - lower_orig_addr */
627
628 for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
629 {
630 if (addrs->other[i].addr != 0)
631 {
632 sect = bfd_get_section_by_name (objfile->obfd,
633 addrs->other[i].name);
634 if (sect)
635 {
636 addrs->other[i].addr
637 -= bfd_section_vma (objfile->obfd, sect)((sect)->vma);
638 lower_offset = addrs->other[i].addr;
639 /* This is the index used by BFD. */
640 addrs->other[i].sectindex = sect->index ;
641 }
642 else
643 {
644 warning ("section %s not found in %s",
645 addrs->other[i].name,
646 objfile->name);
647 addrs->other[i].addr = 0;
648 }
649 }
650 else
651 addrs->other[i].addr = lower_offset;
652 }
653 }
654
655 /* Initialize symbol reading routines for this objfile, allow complaints to
656 appear for this new file, and record how verbose to be, then do the
657 initial symbol reading for this file. */
658
659 (*objfile->sf->sym_init) (objfile);
660 clear_complaints (&symfile_complaints, 1, verbo);
661
662 if (addrs)
663 (*objfile->sf->sym_offsets) (objfile, addrs);
664 else
665 {
666 size_t size = SIZEOF_N_SECTION_OFFSETS (num_offsets)(sizeof (struct section_offsets) + sizeof (((struct section_offsets
*) 0)->offsets) * ((num_offsets)-1))
;
667
668 /* Just copy in the offset table directly as given to us. */
669 objfile->num_sections = num_offsets;
670 objfile->section_offsets
671 = ((struct section_offsets *)
672 obstack_alloc (&objfile->objfile_obstack, size)__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(size)); if (__o->chunk_limit - __o->next_free < __len
) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len
)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h
); void *value; value = (void *) __o1->object_base; if (__o1
->next_free == value) __o1->maybe_empty_object = 1; __o1
->next_free = (((((__o1->next_free) - (char *) 0)+__o1->
alignment_mask) & ~ (__o1->alignment_mask)) + (char *)
0); if (__o1->next_free - (char *)__o1->chunk > __o1
->chunk_limit - (char *)__o1->chunk) __o1->next_free
= __o1->chunk_limit; __o1->object_base = __o1->next_free
; value; }); })
);
673 memcpy (objfile->section_offsets, offsets, size);
674
675 init_objfile_sect_indices (objfile);
676 }
677
678#ifndef DEPRECATED_IBM6000_TARGET
679 /* This is a SVR4/SunOS specific hack, I think. In any event, it
680 screws RS/6000. sym_offsets should be doing this sort of thing,
681 because it knows the mapping between bfd sections and
682 section_offsets. */
683 /* This is a hack. As far as I can tell, section offsets are not
684 target dependent. They are all set to addr with a couple of
685 exceptions. The exceptions are sysvr4 shared libraries, whose
686 offsets are kept in solib structures anyway and rs6000 xcoff
687 which handles shared libraries in a completely unique way.
688
689 Section offsets are built similarly, except that they are built
690 by adding addr in all cases because there is no clear mapping
691 from section_offsets into actual sections. Note that solib.c
692 has a different algorithm for finding section offsets.
693
694 These should probably all be collapsed into some target
695 independent form of shared library support. FIXME. */
696
697 if (addrs)
698 {
699 struct obj_section *s;
700
701 /* Map section offsets in "addr" back to the object's
702 sections by comparing the section names with bfd's
703 section names. Then adjust the section address by
704 the offset. */ /* for gdb/13815 */
705
706 ALL_OBJFILE_OSECTIONS (objfile, s)for (s = objfile->sections; s < objfile->sections_end
; s++)
707 {
708 CORE_ADDR s_addr = 0;
709 int i;
710
711 for (i = 0;
712 !s_addr && i < addrs->num_sections && addrs->other[i].name;
713 i++)
714 if (strcmp (bfd_section_name (s->objfile->obfd,((s->the_bfd_section)->name)
715 s->the_bfd_section)((s->the_bfd_section)->name),
716 addrs->other[i].name) == 0)
717 s_addr = addrs->other[i].addr; /* end added for gdb/13815 */
718
719 s->addr -= s->offset;
720 s->addr += s_addr;
721 s->endaddr -= s->offset;
722 s->endaddr += s_addr;
723 s->offset += s_addr;
724 }
725 }
726#endif /* not DEPRECATED_IBM6000_TARGET */
727
728 (*objfile->sf->sym_read) (objfile, mainline);
729
730 /* Don't allow char * to have a typename (else would get caddr_t).
731 Ditto void *. FIXME: Check whether this is now done by all the
732 symbol readers themselves (many of them now do), and if so remove
733 it from here. */
734
735 TYPE_NAME (lookup_pointer_type (builtin_type_char))(lookup_pointer_type (builtin_type_char))->main_type->name = 0;
736 TYPE_NAME (lookup_pointer_type (builtin_type_void))(lookup_pointer_type (builtin_type_void))->main_type->name = 0;
737
738 /* Mark the objfile has having had initial symbol read attempted. Note
739 that this does not mean we found any symbols... */
740
741 objfile->flags |= OBJF_SYMS(1 << 1);
742
743 /* Discard cleanups as symbol reading was successful. */
744
745 discard_cleanups (old_chain);
746}
747
748/* Perform required actions after either reading in the initial
749 symbols for a new objfile, or mapping in the symbols from a reusable
750 objfile. */
751
752void
753new_symfile_objfile (struct objfile *objfile, int mainline, int verbo)
754{
755
756 /* If this is the main symbol file we have to clean up all users of the
757 old main symbol file. Otherwise it is sufficient to fixup all the
758 breakpoints that may have been redefined by this symbol file. */
759 if (mainline)
760 {
761 /* OK, make it the "real" symbol file. */
762 symfile_objfile = objfile;
763
764 clear_symtab_users ();
765 }
766 else
767 {
768 breakpoint_re_set ();
769 }
770
771 /* We're done reading the symbol file; finish off complaints. */
772 clear_complaints (&symfile_complaints, 0, verbo);
773}
774
775/* Process a symbol file, as either the main file or as a dynamically
776 loaded file.
777
778 ABFD is a BFD already open on the file, as from symfile_bfd_open.
779 This BFD will be closed on error, and is always consumed by this function.
780
781 FROM_TTY says how verbose to be.
782
783 MAINLINE specifies whether this is the main symbol file, or whether
784 it's an extra symbol file such as dynamically loaded code.
785
786 ADDRS, OFFSETS, and NUM_OFFSETS are as described for
787 syms_from_objfile, above. ADDRS is ignored when MAINLINE is
788 non-zero.
789
790 Upon success, returns a pointer to the objfile that was added.
791 Upon failure, jumps back to command level (never returns). */
792static struct objfile *
793symbol_file_add_with_addrs_or_offsets (bfd *abfd, int from_tty,
794 struct section_addr_info *addrs,
795 struct section_offsets *offsets,
796 int num_offsets,
797 int mainline, int flags)
798{
799 struct objfile *objfile;
800 struct partial_symtab *psymtab;
801 char *debugfile;
802 struct section_addr_info *orig_addrs = NULL((void*)0);
803 struct cleanup *my_cleanups;
804 const char *name = bfd_get_filename (abfd)((char *) (abfd)->filename);
805
806 my_cleanups = make_cleanup_bfd_close (abfd);
807
808 /* Give user a chance to burp if we'd be
809 interactively wiping out any existing symbols. */
810
811 if ((have_full_symbols () || have_partial_symbols ())
812 && mainline
813 && from_tty
814 && !query ("Load new symbol table from \"%s\"? ", name))
815 error ("Not confirmed.");
816
817 objfile = allocate_objfile (abfd, flags);
818 discard_cleanups (my_cleanups);
819
820 if (addrs)
821 {
822 orig_addrs = copy_section_addr_info (addrs);
823 make_cleanup_free_section_addr_info (orig_addrs);
824 }
825
826 /* We either created a new mapped symbol table, mapped an existing
827 symbol table file which has not had initial symbol reading
828 performed, or need to read an unmapped symbol table. */
829 if (from_tty || info_verbose)
830 {
831 if (deprecated_pre_add_symbol_hook)
832 deprecated_pre_add_symbol_hook (name);
833 else
834 {
835 printf_unfiltered ("Reading symbols from %s...", name);
836 wrap_here ("");
837 gdb_flush (gdb_stdout);
838 }
839 }
840 syms_from_objfile (objfile, addrs, offsets, num_offsets,
841 mainline, from_tty);
842
843 /* We now have at least a partial symbol table. Check to see if the
844 user requested that all symbols be read on initial access via either
845 the gdb startup command line or on a per symbol file basis. Expand
846 all partial symbol tables for this objfile if so. */
847
848 if ((flags & OBJF_READNOW(1 << 4)) || readnow_symbol_files)
849 {
850 if (from_tty || info_verbose)
851 {
852 printf_unfiltered ("expanding to full symbols...");
853 wrap_here ("");
854 gdb_flush (gdb_stdout);
855 }
856
857 for (psymtab = objfile->psymtabs;
858 psymtab != NULL((void*)0);
859 psymtab = psymtab->next)
860 {
861 psymtab_to_symtab (psymtab);
862 }
863 }
864
865 debugfile = find_separate_debug_file (objfile);
866 if (debugfile)
867 {
868 if (addrs != NULL((void*)0))
869 {
870 objfile->separate_debug_objfile
871 = symbol_file_add (debugfile, from_tty, orig_addrs, 0, flags);
872 }
873 else
874 {
875 objfile->separate_debug_objfile
876 = symbol_file_add (debugfile, from_tty, NULL((void*)0), 0, flags);
877 }
878 objfile->separate_debug_objfile->separate_debug_objfile_backlink
879 = objfile;
880
881 /* Put the separate debug object before the normal one, this is so that
882 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
883 put_objfile_before (objfile->separate_debug_objfile, objfile);
884
885 xfree (debugfile);
886 }
887
888 if (!have_partial_symbols () && !have_full_symbols ())
889 {
890 wrap_here ("");
891 printf_filtered ("(no debugging symbols found)");
892 if (from_tty || info_verbose)
893 printf_filtered ("...");
894 else
895 printf_filtered ("\n");
896 wrap_here ("");
897 }
898
899 if (from_tty || info_verbose)
900 {
901 if (deprecated_post_add_symbol_hook)
902 deprecated_post_add_symbol_hook ();
903 else
904 {
905 printf_unfiltered ("done.\n");
906 }
907 }
908
909 /* We print some messages regardless of whether 'from_tty ||
910 info_verbose' is true, so make sure they go out at the right
911 time. */
912 gdb_flush (gdb_stdout);
913
914 do_cleanups (my_cleanups);
915
916 if (objfile->sf == NULL((void*)0))
917 return objfile; /* No symbols. */
918
919 new_symfile_objfile (objfile, mainline, from_tty);
920
921 if (deprecated_target_new_objfile_hook)
922 deprecated_target_new_objfile_hook (objfile);
923
924 bfd_cache_close_all ();
925 return (objfile);
926}
927
928
929/* Process the symbol file ABFD, as either the main file or as a
930 dynamically loaded file.
931
932 See symbol_file_add_with_addrs_or_offsets's comments for
933 details. */
934struct objfile *
935symbol_file_add_from_bfd (bfd *abfd, int from_tty,
936 struct section_addr_info *addrs,
937 int mainline, int flags)
938{
939 return symbol_file_add_with_addrs_or_offsets (abfd,
940 from_tty, addrs, 0, 0,
941 mainline, flags);
942}
943
944
945/* Process a symbol file, as either the main file or as a dynamically
946 loaded file. See symbol_file_add_with_addrs_or_offsets's comments
947 for details. */
948struct objfile *
949symbol_file_add (char *name, int from_tty, struct section_addr_info *addrs,
950 int mainline, int flags)
951{
952 return symbol_file_add_from_bfd (symfile_bfd_open (name), from_tty,
953 addrs, mainline, flags);
954}
955
956
957/* Call symbol_file_add() with default values and update whatever is
958 affected by the loading of a new main().
959 Used when the file is supplied in the gdb command line
960 and by some targets with special loading requirements.
961 The auxiliary function, symbol_file_add_main_1(), has the flags
962 argument for the switches that can only be specified in the symbol_file
963 command itself. */
964
965void
966symbol_file_add_main (char *args, int from_tty)
967{
968 symbol_file_add_main_1 (args, from_tty, 0);
969}
970
971static void
972symbol_file_add_main_1 (char *args, int from_tty, int flags)
973{
974 symbol_file_add (args, from_tty, NULL((void*)0), 1, flags);
975
976 /* Getting new symbols may change our opinion about
977 what is frameless. */
978 reinit_frame_cache ();
979
980 set_initial_language ();
981}
982
983void
984symbol_file_clear (int from_tty)
985{
986 if ((have_full_symbols () || have_partial_symbols ())
987 && from_tty
988 && !query ("Discard symbol table from `%s'? ",
989 symfile_objfile->name))
990 error ("Not confirmed.");
991#ifdef CLEAR_SOLIBclear_solib
992 CLEAR_SOLIBclear_solib ();
993#endif
994
995 free_all_objfiles ();
996
997 /* solib descriptors may have handles to objfiles. Since their
998 storage has just been released, we'd better wipe the solib
999 descriptors as well.
1000 */
1001#if defined(SOLIB_RESTART)
1002 SOLIB_RESTART ()(0);
1003#endif
1004
1005 symfile_objfile = NULL((void*)0);
1006 if (from_tty)
1007 printf_unfiltered ("No symbol file now.\n");
1008}
1009
1010static char *
1011get_debug_link_info (struct objfile *objfile, unsigned long *crc32_out)
1012{
1013 asection *sect;
1014 bfd_size_type debuglink_size;
1015 unsigned long crc32;
1016 char *contents;
1017 int crc_offset;
1018 unsigned char *p;
1019
1020 sect = bfd_get_section_by_name (objfile->obfd, ".gnu_debuglink");
1021
1022 if (sect == NULL((void*)0))
1023 return NULL((void*)0);
1024
1025 debuglink_size = bfd_section_size (objfile->obfd, sect)((sect)->_raw_size);
1026
1027 contents = xmalloc (debuglink_size);
1028 bfd_get_section_contents (objfile->obfd, sect, contents,
1029 (file_ptr)0, (bfd_size_type)debuglink_size);
1030
1031 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1032 crc_offset = strlen (contents) + 1;
1033 crc_offset = (crc_offset + 3) & ~3;
1034
1035 crc32 = bfd_get_32 (objfile->obfd, (bfd_byte *) (contents + crc_offset))((*((objfile->obfd)->xvec->bfd_getx32)) ((bfd_byte *
) (contents + crc_offset)))
;
1036
1037 *crc32_out = crc32;
1038 return contents;
1039}
1040
1041static int
1042separate_debug_file_exists (const char *name, unsigned long crc)
1043{
1044 unsigned long file_crc = 0;
1045 int fd;
1046 char buffer[8*1024];
1047 int count;
1048
1049 fd = open (name, O_RDONLY0x0000 | O_BINARY0);
1050 if (fd < 0)
1051 return 0;
1052
1053 while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1054 file_crc = gnu_debuglink_crc32 (file_crc, buffer, count);
1055
1056 close (fd);
1057
1058 return crc == file_crc;
1059}
1060
1061static char *debug_file_directory = NULL((void*)0);
1062
1063#if ! defined (DEBUG_SUBDIRECTORY".debug")
1064#define DEBUG_SUBDIRECTORY".debug" ".debug"
1065#endif
1066
1067static char *
1068find_separate_debug_file (struct objfile *objfile)
1069{
1070 asection *sect;
1071 char *basename;
1072 char *dir;
1073 char *debugfile;
1074 char *name_copy;
1075 bfd_size_type debuglink_size;
1076 unsigned long crc32;
1077 int i;
1078
1079 basename = get_debug_link_info (objfile, &crc32);
1080
1081 if (basename == NULL((void*)0))
1082 return NULL((void*)0);
1083
1084 dir = xstrdup (objfile->name);
1085
1086 /* Strip off the final filename part, leaving the directory name,
1087 followed by a slash. Objfile names should always be absolute and
1088 tilde-expanded, so there should always be a slash in there
1089 somewhere. */
1090 for (i = strlen(dir) - 1; i >= 0; i--)
1091 {
1092 if (IS_DIR_SEPARATOR (dir[i])((dir[i]) == '/'))
1093 break;
1094 }
1095 gdb_assert (i >= 0 && IS_DIR_SEPARATOR (dir[i]))((void) ((i >= 0 && ((dir[i]) == '/')) ? 0 : (internal_error
("/usr/src/gnu/usr.bin/binutils/gdb/symfile.c", 1095, "%s: Assertion `%s' failed."
, __PRETTY_FUNCTION__, "i >= 0 && IS_DIR_SEPARATOR (dir[i])"
), 0)))
;
1096 dir[i+1] = '\0';
1097
1098 debugfile = alloca (strlen (debug_file_directory) + 1__builtin_alloca(strlen (debug_file_directory) + 1 + strlen (
dir) + strlen (".debug") + strlen ("/") + strlen (basename) +
1)
1099 + strlen (dir)__builtin_alloca(strlen (debug_file_directory) + 1 + strlen (
dir) + strlen (".debug") + strlen ("/") + strlen (basename) +
1)
1100 + strlen (DEBUG_SUBDIRECTORY)__builtin_alloca(strlen (debug_file_directory) + 1 + strlen (
dir) + strlen (".debug") + strlen ("/") + strlen (basename) +
1)
1101 + strlen ("/")__builtin_alloca(strlen (debug_file_directory) + 1 + strlen (
dir) + strlen (".debug") + strlen ("/") + strlen (basename) +
1)
1102 + strlen (basename)__builtin_alloca(strlen (debug_file_directory) + 1 + strlen (
dir) + strlen (".debug") + strlen ("/") + strlen (basename) +
1)
1103 + 1)__builtin_alloca(strlen (debug_file_directory) + 1 + strlen (
dir) + strlen (".debug") + strlen ("/") + strlen (basename) +
1)
;
1104
1105 /* First try in the same directory as the original file. */
1106 strcpy (debugfile, dir);
1107 strcat (debugfile, basename);
1108
1109 if (separate_debug_file_exists (debugfile, crc32))
1110 {
1111 xfree (basename);
1112 xfree (dir);
1113 return xstrdup (debugfile);
1114 }
1115
1116 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
1117 strcpy (debugfile, dir);
1118 strcat (debugfile, DEBUG_SUBDIRECTORY".debug");
1119 strcat (debugfile, "/");
1120 strcat (debugfile, basename);
1121
1122 if (separate_debug_file_exists (debugfile, crc32))
1123 {
1124 xfree (basename);
1125 xfree (dir);
1126 return xstrdup (debugfile);
1127 }
1128
1129 /* Then try in the global debugfile directory. */
1130 strcpy (debugfile, debug_file_directory);
1131 strcat (debugfile, "/");
1132 strcat (debugfile, dir);
1133 strcat (debugfile, basename);
1134
1135 if (separate_debug_file_exists (debugfile, crc32))
1136 {
1137 xfree (basename);
1138 xfree (dir);
1139 return xstrdup (debugfile);
1140 }
1141
1142 xfree (basename);
1143 xfree (dir);
1144 return NULL((void*)0);
1145}
1146
1147
1148/* This is the symbol-file command. Read the file, analyze its
1149 symbols, and add a struct symtab to a symtab list. The syntax of
1150 the command is rather bizarre--(1) buildargv implements various
1151 quoting conventions which are undocumented and have little or
1152 nothing in common with the way things are quoted (or not quoted)
1153 elsewhere in GDB, (2) options are used, which are not generally
1154 used in GDB (perhaps "set mapped on", "set readnow on" would be
1155 better), (3) the order of options matters, which is contrary to GNU
1156 conventions (because it is confusing and inconvenient). */
1157/* Note: ezannoni 2000-04-17. This function used to have support for
1158 rombug (see remote-os9k.c). It consisted of a call to target_link()
1159 (target.c) to get the address of the text segment from the target,
1160 and pass that to symbol_file_add(). This is no longer supported. */
1161
1162void
1163symbol_file_command (char *args, int from_tty)
1164{
1165 char **argv;
1166 char *name = NULL((void*)0);
1167 struct cleanup *cleanups;
1168 int flags = OBJF_USERLOADED(1 << 5);
1169
1170 dont_repeat ();
1171
1172 if (args == NULL((void*)0))
1173 {
1174 symbol_file_clear (from_tty);
1175 }
1176 else
1177 {
1178 if ((argv = buildargv (args)) == NULL((void*)0))
1179 {
1180 nomem (0);
1181 }
1182 cleanups = make_cleanup_freeargv (argv);
1183 while (*argv != NULL((void*)0))
1184 {
1185 if (strcmp (*argv, "-readnow") == 0)
1186 flags |= OBJF_READNOW(1 << 4);
1187 else if (**argv == '-')
1188 error ("unknown option `%s'", *argv);
1189 else
1190 {
1191 name = *argv;
1192
1193 symbol_file_add_main_1 (name, from_tty, flags);
1194 }
1195 argv++;
1196 }
1197
1198 if (name == NULL((void*)0))
1199 {
1200 error ("no symbol file name was specified");
1201 }
1202 do_cleanups (cleanups);
1203 }
1204}
1205
1206/* Set the initial language.
1207
1208 A better solution would be to record the language in the psymtab when reading
1209 partial symbols, and then use it (if known) to set the language. This would
1210 be a win for formats that encode the language in an easily discoverable place,
1211 such as DWARF. For stabs, we can jump through hoops looking for specially
1212 named symbols or try to intuit the language from the specific type of stabs
1213 we find, but we can't do that until later when we read in full symbols.
1214 FIXME. */
1215
1216static void
1217set_initial_language (void)
1218{
1219 struct partial_symtab *pst;
1220 enum language lang = language_unknown;
1221
1222 pst = find_main_psymtab ();
1223 if (pst != NULL((void*)0))
1224 {
1225 if (pst->filename != NULL((void*)0))
1226 {
1227 lang = deduce_language_from_filename (pst->filename);
1228 }
1229 if (lang == language_unknown)
1230 {
1231 /* Make C the default language */
1232 lang = language_c;
1233 }
1234 set_language (lang);
1235 expected_language = current_language; /* Don't warn the user */
1236 }
1237}
1238
1239/* Open file specified by NAME and hand it off to BFD for preliminary
1240 analysis. Result is a newly initialized bfd *, which includes a newly
1241 malloc'd` copy of NAME (tilde-expanded and made absolute).
1242 In case of trouble, error() is called. */
1243
1244bfd *
1245symfile_bfd_open (char *name)
1246{
1247 bfd *sym_bfd;
1248 int desc;
1249 char *absolute_name;
1250
1251
1252
1253 name = tilde_expand (name); /* Returns 1st new malloc'd copy */
1254
1255 /* Look down path for it, allocate 2nd new malloc'd copy. */
1256 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST0x01, name, O_RDONLY0x0000 | O_BINARY0,
1257 0, &absolute_name);
1258#if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
1259 if (desc < 0)
1260 {
1261 char *exename = alloca (strlen (name) + 5)__builtin_alloca(strlen (name) + 5);
1262 strcat (strcpy (exename, name), ".exe");
1263 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST0x01, exename,
1264 O_RDONLY0x0000 | O_BINARY0, 0, &absolute_name);
1265 }
1266#endif
1267 if (desc < 0)
1268 {
1269 make_cleanup (xfree, name);
1270 perror_with_name (name);
1271 }
1272 xfree (name); /* Free 1st new malloc'd copy */
1273 name = absolute_name; /* Keep 2nd malloc'd copy in bfd */
1274 /* It'll be freed in free_objfile(). */
1275
1276 sym_bfd = bfd_fdopenr (name, gnutarget, desc);
1277 if (!sym_bfd)
1278 {
1279 close (desc);
1280 make_cleanup (xfree, name);
1281 error ("\"%s\": can't open to read symbols: %s.", name,
1282 bfd_errmsg (bfd_get_error ()));
1283 }
1284 bfd_set_cacheable (sym_bfd, 1)(((sym_bfd)->cacheable = 1), 1);
1285
1286 if (!bfd_check_format (sym_bfd, bfd_object))
1287 {
1288 /* FIXME: should be checking for errors from bfd_close (for one thing,
1289 on error it does not free all the storage associated with the
1290 bfd). */
1291 bfd_close (sym_bfd); /* This also closes desc */
1292 make_cleanup (xfree, name);
1293 error ("\"%s\": can't read symbols: %s.", name,
1294 bfd_errmsg (bfd_get_error ()));
1295 }
1296 return (sym_bfd);
1297}
1298
1299/* Return the section index for the given section name. Return -1 if
1300 the section was not found. */
1301int
1302get_section_index (struct objfile *objfile, char *section_name)
1303{
1304 asection *sect = bfd_get_section_by_name (objfile->obfd, section_name);
1305 if (sect)
1306 return sect->index;
1307 else
1308 return -1;
1309}
1310
1311/* Link a new symtab_fns into the global symtab_fns list. Called on gdb
1312 startup by the _initialize routine in each object file format reader,
1313 to register information about each format the the reader is prepared
1314 to handle. */
1315
1316void
1317add_symtab_fns (struct sym_fns *sf)
1318{
1319 sf->next = symtab_fns;
1320 symtab_fns = sf;
1321}
1322
1323
1324/* Initialize to read symbols from the symbol file sym_bfd. It either
1325 returns or calls error(). The result is an initialized struct sym_fns
1326 in the objfile structure, that contains cached information about the
1327 symbol file. */
1328
1329static void
1330find_sym_fns (struct objfile *objfile)
1331{
1332 struct sym_fns *sf;
1333 enum bfd_flavour our_flavour = bfd_get_flavour (objfile->obfd)((objfile->obfd)->xvec->flavour);
1334 char *our_target = bfd_get_target (objfile->obfd)((objfile->obfd)->xvec->name);
1335
1336 if (our_flavour == bfd_target_srec_flavour
1337 || our_flavour == bfd_target_ihex_flavour
1338 || our_flavour == bfd_target_tekhex_flavour)
1339 return; /* No symbols. */
1340
1341 for (sf = symtab_fns; sf != NULL((void*)0); sf = sf->next)
1342 {
1343 if (our_flavour == sf->sym_flavour)
1344 {
1345 objfile->sf = sf;
1346 return;
1347 }
1348 }
1349 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
1350 bfd_get_target (objfile->obfd)((objfile->obfd)->xvec->name));
1351}
1352
1353/* This function runs the load command of our current target. */
1354
1355static void
1356load_command (char *arg, int from_tty)
1357{
1358 if (arg == NULL((void*)0))
1359 arg = get_exec_file (1);
1360 target_load (arg, from_tty);
1361
1362 /* After re-loading the executable, we don't really know which
1363 overlays are mapped any more. */
1364 overlay_cache_invalid = 1;
1365}
1366
1367/* This version of "load" should be usable for any target. Currently
1368 it is just used for remote targets, not inftarg.c or core files,
1369 on the theory that only in that case is it useful.
1370
1371 Avoiding xmodem and the like seems like a win (a) because we don't have
1372 to worry about finding it, and (b) On VMS, fork() is very slow and so
1373 we don't want to run a subprocess. On the other hand, I'm not sure how
1374 performance compares. */
1375
1376static int download_write_size = 512;
1377static int validate_download = 0;
1378
1379/* Callback service function for generic_load (bfd_map_over_sections). */
1380
1381static void
1382add_section_size_callback (bfd *abfd, asection *asec, void *data)
1383{
1384 bfd_size_type *sum = data;
1385
1386 *sum += bfd_get_section_size (asec)((asec)->_raw_size);
1387}
1388
1389/* Opaque data for load_section_callback. */
1390struct load_section_data {
1391 unsigned long load_offset;
1392 unsigned long write_count;
1393 unsigned long data_count;
1394 bfd_size_type total_size;
1395};
1396
1397/* Callback service function for generic_load (bfd_map_over_sections). */
1398
1399static void
1400load_section_callback (bfd *abfd, asection *asec, void *data)
1401{
1402 struct load_section_data *args = data;
1403
1404 if (bfd_get_section_flags (abfd, asec)((asec)->flags + 0) & SEC_LOAD0x002)
1405 {
1406 bfd_size_type size = bfd_get_section_size (asec)((asec)->_raw_size);
1407 if (size > 0)
1408 {
1409 char *buffer;
1410 struct cleanup *old_chain;
1411 CORE_ADDR lma = bfd_section_lma (abfd, asec)((asec)->lma) + args->load_offset;
1412 bfd_size_type block_size;
1413 int err;
1414 const char *sect_name = bfd_get_section_name (abfd, asec)((asec)->name + 0);
1415 bfd_size_type sent;
1416
1417 if (download_write_size > 0 && size > download_write_size)
1418 block_size = download_write_size;
1419 else
1420 block_size = size;
1421
1422 buffer = xmalloc (size);
1423 old_chain = make_cleanup (xfree, buffer);
1424
1425 /* Is this really necessary? I guess it gives the user something
1426 to look at during a long download. */
1427 ui_out_message (uiout, 0, "Loading section %s, size 0x%s lma 0x%s\n",
1428 sect_name, paddr_nz (size), paddr_nz (lma));
1429
1430 bfd_get_section_contents (abfd, asec, buffer, 0, size);
1431
1432 sent = 0;
1433 do
1434 {
1435 int len;
1436 bfd_size_type this_transfer = size - sent;
1437
1438 if (this_transfer >= block_size)
1439 this_transfer = block_size;
1440 len = target_write_memory_partial (lma, buffer,
1441 this_transfer, &err);
1442 if (err)
1443 break;
1444 if (validate_download)
1445 {
1446 /* Broken memories and broken monitors manifest
1447 themselves here when bring new computers to
1448 life. This doubles already slow downloads. */
1449 /* NOTE: cagney/1999-10-18: A more efficient
1450 implementation might add a verify_memory()
1451 method to the target vector and then use
1452 that. remote.c could implement that method
1453 using the ``qCRC'' packet. */
1454 char *check = xmalloc (len);
1455 struct cleanup *verify_cleanups =
1456 make_cleanup (xfree, check);
1457
1458 if (target_read_memory (lma, check, len) != 0)
1459 error ("Download verify read failed at 0x%s",
1460 paddr (lma));
1461 if (memcmp (buffer, check, len) != 0)
1462 error ("Download verify compare failed at 0x%s",
1463 paddr (lma));
1464 do_cleanups (verify_cleanups);
1465 }
1466 args->data_count += len;
1467 lma += len;
1468 buffer += len;
1469 args->write_count += 1;
1470 sent += len;
1471 if (quit_flag
1472 || (deprecated_ui_load_progress_hook != NULL((void*)0)
1473 && deprecated_ui_load_progress_hook (sect_name, sent)))
1474 error ("Canceled the download");
1475
1476 if (deprecated_show_load_progress != NULL((void*)0))
1477 deprecated_show_load_progress (sect_name, sent, size,
1478 args->data_count,
1479 args->total_size);
1480 }
1481 while (sent < size);
1482
1483 if (err != 0)
1484 error ("Memory access error while loading section %s.", sect_name);
1485
1486 do_cleanups (old_chain);
1487 }
1488 }
1489}
1490
1491void
1492generic_load (char *args, int from_tty)
1493{
1494 asection *s;
1495 bfd *loadfile_bfd;
1496 time_t start_time, end_time; /* Start and end times of download */
1497 char *filename;
1498 struct cleanup *old_cleanups;
1499 char *offptr;
1500 struct load_section_data cbdata;
1501 CORE_ADDR entry;
1502
1503 cbdata.load_offset = 0; /* Offset to add to vma for each section. */
1504 cbdata.write_count = 0; /* Number of writes needed. */
1505 cbdata.data_count = 0; /* Number of bytes written to target memory. */
1506 cbdata.total_size = 0; /* Total size of all bfd sectors. */
1507
1508 /* Parse the input argument - the user can specify a load offset as
1509 a second argument. */
1510 filename = xmalloc (strlen (args) + 1);
1511 old_cleanups = make_cleanup (xfree, filename);
1512 strcpy (filename, args);
1513 offptr = strchr (filename, ' ');
1514 if (offptr != NULL((void*)0))
1515 {
1516 char *endptr;
1517
1518 cbdata.load_offset = strtoul (offptr, &endptr, 0);
1519 if (offptr == endptr)
1520 error ("Invalid download offset:%s\n", offptr);
1521 *offptr = '\0';
1522 }
1523 else
1524 cbdata.load_offset = 0;
1525
1526 /* Open the file for loading. */
1527 loadfile_bfd = bfd_openr (filename, gnutarget);
1528 if (loadfile_bfd == NULL((void*)0))
1529 {
1530 perror_with_name (filename);
1531 return;
1532 }
1533
1534 /* FIXME: should be checking for errors from bfd_close (for one thing,
1535 on error it does not free all the storage associated with the
1536 bfd). */
1537 make_cleanup_bfd_close (loadfile_bfd);
1538
1539 if (!bfd_check_format (loadfile_bfd, bfd_object))
1540 {
1541 error ("\"%s\" is not an object file: %s", filename,
1542 bfd_errmsg (bfd_get_error ()));
1543 }
1544
1545 bfd_map_over_sections (loadfile_bfd, add_section_size_callback,
1546 (void *) &cbdata.total_size);
1547
1548 start_time = time (NULL((void*)0));
1549
1550 bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata);
1551
1552 end_time = time (NULL((void*)0));
1553
1554 entry = bfd_get_start_address (loadfile_bfd)((loadfile_bfd)->start_address);
1555 ui_out_text (uiout, "Start address ");
1556 ui_out_field_fmt (uiout, "address", "0x%s", paddr_nz (entry));
1557 ui_out_text (uiout, ", load size ");
1558 ui_out_field_fmt (uiout, "load-size", "%lu", cbdata.data_count);
1559 ui_out_text (uiout, "\n");
1560 /* We were doing this in remote-mips.c, I suspect it is right
1561 for other targets too. */
1562 write_pc (entry);
1563
1564 /* FIXME: are we supposed to call symbol_file_add or not? According
1565 to a comment from remote-mips.c (where a call to symbol_file_add
1566 was commented out), making the call confuses GDB if more than one
1567 file is loaded in. Some targets do (e.g., remote-vx.c) but
1568 others don't (or didn't - perhaps they have all been deleted). */
1569
1570 print_transfer_performance (gdb_stdout, cbdata.data_count,
1571 cbdata.write_count, end_time - start_time);
1572
1573 do_cleanups (old_cleanups);
1574}
1575
1576/* Report how fast the transfer went. */
1577
1578/* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
1579 replaced by print_transfer_performance (with a very different
1580 function signature). */
1581
1582void
1583report_transfer_performance (unsigned long data_count, time_t start_time,
1584 time_t end_time)
1585{
1586 print_transfer_performance (gdb_stdout, data_count,
1587 end_time - start_time, 0);
1588}
1589
1590void
1591print_transfer_performance (struct ui_file *stream,
1592 unsigned long data_count,
1593 unsigned long write_count,
1594 unsigned long time_count)
1595{
1596 ui_out_text (uiout, "Transfer rate: ");
1597 if (time_count > 0)
1598 {
1599 ui_out_field_fmt (uiout, "transfer-rate", "%lu",
1600 (data_count * 8) / time_count);
1601 ui_out_text (uiout, " bits/sec");
1602 }
1603 else
1604 {
1605 ui_out_field_fmt (uiout, "transferred-bits", "%lu", (data_count * 8));
1606 ui_out_text (uiout, " bits in <1 sec");
1607 }
1608 if (write_count > 0)
1609 {
1610 ui_out_text (uiout, ", ");
1611 ui_out_field_fmt (uiout, "write-rate", "%lu", data_count / write_count);
1612 ui_out_text (uiout, " bytes/write");
1613 }
1614 ui_out_text (uiout, ".\n");
1615}
1616
1617/* This function allows the addition of incrementally linked object files.
1618 It does not modify any state in the target, only in the debugger. */
1619/* Note: ezannoni 2000-04-13 This function/command used to have a
1620 special case syntax for the rombug target (Rombug is the boot
1621 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
1622 rombug case, the user doesn't need to supply a text address,
1623 instead a call to target_link() (in target.c) would supply the
1624 value to use. We are now discontinuing this type of ad hoc syntax. */
1625
1626static void
1627add_symbol_file_command (char *args, int from_tty)
1628{
1629 char *filename = NULL((void*)0);
1630 int flags = OBJF_USERLOADED(1 << 5);
1631 char *arg;
1632 int expecting_option = 0;
1633 int section_index = 0;
1634 int argcnt = 0;
1635 int sec_num = 0;
1636 int i;
1637 int expecting_sec_name = 0;
1638 int expecting_sec_addr = 0;
1639
1640 struct sect_opt
1641 {
1642 char *name;
1643 char *value;
1644 };
1645
1646 struct section_addr_info *section_addrs;
1647 struct sect_opt *sect_opts = NULL((void*)0);
1648 size_t num_sect_opts = 0;
1649 struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL((void*)0));
1650
1651 num_sect_opts = 16;
1652 sect_opts = (struct sect_opt *) xmalloc (num_sect_opts
1653 * sizeof (struct sect_opt));
1654
1655 dont_repeat ();
1656
1657 if (args == NULL((void*)0))
1658 error ("add-symbol-file takes a file name and an address");
1659
1660 /* Make a copy of the string that we can safely write into. */
1661 args = xstrdup (args);
1662
1663 while (*args != '\000')
1664 {
1665 /* Any leading spaces? */
1666 while (isspace (*args))
1667 args++;
1668
1669 /* Point arg to the beginning of the argument. */
1670 arg = args;
1671
1672 /* Move args pointer over the argument. */
1673 while ((*args != '\000') && !isspace (*args))
1674 args++;
1675
1676 /* If there are more arguments, terminate arg and
1677 proceed past it. */
1678 if (*args != '\000')
1679 *args++ = '\000';
1680
1681 /* Now process the argument. */
1682 if (argcnt == 0)
1683 {
1684 /* The first argument is the file name. */
1685 filename = tilde_expand (arg);
1686 make_cleanup (xfree, filename);
1687 }
1688 else
1689 if (argcnt == 1)
1690 {
1691 /* The second argument is always the text address at which
1692 to load the program. */
1693 sect_opts[section_index].name = ".text";
1694 sect_opts[section_index].value = arg;
1695 if (++section_index > num_sect_opts)
1696 {
1697 num_sect_opts *= 2;
1698 sect_opts = ((struct sect_opt *)
1699 xrealloc (sect_opts,
1700 num_sect_opts
1701 * sizeof (struct sect_opt)));
1702 }
1703 }
1704 else
1705 {
1706 /* It's an option (starting with '-') or it's an argument
1707 to an option */
1708
1709 if (*arg == '-')
1710 {
1711 if (strcmp (arg, "-readnow") == 0)
1712 flags |= OBJF_READNOW(1 << 4);
1713 else if (strcmp (arg, "-s") == 0)
1714 {
1715 expecting_sec_name = 1;
1716 expecting_sec_addr = 1;
1717 }
1718 }
1719 else
1720 {
1721 if (expecting_sec_name)
1722 {
1723 sect_opts[section_index].name = arg;
1724 expecting_sec_name = 0;
1725 }
1726 else
1727 if (expecting_sec_addr)
1728 {
1729 sect_opts[section_index].value = arg;
1730 expecting_sec_addr = 0;
1731 if (++section_index > num_sect_opts)
1732 {
1733 num_sect_opts *= 2;
1734 sect_opts = ((struct sect_opt *)
1735 xrealloc (sect_opts,
1736 num_sect_opts
1737 * sizeof (struct sect_opt)));
1738 }
1739 }
1740 else
1741 error ("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*");
1742 }
1743 }
1744 argcnt++;
1745 }
1746
1747 /* Print the prompt for the query below. And save the arguments into
1748 a sect_addr_info structure to be passed around to other
1749 functions. We have to split this up into separate print
1750 statements because hex_string returns a local static
1751 string. */
1752
1753 printf_unfiltered ("add symbol table from file \"%s\" at\n", filename);
1754 section_addrs = alloc_section_addr_info (section_index);
1755 make_cleanup (xfree, section_addrs);
1756 for (i = 0; i < section_index; i++)
1757 {
1758 CORE_ADDR addr;
1759 char *val = sect_opts[i].value;
1760 char *sec = sect_opts[i].name;
1761
1762 addr = parse_and_eval_address (val);
1763
1764 /* Here we store the section offsets in the order they were
1765 entered on the command line. */
1766 section_addrs->other[sec_num].name = sec;
1767 section_addrs->other[sec_num].addr = addr;
1768 printf_unfiltered ("\t%s_addr = %s\n",
1769 sec, hex_string ((unsigned long)addr));
1770 sec_num++;
1771
1772 /* The object's sections are initialized when a
1773 call is made to build_objfile_section_table (objfile).
1774 This happens in reread_symbols.
1775 At this point, we don't know what file type this is,
1776 so we can't determine what section names are valid. */
1777 }
1778
1779 if (from_tty && (!query ("%s", "")))
1780 error ("Not confirmed.");
1781
1782 symbol_file_add (filename, from_tty, section_addrs, 0, flags);
1783
1784 /* Getting new symbols may change our opinion about what is
1785 frameless. */
1786 reinit_frame_cache ();
1787 do_cleanups (my_cleanups);
1788}
1789
1790static void
1791add_shared_symbol_files_command (char *args, int from_tty)
1792{
1793#ifdef ADD_SHARED_SYMBOL_FILES
1794 ADD_SHARED_SYMBOL_FILES (args, from_tty);
1795#else
1796 error ("This command is not available in this configuration of GDB.");
1797#endif
1798}
1799
1800/* Re-read symbols if a symbol-file has changed. */
1801void
1802reread_symbols (void)
1803{
1804 struct objfile *objfile;
1805 time_t new_modtime;
1806 int reread_one = 0;
1807 struct stat new_statbuf;
1808 int res;
1809
1810 /* With the addition of shared libraries, this should be modified,
1811 the load time should be saved in the partial symbol tables, since
1812 different tables may come from different source files. FIXME.
1813 This routine should then walk down each partial symbol table
1814 and see if the symbol table that it originates from has been changed */
1815
1816 for (objfile = object_files; objfile; objfile = objfile->next)
1817 {
1818 if (objfile->obfd)
1819 {
1820#ifdef DEPRECATED_IBM6000_TARGET
1821 /* If this object is from a shared library, then you should
1822 stat on the library name, not member name. */
1823
1824 if (objfile->obfd->my_archive)
1825 res = stat (objfile->obfd->my_archive->filename, &new_statbuf);
1826 else
1827#endif
1828 res = stat (objfile->name, &new_statbuf);
1829 if (res != 0)
1830 {
1831 /* FIXME, should use print_sys_errmsg but it's not filtered. */
1832 printf_unfiltered ("`%s' has disappeared; keeping its symbols.\n",
1833 objfile->name);
1834 continue;
1835 }
1836 new_modtime = new_statbuf.st_mtimest_mtim.tv_sec;
1837 if (new_modtime != objfile->mtime)
1838 {
1839 struct cleanup *old_cleanups;
1840 struct section_offsets *offsets;
1841 int num_offsets;
1842 char *obfd_filename;
1843
1844 printf_unfiltered ("`%s' has changed; re-reading symbols.\n",
1845 objfile->name);
1846
1847 /* There are various functions like symbol_file_add,
1848 symfile_bfd_open, syms_from_objfile, etc., which might
1849 appear to do what we want. But they have various other
1850 effects which we *don't* want. So we just do stuff
1851 ourselves. We don't worry about mapped files (for one thing,
1852 any mapped file will be out of date). */
1853
1854 /* If we get an error, blow away this objfile (not sure if
1855 that is the correct response for things like shared
1856 libraries). */
1857 old_cleanups = make_cleanup_free_objfile (objfile);
1858 /* We need to do this whenever any symbols go away. */
1859 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
1860
1861 /* Clean up any state BFD has sitting around. We don't need
1862 to close the descriptor but BFD lacks a way of closing the
1863 BFD without closing the descriptor. */
1864 obfd_filename = bfd_get_filename (objfile->obfd)((char *) (objfile->obfd)->filename);
1865 if (!bfd_close (objfile->obfd))
1866 error ("Can't close BFD for %s: %s", objfile->name,
1867 bfd_errmsg (bfd_get_error ()));
1868 objfile->obfd = bfd_openr (obfd_filename, gnutarget);
1869 if (objfile->obfd == NULL((void*)0))
1870 error ("Can't open %s to read symbols.", objfile->name);
1871 /* bfd_openr sets cacheable to true, which is what we want. */
1872 if (!bfd_check_format (objfile->obfd, bfd_object))
1873 error ("Can't read symbols from %s: %s.", objfile->name,
1874 bfd_errmsg (bfd_get_error ()));
1875
1876 /* Save the offsets, we will nuke them with the rest of the
1877 objfile_obstack. */
1878 num_offsets = objfile->num_sections;
1879 offsets = ((struct section_offsets *)
1880 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets))__builtin_alloca((sizeof (struct section_offsets) + sizeof ((
(struct section_offsets *) 0)->offsets) * ((num_offsets)-1
)))
);
1881 memcpy (offsets, objfile->section_offsets,
1882 SIZEOF_N_SECTION_OFFSETS (num_offsets)(sizeof (struct section_offsets) + sizeof (((struct section_offsets
*) 0)->offsets) * ((num_offsets)-1))
);
1883
1884 /* Nuke all the state that we will re-read. Much of the following
1885 code which sets things to NULL really is necessary to tell
1886 other parts of GDB that there is nothing currently there. */
1887
1888 /* FIXME: Do we have to free a whole linked list, or is this
1889 enough? */
1890 if (objfile->global_psymbols.list)
1891 xfree (objfile->global_psymbols.list);
1892 memset (&objfile->global_psymbols, 0,
1893 sizeof (objfile->global_psymbols));
1894 if (objfile->static_psymbols.list)
1895 xfree (objfile->static_psymbols.list);
1896 memset (&objfile->static_psymbols, 0,
1897 sizeof (objfile->static_psymbols));
1898
1899 /* Free the obstacks for non-reusable objfiles */
1900 bcache_xfree (objfile->psymbol_cache);
1901 objfile->psymbol_cache = bcache_xmalloc ();
1902 bcache_xfree (objfile->macro_cache);
1903 objfile->macro_cache = bcache_xmalloc ();
1904 if (objfile->demangled_names_hash != NULL((void*)0))
1905 {
1906 htab_delete (objfile->demangled_names_hash);
1907 objfile->demangled_names_hash = NULL((void*)0);
1908 }
1909 obstack_free (&objfile->objfile_obstack, 0)__extension__ ({ struct obstack *__o = (&objfile->objfile_obstack
); void *__obj = (0); if (__obj > (void *)__o->chunk &&
__obj < (void *)__o->chunk_limit) __o->next_free = __o
->object_base = __obj; else (obstack_free) (__o, __obj); }
)
;
1910 objfile->sections = NULL((void*)0);
1911 objfile->symtabs = NULL((void*)0);
1912 objfile->psymtabs = NULL((void*)0);
1913 objfile->free_psymtabs = NULL((void*)0);
1914 objfile->cp_namespace_symtab = NULL((void*)0);
1915 objfile->msymbols = NULL((void*)0);
1916 objfile->sym_private = NULL((void*)0);
1917 objfile->minimal_symbol_count = 0;
1918 memset (&objfile->msymbol_hash, 0,
1919 sizeof (objfile->msymbol_hash));
1920 memset (&objfile->msymbol_demangled_hash, 0,
1921 sizeof (objfile->msymbol_demangled_hash));
1922 objfile->fundamental_types = NULL((void*)0);
1923 clear_objfile_data (objfile);
1924 if (objfile->sf != NULL((void*)0))
1925 {
1926 (*objfile->sf->sym_finish) (objfile);
1927 }
1928
1929 /* We never make this a mapped file. */
1930 objfile->md = NULL((void*)0);
1931 objfile->psymbol_cache = bcache_xmalloc ();
1932 objfile->macro_cache = bcache_xmalloc ();
1933 /* obstack_init also initializes the obstack so it is
1934 empty. We could use obstack_specify_allocation but
1935 gdb_obstack.h specifies the alloc/dealloc
1936 functions. */
1937 obstack_init (&objfile->objfile_obstack)_obstack_begin ((&objfile->objfile_obstack), 0, 0, (void
*(*) (long)) xmalloc, (void (*) (void *)) xfree)
;
1938 if (build_objfile_section_table (objfile))
1939 {
1940 error ("Can't find the file sections in `%s': %s",
1941 objfile->name, bfd_errmsg (bfd_get_error ()));
1942 }
1943 terminate_minimal_symbol_table (objfile);
1944
1945 /* We use the same section offsets as from last time. I'm not
1946 sure whether that is always correct for shared libraries. */
1947 objfile->section_offsets = (struct section_offsets *)
1948 obstack_alloc (&objfile->objfile_obstack,__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
((sizeof (struct section_offsets) + sizeof (((struct section_offsets
*) 0)->offsets) * ((num_offsets)-1)))); if (__o->chunk_limit
- __o->next_free < __len) _obstack_newchunk (__o, __len
); ((__o)->next_free += (__len)); (void) 0; }); __extension__
({ struct obstack *__o1 = (__h); void *value; value = (void *
) __o1->object_base; if (__o1->next_free == value) __o1
->maybe_empty_object = 1; __o1->next_free = (((((__o1->
next_free) - (char *) 0)+__o1->alignment_mask) & ~ (__o1
->alignment_mask)) + (char *) 0); if (__o1->next_free -
(char *)__o1->chunk > __o1->chunk_limit - (char *)__o1
->chunk) __o1->next_free = __o1->chunk_limit; __o1->
object_base = __o1->next_free; value; }); })
1949 SIZEOF_N_SECTION_OFFSETS (num_offsets))__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
((sizeof (struct section_offsets) + sizeof (((struct section_offsets
*) 0)->offsets) * ((num_offsets)-1)))); if (__o->chunk_limit
- __o->next_free < __len) _obstack_newchunk (__o, __len
); ((__o)->next_free += (__len)); (void) 0; }); __extension__
({ struct obstack *__o1 = (__h); void *value; value = (void *
) __o1->object_base; if (__o1->next_free == value) __o1
->maybe_empty_object = 1; __o1->next_free = (((((__o1->
next_free) - (char *) 0)+__o1->alignment_mask) & ~ (__o1
->alignment_mask)) + (char *) 0); if (__o1->next_free -
(char *)__o1->chunk > __o1->chunk_limit - (char *)__o1
->chunk) __o1->next_free = __o1->chunk_limit; __o1->
object_base = __o1->next_free; value; }); })
;
1950 memcpy (objfile->section_offsets, offsets,
1951 SIZEOF_N_SECTION_OFFSETS (num_offsets)(sizeof (struct section_offsets) + sizeof (((struct section_offsets
*) 0)->offsets) * ((num_offsets)-1))
);
1952 objfile->num_sections = num_offsets;
1953
1954 /* What the hell is sym_new_init for, anyway? The concept of
1955 distinguishing between the main file and additional files
1956 in this way seems rather dubious. */
1957 if (objfile == symfile_objfile)
1958 {
1959 (*objfile->sf->sym_new_init) (objfile);
1960 }
1961
1962 (*objfile->sf->sym_init) (objfile);
1963 clear_complaints (&symfile_complaints, 1, 1);
1964 /* The "mainline" parameter is a hideous hack; I think leaving it
1965 zero is OK since dbxread.c also does what it needs to do if
1966 objfile->global_psymbols.size is 0. */
1967 (*objfile->sf->sym_read) (objfile, 0);
1968 if (!have_partial_symbols () && !have_full_symbols ())
1969 {
1970 wrap_here ("");
1971 printf_unfiltered ("(no debugging symbols found)\n");
1972 wrap_here ("");
1973 }
1974 objfile->flags |= OBJF_SYMS(1 << 1);
1975
1976 /* We're done reading the symbol file; finish off complaints. */
1977 clear_complaints (&symfile_complaints, 0, 1);
1978
1979 /* Getting new symbols may change our opinion about what is
1980 frameless. */
1981
1982 reinit_frame_cache ();
1983
1984 /* Discard cleanups as symbol reading was successful. */
1985 discard_cleanups (old_cleanups);
1986
1987 init_entry_point_info (objfile);
1988
1989 /* If the mtime has changed between the time we set new_modtime
1990 and now, we *want* this to be out of date, so don't call stat
1991 again now. */
1992 objfile->mtime = new_modtime;
1993 reread_one = 1;
1994 reread_separate_symbols (objfile);
1995 }
1996 }
1997 }
1998
1999 if (reread_one)
2000 clear_symtab_users ();
2001}
2002
2003
2004/* Handle separate debug info for OBJFILE, which has just been
2005 re-read:
2006 - If we had separate debug info before, but now we don't, get rid
2007 of the separated objfile.
2008 - If we didn't have separated debug info before, but now we do,
2009 read in the new separated debug info file.
2010 - If the debug link points to a different file, toss the old one
2011 and read the new one.
2012 This function does *not* handle the case where objfile is still
2013 using the same separate debug info file, but that file's timestamp
2014 has changed. That case should be handled by the loop in
2015 reread_symbols already. */
2016static void
2017reread_separate_symbols (struct objfile *objfile)
2018{
2019 char *debug_file;
2020 unsigned long crc32;
2021
2022 /* Does the updated objfile's debug info live in a
2023 separate file? */
2024 debug_file = find_separate_debug_file (objfile);
2025
2026 if (objfile->separate_debug_objfile)
2027 {
2028 /* There are two cases where we need to get rid of
2029 the old separated debug info objfile:
2030 - if the new primary objfile doesn't have
2031 separated debug info, or
2032 - if the new primary objfile has separate debug
2033 info, but it's under a different filename.
2034
2035 If the old and new objfiles both have separate
2036 debug info, under the same filename, then we're
2037 okay --- if the separated file's contents have
2038 changed, we will have caught that when we
2039 visited it in this function's outermost
2040 loop. */
2041 if (! debug_file
2042 || strcmp (debug_file, objfile->separate_debug_objfile->name) != 0)
2043 free_objfile (objfile->separate_debug_objfile);
2044 }
2045
2046 /* If the new objfile has separate debug info, and we
2047 haven't loaded it already, do so now. */
2048 if (debug_file
2049 && ! objfile->separate_debug_objfile)
2050 {
2051 /* Use the same section offset table as objfile itself.
2052 Preserve the flags from objfile that make sense. */
2053 objfile->separate_debug_objfile
2054 = (symbol_file_add_with_addrs_or_offsets
2055 (symfile_bfd_open (debug_file),
2056 info_verbose, /* from_tty: Don't override the default. */
2057 0, /* No addr table. */
2058 objfile->section_offsets, objfile->num_sections,
2059 0, /* Not mainline. See comments about this above. */
2060 objfile->flags & (OBJF_REORDERED(1 << 2) | OBJF_SHARED(1 << 3) | OBJF_READNOW(1 << 4)
2061 | OBJF_USERLOADED(1 << 5))));
2062 objfile->separate_debug_objfile->separate_debug_objfile_backlink
2063 = objfile;
2064 }
2065}
2066
2067
2068
2069
2070
2071typedef struct
2072{
2073 char *ext;
2074 enum language lang;
2075}
2076filename_language;
2077
2078static filename_language *filename_language_table;
2079static int fl_table_size, fl_table_next;
2080
2081static void
2082add_filename_language (char *ext, enum language lang)
2083{
2084 if (fl_table_next >= fl_table_size)
2085 {
2086 fl_table_size += 10;
2087 filename_language_table =
2088 xrealloc (filename_language_table,
2089 fl_table_size * sizeof (*filename_language_table));
2090 }
2091
2092 filename_language_table[fl_table_next].ext = xstrdup (ext);
2093 filename_language_table[fl_table_next].lang = lang;
2094 fl_table_next++;
2095}
2096
2097static char *ext_args;
2098
2099static void
2100set_ext_lang_command (char *args, int from_tty)
2101{
2102 int i;
2103 char *cp = ext_args;
2104 enum language lang;
2105
2106 /* First arg is filename extension, starting with '.' */
2107 if (*cp != '.')
2108 error ("'%s': Filename extension must begin with '.'", ext_args);
2109
2110 /* Find end of first arg. */
2111 while (*cp && !isspace (*cp))
2112 cp++;
2113
2114 if (*cp == '\0')
2115 error ("'%s': two arguments required -- filename extension and language",
2116 ext_args);
2117
2118 /* Null-terminate first arg */
2119 *cp++ = '\0';
2120
2121 /* Find beginning of second arg, which should be a source language. */
2122 while (*cp && isspace (*cp))
2123 cp++;
2124
2125 if (*cp == '\0')
2126 error ("'%s': two arguments required -- filename extension and language",
2127 ext_args);
2128
2129 /* Lookup the language from among those we know. */
2130 lang = language_enum (cp);
2131
2132 /* Now lookup the filename extension: do we already know it? */
2133 for (i = 0; i < fl_table_next; i++)
2134 if (0 == strcmp (ext_args, filename_language_table[i].ext))
2135 break;
2136
2137 if (i >= fl_table_next)
2138 {
2139 /* new file extension */
2140 add_filename_language (ext_args, lang);
2141 }
2142 else
2143 {
2144 /* redefining a previously known filename extension */
2145
2146 /* if (from_tty) */
2147 /* query ("Really make files of type %s '%s'?", */
2148 /* ext_args, language_str (lang)); */
2149
2150 xfree (filename_language_table[i].ext);
2151 filename_language_table[i].ext = xstrdup (ext_args);
2152 filename_language_table[i].lang = lang;
2153 }
2154}
2155
2156static void
2157info_ext_lang_command (char *args, int from_tty)
2158{
2159 int i;
2160
2161 printf_filtered ("Filename extensions and the languages they represent:");
2162 printf_filtered ("\n\n");
2163 for (i = 0; i < fl_table_next; i++)
2164 printf_filtered ("\t%s\t- %s\n",
2165 filename_language_table[i].ext,
2166 language_str (filename_language_table[i].lang));
2167}
2168
2169static void
2170init_filename_language_table (void)
2171{
2172 if (fl_table_size == 0) /* protect against repetition */
2173 {
2174 fl_table_size = 20;
2175 fl_table_next = 0;
2176 filename_language_table =
2177 xmalloc (fl_table_size * sizeof (*filename_language_table));
2178 add_filename_language (".c", language_c);
2179 add_filename_language (".C", language_cplus);
2180 add_filename_language (".cc", language_cplus);
2181 add_filename_language (".cp", language_cplus);
2182 add_filename_language (".cpp", language_cplus);
2183 add_filename_language (".cxx", language_cplus);
2184 add_filename_language (".c++", language_cplus);
2185 add_filename_language (".java", language_java);
2186 add_filename_language (".class", language_java);
2187 add_filename_language (".m", language_objc);
2188 add_filename_language (".f", language_fortran);
2189 add_filename_language (".F", language_fortran);
2190 add_filename_language (".s", language_asm);
2191 add_filename_language (".S", language_asm);
2192 add_filename_language (".pas", language_pascal);
2193 add_filename_language (".p", language_pascal);
2194 add_filename_language (".pp", language_pascal);
2195 add_filename_language (".adb", language_ada);
2196 add_filename_language (".ads", language_ada);
2197 add_filename_language (".a", language_ada);
2198 add_filename_language (".ada", language_ada);
2199 }
2200}
2201
2202enum language
2203deduce_language_from_filename (char *filename)
2204{
2205 int i;
2206 char *cp;
2207
2208 if (filename != NULL((void*)0))
2209 if ((cp = strrchr (filename, '.')) != NULL((void*)0))
2210 for (i = 0; i < fl_table_next; i++)
2211 if (strcmp (cp, filename_language_table[i].ext) == 0)
2212 return filename_language_table[i].lang;
2213
2214 return language_unknown;
2215}
2216
2217/* allocate_symtab:
2218
2219 Allocate and partly initialize a new symbol table. Return a pointer
2220 to it. error() if no space.
2221
2222 Caller must set these fields:
2223 LINETABLE(symtab)
2224 symtab->blockvector
2225 symtab->dirname
2226 symtab->free_code
2227 symtab->free_ptr
2228 possibly free_named_symtabs (symtab->filename);
2229 */
2230
2231struct symtab *
2232allocate_symtab (char *filename, struct objfile *objfile)
2233{
2234 struct symtab *symtab;
2235
2236 symtab = (struct symtab *)
2237 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symtab))__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(sizeof (struct symtab))); if (__o->chunk_limit - __o->
next_free < __len) _obstack_newchunk (__o, __len); ((__o)->
next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack
*__o1 = (__h); void *value; value = (void *) __o1->object_base
; if (__o1->next_free == value) __o1->maybe_empty_object
= 1; __o1->next_free = (((((__o1->next_free) - (char *
) 0)+__o1->alignment_mask) & ~ (__o1->alignment_mask
)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk
> __o1->chunk_limit - (char *)__o1->chunk) __o1->
next_free = __o1->chunk_limit; __o1->object_base = __o1
->next_free; value; }); })
;
2238 memset (symtab, 0, sizeof (*symtab));
2239 symtab->filename = obsavestring (filename, strlen (filename),
2240 &objfile->objfile_obstack);
2241 symtab->fullname = NULL((void*)0);
2242 symtab->language = deduce_language_from_filename (filename);
2243 symtab->debugformat = obsavestring ("unknown", 7,
2244 &objfile->objfile_obstack);
2245
2246 /* Hook it to the objfile it comes from */
2247
2248 symtab->objfile = objfile;
2249 symtab->next = objfile->symtabs;
2250 objfile->symtabs = symtab;
2251
2252 /* FIXME: This should go away. It is only defined for the Z8000,
2253 and the Z8000 definition of this macro doesn't have anything to
2254 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just
2255 here for convenience. */
2256#ifdef INIT_EXTRA_SYMTAB_INFO
2257 INIT_EXTRA_SYMTAB_INFO (symtab);
2258#endif
2259
2260 return (symtab);
2261}
2262
2263struct partial_symtab *
2264allocate_psymtab (char *filename, struct objfile *objfile)
2265{
2266 struct partial_symtab *psymtab;
2267
2268 if (objfile->free_psymtabs)
2269 {
2270 psymtab = objfile->free_psymtabs;
2271 objfile->free_psymtabs = psymtab->next;
2272 }
2273 else
2274 psymtab = (struct partial_symtab *)
2275 obstack_alloc (&objfile->objfile_obstack,__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(sizeof (struct partial_symtab))); if (__o->chunk_limit - __o
->next_free < __len) _obstack_newchunk (__o, __len); ((
__o)->next_free += (__len)); (void) 0; }); __extension__ (
{ struct obstack *__o1 = (__h); void *value; value = (void *)
__o1->object_base; if (__o1->next_free == value) __o1->
maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free
) - (char *) 0)+__o1->alignment_mask) & ~ (__o1->alignment_mask
)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk
> __o1->chunk_limit - (char *)__o1->chunk) __o1->
next_free = __o1->chunk_limit; __o1->object_base = __o1
->next_free; value; }); })
2276 sizeof (struct partial_symtab))__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(sizeof (struct partial_symtab))); if (__o->chunk_limit - __o
->next_free < __len) _obstack_newchunk (__o, __len); ((
__o)->next_free += (__len)); (void) 0; }); __extension__ (
{ struct obstack *__o1 = (__h); void *value; value = (void *)
__o1->object_base; if (__o1->next_free == value) __o1->
maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free
) - (char *) 0)+__o1->alignment_mask) & ~ (__o1->alignment_mask
)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk
> __o1->chunk_limit - (char *)__o1->chunk) __o1->
next_free = __o1->chunk_limit; __o1->object_base = __o1
->next_free; value; }); })
;
2277
2278 memset (psymtab, 0, sizeof (struct partial_symtab));
2279 psymtab->filename = obsavestring (filename, strlen (filename),
2280 &objfile->objfile_obstack);
2281 psymtab->symtab = NULL((void*)0);
2282
2283 /* Prepend it to the psymtab list for the objfile it belongs to.
2284 Psymtabs are searched in most recent inserted -> least recent
2285 inserted order. */
2286
2287 psymtab->objfile = objfile;
2288 psymtab->next = objfile->psymtabs;
2289 objfile->psymtabs = psymtab;
2290#if 0
2291 {
2292 struct partial_symtab **prev_pst;
2293 psymtab->objfile = objfile;
2294 psymtab->next = NULL((void*)0);
2295 prev_pst = &(objfile->psymtabs);
2296 while ((*prev_pst) != NULL((void*)0))
2297 prev_pst = &((*prev_pst)->next);
2298 (*prev_pst) = psymtab;
2299 }
2300#endif
2301
2302 return (psymtab);
2303}
2304
2305void
2306discard_psymtab (struct partial_symtab *pst)
2307{
2308 struct partial_symtab **prev_pst;
2309
2310 /* From dbxread.c:
2311 Empty psymtabs happen as a result of header files which don't
2312 have any symbols in them. There can be a lot of them. But this
2313 check is wrong, in that a psymtab with N_SLINE entries but
2314 nothing else is not empty, but we don't realize that. Fixing
2315 that without slowing things down might be tricky. */
2316
2317 /* First, snip it out of the psymtab chain */
2318
2319 prev_pst = &(pst->objfile->psymtabs);
2320 while ((*prev_pst) != pst)
2321 prev_pst = &((*prev_pst)->next);
2322 (*prev_pst) = pst->next;
2323
2324 /* Next, put it on a free list for recycling */
2325
2326 pst->next = pst->objfile->free_psymtabs;
2327 pst->objfile->free_psymtabs = pst;
2328}
2329
2330
2331/* Reset all data structures in gdb which may contain references to symbol
2332 table data. */
2333
2334void
2335clear_symtab_users (void)
2336{
2337 /* Someday, we should do better than this, by only blowing away
2338 the things that really need to be blown. */
2339 clear_value_history ();
2340 clear_displays ();
2341 clear_internalvars ();
2342 breakpoint_re_set ();
2343 set_default_breakpoint (0, 0, 0, 0);
2344 clear_current_source_symtab_and_line ();
2345 clear_pc_function_cache ();
2346 if (deprecated_target_new_objfile_hook)
2347 deprecated_target_new_objfile_hook (NULL((void*)0));
2348 varobj_refresh ();
2349}
2350
2351static void
2352clear_symtab_users_cleanup (void *ignore)
2353{
2354 clear_symtab_users ();
2355}
2356
2357/* clear_symtab_users_once:
2358
2359 This function is run after symbol reading, or from a cleanup.
2360 If an old symbol table was obsoleted, the old symbol table
2361 has been blown away, but the other GDB data structures that may
2362 reference it have not yet been cleared or re-directed. (The old
2363 symtab was zapped, and the cleanup queued, in free_named_symtab()
2364 below.)
2365
2366 This function can be queued N times as a cleanup, or called
2367 directly; it will do all the work the first time, and then will be a
2368 no-op until the next time it is queued. This works by bumping a
2369 counter at queueing time. Much later when the cleanup is run, or at
2370 the end of symbol processing (in case the cleanup is discarded), if
2371 the queued count is greater than the "done-count", we do the work
2372 and set the done-count to the queued count. If the queued count is
2373 less than or equal to the done-count, we just ignore the call. This
2374 is needed because reading a single .o file will often replace many
2375 symtabs (one per .h file, for example), and we don't want to reset
2376 the breakpoints N times in the user's face.
2377
2378 The reason we both queue a cleanup, and call it directly after symbol
2379 reading, is because the cleanup protects us in case of errors, but is
2380 discarded if symbol reading is successful. */
2381
2382#if 0
2383/* FIXME: As free_named_symtabs is currently a big noop this function
2384 is no longer needed. */
2385static void clear_symtab_users_once (void);
2386
2387static int clear_symtab_users_queued;
2388static int clear_symtab_users_done;
2389
2390static void
2391clear_symtab_users_once (void)
2392{
2393 /* Enforce once-per-`do_cleanups'-semantics */
2394 if (clear_symtab_users_queued <= clear_symtab_users_done)
2395 return;
2396 clear_symtab_users_done = clear_symtab_users_queued;
2397
2398 clear_symtab_users ();
2399}
2400#endif
2401
2402/* Delete the specified psymtab, and any others that reference it. */
2403
2404static void
2405cashier_psymtab (struct partial_symtab *pst)
2406{
2407 struct partial_symtab *ps, *pprev = NULL((void*)0);
2408 int i;
2409
2410 /* Find its previous psymtab in the chain */
2411 for (ps = pst->objfile->psymtabs; ps; ps = ps->next)
2412 {
2413 if (ps == pst)
2414 break;
2415 pprev = ps;
2416 }
2417
2418 if (ps)
2419 {
2420 /* Unhook it from the chain. */
2421 if (ps == pst->objfile->psymtabs)
2422 pst->objfile->psymtabs = ps->next;
2423 else
2424 pprev->next = ps->next;
2425
2426 /* FIXME, we can't conveniently deallocate the entries in the
2427 partial_symbol lists (global_psymbols/static_psymbols) that
2428 this psymtab points to. These just take up space until all
2429 the psymtabs are reclaimed. Ditto the dependencies list and
2430 filename, which are all in the objfile_obstack. */
2431
2432 /* We need to cashier any psymtab that has this one as a dependency... */
2433 again:
2434 for (ps = pst->objfile->psymtabs; ps; ps = ps->next)
2435 {
2436 for (i = 0; i < ps->number_of_dependencies; i++)
2437 {
2438 if (ps->dependencies[i] == pst)
2439 {
2440 cashier_psymtab (ps);
2441 goto again; /* Must restart, chain has been munged. */
2442 }
2443 }
2444 }
2445 }
2446}
2447
2448/* If a symtab or psymtab for filename NAME is found, free it along
2449 with any dependent breakpoints, displays, etc.
2450 Used when loading new versions of object modules with the "add-file"
2451 command. This is only called on the top-level symtab or psymtab's name;
2452 it is not called for subsidiary files such as .h files.
2453
2454 Return value is 1 if we blew away the environment, 0 if not.
2455 FIXME. The return value appears to never be used.
2456
2457 FIXME. I think this is not the best way to do this. We should
2458 work on being gentler to the environment while still cleaning up
2459 all stray pointers into the freed symtab. */
2460
2461int
2462free_named_symtabs (char *name)
2463{
2464#if 0
2465 /* FIXME: With the new method of each objfile having it's own
2466 psymtab list, this function needs serious rethinking. In particular,
2467 why was it ever necessary to toss psymtabs with specific compilation
2468 unit filenames, as opposed to all psymtabs from a particular symbol
2469 file? -- fnf
2470 Well, the answer is that some systems permit reloading of particular
2471 compilation units. We want to blow away any old info about these
2472 compilation units, regardless of which objfiles they arrived in. --gnu. */
2473
2474 struct symtab *s;
2475 struct symtab *prev;
2476 struct partial_symtab *ps;
2477 struct blockvector *bv;
2478 int blewit = 0;
2479
2480 /* We only wack things if the symbol-reload switch is set. */
2481 if (!symbol_reloading)
2482 return 0;
2483
2484 /* Some symbol formats have trouble providing file names... */
2485 if (name == 0 || *name == '\0')
2486 return 0;
2487
2488 /* Look for a psymtab with the specified name. */
2489
2490again2:
2491 for (ps = partial_symtab_list; ps; ps = ps->next)
2492 {
2493 if (strcmp (name, ps->filename) == 0)
2494 {
2495 cashier_psymtab (ps); /* Blow it away...and its little dog, too. */
2496 goto again2; /* Must restart, chain has been munged */
2497 }
2498 }
2499
2500 /* Look for a symtab with the specified name. */
2501
2502 for (s = symtab_list; s; s = s->next)
2503 {
2504 if (strcmp (name, s->filename) == 0)
2505 break;
2506 prev = s;
2507 }
2508
2509 if (s)
2510 {
2511 if (s == symtab_list)
2512 symtab_list = s->next;
2513 else
2514 prev->next = s->next;
2515
2516 /* For now, queue a delete for all breakpoints, displays, etc., whether
2517 or not they depend on the symtab being freed. This should be
2518 changed so that only those data structures affected are deleted. */
2519
2520 /* But don't delete anything if the symtab is empty.
2521 This test is necessary due to a bug in "dbxread.c" that
2522 causes empty symtabs to be created for N_SO symbols that
2523 contain the pathname of the object file. (This problem
2524 has been fixed in GDB 3.9x). */
2525
2526 bv = BLOCKVECTOR (s)(s)->blockvector;
2527 if (BLOCKVECTOR_NBLOCKS (bv)(bv)->nblocks > 2
2528 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)(bv)->block[GLOBAL_BLOCK])
2529 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)(bv)->block[STATIC_BLOCK]))
2530 {
2531 complaint (&symfile_complaints, "Replacing old symbols for `%s'",
2532 name);
2533 clear_symtab_users_queued++;
2534 make_cleanup (clear_symtab_users_once, 0);
2535 blewit = 1;
2536 }
2537 else
2538 {
2539 complaint (&symfile_complaints, "Empty symbol table found for `%s'",
2540 name);
2541 }
2542
2543 free_symtab (s);
2544 }
2545 else
2546 {
2547 /* It is still possible that some breakpoints will be affected
2548 even though no symtab was found, since the file might have
2549 been compiled without debugging, and hence not be associated
2550 with a symtab. In order to handle this correctly, we would need
2551 to keep a list of text address ranges for undebuggable files.
2552 For now, we do nothing, since this is a fairly obscure case. */
2553 ;
2554 }
2555
2556 /* FIXME, what about the minimal symbol table? */
2557 return blewit;
2558#else
2559 return (0);
2560#endif
2561}
2562
2563/* Allocate and partially fill a partial symtab. It will be
2564 completely filled at the end of the symbol list.
2565
2566 FILENAME is the name of the symbol-file we are reading from. */
2567
2568struct partial_symtab *
2569start_psymtab_common (struct objfile *objfile,
2570 struct section_offsets *section_offsets, char *filename,
2571 CORE_ADDR textlow, struct partial_symbol **global_syms,
2572 struct partial_symbol **static_syms)
2573{
2574 struct partial_symtab *psymtab;
2575
2576 psymtab = allocate_psymtab (filename, objfile);
2577 psymtab->section_offsets = section_offsets;
2578 psymtab->textlow = textlow;
2579 psymtab->texthigh = psymtab->textlow; /* default */
2580 psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
2581 psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
2582 return (psymtab);
2583}
2584
2585/* Add a symbol with a long value to a psymtab.
2586 Since one arg is a struct, we pass in a ptr and deref it (sigh).
2587 Return the partial symbol that has been added. */
2588
2589/* NOTE: carlton/2003-09-11: The reason why we return the partial
2590 symbol is so that callers can get access to the symbol's demangled
2591 name, which they don't have any cheap way to determine otherwise.
2592 (Currenly, dwarf2read.c is the only file who uses that information,
2593 though it's possible that other readers might in the future.)
2594 Elena wasn't thrilled about that, and I don't blame her, but we
2595 couldn't come up with a better way to get that information. If
2596 it's needed in other situations, we could consider breaking up
2597 SYMBOL_SET_NAMES to provide access to the demangled name lookup
2598 cache. */
2599
2600const struct partial_symbol *
2601add_psymbol_to_list (char *name, int namelength, domain_enum domain,
2602 enum address_class class,
2603 struct psymbol_allocation_list *list, long val, /* Value as a long */
2604 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
2605 enum language language, struct objfile *objfile)
2606{
2607 struct partial_symbol *psym;
2608 char *buf = alloca (namelength + 1)__builtin_alloca(namelength + 1);
2609 /* psymbol is static so that there will be no uninitialized gaps in the
2610 structure which might contain random data, causing cache misses in
2611 bcache. */
2612 static struct partial_symbol psymbol;
2613
2614 /* Create local copy of the partial symbol */
2615 memcpy (buf, name, namelength);
2616 buf[namelength] = '\0';
2617 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2618 if (val != 0)
2619 {
2620 SYMBOL_VALUE (&psymbol)(&psymbol)->ginfo.value.ivalue = val;
2621 }
2622 else
2623 {
2624 SYMBOL_VALUE_ADDRESS (&psymbol)(&psymbol)->ginfo.value.address = coreaddr;
2625 }
2626 SYMBOL_SECTION (&psymbol)(&psymbol)->ginfo.section = 0;
2627 SYMBOL_LANGUAGE (&psymbol)(&psymbol)->ginfo.language = language;
2628 PSYMBOL_DOMAIN (&psymbol)(&psymbol)->domain = domain;
2629 PSYMBOL_CLASS (&psymbol)(&psymbol)->aclass = class;
2630
2631 SYMBOL_SET_NAMES (&psymbol, buf, namelength, objfile)symbol_set_names (&(&psymbol)->ginfo, buf, namelength
, objfile)
;
2632
2633 /* Stash the partial symbol away in the cache */
2634 psym = deprecated_bcache (&psymbol, sizeof (struct partial_symbol),
2635 objfile->psymbol_cache);
2636
2637 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2638 if (list->next >= list->list + list->size)
2639 {
2640 extend_psymbol_list (list, objfile);
2641 }
2642 *list->next++ = psym;
2643 OBJSTAT (objfile, n_psyms++)(objfile -> stats.n_psyms++);
2644
2645 return psym;
2646}
2647
2648/* Add a symbol with a long value to a psymtab. This differs from
2649 * add_psymbol_to_list above in taking both a mangled and a demangled
2650 * name. */
2651
2652void
2653add_psymbol_with_dem_name_to_list (char *name, int namelength, char *dem_name,
2654 int dem_namelength, domain_enum domain,
2655 enum address_class class,
2656 struct psymbol_allocation_list *list, long val, /* Value as a long */
2657 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
2658 enum language language,
2659 struct objfile *objfile)
2660{
2661 struct partial_symbol *psym;
2662 char *buf = alloca (namelength + 1)__builtin_alloca(namelength + 1);
2663 /* psymbol is static so that there will be no uninitialized gaps in the
2664 structure which might contain random data, causing cache misses in
2665 bcache. */
2666 static struct partial_symbol psymbol;
2667
2668 /* Create local copy of the partial symbol */
2669
2670 memcpy (buf, name, namelength);
2671 buf[namelength] = '\0';
2672 DEPRECATED_SYMBOL_NAME (&psymbol)(&psymbol)->ginfo.name = deprecated_bcache (buf, namelength + 1,
2673 objfile->psymbol_cache);
2674
2675 buf = alloca (dem_namelength + 1)__builtin_alloca(dem_namelength + 1);
2676 memcpy (buf, dem_name, dem_namelength);
2677 buf[dem_namelength] = '\0';
2678
2679 switch (language)
2680 {
2681 case language_c:
2682 case language_cplus:
2683 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol)(&psymbol)->ginfo.language_specific.cplus_specific.demangled_name =
2684 deprecated_bcache (buf, dem_namelength + 1, objfile->psymbol_cache);
2685 break;
2686 /* FIXME What should be done for the default case? Ignoring for now. */
2687 }
2688
2689 /* val and coreaddr are mutually exclusive, one of them *will* be zero */
2690 if (val != 0)
2691 {
2692 SYMBOL_VALUE (&psymbol)(&psymbol)->ginfo.value.ivalue = val;
2693 }
2694 else
2695 {
2696 SYMBOL_VALUE_ADDRESS (&psymbol)(&psymbol)->ginfo.value.address = coreaddr;
2697 }
2698 SYMBOL_SECTION (&psymbol)(&psymbol)->ginfo.section = 0;
2699 SYMBOL_LANGUAGE (&psymbol)(&psymbol)->ginfo.language = language;
2700 PSYMBOL_DOMAIN (&psymbol)(&psymbol)->domain = domain;
2701 PSYMBOL_CLASS (&psymbol)(&psymbol)->aclass = class;
2702 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol, language)(symbol_init_language_specific (&(&psymbol)->ginfo
, (language)))
;
2703
2704 /* Stash the partial symbol away in the cache */
2705 psym = deprecated_bcache (&psymbol, sizeof (struct partial_symbol),
2706 objfile->psymbol_cache);
2707
2708 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
2709 if (list->next >= list->list + list->size)
2710 {
2711 extend_psymbol_list (list, objfile);
2712 }
2713 *list->next++ = psym;
2714 OBJSTAT (objfile, n_psyms++)(objfile -> stats.n_psyms++);
2715}
2716
2717/* Initialize storage for partial symbols. */
2718
2719void
2720init_psymbol_list (struct objfile *objfile, int total_symbols)
2721{
2722 /* Free any previously allocated psymbol lists. */
2723
2724 if (objfile->global_psymbols.list)
2725 {
2726 xfree (objfile->global_psymbols.list);
2727 }
2728 if (objfile->static_psymbols.list)
2729 {
2730 xfree (objfile->static_psymbols.list);
2731 }
2732
2733 /* Current best guess is that approximately a twentieth
2734 of the total symbols (in a debugging file) are global or static
2735 oriented symbols */
2736
2737 objfile->global_psymbols.size = total_symbols / 10;
2738 objfile->static_psymbols.size = total_symbols / 10;
2739
2740 if (objfile->global_psymbols.size > 0)
2741 {
2742 objfile->global_psymbols.next =
2743 objfile->global_psymbols.list = (struct partial_symbol **)
2744 xmalloc ((objfile->global_psymbols.size
2745 * sizeof (struct partial_symbol *)));
2746 }
2747 if (objfile->static_psymbols.size > 0)
2748 {
2749 objfile->static_psymbols.next =
2750 objfile->static_psymbols.list = (struct partial_symbol **)
2751 xmalloc ((objfile->static_psymbols.size
2752 * sizeof (struct partial_symbol *)));
2753 }
2754}
2755
2756/* OVERLAYS:
2757 The following code implements an abstraction for debugging overlay sections.
2758
2759 The target model is as follows:
2760 1) The gnu linker will permit multiple sections to be mapped into the
2761 same VMA, each with its own unique LMA (or load address).
2762 2) It is assumed that some runtime mechanism exists for mapping the
2763 sections, one by one, from the load address into the VMA address.
2764 3) This code provides a mechanism for gdb to keep track of which
2765 sections should be considered to be mapped from the VMA to the LMA.
2766 This information is used for symbol lookup, and memory read/write.
2767 For instance, if a section has been mapped then its contents
2768 should be read from the VMA, otherwise from the LMA.
2769
2770 Two levels of debugger support for overlays are available. One is
2771 "manual", in which the debugger relies on the user to tell it which
2772 overlays are currently mapped. This level of support is
2773 implemented entirely in the core debugger, and the information about
2774 whether a section is mapped is kept in the objfile->obj_section table.
2775
2776 The second level of support is "automatic", and is only available if
2777 the target-specific code provides functionality to read the target's
2778 overlay mapping table, and translate its contents for the debugger
2779 (by updating the mapped state information in the obj_section tables).
2780
2781 The interface is as follows:
2782 User commands:
2783 overlay map <name> -- tell gdb to consider this section mapped
2784 overlay unmap <name> -- tell gdb to consider this section unmapped
2785 overlay list -- list the sections that GDB thinks are mapped
2786 overlay read-target -- get the target's state of what's mapped
2787 overlay off/manual/auto -- set overlay debugging state
2788 Functional interface:
2789 find_pc_mapped_section(pc): if the pc is in the range of a mapped
2790 section, return that section.
2791 find_pc_overlay(pc): find any overlay section that contains
2792 the pc, either in its VMA or its LMA
2793 overlay_is_mapped(sect): true if overlay is marked as mapped
2794 section_is_overlay(sect): true if section's VMA != LMA
2795 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
2796 pc_in_unmapped_range(...): true if pc belongs to section's LMA
2797 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap
2798 overlay_mapped_address(...): map an address from section's LMA to VMA
2799 overlay_unmapped_address(...): map an address from section's VMA to LMA
2800 symbol_overlayed_address(...): Return a "current" address for symbol:
2801 either in VMA or LMA depending on whether
2802 the symbol's section is currently mapped
2803 */
2804
2805/* Overlay debugging state: */
2806
2807enum overlay_debugging_state overlay_debugging = ovly_off;
2808int overlay_cache_invalid = 0; /* True if need to refresh mapped state */
2809
2810/* Target vector for refreshing overlay mapped state */
2811static void simple_overlay_update (struct obj_section *);
2812void (*target_overlay_update) (struct obj_section *) = simple_overlay_update;
2813
2814/* Function: section_is_overlay (SECTION)
2815 Returns true if SECTION has VMA not equal to LMA, ie.
2816 SECTION is loaded at an address different from where it will "run". */
2817
2818int
2819section_is_overlay (asection *section)
2820{
2821 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2822
2823 if (overlay_debugging)
2824 if (section && section->lma != 0 &&
2825 section->vma != section->lma)
2826 return 1;
2827
2828 return 0;
2829}
2830
2831/* Function: overlay_invalidate_all (void)
2832 Invalidate the mapped state of all overlay sections (mark it as stale). */
2833
2834static void
2835overlay_invalidate_all (void)
2836{
2837 struct objfile *objfile;
2838 struct obj_section *sect;
2839
2840 ALL_OBJSECTIONS (objfile, sect)for ((objfile) = object_files; (objfile) != ((void*)0); (objfile
) = (objfile)->next) for (sect = objfile->sections; sect
< objfile->sections_end; sect++)
2841 if (section_is_overlay (sect->the_bfd_section))
2842 sect->ovly_mapped = -1;
2843}
2844
2845/* Function: overlay_is_mapped (SECTION)
2846 Returns true if section is an overlay, and is currently mapped.
2847 Private: public access is thru function section_is_mapped.
2848
2849 Access to the ovly_mapped flag is restricted to this function, so
2850 that we can do automatic update. If the global flag
2851 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call
2852 overlay_invalidate_all. If the mapped state of the particular
2853 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
2854
2855static int
2856overlay_is_mapped (struct obj_section *osect)
2857{
2858 if (osect == 0 || !section_is_overlay (osect->the_bfd_section))
2859 return 0;
2860
2861 switch (overlay_debugging)
2862 {
2863 default:
2864 case ovly_off:
2865 return 0; /* overlay debugging off */
2866 case ovly_auto: /* overlay debugging automatic */
2867 /* Unles there is a target_overlay_update function,
2868 there's really nothing useful to do here (can't really go auto) */
2869 if (target_overlay_update)
2870 {
2871 if (overlay_cache_invalid)
2872 {
2873 overlay_invalidate_all ();
2874 overlay_cache_invalid = 0;
2875 }
2876 if (osect->ovly_mapped == -1)
2877 (*target_overlay_update) (osect);
2878 }
2879 /* fall thru to manual case */
2880 case ovly_on: /* overlay debugging manual */
2881 return osect->ovly_mapped == 1;
2882 }
2883}
2884
2885/* Function: section_is_mapped
2886 Returns true if section is an overlay, and is currently mapped. */
2887
2888int
2889section_is_mapped (asection *section)
2890{
2891 struct objfile *objfile;
2892 struct obj_section *osect;
2893
2894 if (overlay_debugging)
2895 if (section && section_is_overlay (section))
2896 ALL_OBJSECTIONS (objfile, osect)for ((objfile) = object_files; (objfile) != ((void*)0); (objfile
) = (objfile)->next) for (osect = objfile->sections; osect
< objfile->sections_end; osect++)
2897 if (osect->the_bfd_section == section)
2898 return overlay_is_mapped (osect);
2899
2900 return 0;
2901}
2902
2903/* Function: pc_in_unmapped_range
2904 If PC falls into the lma range of SECTION, return true, else false. */
2905
2906CORE_ADDR
2907pc_in_unmapped_range (CORE_ADDR pc, asection *section)
2908{
2909 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2910
2911 int size;
2912
2913 if (overlay_debugging)
2914 if (section && section_is_overlay (section))
2915 {
2916 size = bfd_get_section_size (section)((section)->_raw_size);
2917 if (section->lma <= pc && pc < section->lma + size)
2918 return 1;
2919 }
2920 return 0;
2921}
2922
2923/* Function: pc_in_mapped_range
2924 If PC falls into the vma range of SECTION, return true, else false. */
2925
2926CORE_ADDR
2927pc_in_mapped_range (CORE_ADDR pc, asection *section)
2928{
2929 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2930
2931 int size;
2932
2933 if (overlay_debugging)
2934 if (section && section_is_overlay (section))
2935 {
2936 size = bfd_get_section_size (section)((section)->_raw_size);
2937 if (section->vma <= pc && pc < section->vma + size)
2938 return 1;
2939 }
2940 return 0;
2941}
2942
2943
2944/* Return true if the mapped ranges of sections A and B overlap, false
2945 otherwise. */
2946static int
2947sections_overlap (asection *a, asection *b)
2948{
2949 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2950
2951 CORE_ADDR a_start = a->vma;
2952 CORE_ADDR a_end = a->vma + bfd_get_section_size (a)((a)->_raw_size);
2953 CORE_ADDR b_start = b->vma;
2954 CORE_ADDR b_end = b->vma + bfd_get_section_size (b)((b)->_raw_size);
2955
2956 return (a_start < b_end && b_start < a_end);
2957}
2958
2959/* Function: overlay_unmapped_address (PC, SECTION)
2960 Returns the address corresponding to PC in the unmapped (load) range.
2961 May be the same as PC. */
2962
2963CORE_ADDR
2964overlay_unmapped_address (CORE_ADDR pc, asection *section)
2965{
2966 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
2967
2968 if (overlay_debugging)
2969 if (section && section_is_overlay (section) &&
2970 pc_in_mapped_range (pc, section))
2971 return pc + section->lma - section->vma;
2972
2973 return pc;
2974}
2975
2976/* Function: overlay_mapped_address (PC, SECTION)
2977 Returns the address corresponding to PC in the mapped (runtime) range.
2978 May be the same as PC. */
2979
2980CORE_ADDR
2981overlay_mapped_address (CORE_ADDR pc, asection *section)
2982{
2983 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
2984
2985 if (overlay_debugging)
2986 if (section && section_is_overlay (section) &&
2987 pc_in_unmapped_range (pc, section))
2988 return pc + section->vma - section->lma;
2989
2990 return pc;
2991}
2992
2993
2994/* Function: symbol_overlayed_address
2995 Return one of two addresses (relative to the VMA or to the LMA),
2996 depending on whether the section is mapped or not. */
2997
2998CORE_ADDR
2999symbol_overlayed_address (CORE_ADDR address, asection *section)
3000{
3001 if (overlay_debugging)
3002 {
3003 /* If the symbol has no section, just return its regular address. */
3004 if (section == 0)
3005 return address;
3006 /* If the symbol's section is not an overlay, just return its address */
3007 if (!section_is_overlay (section))
3008 return address;
3009 /* If the symbol's section is mapped, just return its address */
3010 if (section_is_mapped (section))
3011 return address;
3012 /*
3013 * HOWEVER: if the symbol is in an overlay section which is NOT mapped,
3014 * then return its LOADED address rather than its vma address!!
3015 */
3016 return overlay_unmapped_address (address, section);
3017 }
3018 return address;
3019}
3020
3021/* Function: find_pc_overlay (PC)
3022 Return the best-match overlay section for PC:
3023 If PC matches a mapped overlay section's VMA, return that section.
3024 Else if PC matches an unmapped section's VMA, return that section.
3025 Else if PC matches an unmapped section's LMA, return that section. */
3026
3027asection *
3028find_pc_overlay (CORE_ADDR pc)
3029{
3030 struct objfile *objfile;
3031 struct obj_section *osect, *best_match = NULL((void*)0);
3032
3033 if (overlay_debugging)
3034 ALL_OBJSECTIONS (objfile, osect)for ((objfile) = object_files; (objfile) != ((void*)0); (objfile
) = (objfile)->next) for (osect = objfile->sections; osect
< objfile->sections_end; osect++)
3035 if (section_is_overlay (osect->the_bfd_section))
3036 {
3037 if (pc_in_mapped_range (pc, osect->the_bfd_section))
3038 {
3039 if (overlay_is_mapped (osect))
3040 return osect->the_bfd_section;
3041 else
3042 best_match = osect;
3043 }
3044 else if (pc_in_unmapped_range (pc, osect->the_bfd_section))
3045 best_match = osect;
3046 }
3047 return best_match ? best_match->the_bfd_section : NULL((void*)0);
3048}
3049
3050/* Function: find_pc_mapped_section (PC)
3051 If PC falls into the VMA address range of an overlay section that is
3052 currently marked as MAPPED, return that section. Else return NULL. */
3053
3054asection *
3055find_pc_mapped_section (CORE_ADDR pc)
3056{
3057 struct objfile *objfile;
3058 struct obj_section *osect;
3059
3060 if (overlay_debugging)
3061 ALL_OBJSECTIONS (objfile, osect)for ((objfile) = object_files; (objfile) != ((void*)0); (objfile
) = (objfile)->next) for (osect = objfile->sections; osect
< objfile->sections_end; osect++)
3062 if (pc_in_mapped_range (pc, osect->the_bfd_section) &&
3063 overlay_is_mapped (osect))
3064 return osect->the_bfd_section;
3065
3066 return NULL((void*)0);
3067}
3068
3069/* Function: list_overlays_command
3070 Print a list of mapped sections and their PC ranges */
3071
3072void
3073list_overlays_command (char *args, int from_tty)
3074{
3075 int nmapped = 0;
3076 struct objfile *objfile;
3077 struct obj_section *osect;
3078
3079 if (overlay_debugging)
3080 ALL_OBJSECTIONS (objfile, osect)for ((objfile) = object_files; (objfile) != ((void*)0); (objfile
) = (objfile)->next) for (osect = objfile->sections; osect
< objfile->sections_end; osect++)
3081 if (overlay_is_mapped (osect))
3082 {
3083 const char *name;
3084 bfd_vma lma, vma;
3085 int size;
3086
3087 vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section)((osect->the_bfd_section)->vma);
3088 lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section)((osect->the_bfd_section)->lma);
3089 size = bfd_get_section_size (osect->the_bfd_section)((osect->the_bfd_section)->_raw_size);
3090 name = bfd_section_name (objfile->obfd, osect->the_bfd_section)((osect->the_bfd_section)->name);
3091
3092 printf_filtered ("Section %s, loaded at ", name);
3093 print_address_numeric (lma, 1, gdb_stdout);
3094 puts_filtered (" - ");
3095 print_address_numeric (lma + size, 1, gdb_stdout);
3096 printf_filtered (", mapped at ");
3097 print_address_numeric (vma, 1, gdb_stdout);
3098 puts_filtered (" - ");
3099 print_address_numeric (vma + size, 1, gdb_stdout);
3100 puts_filtered ("\n");
3101
3102 nmapped++;
3103 }
3104 if (nmapped == 0)
3105 printf_filtered ("No sections are mapped.\n");
3106}
3107
3108/* Function: map_overlay_command
3109 Mark the named section as mapped (ie. residing at its VMA address). */
3110
3111void
3112map_overlay_command (char *args, int from_tty)
3113{
3114 struct objfile *objfile, *objfile2;
3115 struct obj_section *sec, *sec2;
3116 asection *bfdsec;
3117
3118 if (!overlay_debugging)
3119 error ("\
3120Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3121the 'overlay manual' command.");
3122
3123 if (args == 0 || *args == 0)
3124 error ("Argument required: name of an overlay section");
3125
3126 /* First, find a section matching the user supplied argument */
3127 ALL_OBJSECTIONS (objfile, sec)for ((objfile) = object_files; (objfile) != ((void*)0); (objfile
) = (objfile)->next) for (sec = objfile->sections; sec <
objfile->sections_end; sec++)
3128 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section)((sec->the_bfd_section)->name), args))
3129 {
3130 /* Now, check to see if the section is an overlay. */
3131 bfdsec = sec->the_bfd_section;
3132 if (!section_is_overlay (bfdsec))
3133 continue; /* not an overlay section */
3134
3135 /* Mark the overlay as "mapped" */
3136 sec->ovly_mapped = 1;
3137
3138 /* Next, make a pass and unmap any sections that are
3139 overlapped by this new section: */
3140 ALL_OBJSECTIONS (objfile2, sec2)for ((objfile2) = object_files; (objfile2) != ((void*)0); (objfile2
) = (objfile2)->next) for (sec2 = objfile2->sections; sec2
< objfile2->sections_end; sec2++)
3141 if (sec2->ovly_mapped
3142 && sec != sec2
3143 && sec->the_bfd_section != sec2->the_bfd_section
3144 && sections_overlap (sec->the_bfd_section,
3145 sec2->the_bfd_section))
3146 {
3147 if (info_verbose)
3148 printf_unfiltered ("Note: section %s unmapped by overlap\n",
3149 bfd_section_name (objfile->obfd,((sec2->the_bfd_section)->name)
3150 sec2->the_bfd_section)((sec2->the_bfd_section)->name));
3151 sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2 */
3152 }
3153 return;
3154 }
3155 error ("No overlay section called %s", args);
3156}
3157
3158/* Function: unmap_overlay_command
3159 Mark the overlay section as unmapped
3160 (ie. resident in its LMA address range, rather than the VMA range). */
3161
3162void
3163unmap_overlay_command (char *args, int from_tty)
3164{
3165 struct objfile *objfile;
3166 struct obj_section *sec;
3167
3168 if (!overlay_debugging)
3169 error ("\
3170Overlay debugging not enabled. Use either the 'overlay auto' or\n\
3171the 'overlay manual' command.");
3172
3173 if (args == 0 || *args == 0)
3174 error ("Argument required: name of an overlay section");
3175
3176 /* First, find a section matching the user supplied argument */
3177 ALL_OBJSECTIONS (objfile, sec)for ((objfile) = object_files; (objfile) != ((void*)0); (objfile
) = (objfile)->next) for (sec = objfile->sections; sec <
objfile->sections_end; sec++)
3178 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section)((sec->the_bfd_section)->name), args))
3179 {
3180 if (!sec->ovly_mapped)
3181 error ("Section %s is not mapped", args);
3182 sec->ovly_mapped = 0;
3183 return;
3184 }
3185 error ("No overlay section called %s", args);
3186}
3187
3188/* Function: overlay_auto_command
3189 A utility command to turn on overlay debugging.
3190 Possibly this should be done via a set/show command. */
3191
3192static void
3193overlay_auto_command (char *args, int from_tty)
3194{
3195 overlay_debugging = ovly_auto;
3196 enable_overlay_breakpoints ();
3197 if (info_verbose)
3198 printf_unfiltered ("Automatic overlay debugging enabled.");
3199}
3200
3201/* Function: overlay_manual_command
3202 A utility command to turn on overlay debugging.
3203 Possibly this should be done via a set/show command. */
3204
3205static void
3206overlay_manual_command (char *args, int from_tty)
3207{
3208 overlay_debugging = ovly_on;
3209 disable_overlay_breakpoints ();
3210 if (info_verbose)
3211 printf_unfiltered ("Overlay debugging enabled.");
3212}
3213
3214/* Function: overlay_off_command
3215 A utility command to turn on overlay debugging.
3216 Possibly this should be done via a set/show command. */
3217
3218static void
3219overlay_off_command (char *args, int from_tty)
3220{
3221 overlay_debugging = ovly_off;
3222 disable_overlay_breakpoints ();
3223 if (info_verbose)
3224 printf_unfiltered ("Overlay debugging disabled.");
3225}
3226
3227static void
3228overlay_load_command (char *args, int from_tty)
3229{
3230 if (target_overlay_update)
3231 (*target_overlay_update) (NULL((void*)0));
3232 else
3233 error ("This target does not know how to read its overlay state.");
3234}
3235
3236/* Function: overlay_command
3237 A place-holder for a mis-typed command */
3238
3239/* Command list chain containing all defined "overlay" subcommands. */
3240struct cmd_list_element *overlaylist;
3241
3242static void
3243overlay_command (char *args, int from_tty)
3244{
3245 printf_unfiltered
3246 ("\"overlay\" must be followed by the name of an overlay command.\n");
3247 help_list (overlaylist, "overlay ", -1, gdb_stdout);
3248}
3249
3250
3251/* Target Overlays for the "Simplest" overlay manager:
3252
3253 This is GDB's default target overlay layer. It works with the
3254 minimal overlay manager supplied as an example by Cygnus. The
3255 entry point is via a function pointer "target_overlay_update",
3256 so targets that use a different runtime overlay manager can
3257 substitute their own overlay_update function and take over the
3258 function pointer.
3259
3260 The overlay_update function pokes around in the target's data structures
3261 to see what overlays are mapped, and updates GDB's overlay mapping with
3262 this information.
3263
3264 In this simple implementation, the target data structures are as follows:
3265 unsigned _novlys; /# number of overlay sections #/
3266 unsigned _ovly_table[_novlys][4] = {
3267 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
3268 {..., ..., ..., ...},
3269 }
3270 unsigned _novly_regions; /# number of overlay regions #/
3271 unsigned _ovly_region_table[_novly_regions][3] = {
3272 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
3273 {..., ..., ...},
3274 }
3275 These functions will attempt to update GDB's mappedness state in the
3276 symbol section table, based on the target's mappedness state.
3277
3278 To do this, we keep a cached copy of the target's _ovly_table, and
3279 attempt to detect when the cached copy is invalidated. The main
3280 entry point is "simple_overlay_update(SECT), which looks up SECT in
3281 the cached table and re-reads only the entry for that section from
3282 the target (whenever possible).
3283 */
3284
3285/* Cached, dynamically allocated copies of the target data structures: */
3286static unsigned (*cache_ovly_table)[4] = 0;
3287#if 0
3288static unsigned (*cache_ovly_region_table)[3] = 0;
3289#endif
3290static unsigned cache_novlys = 0;
3291#if 0
3292static unsigned cache_novly_regions = 0;
3293#endif
3294static CORE_ADDR cache_ovly_table_base = 0;
3295#if 0
3296static CORE_ADDR cache_ovly_region_table_base = 0;
3297#endif
3298enum ovly_index
3299 {
3300 VMA, SIZE, LMA, MAPPED
3301 };
3302#define TARGET_LONG_BYTES((gdbarch_long_bit (current_gdbarch)) / 8) (TARGET_LONG_BIT(gdbarch_long_bit (current_gdbarch)) / TARGET_CHAR_BIT8)
3303
3304/* Throw away the cached copy of _ovly_table */
3305static void
3306simple_free_overlay_table (void)
3307{
3308 if (cache_ovly_table)
3309 xfree (cache_ovly_table);
3310 cache_novlys = 0;
3311 cache_ovly_table = NULL((void*)0);
3312 cache_ovly_table_base = 0;
3313}
3314
3315#if 0
3316/* Throw away the cached copy of _ovly_region_table */
3317static void
3318simple_free_overlay_region_table (void)
3319{
3320 if (cache_ovly_region_table)
3321 xfree (cache_ovly_region_table);
3322 cache_novly_regions = 0;
3323 cache_ovly_region_table = NULL((void*)0);
3324 cache_ovly_region_table_base = 0;
3325}
3326#endif
3327
3328/* Read an array of ints from the target into a local buffer.
3329 Convert to host order. int LEN is number of ints */
3330static void
3331read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr, int len)
3332{
3333 /* FIXME (alloca): Not safe if array is very large. */
3334 char *buf = alloca (len * TARGET_LONG_BYTES)__builtin_alloca(len * ((gdbarch_long_bit (current_gdbarch)) /
8))
;
3335 int i;
3336
3337 read_memory (memaddr, buf, len * TARGET_LONG_BYTES((gdbarch_long_bit (current_gdbarch)) / 8));
3338 for (i = 0; i < len; i++)
3339 myaddr[i] = extract_unsigned_integer (TARGET_LONG_BYTES((gdbarch_long_bit (current_gdbarch)) / 8) * i + buf,
3340 TARGET_LONG_BYTES((gdbarch_long_bit (current_gdbarch)) / 8));
3341}
3342
3343/* Find and grab a copy of the target _ovly_table
3344 (and _novlys, which is needed for the table's size) */
3345static int
3346simple_read_overlay_table (void)
3347{
3348 struct minimal_symbol *novlys_msym, *ovly_table_msym;
3349
3350 simple_free_overlay_table ();
3351 novlys_msym = lookup_minimal_symbol ("_novlys", NULL((void*)0), NULL((void*)0));
3352 if (! novlys_msym)
3353 {
3354 error ("Error reading inferior's overlay table: "
3355 "couldn't find `_novlys' variable\n"
3356 "in inferior. Use `overlay manual' mode.");
3357 return 0;
3358 }
3359
3360 ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL((void*)0), NULL((void*)0));
3361 if (! ovly_table_msym)
3362 {
3363 error ("Error reading inferior's overlay table: couldn't find "
3364 "`_ovly_table' array\n"
3365 "in inferior. Use `overlay manual' mode.");
3366 return 0;
3367 }
3368
3369 cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym)(novlys_msym)->ginfo.value.address, 4);
3370 cache_ovly_table
3371 = (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
3372 cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym)(ovly_table_msym)->ginfo.value.address;
3373 read_target_long_array (cache_ovly_table_base,
3374 (int *) cache_ovly_table,
3375 cache_novlys * 4);
3376
3377 return 1; /* SUCCESS */
3378}
3379
3380#if 0
3381/* Find and grab a copy of the target _ovly_region_table
3382 (and _novly_regions, which is needed for the table's size) */
3383static int
3384simple_read_overlay_region_table (void)
3385{
3386 struct minimal_symbol *msym;
3387
3388 simple_free_overlay_region_table ();
3389 msym = lookup_minimal_symbol ("_novly_regions", NULL((void*)0), NULL((void*)0));
3390 if (msym != NULL((void*)0))
3391 cache_novly_regions = read_memory_integer (SYMBOL_VALUE_ADDRESS (msym)(msym)->ginfo.value.address, 4);
3392 else
3393 return 0; /* failure */
3394 cache_ovly_region_table = (void *) xmalloc (cache_novly_regions * 12);
3395 if (cache_ovly_region_table != NULL((void*)0))
3396 {
3397 msym = lookup_minimal_symbol ("_ovly_region_table", NULL((void*)0), NULL((void*)0));
3398 if (msym != NULL((void*)0))
3399 {
3400 cache_ovly_region_table_base = SYMBOL_VALUE_ADDRESS (msym)(msym)->ginfo.value.address;
3401 read_target_long_array (cache_ovly_region_table_base,
3402 (int *) cache_ovly_region_table,
3403 cache_novly_regions * 3);
3404 }
3405 else
3406 return 0; /* failure */
3407 }
3408 else
3409 return 0; /* failure */
3410 return 1; /* SUCCESS */
3411}
3412#endif
3413
3414/* Function: simple_overlay_update_1
3415 A helper function for simple_overlay_update. Assuming a cached copy
3416 of _ovly_table exists, look through it to find an entry whose vma,
3417 lma and size match those of OSECT. Re-read the entry and make sure
3418 it still matches OSECT (else the table may no longer be valid).
3419 Set OSECT's mapped state to match the entry. Return: 1 for
3420 success, 0 for failure. */
3421
3422static int
3423simple_overlay_update_1 (struct obj_section *osect)
3424{
3425 int i, size;
3426 bfd *obfd = osect->objfile->obfd;
3427 asection *bsect = osect->the_bfd_section;
3428
3429 size = bfd_get_section_size (osect->the_bfd_section)((osect->the_bfd_section)->_raw_size);
3430 for (i = 0; i < cache_novlys; i++)
3431 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)((bsect)->vma)
3432 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)((bsect)->lma)
3433 /* && cache_ovly_table[i][SIZE] == size */ )
3434 {
3435 read_target_long_array (cache_ovly_table_base + i * TARGET_LONG_BYTES((gdbarch_long_bit (current_gdbarch)) / 8),
3436 (int *) cache_ovly_table[i], 4);
3437 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)((bsect)->vma)
3438 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)((bsect)->lma)
3439 /* && cache_ovly_table[i][SIZE] == size */ )
3440 {
3441 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3442 return 1;
3443 }
3444 else /* Warning! Warning! Target's ovly table has changed! */
3445 return 0;
3446 }
3447 return 0;
3448}
3449
3450/* Function: simple_overlay_update
3451 If OSECT is NULL, then update all sections' mapped state
3452 (after re-reading the entire target _ovly_table).
3453 If OSECT is non-NULL, then try to find a matching entry in the
3454 cached ovly_table and update only OSECT's mapped state.
3455 If a cached entry can't be found or the cache isn't valid, then
3456 re-read the entire cache, and go ahead and update all sections. */
3457
3458static void
3459simple_overlay_update (struct obj_section *osect)
3460{
3461 struct objfile *objfile;
3462
3463 /* Were we given an osect to look up? NULL means do all of them. */
3464 if (osect)
3465 /* Have we got a cached copy of the target's overlay table? */
3466 if (cache_ovly_table != NULL((void*)0))
3467 /* Does its cached location match what's currently in the symtab? */
3468 if (cache_ovly_table_base ==
3469 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL, NULL))(lookup_minimal_symbol ("_ovly_table", ((void*)0), ((void*)0)
))->ginfo.value.address
)
3470 /* Then go ahead and try to look up this single section in the cache */
3471 if (simple_overlay_update_1 (osect))
3472 /* Found it! We're done. */
3473 return;
3474
3475 /* Cached table no good: need to read the entire table anew.
3476 Or else we want all the sections, in which case it's actually
3477 more efficient to read the whole table in one block anyway. */
3478
3479 if (! simple_read_overlay_table ())
3480 return;
3481
3482 /* Now may as well update all sections, even if only one was requested. */
3483 ALL_OBJSECTIONS (objfile, osect)for ((objfile) = object_files; (objfile) != ((void*)0); (objfile
) = (objfile)->next) for (osect = objfile->sections; osect
< objfile->sections_end; osect++)
3484 if (section_is_overlay (osect->the_bfd_section))
3485 {
3486 int i, size;
3487 bfd *obfd = osect->objfile->obfd;
3488 asection *bsect = osect->the_bfd_section;
3489
3490 size = bfd_get_section_size (bsect)((bsect)->_raw_size);
3491 for (i = 0; i < cache_novlys; i++)
3492 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)((bsect)->vma)
3493 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)((bsect)->lma)
3494 /* && cache_ovly_table[i][SIZE] == size */ )
3495 { /* obj_section matches i'th entry in ovly_table */
3496 osect->ovly_mapped = cache_ovly_table[i][MAPPED];
3497 break; /* finished with inner for loop: break out */
3498 }
3499 }
3500}
3501
3502/* Set the output sections and output offsets for section SECTP in
3503 ABFD. The relocation code in BFD will read these offsets, so we
3504 need to be sure they're initialized. We map each section to itself,
3505 with no offset; this means that SECTP->vma will be honored. */
3506
3507static void
3508symfile_dummy_outputs (bfd *abfd, asection *sectp, void *dummy)
3509{
3510 sectp->output_section = sectp;
3511 sectp->output_offset = 0;
3512}
3513
3514/* Relocate the contents of a debug section SECTP in ABFD. The
3515 contents are stored in BUF if it is non-NULL, or returned in a
3516 malloc'd buffer otherwise.
3517
3518 For some platforms and debug info formats, shared libraries contain
3519 relocations against the debug sections (particularly for DWARF-2;
3520 one affected platform is PowerPC GNU/Linux, although it depends on
3521 the version of the linker in use). Also, ELF object files naturally
3522 have unresolved relocations for their debug sections. We need to apply
3523 the relocations in order to get the locations of symbols correct. */
3524
3525bfd_byte *
3526symfile_relocate_debug_section (bfd *abfd, asection *sectp, bfd_byte *buf)
3527{
3528 /* We're only interested in debugging sections with relocation
3529 information. */
3530 if ((sectp->flags & SEC_RELOC0x004) == 0)
3531 return NULL((void*)0);
3532 if ((sectp->flags & SEC_DEBUGGING0x10000) == 0)
3533 return NULL((void*)0);
3534
3535 /* We will handle section offsets properly elsewhere, so relocate as if
3536 all sections begin at 0. */
3537 bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL((void*)0));
3538
3539 return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL((void*)0));
3540}
3541
3542void
3543_initialize_symfile (void)
3544{
3545 struct cmd_list_element *c;
3546
3547 c = add_cmd ("symbol-file", class_files, symbol_file_command,
3548 "Load symbol table from executable file FILE.\n\
3549The `file' command can also load symbol tables, as well as setting the file\n\
3550to execute.", &cmdlist);
3551 set_cmd_completer (c, filename_completer);
3552
3553 c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command,
3554 "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
3555Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
3556ADDR is the starting address of the file's text.\n\
3557The optional arguments are section-name section-address pairs and\n\
3558should be specified if the data and bss segments are not contiguous\n\
3559with the text. SECT is a section name to be loaded at SECT_ADDR.",
3560 &cmdlist);
3561 set_cmd_completer (c, filename_completer);
3562
3563 c = add_cmd ("add-shared-symbol-files", class_files,
Value stored to 'c' is never read
3564 add_shared_symbol_files_command,
3565 "Load the symbols from shared objects in the dynamic linker's link map.",
3566 &cmdlist);
3567 c = add_alias_cmd ("assf", "add-shared-symbol-files", class_files, 1,
3568 &cmdlist);
3569
3570 c = add_cmd ("load", class_files, load_command,
3571 "Dynamically load FILE into the running program, and record its symbols\n\
3572for access from GDB.", &cmdlist);
3573 set_cmd_completer (c, filename_completer);
3574
3575 deprecated_add_show_from_set
3576 (add_set_cmd ("symbol-reloading", class_support, var_boolean,
3577 (char *) &symbol_reloading,
3578 "Set dynamic symbol table reloading multiple times in one run.",
3579 &setlist),
3580 &showlist);
3581
3582 add_prefix_cmd ("overlay", class_support, overlay_command,
3583 "Commands for debugging overlays.", &overlaylist,
3584 "overlay ", 0, &cmdlist);
3585
3586 add_com_alias ("ovly", "overlay", class_alias, 1);
3587 add_com_alias ("ov", "overlay", class_alias, 1);
3588
3589 add_cmd ("map-overlay", class_support, map_overlay_command,
3590 "Assert that an overlay section is mapped.", &overlaylist);
3591
3592 add_cmd ("unmap-overlay", class_support, unmap_overlay_command,
3593 "Assert that an overlay section is unmapped.", &overlaylist);
3594
3595 add_cmd ("list-overlays", class_support, list_overlays_command,
3596 "List mappings of overlay sections.", &overlaylist);
3597
3598 add_cmd ("manual", class_support, overlay_manual_command,
3599 "Enable overlay debugging.", &overlaylist);
3600 add_cmd ("off", class_support, overlay_off_command,
3601 "Disable overlay debugging.", &overlaylist);
3602 add_cmd ("auto", class_support, overlay_auto_command,
3603 "Enable automatic overlay debugging.", &overlaylist);
3604 add_cmd ("load-target", class_support, overlay_load_command,
3605 "Read the overlay mapping state from the target.", &overlaylist);
3606
3607 /* Filename extension to source language lookup table: */
3608 init_filename_language_table ();
3609 c = add_set_cmd ("extension-language", class_files, var_string_noescape,
3610 (char *) &ext_args,
3611 "Set mapping between filename extension and source language.\n\
3612Usage: set extension-language .foo bar",
3613 &setlist);
3614 set_cmd_cfunc (c, set_ext_lang_command);
3615
3616 add_info ("extensions", info_ext_lang_command,
3617 "All filename extensions associated with a source language.");
3618
3619 deprecated_add_show_from_set
3620 (add_set_cmd ("download-write-size", class_obscure,
3621 var_integer, (char *) &download_write_size,
3622 "Set the write size used when downloading a program.\n"
3623 "Only used when downloading a program onto a remote\n"
3624 "target. Specify zero, or a negative value, to disable\n"
3625 "blocked writes. The actual size of each transfer is also\n"
3626 "limited by the size of the target packet and the memory\n"
3627 "cache.\n",
3628 &setlist),
3629 &showlist);
3630
3631 debug_file_directory = xstrdup (DEBUGDIR"/usr/lib/debug");
3632 c = (add_set_cmd
3633 ("debug-file-directory", class_support, var_string,
3634 (char *) &debug_file_directory,
3635 "Set the directory where separate debug symbols are searched for.\n"
3636 "Separate debug symbols are first searched for in the same\n"
3637 "directory as the binary, then in the `" DEBUG_SUBDIRECTORY".debug"
3638 "' subdirectory,\n"
3639 "and lastly at the path of the directory of the binary with\n"
3640 "the global debug-file directory prepended\n",
3641 &setlist));
3642 deprecated_add_show_from_set (c, &showlist);
3643 set_cmd_completer (c, filename_completer);
3644}