3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
4 2010 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 "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
);
58 parse_error (const char *filename
)
60 fprintf (stderr
, _("%s: unable to parse mapping file %s.\n"), whoami
, filename
);
64 /* Compare two function_map structs based on function name.
65 We want to sort in ascending order. */
68 cmp_symbol_map (const void * l
, const void * r
)
70 return strcmp (((struct function_map
*) l
)->function_name
,
71 ((struct function_map
*) r
)->function_name
);
75 read_function_mappings (const char *filename
)
77 FILE * file
= fopen (filename
, "r");
84 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, filename
);
88 /* First parse the mapping file so we know how big we need to
89 make our tables. We also do some sanity checks at this
95 matches
= fscanf (file
, "%[^\n:]", dummy
);
97 parse_error (filename
);
99 /* Just skip messages about files with no symbols. */
100 if (!strncmp (dummy
, "No symbols in ", 14))
102 matches
= fscanf (file
, "\n");
104 parse_error (filename
);
108 /* Don't care what else is on this line at this point. */
109 matches
= fscanf (file
, "%[^\n]\n", dummy
);
111 parse_error (filename
);
115 /* Now we know how big we need to make our table. */
116 symbol_map
= ((struct function_map
*)
117 xmalloc (count
* sizeof (struct function_map
)));
119 /* Rewind the input file so we can read it again. */
122 /* Read each entry and put it into the table. */
129 matches
= fscanf (file
, "%[^\n:]", dummy
);
131 parse_error (filename
);
133 /* Just skip messages about files with no symbols. */
134 if (!strncmp (dummy
, "No symbols in ", 14))
136 matches
= fscanf (file
, "\n");
138 parse_error (filename
);
142 /* dummy has the filename, go ahead and copy it. */
143 symbol_map
[count
].file_name
= (char *) xmalloc (strlen (dummy
) + 1);
144 strcpy (symbol_map
[count
].file_name
, dummy
);
146 /* Now we need the function name. */
147 matches
= fscanf (file
, "%[^\n]\n", dummy
);
149 parse_error (filename
);
150 tmp
= strrchr (dummy
, ' ') + 1;
151 symbol_map
[count
].function_name
= (char *) xmalloc (strlen (tmp
) + 1);
152 strcpy (symbol_map
[count
].function_name
, tmp
);
156 /* Record the size of the map table for future reference. */
157 symbol_map_count
= count
;
159 for (i
= 0; i
< symbol_map_count
; ++i
)
160 if (i
== 0 || strcmp (symbol_map
[i
].file_name
, symbol_map
[i
- 1].file_name
))
161 symbol_map
[i
].is_first
= 1;
163 qsort (symbol_map
, symbol_map_count
, sizeof (struct function_map
), cmp_symbol_map
);
167 core_init (const char * aout_name
)
173 core_bfd
= bfd_openr (aout_name
, 0);
181 if (!bfd_check_format (core_bfd
, bfd_object
))
183 fprintf (stderr
, _("%s: %s: not in executable format\n"), whoami
, aout_name
);
187 /* Get core's text section. */
188 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
191 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
194 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
200 /* Read core's symbol table. */
202 /* This will probably give us more than we need, but that's ok. */
203 core_sym_bytes
= bfd_get_symtab_upper_bound (core_bfd
);
204 if (core_sym_bytes
< 0)
206 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
207 bfd_errmsg (bfd_get_error ()));
211 core_syms
= (asymbol
**) xmalloc (core_sym_bytes
);
212 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
214 if (core_num_syms
< 0)
216 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
217 bfd_errmsg (bfd_get_error ()));
221 synth_count
= bfd_get_synthetic_symtab (core_bfd
, core_num_syms
, core_syms
,
222 0, NULL
, &synthsyms
);
229 new_size
= (core_num_syms
+ synth_count
+ 1) * sizeof (*core_syms
);
230 core_syms
= (asymbol
**) xrealloc (core_syms
, new_size
);
231 symp
= core_syms
+ core_num_syms
;
232 core_num_syms
+= synth_count
;
233 for (i
= 0; i
< synth_count
; i
++)
234 *symp
++ = synthsyms
+ i
;
241 switch (bfd_get_arch (core_bfd
))
256 if (function_mapping_file
)
257 read_function_mappings (function_mapping_file
);
260 /* Read in the text space of an a.out file. */
263 core_get_text_space (bfd
*cbfd
)
265 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
267 if (!core_text_space
)
269 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
270 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
274 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
275 0, bfd_get_section_size (core_text_sect
)))
277 bfd_perror ("bfd_get_section_contents");
278 free (core_text_space
);
282 if (!core_text_space
)
283 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
288 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
290 if (core_text_space
== 0)
293 hist_clip_symbol_address (&p_lowpc
, &p_highpc
);
295 switch (bfd_get_arch (core_bfd
))
298 i386_find_call (parent
, p_lowpc
, p_highpc
);
302 alpha_find_call (parent
, p_lowpc
, p_highpc
);
306 vax_find_call (parent
, p_lowpc
, p_highpc
);
310 sparc_find_call (parent
, p_lowpc
, p_highpc
);
314 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
318 mips_find_call (parent
, p_lowpc
, p_highpc
);
322 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
323 whoami
, bfd_printable_name(core_bfd
));
325 /* Don't give the error more than once. */
326 ignore_direct_calls
= FALSE
;
330 /* Return class of symbol SYM. The returned class can be any of:
331 0 -> symbol is not interesting to us
332 'T' -> symbol is a global name
333 't' -> symbol is a local (static) name. */
336 core_sym_class (asymbol
*sym
)
343 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
346 /* Must be a text symbol, and static text symbols
347 don't qualify if ignore_static_funcs set. */
348 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
350 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
355 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
359 return i
; /* It's a global symbol. */
362 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
363 also be a data symbol. */
368 /* Not a static text symbol. */
369 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
374 /* Do some more filtering on static function-names. */
375 if (ignore_static_funcs
)
378 /* Can't zero-length name or funny characters in name, where
379 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
380 if (!sym
->name
|| sym
->name
[0] == '\0')
383 for (name
= sym
->name
; *name
; ++name
)
390 /* Allow GCC cloned functions. */
391 if (strlen (name
) > 7 && strncmp (name
, ".clone.", 7) == 0)
394 /* Do not discard nested subprograms (those
395 which end with .NNN, where N are digits). */
396 for (name
++; *name
; name
++)
397 if (! ISDIGIT (*name
))
404 /* On systems where the C compiler adds an underscore to all
405 names, static names without underscores seem usually to be
406 labels in hand written assembler in the library. We don't want
407 these names. This is certainly necessary on a Sparc running
408 SunOS 4.1 (try profiling a program that does a lot of
409 division). I don't know whether it has harmful side effects on
410 other systems. Perhaps it should be made configurable. */
411 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
413 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
414 /* GCC may add special symbols to help gdb figure out the file
415 language. We want to ignore these, since sometimes they mask
416 the real function. (dj@ctron) */
417 || !strncmp (sym
->name
, "__gnu_compiled", 14)
418 || !strncmp (sym
->name
, "___gnu_compiled", 15))
423 /* If the object file supports marking of function symbols, then
424 we can zap anything that doesn't have BSF_FUNCTION set. */
425 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
428 return 't'; /* It's a static text symbol. */
431 /* Get whatever source info we can get regarding address ADDR. */
434 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
436 const char *fname
= 0, *func_name
= 0;
439 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
440 addr
- core_text_sect
->vma
,
441 &fname
, &func_name
, (unsigned int *) &l
)
442 && fname
&& func_name
&& l
)
444 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
445 (unsigned long) addr
, fname
, l
, func_name
));
453 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
454 (unsigned long) addr
,
455 fname
? fname
: "<unknown>", l
,
456 func_name
? func_name
: "<unknown>"));
461 /* Return number of symbols in a symbol-table file. */
464 num_of_syms_in (FILE * f
)
466 const int BUFSIZE
= 1024;
467 char * buf
= (char *) xmalloc (BUFSIZE
);
468 char * address
= (char *) xmalloc (BUFSIZE
);
470 char * name
= (char *) xmalloc (BUFSIZE
);
473 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
475 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
476 if (type
== 't' || type
== 'T')
487 /* Read symbol table from a file. */
490 core_create_syms_from (const char * sym_table_file
)
492 const int BUFSIZE
= 1024;
493 char * buf
= (char *) xmalloc (BUFSIZE
);
494 char * address
= (char *) xmalloc (BUFSIZE
);
496 char * name
= (char *) xmalloc (BUFSIZE
);
497 bfd_vma min_vma
= ~(bfd_vma
) 0;
501 f
= fopen (sym_table_file
, "r");
504 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, sym_table_file
);
508 /* Pass 1 - determine upper bound on number of function names. */
509 symtab
.len
= num_of_syms_in (f
);
513 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, sym_table_file
);
517 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
519 /* Pass 2 - create symbols. */
520 symtab
.limit
= symtab
.base
;
522 if (fseek (f
, 0, SEEK_SET
) != 0)
524 perror (sym_table_file
);
528 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
530 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
531 if (type
!= 't' && type
!= 'T')
534 sym_init (symtab
.limit
);
536 sscanf (address
, "%" BFD_VMA_FMT
"x", &(symtab
.limit
->addr
) );
538 symtab
.limit
->name
= (char *) xmalloc (strlen (name
) + 1);
539 strcpy ((char *) symtab
.limit
->name
, name
);
540 symtab
.limit
->mapped
= 0;
541 symtab
.limit
->is_func
= TRUE
;
542 symtab
.limit
->is_bb_head
= TRUE
;
543 symtab
.limit
->is_static
= (type
== 't');
544 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
545 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
551 symtab
.len
= symtab
.limit
- symtab
.base
;
552 symtab_finalize (&symtab
);
560 search_mapped_symbol (const void * l
, const void * r
)
562 return strcmp ((const char *) l
, ((const struct function_map
*) r
)->function_name
);
565 /* Read in symbol table from core.
566 One symbol per function is entered. */
569 core_create_function_syms (void)
571 bfd_vma min_vma
= ~ (bfd_vma
) 0;
575 struct function_map
* found
;
577 /* Pass 1 - determine upper bound on number of function names. */
580 for (i
= 0; i
< core_num_syms
; ++i
)
582 if (!core_sym_class (core_syms
[i
]))
585 /* Don't create a symtab entry for a function that has
586 a mapping to a file, unless it's the first function
588 found
= (struct function_map
*) bsearch (core_syms
[i
]->name
, symbol_map
,
590 sizeof (struct function_map
),
591 search_mapped_symbol
);
592 if (found
== NULL
|| found
->is_first
)
598 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
602 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
604 /* Pass 2 - create symbols. */
605 symtab
.limit
= symtab
.base
;
607 for (i
= 0; i
< core_num_syms
; ++i
)
611 cxxclass
= core_sym_class (core_syms
[i
]);
616 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
617 (unsigned long) core_syms
[i
]->value
,
618 core_syms
[i
]->name
));
622 found
= (struct function_map
*) bsearch (core_syms
[i
]->name
, symbol_map
,
624 sizeof (struct function_map
), search_mapped_symbol
);
625 if (found
&& ! found
->is_first
)
628 sym_init (symtab
.limit
);
630 /* Symbol offsets are always section-relative. */
631 sym_sec
= core_syms
[i
]->section
;
632 symtab
.limit
->addr
= core_syms
[i
]->value
;
634 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
638 symtab
.limit
->name
= found
->file_name
;
639 symtab
.limit
->mapped
= 1;
643 symtab
.limit
->name
= core_syms
[i
]->name
;
644 symtab
.limit
->mapped
= 0;
647 /* Lookup filename and line number, if we can. */
649 const char * filename
;
650 const char * func_name
;
652 if (get_src_info (symtab
.limit
->addr
, & filename
, & func_name
,
653 & symtab
.limit
->line_num
))
655 symtab
.limit
->file
= source_file_lookup_path (filename
);
657 /* FIXME: Checking __osf__ here does not work with a cross
660 /* Suppress symbols that are not function names. This is
661 useful to suppress code-labels and aliases.
663 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
664 labels do not appear in the symbol table info, so this isn't
667 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
669 /* The symbol's address maps to a different name, so
670 it can't be a function-entry point. This happens
671 for labels, for example. */
673 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
674 symtab
.limit
->name
, func_name
));
681 symtab
.limit
->is_func
= (core_syms
[i
]->flags
& BSF_FUNCTION
) != 0;
682 symtab
.limit
->is_bb_head
= TRUE
;
685 symtab
.limit
->is_static
= TRUE
;
687 /* Keep track of the minimum and maximum vma addresses used by all
688 symbols. When computing the max_vma, use the ending address of the
689 section containing the symbol, if available. */
690 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
692 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
693 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
696 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
698 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
699 (long) (symtab
.limit
- symtab
.base
),
701 (unsigned long) symtab
.limit
->addr
));
705 symtab
.len
= symtab
.limit
- symtab
.base
;
706 symtab_finalize (&symtab
);
709 /* Read in symbol table from core.
710 One symbol per line of source code is entered. */
713 core_create_line_syms (void)
715 char *prev_name
, *prev_filename
;
716 unsigned int prev_name_len
, prev_filename_len
;
717 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
718 Sym
*prev
, dummy
, *sym
;
719 const char *filename
;
724 /* Create symbols for functions as usual. This is necessary in
725 cases where parts of a program were not compiled with -g. For
726 those parts we still want to get info at the function level. */
727 core_create_function_syms ();
729 /* Pass 1: count the number of symbols. */
731 /* To find all line information, walk through all possible
732 text-space addresses (one by one!) and get the debugging
733 info for each address. When the debugging info changes,
734 it is time to create a new symbol.
736 Of course, this is rather slow and it would be better if
737 BFD would provide an iterator for enumerating all line infos. */
738 prev_name_len
= PATH_MAX
;
739 prev_filename_len
= PATH_MAX
;
740 prev_name
= (char *) xmalloc (prev_name_len
);
741 prev_filename
= (char *) xmalloc (prev_filename_len
);
745 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
746 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
750 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
751 || (prev_line_num
== dummy
.line_num
753 && strcmp (prev_name
, dummy
.name
) == 0
754 && strcmp (prev_filename
, filename
) == 0))
758 prev_line_num
= dummy
.line_num
;
760 len
= strlen (dummy
.name
);
761 if (len
>= prev_name_len
)
763 prev_name_len
= len
+ 1024;
765 prev_name
= (char *) xmalloc (prev_name_len
);
768 strcpy (prev_name
, dummy
.name
);
769 len
= strlen (filename
);
771 if (len
>= prev_filename_len
)
773 prev_filename_len
= len
+ 1024;
774 free (prev_filename
);
775 prev_filename
= (char *) xmalloc (prev_filename_len
);
778 strcpy (prev_filename
, filename
);
780 min_vma
= MIN (vma
, min_vma
);
781 max_vma
= MAX (vma
, max_vma
);
785 free (prev_filename
);
787 /* Make room for function symbols, too. */
788 ltab
.len
+= symtab
.len
;
789 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
790 ltab
.limit
= ltab
.base
;
792 /* Pass 2 - create symbols. */
794 /* We now set is_static as we go along, rather than by running
795 through the symbol table at the end.
797 The old way called symtab_finalize before the is_static pass,
798 causing a problem since symtab_finalize uses is_static as part of
799 its address conflict resolution algorithm. Since global symbols
800 were prefered over static symbols, and all line symbols were
801 global at that point, static function names that conflicted with
802 their own line numbers (static, but labeled as global) were
803 rejected in favor of the line num.
805 This was not the desired functionality. We always want to keep
806 our function symbols and discard any conflicting line symbols.
807 Perhaps symtab_finalize should be modified to make this
808 distinction as well, but the current fix works and the code is a
812 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
814 sym_init (ltab
.limit
);
816 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
817 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
818 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
819 && strcmp (prev
->file
->name
, filename
) == 0))
822 /* Make name pointer a malloc'ed string. */
823 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
824 ltab
.limit
->file
= source_file_lookup_path (filename
);
826 ltab
.limit
->addr
= vma
;
828 /* Set is_static based on the enclosing function, using either:
829 1) the previous symbol, if it's from the same function, or
830 2) a symtab lookup. */
831 if (prev
&& ltab
.limit
->file
== prev
->file
&&
832 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
834 ltab
.limit
->is_static
= prev
->is_static
;
838 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
840 ltab
.limit
->is_static
= sym
->is_static
;
845 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
846 (unsigned long) (ltab
.limit
- ltab
.base
),
848 (unsigned long) ltab
.limit
->addr
));
852 /* Copy in function symbols. */
853 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
854 ltab
.limit
+= symtab
.len
;
856 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
859 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
860 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
864 /* Finalize ltab and make it symbol table. */
865 symtab_finalize (<ab
);
This page took 0.058764 seconds and 4 git commands to generate.