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