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