3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
4 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 #include "libiberty.h"
25 #include "filenames.h"
26 #include "search_list.h"
31 #include "safe-ctype.h"
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
);
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
);
169 core_init (const char * aout_name
)
175 core_bfd
= bfd_openr (aout_name
, 0);
183 if (!bfd_check_format (core_bfd
, bfd_object
))
185 fprintf (stderr
, _("%s: %s: not in executable format\n"), whoami
, aout_name
);
189 /* Get core's text section. */
190 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
193 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
196 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
202 /* Read core's symbol table. */
204 /* This will probably give us more than we need, but that's ok. */
205 core_sym_bytes
= bfd_get_symtab_upper_bound (core_bfd
);
206 if (core_sym_bytes
< 0)
208 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
209 bfd_errmsg (bfd_get_error ()));
213 core_syms
= (asymbol
**) xmalloc (core_sym_bytes
);
214 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
216 if (core_num_syms
< 0)
218 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
219 bfd_errmsg (bfd_get_error ()));
223 synth_count
= bfd_get_synthetic_symtab (core_bfd
, core_num_syms
, core_syms
,
224 0, NULL
, &synthsyms
);
231 new_size
= (core_num_syms
+ synth_count
+ 1) * sizeof (*core_syms
);
232 core_syms
= (asymbol
**) xrealloc (core_syms
, new_size
);
233 symp
= core_syms
+ core_num_syms
;
234 core_num_syms
+= synth_count
;
235 for (i
= 0; i
< synth_count
; i
++)
236 *symp
++ = synthsyms
+ i
;
243 switch (bfd_get_arch (core_bfd
))
258 if (function_mapping_file
)
259 read_function_mappings (function_mapping_file
);
262 /* Read in the text space of an a.out file. */
265 core_get_text_space (bfd
*cbfd
)
267 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
269 if (!core_text_space
)
271 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
272 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
276 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
277 0, bfd_get_section_size (core_text_sect
)))
279 bfd_perror ("bfd_get_section_contents");
280 free (core_text_space
);
284 if (!core_text_space
)
285 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
290 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
292 if (core_text_space
== 0)
295 hist_clip_symbol_address (&p_lowpc
, &p_highpc
);
297 switch (bfd_get_arch (core_bfd
))
300 i386_find_call (parent
, p_lowpc
, p_highpc
);
304 alpha_find_call (parent
, p_lowpc
, p_highpc
);
308 vax_find_call (parent
, p_lowpc
, p_highpc
);
312 sparc_find_call (parent
, p_lowpc
, p_highpc
);
316 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
320 mips_find_call (parent
, p_lowpc
, p_highpc
);
324 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
325 whoami
, bfd_printable_name(core_bfd
));
327 /* Don't give the error more than once. */
328 ignore_direct_calls
= FALSE
;
332 /* Return class of symbol SYM. The returned class can be any of:
333 0 -> symbol is not interesting to us
334 'T' -> symbol is a global name
335 't' -> symbol is a local (static) name. */
338 core_sym_class (asymbol
*sym
)
345 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
348 /* Must be a text symbol, and static text symbols
349 don't qualify if ignore_static_funcs set. */
350 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
352 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
357 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
361 return i
; /* It's a global symbol. */
364 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
365 also be a data symbol. */
370 /* Not a static text symbol. */
371 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
376 /* Do some more filtering on static function-names. */
377 if (ignore_static_funcs
)
380 /* Can't zero-length name or funny characters in name, where
381 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
382 if (!sym
->name
|| sym
->name
[0] == '\0')
385 for (name
= sym
->name
; *name
; ++name
)
392 /* Allow both nested subprograms (which end with ".NNN", where N is
393 a digit) and GCC cloned functions (which contain ".clone").
394 Allow for multiple iterations of both - apparently GCC can clone
395 clones and subprograms. */
397 #define CLONE_NAME ".clone."
398 #define CLONE_NAME_LEN strlen (CLONE_NAME)
400 if (strlen (name
) > CLONE_NAME_LEN
401 && strncmp (name
, CLONE_NAME
, CLONE_NAME_LEN
) == 0)
402 name
+= CLONE_NAME_LEN
- 1;
404 for (name
++; *name
; name
++)
405 if (digit_seen
&& *name
== '.')
407 else if (ISDIGIT (*name
))
414 /* On systems where the C compiler adds an underscore to all
415 names, static names without underscores seem usually to be
416 labels in hand written assembler in the library. We don't want
417 these names. This is certainly necessary on a Sparc running
418 SunOS 4.1 (try profiling a program that does a lot of
419 division). I don't know whether it has harmful side effects on
420 other systems. Perhaps it should be made configurable. */
421 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
423 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
424 /* GCC may add special symbols to help gdb figure out the file
425 language. We want to ignore these, since sometimes they mask
426 the real function. (dj@ctron) */
427 || !strncmp (sym
->name
, "__gnu_compiled", 14)
428 || !strncmp (sym
->name
, "___gnu_compiled", 15))
433 /* If the object file supports marking of function symbols, then
434 we can zap anything that doesn't have BSF_FUNCTION set. */
435 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
438 return 't'; /* It's a static text symbol. */
441 /* Get whatever source info we can get regarding address ADDR. */
444 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
446 const char *fname
= 0, *func_name
= 0;
449 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
450 addr
- core_text_sect
->vma
,
451 &fname
, &func_name
, (unsigned int *) &l
)
452 && fname
&& func_name
&& l
)
454 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
455 (unsigned long) addr
, fname
, l
, func_name
));
463 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
464 (unsigned long) addr
,
465 fname
? fname
: "<unknown>", l
,
466 func_name
? func_name
: "<unknown>"));
471 /* Return number of symbols in a symbol-table file. */
474 num_of_syms_in (FILE * f
)
476 const int BUFSIZE
= 1024;
477 char * buf
= (char *) xmalloc (BUFSIZE
);
478 char * address
= (char *) xmalloc (BUFSIZE
);
480 char * name
= (char *) xmalloc (BUFSIZE
);
483 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
485 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
486 if (type
== 't' || type
== 'T')
497 /* Read symbol table from a file. */
500 core_create_syms_from (const char * sym_table_file
)
502 const int BUFSIZE
= 1024;
503 char * buf
= (char *) xmalloc (BUFSIZE
);
504 char * address
= (char *) xmalloc (BUFSIZE
);
506 char * name
= (char *) xmalloc (BUFSIZE
);
507 bfd_vma min_vma
= ~(bfd_vma
) 0;
511 f
= fopen (sym_table_file
, "r");
514 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, sym_table_file
);
518 /* Pass 1 - determine upper bound on number of function names. */
519 symtab
.len
= num_of_syms_in (f
);
523 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, sym_table_file
);
527 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
529 /* Pass 2 - create symbols. */
530 symtab
.limit
= symtab
.base
;
532 if (fseek (f
, 0, SEEK_SET
) != 0)
534 perror (sym_table_file
);
538 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
540 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
541 if (type
!= 't' && type
!= 'T')
544 sym_init (symtab
.limit
);
546 sscanf (address
, "%" BFD_VMA_FMT
"x", &(symtab
.limit
->addr
) );
548 symtab
.limit
->name
= (char *) xmalloc (strlen (name
) + 1);
549 strcpy ((char *) symtab
.limit
->name
, name
);
550 symtab
.limit
->mapped
= 0;
551 symtab
.limit
->is_func
= TRUE
;
552 symtab
.limit
->is_bb_head
= TRUE
;
553 symtab
.limit
->is_static
= (type
== 't');
554 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
555 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
561 symtab
.len
= symtab
.limit
- symtab
.base
;
562 symtab_finalize (&symtab
);
570 search_mapped_symbol (const void * l
, const void * r
)
572 return strcmp ((const char *) l
, ((const struct function_map
*) r
)->function_name
);
575 /* Read in symbol table from core.
576 One symbol per function is entered. */
579 core_create_function_syms (void)
581 bfd_vma min_vma
= ~ (bfd_vma
) 0;
585 struct function_map
* found
;
586 int core_has_func_syms
= 0;
588 switch (core_bfd
->xvec
->flavour
)
592 case bfd_target_coff_flavour
:
593 case bfd_target_ecoff_flavour
:
594 case bfd_target_xcoff_flavour
:
595 case bfd_target_elf_flavour
:
596 case bfd_target_nlm_flavour
:
597 case bfd_target_som_flavour
:
598 core_has_func_syms
= 1;
601 /* Pass 1 - determine upper bound on number of function names. */
604 for (i
= 0; i
< core_num_syms
; ++i
)
606 if (!core_sym_class (core_syms
[i
]))
609 /* Don't create a symtab entry for a function that has
610 a mapping to a file, unless it's the first function
612 found
= (struct function_map
*) bsearch (core_syms
[i
]->name
, symbol_map
,
614 sizeof (struct function_map
),
615 search_mapped_symbol
);
616 if (found
== NULL
|| found
->is_first
)
622 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
626 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
628 /* Pass 2 - create symbols. */
629 symtab
.limit
= symtab
.base
;
631 for (i
= 0; i
< core_num_syms
; ++i
)
635 cxxclass
= core_sym_class (core_syms
[i
]);
640 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
641 (unsigned long) core_syms
[i
]->value
,
642 core_syms
[i
]->name
));
646 found
= (struct function_map
*) bsearch (core_syms
[i
]->name
, symbol_map
,
648 sizeof (struct function_map
), search_mapped_symbol
);
649 if (found
&& ! found
->is_first
)
652 sym_init (symtab
.limit
);
654 /* Symbol offsets are always section-relative. */
655 sym_sec
= core_syms
[i
]->section
;
656 symtab
.limit
->addr
= core_syms
[i
]->value
;
658 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
662 symtab
.limit
->name
= found
->file_name
;
663 symtab
.limit
->mapped
= 1;
667 symtab
.limit
->name
= core_syms
[i
]->name
;
668 symtab
.limit
->mapped
= 0;
671 /* Lookup filename and line number, if we can. */
673 const char * filename
;
674 const char * func_name
;
676 if (get_src_info (symtab
.limit
->addr
, & filename
, & func_name
,
677 & symtab
.limit
->line_num
))
679 symtab
.limit
->file
= source_file_lookup_path (filename
);
681 /* FIXME: Checking __osf__ here does not work with a cross
684 /* Suppress symbols that are not function names. This is
685 useful to suppress code-labels and aliases.
687 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
688 labels do not appear in the symbol table info, so this isn't
691 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
693 /* The symbol's address maps to a different name, so
694 it can't be a function-entry point. This happens
695 for labels, for example. */
697 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
698 symtab
.limit
->name
, func_name
));
705 symtab
.limit
->is_func
= (!core_has_func_syms
706 || (core_syms
[i
]->flags
& BSF_FUNCTION
) != 0);
707 symtab
.limit
->is_bb_head
= TRUE
;
710 symtab
.limit
->is_static
= TRUE
;
712 /* Keep track of the minimum and maximum vma addresses used by all
713 symbols. When computing the max_vma, use the ending address of the
714 section containing the symbol, if available. */
715 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
717 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
718 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
721 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
723 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
724 (long) (symtab
.limit
- symtab
.base
),
726 (unsigned long) symtab
.limit
->addr
));
730 symtab
.len
= symtab
.limit
- symtab
.base
;
731 symtab_finalize (&symtab
);
734 /* Read in symbol table from core.
735 One symbol per line of source code is entered. */
738 core_create_line_syms (void)
740 char *prev_name
, *prev_filename
;
741 unsigned int prev_name_len
, prev_filename_len
;
742 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
743 Sym
*prev
, dummy
, *sym
;
744 const char *filename
;
749 /* Create symbols for functions as usual. This is necessary in
750 cases where parts of a program were not compiled with -g. For
751 those parts we still want to get info at the function level. */
752 core_create_function_syms ();
754 /* Pass 1: count the number of symbols. */
756 /* To find all line information, walk through all possible
757 text-space addresses (one by one!) and get the debugging
758 info for each address. When the debugging info changes,
759 it is time to create a new symbol.
761 Of course, this is rather slow and it would be better if
762 BFD would provide an iterator for enumerating all line infos. */
763 prev_name_len
= PATH_MAX
;
764 prev_filename_len
= PATH_MAX
;
765 prev_name
= (char *) xmalloc (prev_name_len
);
766 prev_filename
= (char *) xmalloc (prev_filename_len
);
770 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
771 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
775 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
776 || (prev_line_num
== dummy
.line_num
778 && strcmp (prev_name
, dummy
.name
) == 0
779 && filename_cmp (prev_filename
, filename
) == 0))
783 prev_line_num
= dummy
.line_num
;
785 len
= strlen (dummy
.name
);
786 if (len
>= prev_name_len
)
788 prev_name_len
= len
+ 1024;
790 prev_name
= (char *) xmalloc (prev_name_len
);
793 strcpy (prev_name
, dummy
.name
);
794 len
= strlen (filename
);
796 if (len
>= prev_filename_len
)
798 prev_filename_len
= len
+ 1024;
799 free (prev_filename
);
800 prev_filename
= (char *) xmalloc (prev_filename_len
);
803 strcpy (prev_filename
, filename
);
805 min_vma
= MIN (vma
, min_vma
);
806 max_vma
= MAX (vma
, max_vma
);
810 free (prev_filename
);
812 /* Make room for function symbols, too. */
813 ltab
.len
+= symtab
.len
;
814 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
815 ltab
.limit
= ltab
.base
;
817 /* Pass 2 - create symbols. */
819 /* We now set is_static as we go along, rather than by running
820 through the symbol table at the end.
822 The old way called symtab_finalize before the is_static pass,
823 causing a problem since symtab_finalize uses is_static as part of
824 its address conflict resolution algorithm. Since global symbols
825 were prefered over static symbols, and all line symbols were
826 global at that point, static function names that conflicted with
827 their own line numbers (static, but labeled as global) were
828 rejected in favor of the line num.
830 This was not the desired functionality. We always want to keep
831 our function symbols and discard any conflicting line symbols.
832 Perhaps symtab_finalize should be modified to make this
833 distinction as well, but the current fix works and the code is a
837 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
839 sym_init (ltab
.limit
);
841 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
842 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
843 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
844 && filename_cmp (prev
->file
->name
, filename
) == 0))
847 /* Make name pointer a malloc'ed string. */
848 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
849 ltab
.limit
->file
= source_file_lookup_path (filename
);
851 ltab
.limit
->addr
= vma
;
853 /* Set is_static based on the enclosing function, using either:
854 1) the previous symbol, if it's from the same function, or
855 2) a symtab lookup. */
856 if (prev
&& ltab
.limit
->file
== prev
->file
&&
857 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
859 ltab
.limit
->is_static
= prev
->is_static
;
863 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
865 ltab
.limit
->is_static
= sym
->is_static
;
870 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
871 (unsigned long) (ltab
.limit
- ltab
.base
),
873 (unsigned long) ltab
.limit
->addr
));
877 /* Copy in function symbols. */
878 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
879 ltab
.limit
+= symtab
.len
;
881 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
884 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
885 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
889 /* Finalize ltab and make it symbol table. */
890 symtab_finalize (<ab
);
This page took 0.046772 seconds and 4 git commands to generate.