3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
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 2 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"
32 static int core_num_syms
;
33 static asymbol
**core_syms
;
34 asection
*core_text_sect
;
37 static int min_insn_size
;
40 /* For mapping symbols to specific .o files during file ordering. */
41 struct function_map
*symbol_map
;
42 unsigned int symbol_map_count
;
44 static void read_function_mappings (const char *);
45 static int core_sym_class (asymbol
*);
46 static bfd_boolean get_src_info
47 (bfd_vma
, const char **, const char **, int *);
49 extern void i386_find_call (Sym
*, bfd_vma
, bfd_vma
);
50 extern void alpha_find_call (Sym
*, bfd_vma
, bfd_vma
);
51 extern void vax_find_call (Sym
*, bfd_vma
, bfd_vma
);
52 extern void tahoe_find_call (Sym
*, bfd_vma
, bfd_vma
);
53 extern void sparc_find_call (Sym
*, bfd_vma
, bfd_vma
);
54 extern void mips_find_call (Sym
*, bfd_vma
, bfd_vma
);
57 parse_error (const char *filename
)
59 fprintf (stderr
, _("%s: unable to parse mapping file %s.\n"), whoami
, filename
);
64 read_function_mappings (const char *filename
)
66 FILE *file
= fopen (filename
, "r");
72 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, filename
);
76 /* First parse the mapping file so we know how big we need to
77 make our tables. We also do some sanity checks at this
83 matches
= fscanf (file
, "%[^\n:]", dummy
);
85 parse_error (filename
);
87 /* Just skip messages about files with no symbols. */
88 if (!strncmp (dummy
, "No symbols in ", 14))
90 matches
= fscanf (file
, "\n");
92 parse_error (filename
);
96 /* Don't care what else is on this line at this point. */
97 matches
= fscanf (file
, "%[^\n]\n", dummy
);
99 parse_error (filename
);
103 /* Now we know how big we need to make our table. */
104 symbol_map
= ((struct function_map
*)
105 xmalloc (count
* sizeof (struct function_map
)));
107 /* Rewind the input file so we can read it again. */
110 /* Read each entry and put it into the table. */
117 matches
= fscanf (file
, "%[^\n:]", dummy
);
119 parse_error (filename
);
121 /* Just skip messages about files with no symbols. */
122 if (!strncmp (dummy
, "No symbols in ", 14))
124 matches
= fscanf (file
, "\n");
126 parse_error (filename
);
130 /* dummy has the filename, go ahead and copy it. */
131 symbol_map
[count
].file_name
= xmalloc (strlen (dummy
) + 1);
132 strcpy (symbol_map
[count
].file_name
, dummy
);
134 /* Now we need the function name. */
135 matches
= fscanf (file
, "%[^\n]\n", dummy
);
137 parse_error (filename
);
138 tmp
= strrchr (dummy
, ' ') + 1;
139 symbol_map
[count
].function_name
= xmalloc (strlen (tmp
) + 1);
140 strcpy (symbol_map
[count
].function_name
, tmp
);
144 /* Record the size of the map table for future reference. */
145 symbol_map_count
= count
;
150 core_init (const char *aout_name
)
156 core_bfd
= bfd_openr (aout_name
, 0);
164 if (!bfd_check_format (core_bfd
, bfd_object
))
166 fprintf (stderr
, _("%s: %s: not in executable format\n"), whoami
, aout_name
);
170 /* Get core's text section. */
171 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
174 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
177 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
183 /* Read core's symbol table. */
185 /* This will probably give us more than we need, but that's ok. */
186 core_sym_bytes
= bfd_get_symtab_upper_bound (core_bfd
);
187 if (core_sym_bytes
< 0)
189 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
190 bfd_errmsg (bfd_get_error ()));
194 core_syms
= (asymbol
**) xmalloc (core_sym_bytes
);
195 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
197 if (core_num_syms
< 0)
199 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
200 bfd_errmsg (bfd_get_error ()));
204 synth_count
= bfd_get_synthetic_symtab (core_bfd
, core_num_syms
, core_syms
,
205 0, NULL
, &synthsyms
);
212 new_size
= (core_num_syms
+ synth_count
+ 1) * sizeof (*core_syms
);
213 core_syms
= xrealloc (core_syms
, new_size
);
214 symp
= core_syms
+ core_num_syms
;
215 core_num_syms
+= synth_count
;
216 for (i
= 0; i
< synth_count
; i
++)
217 *symp
++ = synthsyms
+ i
;
224 switch (bfd_get_arch (core_bfd
))
239 if (function_mapping_file
)
240 read_function_mappings (function_mapping_file
);
243 /* Read in the text space of an a.out file. */
246 core_get_text_space (bfd
*cbfd
)
248 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
250 if (!core_text_space
)
252 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
253 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
257 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
258 0, bfd_get_section_size (core_text_sect
)))
260 bfd_perror ("bfd_get_section_contents");
261 free (core_text_space
);
265 if (!core_text_space
)
266 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
271 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
273 if (core_text_space
== 0)
276 hist_clip_symbol_address (&p_lowpc
, &p_highpc
);
278 switch (bfd_get_arch (core_bfd
))
281 i386_find_call (parent
, p_lowpc
, p_highpc
);
285 alpha_find_call (parent
, p_lowpc
, p_highpc
);
289 vax_find_call (parent
, p_lowpc
, p_highpc
);
293 sparc_find_call (parent
, p_lowpc
, p_highpc
);
297 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
301 mips_find_call (parent
, p_lowpc
, p_highpc
);
305 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
306 whoami
, bfd_printable_name(core_bfd
));
308 /* Don't give the error more than once. */
309 ignore_direct_calls
= FALSE
;
313 /* Return class of symbol SYM. The returned class can be any of:
314 0 -> symbol is not interesting to us
315 'T' -> symbol is a global name
316 't' -> symbol is a local (static) name. */
319 core_sym_class (asymbol
*sym
)
326 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
329 /* Must be a text symbol, and static text symbols
330 don't qualify if ignore_static_funcs set. */
331 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
333 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
338 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
342 return i
; /* It's a global symbol. */
345 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
346 also be a data symbol. */
351 /* Not a static text symbol. */
352 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
357 /* Do some more filtering on static function-names. */
358 if (ignore_static_funcs
)
361 /* Can't zero-length name or funny characters in name, where
362 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
363 if (!sym
->name
|| sym
->name
[0] == '\0')
366 for (name
= sym
->name
; *name
; ++name
)
368 if (*name
== '.' || *name
== '$')
372 /* On systems where the C compiler adds an underscore to all
373 names, static names without underscores seem usually to be
374 labels in hand written assembler in the library. We don't want
375 these names. This is certainly necessary on a Sparc running
376 SunOS 4.1 (try profiling a program that does a lot of
377 division). I don't know whether it has harmful side effects on
378 other systems. Perhaps it should be made configurable. */
379 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
381 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
382 /* GCC may add special symbols to help gdb figure out the file
383 language. We want to ignore these, since sometimes they mask
384 the real function. (dj@ctron) */
385 || !strncmp (sym
->name
, "__gnu_compiled", 14)
386 || !strncmp (sym
->name
, "___gnu_compiled", 15))
391 /* If the object file supports marking of function symbols, then
392 we can zap anything that doesn't have BSF_FUNCTION set. */
393 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
396 return 't'; /* It's a static text symbol. */
399 /* Get whatever source info we can get regarding address ADDR. */
402 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
404 const char *fname
= 0, *func_name
= 0;
407 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
408 addr
- core_text_sect
->vma
,
409 &fname
, &func_name
, (unsigned int *) &l
)
410 && fname
&& func_name
&& l
)
412 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
413 (unsigned long) addr
, fname
, l
, func_name
));
421 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
422 (long) addr
, fname
? fname
: "<unknown>", l
,
423 func_name
? func_name
: "<unknown>"));
428 /* Read in symbol table from core.
429 One symbol per function is entered. */
432 core_create_function_syms ()
434 bfd_vma min_vma
= ~(bfd_vma
) 0;
440 /* Pass 1 - determine upper bound on number of function names. */
443 for (i
= 0; i
< core_num_syms
; ++i
)
445 if (!core_sym_class (core_syms
[i
]))
448 /* This should be replaced with a binary search or hashed
451 Don't create a symtab entry for a function that has
452 a mapping to a file, unless it's the first function
455 for (j
= 0; j
< symbol_map_count
; j
++)
456 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
458 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
459 symbol_map
[j
- 1].file_name
))
470 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
474 /* The "+ 2" is for the sentinels. */
475 symtab
.base
= (Sym
*) xmalloc ((symtab
.len
+ 2) * sizeof (Sym
));
477 /* Pass 2 - create symbols. */
478 symtab
.limit
= symtab
.base
;
480 for (i
= 0; i
< core_num_syms
; ++i
)
484 class = core_sym_class (core_syms
[i
]);
489 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
490 (unsigned long) core_syms
[i
]->value
,
491 core_syms
[i
]->name
));
495 /* This should be replaced with a binary search or hashed
500 for (j
= 0; j
< symbol_map_count
; j
++)
501 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
503 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
504 symbol_map
[j
- 1].file_name
))
514 sym_init (symtab
.limit
);
516 /* Symbol offsets are always section-relative. */
517 sym_sec
= core_syms
[i
]->section
;
518 symtab
.limit
->addr
= core_syms
[i
]->value
;
520 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
523 && !strcmp (core_syms
[i
]->name
, symbol_map
[found
].function_name
))
525 symtab
.limit
->name
= symbol_map
[found
].file_name
;
526 symtab
.limit
->mapped
= 1;
530 symtab
.limit
->name
= core_syms
[i
]->name
;
531 symtab
.limit
->mapped
= 0;
534 /* Lookup filename and line number, if we can. */
536 const char *filename
, *func_name
;
538 if (get_src_info (symtab
.limit
->addr
, &filename
, &func_name
,
539 &symtab
.limit
->line_num
))
541 symtab
.limit
->file
= source_file_lookup_path (filename
);
543 /* FIXME: Checking __osf__ here does not work with a cross
546 /* Suppress symbols that are not function names. This is
547 useful to suppress code-labels and aliases.
549 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
550 labels do not appear in the symbol table info, so this isn't
553 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
555 /* The symbol's address maps to a different name, so
556 it can't be a function-entry point. This happens
557 for labels, for example. */
559 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
560 symtab
.limit
->name
, func_name
));
567 symtab
.limit
->is_func
= TRUE
;
568 symtab
.limit
->is_bb_head
= TRUE
;
571 symtab
.limit
->is_static
= TRUE
;
573 /* Keep track of the minimum and maximum vma addresses used by all
574 symbols. When computing the max_vma, use the ending address of the
575 section containing the symbol, if available. */
576 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
578 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
579 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
582 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
584 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
585 (long) (symtab
.limit
- symtab
.base
),
587 (unsigned long) symtab
.limit
->addr
));
591 /* Create sentinels. */
592 sym_init (symtab
.limit
);
593 symtab
.limit
->name
= "<locore>";
594 symtab
.limit
->addr
= 0;
595 symtab
.limit
->end_addr
= min_vma
- 1;
598 sym_init (symtab
.limit
);
599 symtab
.limit
->name
= "<hicore>";
600 symtab
.limit
->addr
= max_vma
+ 1;
601 symtab
.limit
->end_addr
= ~(bfd_vma
) 0;
604 symtab
.len
= symtab
.limit
- symtab
.base
;
605 symtab_finalize (&symtab
);
608 /* Read in symbol table from core.
609 One symbol per line of source code is entered. */
612 core_create_line_syms ()
614 char *prev_name
, *prev_filename
;
615 unsigned int prev_name_len
, prev_filename_len
;
616 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
617 Sym
*prev
, dummy
, *sentinel
, *sym
;
618 const char *filename
;
623 /* Create symbols for functions as usual. This is necessary in
624 cases where parts of a program were not compiled with -g. For
625 those parts we still want to get info at the function level. */
626 core_create_function_syms ();
628 /* Pass 1: count the number of symbols. */
630 /* To find all line information, walk through all possible
631 text-space addresses (one by one!) and get the debugging
632 info for each address. When the debugging info changes,
633 it is time to create a new symbol.
635 Of course, this is rather slow and it would be better if
636 BFD would provide an iterator for enumerating all line infos. */
637 prev_name_len
= PATH_MAX
;
638 prev_filename_len
= PATH_MAX
;
639 prev_name
= xmalloc (prev_name_len
);
640 prev_filename
= xmalloc (prev_filename_len
);
644 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
645 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
649 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
650 || (prev_line_num
== dummy
.line_num
652 && strcmp (prev_name
, dummy
.name
) == 0
653 && strcmp (prev_filename
, filename
) == 0))
657 prev_line_num
= dummy
.line_num
;
659 len
= strlen (dummy
.name
);
660 if (len
>= prev_name_len
)
662 prev_name_len
= len
+ 1024;
664 prev_name
= xmalloc (prev_name_len
);
667 strcpy (prev_name
, dummy
.name
);
668 len
= strlen (filename
);
670 if (len
>= prev_filename_len
)
672 prev_filename_len
= len
+ 1024;
673 free (prev_filename
);
674 prev_filename
= xmalloc (prev_filename_len
);
677 strcpy (prev_filename
, filename
);
679 min_vma
= MIN (vma
, min_vma
);
680 max_vma
= MAX (vma
, max_vma
);
684 free (prev_filename
);
686 /* Make room for function symbols, too. */
687 ltab
.len
+= symtab
.len
;
688 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
689 ltab
.limit
= ltab
.base
;
691 /* Pass 2 - create symbols. */
693 /* We now set is_static as we go along, rather than by running
694 through the symbol table at the end.
696 The old way called symtab_finalize before the is_static pass,
697 causing a problem since symtab_finalize uses is_static as part of
698 its address conflict resolution algorithm. Since global symbols
699 were prefered over static symbols, and all line symbols were
700 global at that point, static function names that conflicted with
701 their own line numbers (static, but labeled as global) were
702 rejected in favor of the line num.
704 This was not the desired functionality. We always want to keep
705 our function symbols and discard any conflicting line symbols.
706 Perhaps symtab_finalize should be modified to make this
707 distinction as well, but the current fix works and the code is a
711 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
713 sym_init (ltab
.limit
);
715 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
716 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
717 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
718 && strcmp (prev
->file
->name
, filename
) == 0))
721 /* Make name pointer a malloc'ed string. */
722 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
723 ltab
.limit
->file
= source_file_lookup_path (filename
);
725 ltab
.limit
->addr
= vma
;
727 /* Set is_static based on the enclosing function, using either:
728 1) the previous symbol, if it's from the same function, or
729 2) a symtab lookup. */
730 if (prev
&& ltab
.limit
->file
== prev
->file
&&
731 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
733 ltab
.limit
->is_static
= prev
->is_static
;
737 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
738 ltab
.limit
->is_static
= sym
->is_static
;
743 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
744 (unsigned long) (ltab
.limit
- ltab
.base
),
746 (unsigned long) ltab
.limit
->addr
));
750 /* Update sentinels. */
751 sentinel
= sym_lookup (&symtab
, (bfd_vma
) 0);
754 && strcmp (sentinel
->name
, "<locore>") == 0
755 && min_vma
<= sentinel
->end_addr
)
756 sentinel
->end_addr
= min_vma
- 1;
758 sentinel
= sym_lookup (&symtab
, ~(bfd_vma
) 0);
761 && strcmp (sentinel
->name
, "<hicore>") == 0
762 && max_vma
>= sentinel
->addr
)
763 sentinel
->addr
= max_vma
+ 1;
765 /* Copy in function symbols. */
766 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
767 ltab
.limit
+= symtab
.len
;
769 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
772 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
773 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
777 /* Finalize ltab and make it symbol table. */
778 symtab_finalize (<ab
);
This page took 0.049265 seconds and 4 git commands to generate.