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