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