3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
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
23 #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
;
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
);
65 read_function_mappings (const char *filename
)
67 FILE *file
= fopen (filename
, "r");
73 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, filename
);
77 /* First parse the mapping file so we know how big we need to
78 make our tables. We also do some sanity checks at this
84 matches
= fscanf (file
, "%[^\n:]", dummy
);
86 parse_error (filename
);
88 /* Just skip messages about files with no symbols. */
89 if (!strncmp (dummy
, "No symbols in ", 14))
91 matches
= fscanf (file
, "\n");
93 parse_error (filename
);
97 /* Don't care what else is on this line at this point. */
98 matches
= fscanf (file
, "%[^\n]\n", dummy
);
100 parse_error (filename
);
104 /* Now we know how big we need to make our table. */
105 symbol_map
= ((struct function_map
*)
106 xmalloc (count
* sizeof (struct function_map
)));
108 /* Rewind the input file so we can read it again. */
111 /* Read each entry and put it into the table. */
118 matches
= fscanf (file
, "%[^\n:]", dummy
);
120 parse_error (filename
);
122 /* Just skip messages about files with no symbols. */
123 if (!strncmp (dummy
, "No symbols in ", 14))
125 matches
= fscanf (file
, "\n");
127 parse_error (filename
);
131 /* dummy has the filename, go ahead and copy it. */
132 symbol_map
[count
].file_name
= xmalloc (strlen (dummy
) + 1);
133 strcpy (symbol_map
[count
].file_name
, dummy
);
135 /* Now we need the function name. */
136 matches
= fscanf (file
, "%[^\n]\n", dummy
);
138 parse_error (filename
);
139 tmp
= strrchr (dummy
, ' ') + 1;
140 symbol_map
[count
].function_name
= xmalloc (strlen (tmp
) + 1);
141 strcpy (symbol_map
[count
].function_name
, tmp
);
145 /* Record the size of the map table for future reference. */
146 symbol_map_count
= count
;
151 core_init (const char *aout_name
)
157 core_bfd
= bfd_openr (aout_name
, 0);
165 if (!bfd_check_format (core_bfd
, bfd_object
))
167 fprintf (stderr
, _("%s: %s: not in executable format\n"), whoami
, aout_name
);
171 /* Get core's text section. */
172 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
175 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
178 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
184 /* Read core's symbol table. */
186 /* This will probably give us more than we need, but that's ok. */
187 core_sym_bytes
= bfd_get_symtab_upper_bound (core_bfd
);
188 if (core_sym_bytes
< 0)
190 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
191 bfd_errmsg (bfd_get_error ()));
195 core_syms
= (asymbol
**) xmalloc (core_sym_bytes
);
196 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
198 if (core_num_syms
< 0)
200 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
201 bfd_errmsg (bfd_get_error ()));
205 synth_count
= bfd_get_synthetic_symtab (core_bfd
, core_num_syms
, core_syms
,
206 0, NULL
, &synthsyms
);
213 new_size
= (core_num_syms
+ synth_count
+ 1) * sizeof (*core_syms
);
214 core_syms
= xrealloc (core_syms
, new_size
);
215 symp
= core_syms
+ core_num_syms
;
216 core_num_syms
+= synth_count
;
217 for (i
= 0; i
< synth_count
; i
++)
218 *symp
++ = synthsyms
+ i
;
225 switch (bfd_get_arch (core_bfd
))
240 if (function_mapping_file
)
241 read_function_mappings (function_mapping_file
);
244 /* Read in the text space of an a.out file. */
247 core_get_text_space (bfd
*cbfd
)
249 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
251 if (!core_text_space
)
253 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
254 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
258 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
259 0, bfd_get_section_size (core_text_sect
)))
261 bfd_perror ("bfd_get_section_contents");
262 free (core_text_space
);
266 if (!core_text_space
)
267 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
272 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
274 if (core_text_space
== 0)
277 hist_clip_symbol_address (&p_lowpc
, &p_highpc
);
279 switch (bfd_get_arch (core_bfd
))
282 i386_find_call (parent
, p_lowpc
, p_highpc
);
286 alpha_find_call (parent
, p_lowpc
, p_highpc
);
290 vax_find_call (parent
, p_lowpc
, p_highpc
);
294 sparc_find_call (parent
, p_lowpc
, p_highpc
);
298 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
302 mips_find_call (parent
, p_lowpc
, p_highpc
);
306 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
307 whoami
, bfd_printable_name(core_bfd
));
309 /* Don't give the error more than once. */
310 ignore_direct_calls
= FALSE
;
314 /* Return class of symbol SYM. The returned class can be any of:
315 0 -> symbol is not interesting to us
316 'T' -> symbol is a global name
317 't' -> symbol is a local (static) name. */
320 core_sym_class (asymbol
*sym
)
327 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
330 /* Must be a text symbol, and static text symbols
331 don't qualify if ignore_static_funcs set. */
332 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
334 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
339 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
343 return i
; /* It's a global symbol. */
346 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
347 also be a data symbol. */
352 /* Not a static text symbol. */
353 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
358 /* Do some more filtering on static function-names. */
359 if (ignore_static_funcs
)
362 /* Can't zero-length name or funny characters in name, where
363 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
364 if (!sym
->name
|| sym
->name
[0] == '\0')
367 for (name
= sym
->name
; *name
; ++name
)
372 /* Do not discard nested subprograms (those
373 which end with .NNN, where N are digits). */
375 for (name
++; *name
; name
++)
376 if (! ISDIGIT (*name
))
380 /* On systems where the C compiler adds an underscore to all
381 names, static names without underscores seem usually to be
382 labels in hand written assembler in the library. We don't want
383 these names. This is certainly necessary on a Sparc running
384 SunOS 4.1 (try profiling a program that does a lot of
385 division). I don't know whether it has harmful side effects on
386 other systems. Perhaps it should be made configurable. */
387 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
389 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
390 /* GCC may add special symbols to help gdb figure out the file
391 language. We want to ignore these, since sometimes they mask
392 the real function. (dj@ctron) */
393 || !strncmp (sym
->name
, "__gnu_compiled", 14)
394 || !strncmp (sym
->name
, "___gnu_compiled", 15))
399 /* If the object file supports marking of function symbols, then
400 we can zap anything that doesn't have BSF_FUNCTION set. */
401 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
404 return 't'; /* It's a static text symbol. */
407 /* Get whatever source info we can get regarding address ADDR. */
410 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
412 const char *fname
= 0, *func_name
= 0;
415 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
416 addr
- core_text_sect
->vma
,
417 &fname
, &func_name
, (unsigned int *) &l
)
418 && fname
&& func_name
&& l
)
420 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
421 (unsigned long) addr
, fname
, l
, func_name
));
429 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
430 (long) addr
, fname
? fname
: "<unknown>", l
,
431 func_name
? func_name
: "<unknown>"));
436 /* Read in symbol table from core.
437 One symbol per function is entered. */
440 core_create_function_syms ()
442 bfd_vma min_vma
= ~(bfd_vma
) 0;
448 /* Pass 1 - determine upper bound on number of function names. */
451 for (i
= 0; i
< core_num_syms
; ++i
)
453 if (!core_sym_class (core_syms
[i
]))
456 /* This should be replaced with a binary search or hashed
459 Don't create a symtab entry for a function that has
460 a mapping to a file, unless it's the first function
463 for (j
= 0; j
< symbol_map_count
; j
++)
464 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
466 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
467 symbol_map
[j
- 1].file_name
))
478 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
482 /* The "+ 2" is for the sentinels. */
483 symtab
.base
= (Sym
*) xmalloc ((symtab
.len
+ 2) * sizeof (Sym
));
485 /* Pass 2 - create symbols. */
486 symtab
.limit
= symtab
.base
;
488 for (i
= 0; i
< core_num_syms
; ++i
)
492 class = core_sym_class (core_syms
[i
]);
497 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
498 (unsigned long) core_syms
[i
]->value
,
499 core_syms
[i
]->name
));
503 /* This should be replaced with a binary search or hashed
508 for (j
= 0; j
< symbol_map_count
; j
++)
509 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
511 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
512 symbol_map
[j
- 1].file_name
))
522 sym_init (symtab
.limit
);
524 /* Symbol offsets are always section-relative. */
525 sym_sec
= core_syms
[i
]->section
;
526 symtab
.limit
->addr
= core_syms
[i
]->value
;
528 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
531 && !strcmp (core_syms
[i
]->name
, symbol_map
[found
].function_name
))
533 symtab
.limit
->name
= symbol_map
[found
].file_name
;
534 symtab
.limit
->mapped
= 1;
538 symtab
.limit
->name
= core_syms
[i
]->name
;
539 symtab
.limit
->mapped
= 0;
542 /* Lookup filename and line number, if we can. */
544 const char *filename
, *func_name
;
546 if (get_src_info (symtab
.limit
->addr
, &filename
, &func_name
,
547 &symtab
.limit
->line_num
))
549 symtab
.limit
->file
= source_file_lookup_path (filename
);
551 /* FIXME: Checking __osf__ here does not work with a cross
554 /* Suppress symbols that are not function names. This is
555 useful to suppress code-labels and aliases.
557 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
558 labels do not appear in the symbol table info, so this isn't
561 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
563 /* The symbol's address maps to a different name, so
564 it can't be a function-entry point. This happens
565 for labels, for example. */
567 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
568 symtab
.limit
->name
, func_name
));
575 symtab
.limit
->is_func
= TRUE
;
576 symtab
.limit
->is_bb_head
= TRUE
;
579 symtab
.limit
->is_static
= TRUE
;
581 /* Keep track of the minimum and maximum vma addresses used by all
582 symbols. When computing the max_vma, use the ending address of the
583 section containing the symbol, if available. */
584 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
586 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
587 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
590 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
592 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
593 (long) (symtab
.limit
- symtab
.base
),
595 (unsigned long) symtab
.limit
->addr
));
599 /* Create sentinels. */
600 sym_init (symtab
.limit
);
601 symtab
.limit
->name
= "<locore>";
602 symtab
.limit
->addr
= 0;
603 symtab
.limit
->end_addr
= min_vma
- 1;
606 sym_init (symtab
.limit
);
607 symtab
.limit
->name
= "<hicore>";
608 symtab
.limit
->addr
= max_vma
+ 1;
609 symtab
.limit
->end_addr
= ~(bfd_vma
) 0;
612 symtab
.len
= symtab
.limit
- symtab
.base
;
613 symtab_finalize (&symtab
);
616 /* Read in symbol table from core.
617 One symbol per line of source code is entered. */
620 core_create_line_syms ()
622 char *prev_name
, *prev_filename
;
623 unsigned int prev_name_len
, prev_filename_len
;
624 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
625 Sym
*prev
, dummy
, *sentinel
, *sym
;
626 const char *filename
;
631 /* Create symbols for functions as usual. This is necessary in
632 cases where parts of a program were not compiled with -g. For
633 those parts we still want to get info at the function level. */
634 core_create_function_syms ();
636 /* Pass 1: count the number of symbols. */
638 /* To find all line information, walk through all possible
639 text-space addresses (one by one!) and get the debugging
640 info for each address. When the debugging info changes,
641 it is time to create a new symbol.
643 Of course, this is rather slow and it would be better if
644 BFD would provide an iterator for enumerating all line infos. */
645 prev_name_len
= PATH_MAX
;
646 prev_filename_len
= PATH_MAX
;
647 prev_name
= xmalloc (prev_name_len
);
648 prev_filename
= xmalloc (prev_filename_len
);
652 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
653 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
657 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
658 || (prev_line_num
== dummy
.line_num
660 && strcmp (prev_name
, dummy
.name
) == 0
661 && strcmp (prev_filename
, filename
) == 0))
665 prev_line_num
= dummy
.line_num
;
667 len
= strlen (dummy
.name
);
668 if (len
>= prev_name_len
)
670 prev_name_len
= len
+ 1024;
672 prev_name
= xmalloc (prev_name_len
);
675 strcpy (prev_name
, dummy
.name
);
676 len
= strlen (filename
);
678 if (len
>= prev_filename_len
)
680 prev_filename_len
= len
+ 1024;
681 free (prev_filename
);
682 prev_filename
= xmalloc (prev_filename_len
);
685 strcpy (prev_filename
, filename
);
687 min_vma
= MIN (vma
, min_vma
);
688 max_vma
= MAX (vma
, max_vma
);
692 free (prev_filename
);
694 /* Make room for function symbols, too. */
695 ltab
.len
+= symtab
.len
;
696 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
697 ltab
.limit
= ltab
.base
;
699 /* Pass 2 - create symbols. */
701 /* We now set is_static as we go along, rather than by running
702 through the symbol table at the end.
704 The old way called symtab_finalize before the is_static pass,
705 causing a problem since symtab_finalize uses is_static as part of
706 its address conflict resolution algorithm. Since global symbols
707 were prefered over static symbols, and all line symbols were
708 global at that point, static function names that conflicted with
709 their own line numbers (static, but labeled as global) were
710 rejected in favor of the line num.
712 This was not the desired functionality. We always want to keep
713 our function symbols and discard any conflicting line symbols.
714 Perhaps symtab_finalize should be modified to make this
715 distinction as well, but the current fix works and the code is a
719 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
721 sym_init (ltab
.limit
);
723 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
724 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
725 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
726 && strcmp (prev
->file
->name
, filename
) == 0))
729 /* Make name pointer a malloc'ed string. */
730 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
731 ltab
.limit
->file
= source_file_lookup_path (filename
);
733 ltab
.limit
->addr
= vma
;
735 /* Set is_static based on the enclosing function, using either:
736 1) the previous symbol, if it's from the same function, or
737 2) a symtab lookup. */
738 if (prev
&& ltab
.limit
->file
== prev
->file
&&
739 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
741 ltab
.limit
->is_static
= prev
->is_static
;
745 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
746 ltab
.limit
->is_static
= sym
->is_static
;
751 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
752 (unsigned long) (ltab
.limit
- ltab
.base
),
754 (unsigned long) ltab
.limit
->addr
));
758 /* Update sentinels. */
759 sentinel
= sym_lookup (&symtab
, (bfd_vma
) 0);
762 && strcmp (sentinel
->name
, "<locore>") == 0
763 && min_vma
<= sentinel
->end_addr
)
764 sentinel
->end_addr
= min_vma
- 1;
766 sentinel
= sym_lookup (&symtab
, ~(bfd_vma
) 0);
769 && strcmp (sentinel
->name
, "<hicore>") == 0
770 && max_vma
>= sentinel
->addr
)
771 sentinel
->addr
= max_vma
+ 1;
773 /* Copy in function symbols. */
774 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
775 ltab
.limit
+= symtab
.len
;
777 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
780 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
781 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
785 /* Finalize ltab and make it symbol table. */
786 symtab_finalize (<ab
);
This page took 0.04787 seconds and 4 git commands to generate.