3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 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
)
388 /* Do not discard nested subprograms (those
389 which end with .NNN, where N are digits). */
391 for (name
++; *name
; name
++)
392 if (! ISDIGIT (*name
))
396 /* On systems where the C compiler adds an underscore to all
397 names, static names without underscores seem usually to be
398 labels in hand written assembler in the library. We don't want
399 these names. This is certainly necessary on a Sparc running
400 SunOS 4.1 (try profiling a program that does a lot of
401 division). I don't know whether it has harmful side effects on
402 other systems. Perhaps it should be made configurable. */
403 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
405 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
406 /* GCC may add special symbols to help gdb figure out the file
407 language. We want to ignore these, since sometimes they mask
408 the real function. (dj@ctron) */
409 || !strncmp (sym
->name
, "__gnu_compiled", 14)
410 || !strncmp (sym
->name
, "___gnu_compiled", 15))
415 /* If the object file supports marking of function symbols, then
416 we can zap anything that doesn't have BSF_FUNCTION set. */
417 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
420 return 't'; /* It's a static text symbol. */
423 /* Get whatever source info we can get regarding address ADDR. */
426 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
428 const char *fname
= 0, *func_name
= 0;
431 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
432 addr
- core_text_sect
->vma
,
433 &fname
, &func_name
, (unsigned int *) &l
)
434 && fname
&& func_name
&& l
)
436 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
437 (unsigned long) addr
, fname
, l
, func_name
));
445 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
446 (unsigned long) addr
,
447 fname
? fname
: "<unknown>", l
,
448 func_name
? func_name
: "<unknown>"));
453 /* Return number of symbols in a symbol-table file. */
456 num_of_syms_in (FILE * f
)
458 const int BUFSIZE
= 1024;
459 char * buf
= (char *) xmalloc (BUFSIZE
);
460 char * address
= (char *) xmalloc (BUFSIZE
);
462 char * name
= (char *) xmalloc (BUFSIZE
);
465 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
467 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
468 if (type
== 't' || type
== 'T')
479 /* Read symbol table from a file. */
482 core_create_syms_from (const char * sym_table_file
)
484 const int BUFSIZE
= 1024;
485 char * buf
= (char *) xmalloc (BUFSIZE
);
486 char * address
= (char *) xmalloc (BUFSIZE
);
488 char * name
= (char *) xmalloc (BUFSIZE
);
489 bfd_vma min_vma
= ~(bfd_vma
) 0;
493 f
= fopen (sym_table_file
, "r");
496 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, sym_table_file
);
500 /* Pass 1 - determine upper bound on number of function names. */
501 symtab
.len
= num_of_syms_in (f
);
505 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, sym_table_file
);
509 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
511 /* Pass 2 - create symbols. */
512 symtab
.limit
= symtab
.base
;
514 if (fseek (f
, 0, SEEK_SET
) != 0)
516 perror (sym_table_file
);
520 while (!feof (f
) && fgets (buf
, sizeof (buf
), f
))
522 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
523 if (type
!= 't' && type
!= 'T')
526 sym_init (symtab
.limit
);
528 sscanf (address
, "%" BFD_VMA_FMT
"x", &(symtab
.limit
->addr
) );
530 symtab
.limit
->name
= (char *) xmalloc (strlen (name
) + 1);
531 strcpy ((char *) symtab
.limit
->name
, name
);
532 symtab
.limit
->mapped
= 0;
533 symtab
.limit
->is_func
= TRUE
;
534 symtab
.limit
->is_bb_head
= TRUE
;
535 symtab
.limit
->is_static
= (type
== 't');
536 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
537 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
543 symtab
.len
= symtab
.limit
- symtab
.base
;
544 symtab_finalize (&symtab
);
552 search_mapped_symbol (const void * l
, const void * r
)
554 return strcmp ((const char *) l
, ((const struct function_map
*) r
)->function_name
);
557 /* Read in symbol table from core.
558 One symbol per function is entered. */
561 core_create_function_syms (void)
563 bfd_vma min_vma
= ~ (bfd_vma
) 0;
567 struct function_map
* found
;
569 /* Pass 1 - determine upper bound on number of function names. */
572 for (i
= 0; i
< core_num_syms
; ++i
)
574 if (!core_sym_class (core_syms
[i
]))
577 /* Don't create a symtab entry for a function that has
578 a mapping to a file, unless it's the first function
580 found
= (struct function_map
*) bsearch (core_syms
[i
]->name
, symbol_map
,
582 sizeof (struct function_map
),
583 search_mapped_symbol
);
584 if (found
== NULL
|| found
->is_first
)
590 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
594 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
596 /* Pass 2 - create symbols. */
597 symtab
.limit
= symtab
.base
;
599 for (i
= 0; i
< core_num_syms
; ++i
)
603 cxxclass
= core_sym_class (core_syms
[i
]);
608 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
609 (unsigned long) core_syms
[i
]->value
,
610 core_syms
[i
]->name
));
614 found
= (struct function_map
*) bsearch (core_syms
[i
]->name
, symbol_map
,
616 sizeof (struct function_map
), search_mapped_symbol
);
617 if (found
&& ! found
->is_first
)
620 sym_init (symtab
.limit
);
622 /* Symbol offsets are always section-relative. */
623 sym_sec
= core_syms
[i
]->section
;
624 symtab
.limit
->addr
= core_syms
[i
]->value
;
626 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
630 symtab
.limit
->name
= found
->file_name
;
631 symtab
.limit
->mapped
= 1;
635 symtab
.limit
->name
= core_syms
[i
]->name
;
636 symtab
.limit
->mapped
= 0;
639 /* Lookup filename and line number, if we can. */
641 const char * filename
;
642 const char * func_name
;
644 if (get_src_info (symtab
.limit
->addr
, & filename
, & func_name
,
645 & symtab
.limit
->line_num
))
647 symtab
.limit
->file
= source_file_lookup_path (filename
);
649 /* FIXME: Checking __osf__ here does not work with a cross
652 /* Suppress symbols that are not function names. This is
653 useful to suppress code-labels and aliases.
655 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
656 labels do not appear in the symbol table info, so this isn't
659 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
661 /* The symbol's address maps to a different name, so
662 it can't be a function-entry point. This happens
663 for labels, for example. */
665 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
666 symtab
.limit
->name
, func_name
));
673 symtab
.limit
->is_func
= (core_syms
[i
]->flags
& BSF_FUNCTION
) != 0;
674 symtab
.limit
->is_bb_head
= TRUE
;
677 symtab
.limit
->is_static
= TRUE
;
679 /* Keep track of the minimum and maximum vma addresses used by all
680 symbols. When computing the max_vma, use the ending address of the
681 section containing the symbol, if available. */
682 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
684 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
685 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
688 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
690 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
691 (long) (symtab
.limit
- symtab
.base
),
693 (unsigned long) symtab
.limit
->addr
));
697 symtab
.len
= symtab
.limit
- symtab
.base
;
698 symtab_finalize (&symtab
);
701 /* Read in symbol table from core.
702 One symbol per line of source code is entered. */
705 core_create_line_syms (void)
707 char *prev_name
, *prev_filename
;
708 unsigned int prev_name_len
, prev_filename_len
;
709 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
710 Sym
*prev
, dummy
, *sym
;
711 const char *filename
;
716 /* Create symbols for functions as usual. This is necessary in
717 cases where parts of a program were not compiled with -g. For
718 those parts we still want to get info at the function level. */
719 core_create_function_syms ();
721 /* Pass 1: count the number of symbols. */
723 /* To find all line information, walk through all possible
724 text-space addresses (one by one!) and get the debugging
725 info for each address. When the debugging info changes,
726 it is time to create a new symbol.
728 Of course, this is rather slow and it would be better if
729 BFD would provide an iterator for enumerating all line infos. */
730 prev_name_len
= PATH_MAX
;
731 prev_filename_len
= PATH_MAX
;
732 prev_name
= (char *) xmalloc (prev_name_len
);
733 prev_filename
= (char *) xmalloc (prev_filename_len
);
737 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
738 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
742 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
743 || (prev_line_num
== dummy
.line_num
745 && strcmp (prev_name
, dummy
.name
) == 0
746 && strcmp (prev_filename
, filename
) == 0))
750 prev_line_num
= dummy
.line_num
;
752 len
= strlen (dummy
.name
);
753 if (len
>= prev_name_len
)
755 prev_name_len
= len
+ 1024;
757 prev_name
= (char *) xmalloc (prev_name_len
);
760 strcpy (prev_name
, dummy
.name
);
761 len
= strlen (filename
);
763 if (len
>= prev_filename_len
)
765 prev_filename_len
= len
+ 1024;
766 free (prev_filename
);
767 prev_filename
= (char *) xmalloc (prev_filename_len
);
770 strcpy (prev_filename
, filename
);
772 min_vma
= MIN (vma
, min_vma
);
773 max_vma
= MAX (vma
, max_vma
);
777 free (prev_filename
);
779 /* Make room for function symbols, too. */
780 ltab
.len
+= symtab
.len
;
781 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
782 ltab
.limit
= ltab
.base
;
784 /* Pass 2 - create symbols. */
786 /* We now set is_static as we go along, rather than by running
787 through the symbol table at the end.
789 The old way called symtab_finalize before the is_static pass,
790 causing a problem since symtab_finalize uses is_static as part of
791 its address conflict resolution algorithm. Since global symbols
792 were prefered over static symbols, and all line symbols were
793 global at that point, static function names that conflicted with
794 their own line numbers (static, but labeled as global) were
795 rejected in favor of the line num.
797 This was not the desired functionality. We always want to keep
798 our function symbols and discard any conflicting line symbols.
799 Perhaps symtab_finalize should be modified to make this
800 distinction as well, but the current fix works and the code is a
804 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
806 sym_init (ltab
.limit
);
808 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
809 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
810 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
811 && strcmp (prev
->file
->name
, filename
) == 0))
814 /* Make name pointer a malloc'ed string. */
815 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
816 ltab
.limit
->file
= source_file_lookup_path (filename
);
818 ltab
.limit
->addr
= vma
;
820 /* Set is_static based on the enclosing function, using either:
821 1) the previous symbol, if it's from the same function, or
822 2) a symtab lookup. */
823 if (prev
&& ltab
.limit
->file
== prev
->file
&&
824 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
826 ltab
.limit
->is_static
= prev
->is_static
;
830 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
832 ltab
.limit
->is_static
= sym
->is_static
;
837 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
838 (unsigned long) (ltab
.limit
- ltab
.base
),
840 (unsigned long) ltab
.limit
->addr
));
844 /* Copy in function symbols. */
845 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
846 ltab
.limit
+= symtab
.len
;
848 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
851 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
852 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
856 /* Finalize ltab and make it symbol table. */
857 symtab_finalize (<ab
);
This page took 0.046525 seconds and 4 git commands to generate.