3 Copyright (C) 1999-2016 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"
33 static int core_num_syms;
34 static asymbol **core_syms;
35 asection *core_text_sect;
36 void * core_text_space;
38 static int min_insn_size;
41 /* For mapping symbols to specific .o files during file ordering. */
42 struct function_map * symbol_map;
43 unsigned int symbol_map_count;
45 static void read_function_mappings (const char *);
46 static int core_sym_class (asymbol *);
47 static bfd_boolean get_src_info
48 (bfd_vma, const char **, const char **, int *);
50 extern void i386_find_call (Sym *, bfd_vma, bfd_vma);
51 extern void alpha_find_call (Sym *, bfd_vma, bfd_vma);
52 extern void vax_find_call (Sym *, bfd_vma, bfd_vma);
53 extern void tahoe_find_call (Sym *, bfd_vma, bfd_vma);
54 extern void sparc_find_call (Sym *, bfd_vma, bfd_vma);
55 extern void mips_find_call (Sym *, bfd_vma, bfd_vma);
56 extern void aarch64_find_call (Sym *, bfd_vma, bfd_vma);
59 parse_error (const char *filename)
61 fprintf (stderr, _("%s: unable to parse mapping file %s.\n"), whoami, filename);
65 /* Compare two function_map structs based on function name.
66 We want to sort in ascending order. */
69 cmp_symbol_map (const void * l, const void * r)
71 return strcmp (((struct function_map *) l)->function_name,
72 ((struct function_map *) r)->function_name);
76 read_function_mappings (const char *filename)
78 FILE * file = fopen (filename, "r");
85 fprintf (stderr, _("%s: could not open %s.\n"), whoami, filename);
89 /* First parse the mapping file so we know how big we need to
90 make our tables. We also do some sanity checks at this
96 matches = fscanf (file, "%[^\n:]", dummy);
98 parse_error (filename);
100 /* Just skip messages about files with no symbols. */
101 if (!strncmp (dummy, "No symbols in ", 14))
103 matches = fscanf (file, "\n");
105 parse_error (filename);
109 /* Don't care what else is on this line at this point. */
110 matches = fscanf (file, "%[^\n]\n", dummy);
112 parse_error (filename);
116 /* Now we know how big we need to make our table. */
117 symbol_map = ((struct function_map *)
118 xmalloc (count * sizeof (struct function_map)));
120 /* Rewind the input file so we can read it again. */
123 /* Read each entry and put it into the table. */
130 matches = fscanf (file, "%[^\n:]", dummy);
132 parse_error (filename);
134 /* Just skip messages about files with no symbols. */
135 if (!strncmp (dummy, "No symbols in ", 14))
137 matches = fscanf (file, "\n");
139 parse_error (filename);
143 /* dummy has the filename, go ahead and copy it. */
144 symbol_map[count].file_name = (char *) xmalloc (strlen (dummy) + 1);
145 strcpy (symbol_map[count].file_name, dummy);
147 /* Now we need the function name. */
148 matches = fscanf (file, "%[^\n]\n", dummy);
150 parse_error (filename);
151 tmp = strrchr (dummy, ' ') + 1;
152 symbol_map[count].function_name = (char *) xmalloc (strlen (tmp) + 1);
153 strcpy (symbol_map[count].function_name, tmp);
157 /* Record the size of the map table for future reference. */
158 symbol_map_count = count;
160 for (i = 0; i < symbol_map_count; ++i)
162 || filename_cmp (symbol_map[i].file_name, symbol_map[i - 1].file_name))
163 symbol_map[i].is_first = 1;
165 qsort (symbol_map, symbol_map_count, sizeof (struct function_map), cmp_symbol_map);
171 core_init (const char * aout_name)
177 core_bfd = bfd_openr (aout_name, 0);
185 if (!bfd_check_format (core_bfd, bfd_object))
187 fprintf (stderr, _("%s: %s: not in executable format\n"), whoami, aout_name);
191 /* Get core's text section. */
192 core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
195 core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
198 fprintf (stderr, _("%s: can't find .text section in %s\n"),
204 /* Read core's symbol table. */
206 /* This will probably give us more than we need, but that's ok. */
207 core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);
208 if (core_sym_bytes < 0)
210 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
211 bfd_errmsg (bfd_get_error ()));
215 core_syms = (asymbol **) xmalloc (core_sym_bytes);
216 core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
218 if (core_num_syms < 0)
220 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
221 bfd_errmsg (bfd_get_error ()));
225 synth_count = bfd_get_synthetic_symtab (core_bfd, core_num_syms, core_syms,
226 0, NULL, &synthsyms);
233 new_size = (core_num_syms + synth_count + 1) * sizeof (*core_syms);
234 core_syms = (asymbol **) xrealloc (core_syms, new_size);
235 symp = core_syms + core_num_syms;
236 core_num_syms += synth_count;
237 for (i = 0; i < synth_count; i++)
238 *symp++ = synthsyms + i;
245 switch (bfd_get_arch (core_bfd))
260 if (function_mapping_file)
261 read_function_mappings (function_mapping_file);
264 /* Read in the text space of an a.out file. */
267 core_get_text_space (bfd *cbfd)
269 core_text_space = malloc (bfd_get_section_size (core_text_sect));
271 if (!core_text_space)
273 fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
274 whoami, (unsigned long) bfd_get_section_size (core_text_sect));
278 if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
279 0, bfd_get_section_size (core_text_sect)))
281 bfd_perror ("bfd_get_section_contents");
282 free (core_text_space);
286 if (!core_text_space)
287 fprintf (stderr, _("%s: can't do -c\n"), whoami);
292 find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
294 if (core_text_space == 0)
297 hist_clip_symbol_address (&p_lowpc, &p_highpc);
299 switch (bfd_get_arch (core_bfd))
302 i386_find_call (parent, p_lowpc, p_highpc);
306 alpha_find_call (parent, p_lowpc, p_highpc);
310 vax_find_call (parent, p_lowpc, p_highpc);
314 sparc_find_call (parent, p_lowpc, p_highpc);
318 tahoe_find_call (parent, p_lowpc, p_highpc);
322 mips_find_call (parent, p_lowpc, p_highpc);
325 case bfd_arch_aarch64:
326 aarch64_find_call (parent, p_lowpc, p_highpc);
330 fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
331 whoami, bfd_printable_name(core_bfd));
333 /* Don't give the error more than once. */
334 ignore_direct_calls = FALSE;
338 /* Return class of symbol SYM. The returned class can be any of:
339 0 -> symbol is not interesting to us
340 'T' -> symbol is a global name
341 't' -> symbol is a local (static) name. */
344 core_sym_class (asymbol *sym)
351 if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
354 /* Must be a text symbol, and static text symbols
355 don't qualify if ignore_static_funcs set. */
356 if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
358 DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
363 bfd_get_symbol_info (core_bfd, sym, &syminfo);
367 return i; /* It's a global symbol. */
370 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
371 also be a data symbol. */
376 /* Not a static text symbol. */
377 DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
382 /* Do some more filtering on static function-names. */
383 if (ignore_static_funcs)
386 /* Can't zero-length name or funny characters in name, where
387 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
388 if (!sym->name || sym->name[0] == '\0')
391 for (name = sym->name; *name; ++name)
398 /* Allow both nested subprograms (which end with ".NNN", where N is
399 a digit) and GCC cloned functions (which contain ".clone").
400 Allow for multiple iterations of both - apparently GCC can clone
401 clones and subprograms. */
403 #define CLONE_NAME ".clone."
404 #define CLONE_NAME_LEN strlen (CLONE_NAME)
405 #define CONSTPROP_NAME ".constprop."
406 #define CONSTPROP_NAME_LEN strlen (CONSTPROP_NAME)
408 if (strlen (name) > CLONE_NAME_LEN
409 && strncmp (name, CLONE_NAME, CLONE_NAME_LEN) == 0)
410 name += CLONE_NAME_LEN - 1;
412 else if (strlen (name) > CONSTPROP_NAME_LEN
413 && strncmp (name, CONSTPROP_NAME, CONSTPROP_NAME_LEN) == 0)
414 name += CONSTPROP_NAME_LEN - 1;
416 for (name++; *name; name++)
417 if (digit_seen && *name == '.')
419 else if (ISDIGIT (*name))
426 /* On systems where the C compiler adds an underscore to all
427 names, static names without underscores seem usually to be
428 labels in hand written assembler in the library. We don't want
429 these names. This is certainly necessary on a Sparc running
430 SunOS 4.1 (try profiling a program that does a lot of
431 division). I don't know whether it has harmful side effects on
432 other systems. Perhaps it should be made configurable. */
433 sym_prefix = bfd_get_symbol_leading_char (core_bfd);
435 if ((sym_prefix && sym_prefix != sym->name[0])
436 /* GCC may add special symbols to help gdb figure out the file
437 language. We want to ignore these, since sometimes they mask
438 the real function. (dj@ctron) */
439 || !strncmp (sym->name, "__gnu_compiled", 14)
440 || !strncmp (sym->name, "___gnu_compiled", 15))
445 /* If the object file supports marking of function symbols, then
446 we can zap anything that doesn't have BSF_FUNCTION set. */
447 if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)
450 return 't'; /* It's a static text symbol. */
453 /* Get whatever source info we can get regarding address ADDR. */
456 get_src_info (bfd_vma addr, const char **filename, const char **name, int *line_num)
458 const char *fname = 0, *func_name = 0;
461 if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
462 addr - core_text_sect->vma,
463 &fname, &func_name, (unsigned int *) &l)
464 && fname && func_name && l)
466 DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
467 (unsigned long) addr, fname, l, func_name));
475 DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
476 (unsigned long) addr,
477 fname ? fname : "<unknown>", l,
478 func_name ? func_name : "<unknown>"));
483 /* Return number of symbols in a symbol-table file. */
486 num_of_syms_in (FILE * f)
488 const int BUFSIZE = 1024;
489 char * buf = (char *) xmalloc (BUFSIZE);
490 char * address = (char *) xmalloc (BUFSIZE);
492 char * name = (char *) xmalloc (BUFSIZE);
495 while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
497 if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
498 if (type == 't' || type == 'T')
509 /* Read symbol table from a file. */
512 core_create_syms_from (const char * sym_table_file)
514 const int BUFSIZE = 1024;
515 char * buf = (char *) xmalloc (BUFSIZE);
516 char * address = (char *) xmalloc (BUFSIZE);
518 char * name = (char *) xmalloc (BUFSIZE);
519 bfd_vma min_vma = ~(bfd_vma) 0;
523 f = fopen (sym_table_file, "r");
526 fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
530 /* Pass 1 - determine upper bound on number of function names. */
531 symtab.len = num_of_syms_in (f);
535 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
539 symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
541 /* Pass 2 - create symbols. */
542 symtab.limit = symtab.base;
544 if (fseek (f, 0, SEEK_SET) != 0)
546 perror (sym_table_file);
550 while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
552 if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
553 if (type != 't' && type != 'T')
557 if ((symtab.limit - symtab.base) >= symtab.len)
559 fprintf (stderr, _("%s: too many symbols in file '%s'\n"), whoami, sym_table_file);
563 sym_init (symtab.limit);
565 sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
567 symtab.limit->name = (char *) xmalloc (strlen (name) + 1);
568 strcpy ((char *) symtab.limit->name, name);
569 symtab.limit->mapped = 0;
570 symtab.limit->is_func = TRUE;
571 symtab.limit->is_bb_head = TRUE;
572 symtab.limit->is_static = (type == 't');
573 min_vma = MIN (symtab.limit->addr, min_vma);
574 max_vma = MAX (symtab.limit->addr, max_vma);
580 symtab.len = symtab.limit - symtab.base;
581 symtab_finalize (&symtab);
589 search_mapped_symbol (const void * l, const void * r)
591 return strcmp ((const char *) l, ((const struct function_map *) r)->function_name);
594 /* Read in symbol table from core.
595 One symbol per function is entered. */
598 core_create_function_syms (void)
600 bfd_vma min_vma = ~ (bfd_vma) 0;
604 struct function_map * found = NULL;
605 int core_has_func_syms = 0;
607 switch (core_bfd->xvec->flavour)
611 case bfd_target_coff_flavour:
612 case bfd_target_ecoff_flavour:
613 case bfd_target_xcoff_flavour:
614 case bfd_target_elf_flavour:
615 case bfd_target_nlm_flavour:
616 case bfd_target_som_flavour:
617 core_has_func_syms = 1;
620 /* Pass 1 - determine upper bound on number of function names. */
623 for (i = 0; i < core_num_syms; ++i)
625 if (!core_sym_class (core_syms[i]))
628 /* Don't create a symtab entry for a function that has
629 a mapping to a file, unless it's the first function
631 if (symbol_map_count != 0)
633 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
635 found = (struct function_map *) bsearch
636 (core_syms[i]->name, symbol_map, symbol_map_count,
637 sizeof (struct function_map), search_mapped_symbol);
639 if (found == NULL || found->is_first)
645 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
649 symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
651 /* Pass 2 - create symbols. */
652 symtab.limit = symtab.base;
654 for (i = 0; i < core_num_syms; ++i)
658 cxxclass = core_sym_class (core_syms[i]);
663 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
664 (unsigned long) core_syms[i]->value,
665 core_syms[i]->name));
669 if (symbol_map_count != 0)
671 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
673 found = (struct function_map *) bsearch
674 (core_syms[i]->name, symbol_map, symbol_map_count,
675 sizeof (struct function_map), search_mapped_symbol);
677 if (found && ! found->is_first)
680 sym_init (symtab.limit);
682 /* Symbol offsets are always section-relative. */
683 sym_sec = core_syms[i]->section;
684 symtab.limit->addr = core_syms[i]->value;
686 symtab.limit->addr += bfd_get_section_vma (sym_sec->owner, sym_sec);
690 symtab.limit->name = found->file_name;
691 symtab.limit->mapped = 1;
695 symtab.limit->name = core_syms[i]->name;
696 symtab.limit->mapped = 0;
699 /* Lookup filename and line number, if we can. */
701 const char * filename;
702 const char * func_name;
704 if (get_src_info (symtab.limit->addr, & filename, & func_name,
705 & symtab.limit->line_num))
707 symtab.limit->file = source_file_lookup_path (filename);
709 /* FIXME: Checking __osf__ here does not work with a cross
712 /* Suppress symbols that are not function names. This is
713 useful to suppress code-labels and aliases.
715 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
716 labels do not appear in the symbol table info, so this isn't
719 if (strcmp (symtab.limit->name, func_name) != 0)
721 /* The symbol's address maps to a different name, so
722 it can't be a function-entry point. This happens
723 for labels, for example. */
725 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
726 symtab.limit->name, func_name));
733 symtab.limit->is_func = (!core_has_func_syms
734 || (core_syms[i]->flags & BSF_FUNCTION) != 0);
735 symtab.limit->is_bb_head = TRUE;
738 symtab.limit->is_static = TRUE;
740 /* Keep track of the minimum and maximum vma addresses used by all
741 symbols. When computing the max_vma, use the ending address of the
742 section containing the symbol, if available. */
743 min_vma = MIN (symtab.limit->addr, min_vma);
745 max_vma = MAX (bfd_get_section_vma (sym_sec->owner, sym_sec)
746 + bfd_section_size (sym_sec->owner, sym_sec) - 1,
749 max_vma = MAX (symtab.limit->addr, max_vma);
751 DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
752 (long) (symtab.limit - symtab.base),
754 (unsigned long) symtab.limit->addr));
758 symtab.len = symtab.limit - symtab.base;
759 symtab_finalize (&symtab);
762 /* Read in symbol table from core.
763 One symbol per line of source code is entered. */
766 core_create_line_syms (void)
768 char *prev_name, *prev_filename;
769 unsigned int prev_name_len, prev_filename_len;
770 bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
771 Sym *prev, dummy, *sym;
772 const char *filename;
777 /* Create symbols for functions as usual. This is necessary in
778 cases where parts of a program were not compiled with -g. For
779 those parts we still want to get info at the function level. */
780 core_create_function_syms ();
782 /* Pass 1: count the number of symbols. */
784 /* To find all line information, walk through all possible
785 text-space addresses (one by one!) and get the debugging
786 info for each address. When the debugging info changes,
787 it is time to create a new symbol.
789 Of course, this is rather slow and it would be better if
790 BFD would provide an iterator for enumerating all line infos. */
791 prev_name_len = PATH_MAX;
792 prev_filename_len = PATH_MAX;
793 prev_name = (char *) xmalloc (prev_name_len);
794 prev_filename = (char *) xmalloc (prev_filename_len);
798 vma_high = core_text_sect->vma + bfd_get_section_size (core_text_sect);
799 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
803 if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
804 || (prev_line_num == dummy.line_num
806 && strcmp (prev_name, dummy.name) == 0
807 && filename_cmp (prev_filename, filename) == 0))
811 prev_line_num = dummy.line_num;
813 len = strlen (dummy.name);
814 if (len >= prev_name_len)
816 prev_name_len = len + 1024;
818 prev_name = (char *) xmalloc (prev_name_len);
821 strcpy (prev_name, dummy.name);
822 len = strlen (filename);
824 if (len >= prev_filename_len)
826 prev_filename_len = len + 1024;
827 free (prev_filename);
828 prev_filename = (char *) xmalloc (prev_filename_len);
831 strcpy (prev_filename, filename);
833 min_vma = MIN (vma, min_vma);
834 max_vma = MAX (vma, max_vma);
838 free (prev_filename);
840 /* Make room for function symbols, too. */
841 ltab.len += symtab.len;
842 ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
843 ltab.limit = ltab.base;
845 /* Pass 2 - create symbols. */
847 /* We now set is_static as we go along, rather than by running
848 through the symbol table at the end.
850 The old way called symtab_finalize before the is_static pass,
851 causing a problem since symtab_finalize uses is_static as part of
852 its address conflict resolution algorithm. Since global symbols
853 were prefered over static symbols, and all line symbols were
854 global at that point, static function names that conflicted with
855 their own line numbers (static, but labeled as global) were
856 rejected in favor of the line num.
858 This was not the desired functionality. We always want to keep
859 our function symbols and discard any conflicting line symbols.
860 Perhaps symtab_finalize should be modified to make this
861 distinction as well, but the current fix works and the code is a
865 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
867 sym_init (ltab.limit);
869 if (!get_src_info (vma, &filename, <ab.limit->name, <ab.limit->line_num)
870 || (prev && prev->line_num == ltab.limit->line_num
871 && strcmp (prev->name, ltab.limit->name) == 0
872 && filename_cmp (prev->file->name, filename) == 0))
875 /* Make name pointer a malloc'ed string. */
876 ltab.limit->name = xstrdup (ltab.limit->name);
877 ltab.limit->file = source_file_lookup_path (filename);
879 ltab.limit->addr = vma;
881 /* Set is_static based on the enclosing function, using either:
882 1) the previous symbol, if it's from the same function, or
883 2) a symtab lookup. */
884 if (prev && ltab.limit->file == prev->file &&
885 strcmp (ltab.limit->name, prev->name) == 0)
887 ltab.limit->is_static = prev->is_static;
891 sym = sym_lookup(&symtab, ltab.limit->addr);
893 ltab.limit->is_static = sym->is_static;
898 DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
899 (unsigned long) (ltab.limit - ltab.base),
901 (unsigned long) ltab.limit->addr));
905 /* Copy in function symbols. */
906 memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
907 ltab.limit += symtab.len;
909 if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
912 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
913 whoami, ltab.len, (long) (ltab.limit - ltab.base));
917 /* Finalize ltab and make it symbol table. */
918 symtab_finalize (<ab);