OSDN Git Service

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