3 Copyright (C) 1999-2018 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "libiberty.h"
24 #include "filenames.h"
25 #include "search_list.h"
30 #include "safe-ctype.h"
31 #include <limits.h> /* For UINT_MAX. */
34 static int core_num_syms;
35 static asymbol **core_syms;
36 asection *core_text_sect;
37 void * core_text_space;
39 static int min_insn_size;
42 /* For mapping symbols to specific .o files during file ordering. */
43 struct function_map * symbol_map;
44 unsigned int symbol_map_count;
46 static void read_function_mappings (const char *);
47 static int core_sym_class (asymbol *);
48 static bfd_boolean get_src_info
49 (bfd_vma, const char **, const char **, int *);
51 extern void i386_find_call (Sym *, bfd_vma, bfd_vma);
52 extern void alpha_find_call (Sym *, bfd_vma, bfd_vma);
53 extern void vax_find_call (Sym *, bfd_vma, bfd_vma);
54 extern void tahoe_find_call (Sym *, bfd_vma, bfd_vma);
55 extern void sparc_find_call (Sym *, bfd_vma, bfd_vma);
56 extern void mips_find_call (Sym *, bfd_vma, bfd_vma);
57 extern void aarch64_find_call (Sym *, bfd_vma, bfd_vma);
60 parse_error (const char *filename)
62 fprintf (stderr, _("%s: unable to parse mapping file %s.\n"), whoami, filename);
66 /* Compare two function_map structs based on function name.
67 We want to sort in ascending order. */
70 cmp_symbol_map (const void * l, const void * r)
72 return strcmp (((struct function_map *) l)->function_name,
73 ((struct function_map *) r)->function_name);
76 #define BUFSIZE (1024)
77 /* This is BUFSIZE - 1 as a string. Suitable for use in fprintf/sscanf format strings. */
78 #define STR_BUFSIZE "1023"
81 read_function_mappings (const char *filename)
83 FILE * file = fopen (filename, "r");
90 fprintf (stderr, _("%s: could not open %s.\n"), whoami, filename);
94 /* First parse the mapping file so we know how big we need to
95 make our tables. We also do some sanity checks at this
101 matches = fscanf (file, "%" STR_BUFSIZE "[^\n:]", dummy);
103 parse_error (filename);
105 /* Just skip messages about files with no symbols. */
106 if (!strncmp (dummy, "No symbols in ", 14))
108 matches = fscanf (file, "\n");
110 parse_error (filename);
114 /* Don't care what else is on this line at this point. */
115 matches = fscanf (file, "%" STR_BUFSIZE "[^\n]\n", dummy);
117 parse_error (filename);
121 /* Now we know how big we need to make our table. */
122 symbol_map = ((struct function_map *)
123 xmalloc (count * sizeof (struct function_map)));
125 /* Rewind the input file so we can read it again. */
128 /* Read each entry and put it into the table. */
135 matches = fscanf (file, "%" STR_BUFSIZE "[^\n:]", dummy);
137 parse_error (filename);
139 /* Just skip messages about files with no symbols. */
140 if (!strncmp (dummy, "No symbols in ", 14))
142 matches = fscanf (file, "\n");
144 parse_error (filename);
148 /* dummy has the filename, go ahead and copy it. */
149 symbol_map[count].file_name = (char *) xmalloc (strlen (dummy) + 1);
150 strcpy (symbol_map[count].file_name, dummy);
152 /* Now we need the function name. */
153 matches = fscanf (file, "%" STR_BUFSIZE "[^\n]\n", dummy);
155 parse_error (filename);
156 tmp = strrchr (dummy, ' ') + 1;
157 symbol_map[count].function_name = (char *) xmalloc (strlen (tmp) + 1);
158 strcpy (symbol_map[count].function_name, tmp);
162 /* Record the size of the map table for future reference. */
163 symbol_map_count = count;
165 for (i = 0; i < symbol_map_count; ++i)
167 || filename_cmp (symbol_map[i].file_name, symbol_map[i - 1].file_name))
168 symbol_map[i].is_first = 1;
170 qsort (symbol_map, symbol_map_count, sizeof (struct function_map), cmp_symbol_map);
176 core_init (const char * aout_name)
182 core_bfd = bfd_openr (aout_name, 0);
190 if (!bfd_check_format (core_bfd, bfd_object))
192 fprintf (stderr, _("%s: %s: not in executable format\n"), whoami, aout_name);
196 /* Get core's text section. */
197 core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
200 core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
203 fprintf (stderr, _("%s: can't find .text section in %s\n"),
209 /* Read core's symbol table. */
211 /* This will probably give us more than we need, but that's ok. */
212 core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);
213 if (core_sym_bytes < 0)
215 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
216 bfd_errmsg (bfd_get_error ()));
220 core_syms = (asymbol **) xmalloc (core_sym_bytes);
221 core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
223 if (core_num_syms < 0)
225 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
226 bfd_errmsg (bfd_get_error ()));
230 synth_count = bfd_get_synthetic_symtab (core_bfd, core_num_syms, core_syms,
231 0, NULL, &synthsyms);
238 new_size = (core_num_syms + synth_count + 1) * sizeof (*core_syms);
239 core_syms = (asymbol **) xrealloc (core_syms, new_size);
240 symp = core_syms + core_num_syms;
241 core_num_syms += synth_count;
242 for (i = 0; i < synth_count; i++)
243 *symp++ = synthsyms + i;
250 switch (bfd_get_arch (core_bfd))
265 if (function_mapping_file)
266 read_function_mappings (function_mapping_file);
269 /* Read in the text space of an a.out file. */
272 core_get_text_space (bfd *cbfd)
274 core_text_space = malloc (bfd_get_section_size (core_text_sect));
276 if (!core_text_space)
278 fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
279 whoami, (unsigned long) bfd_get_section_size (core_text_sect));
283 if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
284 0, bfd_get_section_size (core_text_sect)))
286 bfd_perror ("bfd_get_section_contents");
287 free (core_text_space);
291 if (!core_text_space)
292 fprintf (stderr, _("%s: can't do -c\n"), whoami);
297 find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
299 if (core_text_space == 0)
302 hist_clip_symbol_address (&p_lowpc, &p_highpc);
304 switch (bfd_get_arch (core_bfd))
307 i386_find_call (parent, p_lowpc, p_highpc);
311 alpha_find_call (parent, p_lowpc, p_highpc);
315 vax_find_call (parent, p_lowpc, p_highpc);
319 sparc_find_call (parent, p_lowpc, p_highpc);
323 tahoe_find_call (parent, p_lowpc, p_highpc);
327 mips_find_call (parent, p_lowpc, p_highpc);
330 case bfd_arch_aarch64:
331 aarch64_find_call (parent, p_lowpc, p_highpc);
335 fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
336 whoami, bfd_printable_name(core_bfd));
338 /* Don't give the error more than once. */
339 ignore_direct_calls = FALSE;
343 /* Return class of symbol SYM. The returned class can be any of:
344 0 -> symbol is not interesting to us
345 'T' -> symbol is a global name
346 't' -> symbol is a local (static) name. */
349 core_sym_class (asymbol *sym)
356 if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
359 /* Must be a text symbol, and static text symbols
360 don't qualify if ignore_static_funcs set. */
361 if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
363 DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
368 bfd_get_symbol_info (core_bfd, sym, &syminfo);
372 return i; /* It's a global symbol. */
375 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
376 also be a data symbol. */
381 /* Not a static text symbol. */
382 DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
387 /* Do some more filtering on static function-names. */
388 if (ignore_static_funcs)
391 /* Can't zero-length name or funny characters in name, where
392 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
393 if (!sym->name || sym->name[0] == '\0')
396 for (name = sym->name; *name; ++name)
403 /* Allow both nested subprograms (which end with ".NNN", where N is
404 a digit) and GCC cloned functions (which contain ".clone").
405 Allow for multiple iterations of both - apparently GCC can clone
406 clones and subprograms. */
408 #define CLONE_NAME ".clone."
409 #define CLONE_NAME_LEN strlen (CLONE_NAME)
410 #define CONSTPROP_NAME ".constprop."
411 #define CONSTPROP_NAME_LEN strlen (CONSTPROP_NAME)
413 if (strlen (name) > CLONE_NAME_LEN
414 && strncmp (name, CLONE_NAME, CLONE_NAME_LEN) == 0)
415 name += CLONE_NAME_LEN - 1;
417 else if (strlen (name) > CONSTPROP_NAME_LEN
418 && strncmp (name, CONSTPROP_NAME, CONSTPROP_NAME_LEN) == 0)
419 name += CONSTPROP_NAME_LEN - 1;
421 for (name++; *name; name++)
422 if (digit_seen && *name == '.')
424 else if (ISDIGIT (*name))
431 /* On systems where the C compiler adds an underscore to all
432 names, static names without underscores seem usually to be
433 labels in hand written assembler in the library. We don't want
434 these names. This is certainly necessary on a Sparc running
435 SunOS 4.1 (try profiling a program that does a lot of
436 division). I don't know whether it has harmful side effects on
437 other systems. Perhaps it should be made configurable. */
438 sym_prefix = bfd_get_symbol_leading_char (core_bfd);
440 if ((sym_prefix && sym_prefix != sym->name[0])
441 /* GCC may add special symbols to help gdb figure out the file
442 language. We want to ignore these, since sometimes they mask
443 the real function. (dj@ctron) */
444 || !strncmp (sym->name, "__gnu_compiled", 14)
445 || !strncmp (sym->name, "___gnu_compiled", 15))
450 /* If the object file supports marking of function symbols, then
451 we can zap anything that doesn't have BSF_FUNCTION set. */
452 if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)
455 return 't'; /* It's a static text symbol. */
458 /* Get whatever source info we can get regarding address ADDR. */
461 get_src_info (bfd_vma addr, const char **filename, const char **name, int *line_num)
463 const char *fname = 0, *func_name = 0;
466 if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
467 addr - core_text_sect->vma,
468 &fname, &func_name, (unsigned int *) &l)
469 && fname && func_name && l)
471 DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
472 (unsigned long) addr, fname, l, func_name));
480 DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
481 (unsigned long) addr,
482 fname ? fname : "<unknown>", l,
483 func_name ? func_name : "<unknown>"));
488 static char buf[BUFSIZE];
489 static char address[BUFSIZE];
490 static char name[BUFSIZE];
492 /* Return number of symbols in a symbol-table file. */
495 num_of_syms_in (FILE * f)
498 unsigned int num = 0;
500 while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
502 if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) == 3)
503 if (type == 't' || type == 'T')
505 /* PR 20499 - prevent integer overflow computing argument to xmalloc. */
506 if (++num >= UINT_MAX / sizeof (Sym))
514 /* Read symbol table from a file. */
517 core_create_syms_from (const char * sym_table_file)
520 bfd_vma min_vma = ~(bfd_vma) 0;
524 f = fopen (sym_table_file, "r");
527 fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
531 /* Pass 1 - determine upper bound on number of function names. */
532 symtab.len = num_of_syms_in (f);
536 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
539 else if (symtab.len == -1U)
541 fprintf (stderr, _("%s: file `%s' has too many symbols\n"),
542 whoami, sym_table_file);
546 symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
548 /* Pass 2 - create symbols. */
549 symtab.limit = symtab.base;
551 if (fseek (f, 0, SEEK_SET) != 0)
553 perror (sym_table_file);
557 while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
559 if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) != 3)
561 if (type != 't' && type != 'T')
564 sym_init (symtab.limit);
566 sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
568 symtab.limit->name = (char *) xmalloc (strlen (name) + 1);
569 strcpy ((char *) symtab.limit->name, name);
570 symtab.limit->mapped = 0;
571 symtab.limit->is_func = TRUE;
572 symtab.limit->is_bb_head = TRUE;
573 symtab.limit->is_static = (type == 't');
574 min_vma = MIN (symtab.limit->addr, min_vma);
575 max_vma = MAX (symtab.limit->addr, max_vma);
581 symtab.len = symtab.limit - symtab.base;
582 symtab_finalize (&symtab);
586 search_mapped_symbol (const void * l, const void * r)
588 return strcmp ((const char *) l, ((const struct function_map *) r)->function_name);
591 /* Read in symbol table from core.
592 One symbol per function is entered. */
595 core_create_function_syms (void)
597 bfd_vma min_vma = ~ (bfd_vma) 0;
601 struct function_map * found = NULL;
602 int core_has_func_syms = 0;
604 switch (core_bfd->xvec->flavour)
608 case bfd_target_coff_flavour:
609 case bfd_target_ecoff_flavour:
610 case bfd_target_xcoff_flavour:
611 case bfd_target_elf_flavour:
612 case bfd_target_nlm_flavour:
613 case bfd_target_som_flavour:
614 core_has_func_syms = 1;
617 /* Pass 1 - determine upper bound on number of function names. */
620 for (i = 0; i < core_num_syms; ++i)
622 if (!core_sym_class (core_syms[i]))
625 /* Don't create a symtab entry for a function that has
626 a mapping to a file, unless it's the first function
628 if (symbol_map_count != 0)
630 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
632 found = (struct function_map *) bsearch
633 (core_syms[i]->name, symbol_map, symbol_map_count,
634 sizeof (struct function_map), search_mapped_symbol);
636 if (found == NULL || found->is_first)
642 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
646 symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
648 /* Pass 2 - create symbols. */
649 symtab.limit = symtab.base;
651 for (i = 0; i < core_num_syms; ++i)
655 cxxclass = core_sym_class (core_syms[i]);
660 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
661 (unsigned long) core_syms[i]->value,
662 core_syms[i]->name));
666 if (symbol_map_count != 0)
668 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
670 found = (struct function_map *) bsearch
671 (core_syms[i]->name, symbol_map, symbol_map_count,
672 sizeof (struct function_map), search_mapped_symbol);
674 if (found && ! found->is_first)
677 sym_init (symtab.limit);
679 /* Symbol offsets are always section-relative. */
680 sym_sec = core_syms[i]->section;
681 symtab.limit->addr = core_syms[i]->value;
683 symtab.limit->addr += bfd_get_section_vma (sym_sec->owner, sym_sec);
687 symtab.limit->name = found->file_name;
688 symtab.limit->mapped = 1;
692 symtab.limit->name = core_syms[i]->name;
693 symtab.limit->mapped = 0;
696 /* Lookup filename and line number, if we can. */
698 const char * filename;
699 const char * func_name;
701 if (get_src_info (symtab.limit->addr, & filename, & func_name,
702 & symtab.limit->line_num))
704 symtab.limit->file = source_file_lookup_path (filename);
706 /* FIXME: Checking __osf__ here does not work with a cross
709 /* Suppress symbols that are not function names. This is
710 useful to suppress code-labels and aliases.
712 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
713 labels do not appear in the symbol table info, so this isn't
716 if (strcmp (symtab.limit->name, func_name) != 0)
718 /* The symbol's address maps to a different name, so
719 it can't be a function-entry point. This happens
720 for labels, for example. */
722 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
723 symtab.limit->name, func_name));
730 symtab.limit->is_func = (!core_has_func_syms
731 || (core_syms[i]->flags & BSF_FUNCTION) != 0);
732 symtab.limit->is_bb_head = TRUE;
735 symtab.limit->is_static = TRUE;
737 /* Keep track of the minimum and maximum vma addresses used by all
738 symbols. When computing the max_vma, use the ending address of the
739 section containing the symbol, if available. */
740 min_vma = MIN (symtab.limit->addr, min_vma);
742 max_vma = MAX (bfd_get_section_vma (sym_sec->owner, sym_sec)
743 + bfd_section_size (sym_sec->owner, sym_sec) - 1,
746 max_vma = MAX (symtab.limit->addr, max_vma);
748 DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
749 (long) (symtab.limit - symtab.base),
751 (unsigned long) symtab.limit->addr));
755 symtab.len = symtab.limit - symtab.base;
756 symtab_finalize (&symtab);
759 /* Read in symbol table from core.
760 One symbol per line of source code is entered. */
763 core_create_line_syms (void)
765 char *prev_name, *prev_filename;
766 unsigned int prev_name_len, prev_filename_len;
767 bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
768 Sym *prev, dummy, *sym;
769 const char *filename;
774 /* Create symbols for functions as usual. This is necessary in
775 cases where parts of a program were not compiled with -g. For
776 those parts we still want to get info at the function level. */
777 core_create_function_syms ();
779 /* Pass 1: count the number of symbols. */
781 /* To find all line information, walk through all possible
782 text-space addresses (one by one!) and get the debugging
783 info for each address. When the debugging info changes,
784 it is time to create a new symbol.
786 Of course, this is rather slow and it would be better if
787 BFD would provide an iterator for enumerating all line infos. */
788 prev_name_len = PATH_MAX;
789 prev_filename_len = PATH_MAX;
790 prev_name = (char *) xmalloc (prev_name_len);
791 prev_filename = (char *) xmalloc (prev_filename_len);
795 vma_high = core_text_sect->vma + bfd_get_section_size (core_text_sect);
796 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
800 if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
801 || (prev_line_num == dummy.line_num
803 && strcmp (prev_name, dummy.name) == 0
804 && filename_cmp (prev_filename, filename) == 0))
808 prev_line_num = dummy.line_num;
810 len = strlen (dummy.name);
811 if (len >= prev_name_len)
813 prev_name_len = len + 1024;
815 prev_name = (char *) xmalloc (prev_name_len);
818 strcpy (prev_name, dummy.name);
819 len = strlen (filename);
821 if (len >= prev_filename_len)
823 prev_filename_len = len + 1024;
824 free (prev_filename);
825 prev_filename = (char *) xmalloc (prev_filename_len);
828 strcpy (prev_filename, filename);
830 min_vma = MIN (vma, min_vma);
831 max_vma = MAX (vma, max_vma);
835 free (prev_filename);
837 /* Make room for function symbols, too. */
838 ltab.len += symtab.len;
839 ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
840 ltab.limit = ltab.base;
842 /* Pass 2 - create symbols. */
844 /* We now set is_static as we go along, rather than by running
845 through the symbol table at the end.
847 The old way called symtab_finalize before the is_static pass,
848 causing a problem since symtab_finalize uses is_static as part of
849 its address conflict resolution algorithm. Since global symbols
850 were preferred over static symbols, and all line symbols were
851 global at that point, static function names that conflicted with
852 their own line numbers (static, but labeled as global) were
853 rejected in favor of the line num.
855 This was not the desired functionality. We always want to keep
856 our function symbols and discard any conflicting line symbols.
857 Perhaps symtab_finalize should be modified to make this
858 distinction as well, but the current fix works and the code is a
862 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
864 sym_init (ltab.limit);
866 if (!get_src_info (vma, &filename, <ab.limit->name, <ab.limit->line_num)
867 || (prev && prev->line_num == ltab.limit->line_num
868 && strcmp (prev->name, ltab.limit->name) == 0
869 && filename_cmp (prev->file->name, filename) == 0))
872 /* Make name pointer a malloc'ed string. */
873 ltab.limit->name = xstrdup (ltab.limit->name);
874 ltab.limit->file = source_file_lookup_path (filename);
876 ltab.limit->addr = vma;
878 /* Set is_static based on the enclosing function, using either:
879 1) the previous symbol, if it's from the same function, or
880 2) a symtab lookup. */
881 if (prev && ltab.limit->file == prev->file &&
882 strcmp (ltab.limit->name, prev->name) == 0)
884 ltab.limit->is_static = prev->is_static;
888 sym = sym_lookup(&symtab, ltab.limit->addr);
890 ltab.limit->is_static = sym->is_static;
895 DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
896 (unsigned long) (ltab.limit - ltab.base),
898 (unsigned long) ltab.limit->addr));
902 /* Copy in function symbols. */
903 memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
904 ltab.limit += symtab.len;
906 if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
909 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
910 whoami, ltab.len, (long) (ltab.limit - ltab.base));
914 /* Finalize ltab and make it symbol table. */
915 symtab_finalize (<ab);