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