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"
31 static int core_num_syms
;
32 static asymbol
**core_syms
;
33 asection
*core_text_sect
;
36 static int min_insn_size
;
39 /* For mapping symbols to specific .o files during file ordering. */
40 struct function_map
*symbol_map
;
41 unsigned int symbol_map_count
;
43 static void read_function_mappings (const char *);
44 static int core_sym_class (asymbol
*);
45 static bfd_boolean get_src_info
46 (bfd_vma
, const char **, const char **, int *);
48 extern void i386_find_call (Sym
*, bfd_vma
, bfd_vma
);
49 extern void alpha_find_call (Sym
*, bfd_vma
, bfd_vma
);
50 extern void vax_find_call (Sym
*, bfd_vma
, bfd_vma
);
51 extern void tahoe_find_call (Sym
*, bfd_vma
, bfd_vma
);
52 extern void sparc_find_call (Sym
*, bfd_vma
, bfd_vma
);
53 extern void mips_find_call (Sym
*, bfd_vma
, bfd_vma
);
56 parse_error (const char *filename
)
58 fprintf (stderr
, _("%s: unable to parse mapping file %s.\n"), whoami
, filename
);
63 read_function_mappings (const char *filename
)
65 FILE *file
= fopen (filename
, "r");
71 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, filename
);
75 /* First parse the mapping file so we know how big we need to
76 make our tables. We also do some sanity checks at this
82 matches
= fscanf (file
, "%[^\n:]", dummy
);
84 parse_error (filename
);
86 /* Just skip messages about files with no symbols. */
87 if (!strncmp (dummy
, "No symbols in ", 14))
89 matches
= fscanf (file
, "\n");
91 parse_error (filename
);
95 /* Don't care what else is on this line at this point. */
96 matches
= fscanf (file
, "%[^\n]\n", dummy
);
98 parse_error (filename
);
102 /* Now we know how big we need to make our table. */
103 symbol_map
= ((struct function_map
*)
104 xmalloc (count
* sizeof (struct function_map
)));
106 /* Rewind the input file so we can read it again. */
109 /* Read each entry and put it into the table. */
116 matches
= fscanf (file
, "%[^\n:]", dummy
);
118 parse_error (filename
);
120 /* Just skip messages about files with no symbols. */
121 if (!strncmp (dummy
, "No symbols in ", 14))
123 matches
= fscanf (file
, "\n");
125 parse_error (filename
);
129 /* dummy has the filename, go ahead and copy it. */
130 symbol_map
[count
].file_name
= xmalloc (strlen (dummy
) + 1);
131 strcpy (symbol_map
[count
].file_name
, dummy
);
133 /* Now we need the function name. */
134 matches
= fscanf (file
, "%[^\n]\n", dummy
);
136 parse_error (filename
);
137 tmp
= strrchr (dummy
, ' ') + 1;
138 symbol_map
[count
].function_name
= xmalloc (strlen (tmp
) + 1);
139 strcpy (symbol_map
[count
].function_name
, tmp
);
143 /* Record the size of the map table for future reference. */
144 symbol_map_count
= count
;
149 core_init (const char *aout_name
)
155 core_bfd
= bfd_openr (aout_name
, 0);
163 if (!bfd_check_format (core_bfd
, bfd_object
))
165 fprintf (stderr
, _("%s: %s: not in executable format\n"), whoami
, aout_name
);
169 /* Get core's text section. */
170 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
173 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
176 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
182 /* Read core's symbol table. */
184 /* This will probably give us more than we need, but that's ok. */
185 core_sym_bytes
= bfd_get_symtab_upper_bound (core_bfd
);
186 if (core_sym_bytes
< 0)
188 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
189 bfd_errmsg (bfd_get_error ()));
193 core_syms
= (asymbol
**) xmalloc (core_sym_bytes
);
194 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
196 if (core_num_syms
< 0)
198 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
199 bfd_errmsg (bfd_get_error ()));
203 synth_count
= bfd_get_synthetic_symtab (core_bfd
, core_num_syms
, core_syms
,
204 0, NULL
, &synthsyms
);
211 new_size
= (core_num_syms
+ synth_count
+ 1) * sizeof (*core_syms
);
212 core_syms
= xrealloc (core_syms
, new_size
);
213 symp
= core_syms
+ core_num_syms
;
214 core_num_syms
+= synth_count
;
215 for (i
= 0; i
< synth_count
; i
++)
216 *symp
++ = synthsyms
+ i
;
223 switch (bfd_get_arch (core_bfd
))
238 if (function_mapping_file
)
239 read_function_mappings (function_mapping_file
);
242 /* Read in the text space of an a.out file. */
245 core_get_text_space (bfd
*cbfd
)
247 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
249 if (!core_text_space
)
251 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
252 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
256 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
257 0, bfd_get_section_size (core_text_sect
)))
259 bfd_perror ("bfd_get_section_contents");
260 free (core_text_space
);
264 if (!core_text_space
)
265 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
270 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
272 switch (bfd_get_arch (core_bfd
))
275 i386_find_call (parent
, p_lowpc
, p_highpc
);
279 alpha_find_call (parent
, p_lowpc
, p_highpc
);
283 vax_find_call (parent
, p_lowpc
, p_highpc
);
287 sparc_find_call (parent
, p_lowpc
, p_highpc
);
291 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
295 mips_find_call (parent
, p_lowpc
, p_highpc
);
299 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
300 whoami
, bfd_printable_name(core_bfd
));
302 /* Don't give the error more than once. */
303 ignore_direct_calls
= FALSE
;
307 /* Return class of symbol SYM. The returned class can be any of:
308 0 -> symbol is not interesting to us
309 'T' -> symbol is a global name
310 't' -> symbol is a local (static) name. */
313 core_sym_class (asymbol
*sym
)
320 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
323 /* Must be a text symbol, and static text symbols
324 don't qualify if ignore_static_funcs set. */
325 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
327 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
332 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
336 return i
; /* It's a global symbol. */
339 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
340 also be a data symbol. */
345 /* Not a static text symbol. */
346 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
351 /* Do some more filtering on static function-names. */
352 if (ignore_static_funcs
)
355 /* Can't zero-length name or funny characters in name, where
356 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
357 if (!sym
->name
|| sym
->name
[0] == '\0')
360 for (name
= sym
->name
; *name
; ++name
)
362 if (*name
== '.' || *name
== '$')
366 /* On systems where the C compiler adds an underscore to all
367 names, static names without underscores seem usually to be
368 labels in hand written assembler in the library. We don't want
369 these names. This is certainly necessary on a Sparc running
370 SunOS 4.1 (try profiling a program that does a lot of
371 division). I don't know whether it has harmful side effects on
372 other systems. Perhaps it should be made configurable. */
373 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
375 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
376 /* GCC may add special symbols to help gdb figure out the file
377 language. We want to ignore these, since sometimes they mask
378 the real function. (dj@ctron) */
379 || !strncmp (sym
->name
, "__gnu_compiled", 14)
380 || !strncmp (sym
->name
, "___gnu_compiled", 15))
385 /* If the object file supports marking of function symbols, then
386 we can zap anything that doesn't have BSF_FUNCTION set. */
387 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
390 return 't'; /* It's a static text symbol. */
393 /* Get whatever source info we can get regarding address ADDR. */
396 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
398 const char *fname
= 0, *func_name
= 0;
401 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
402 addr
- core_text_sect
->vma
,
403 &fname
, &func_name
, (unsigned int *) &l
)
404 && fname
&& func_name
&& l
)
406 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
407 (unsigned long) addr
, fname
, l
, func_name
));
415 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
416 (long) addr
, fname
? fname
: "<unknown>", l
,
417 func_name
? func_name
: "<unknown>"));
422 /* Read in symbol table from core.
423 One symbol per function is entered. */
426 core_create_function_syms ()
428 bfd_vma min_vma
= ~(bfd_vma
) 0;
434 /* Pass 1 - determine upper bound on number of function names. */
437 for (i
= 0; i
< core_num_syms
; ++i
)
439 if (!core_sym_class (core_syms
[i
]))
442 /* This should be replaced with a binary search or hashed
445 Don't create a symtab entry for a function that has
446 a mapping to a file, unless it's the first function
449 for (j
= 0; j
< symbol_map_count
; j
++)
450 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
452 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
453 symbol_map
[j
- 1].file_name
))
464 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
468 /* The "+ 2" is for the sentinels. */
469 symtab
.base
= (Sym
*) xmalloc ((symtab
.len
+ 2) * sizeof (Sym
));
471 /* Pass 2 - create symbols. */
472 symtab
.limit
= symtab
.base
;
474 for (i
= 0; i
< core_num_syms
; ++i
)
478 class = core_sym_class (core_syms
[i
]);
483 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
484 (unsigned long) core_syms
[i
]->value
,
485 core_syms
[i
]->name
));
489 /* This should be replaced with a binary search or hashed
494 for (j
= 0; j
< symbol_map_count
; j
++)
495 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
497 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
498 symbol_map
[j
- 1].file_name
))
508 sym_init (symtab
.limit
);
510 /* Symbol offsets are always section-relative. */
511 sym_sec
= core_syms
[i
]->section
;
512 symtab
.limit
->addr
= core_syms
[i
]->value
;
514 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
517 && !strcmp (core_syms
[i
]->name
, symbol_map
[found
].function_name
))
519 symtab
.limit
->name
= symbol_map
[found
].file_name
;
520 symtab
.limit
->mapped
= 1;
524 symtab
.limit
->name
= core_syms
[i
]->name
;
525 symtab
.limit
->mapped
= 0;
528 /* Lookup filename and line number, if we can. */
530 const char *filename
, *func_name
;
532 if (get_src_info (symtab
.limit
->addr
, &filename
, &func_name
,
533 &symtab
.limit
->line_num
))
535 symtab
.limit
->file
= source_file_lookup_path (filename
);
537 /* FIXME: Checking __osf__ here does not work with a cross
540 /* Suppress symbols that are not function names. This is
541 useful to suppress code-labels and aliases.
543 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
544 labels do not appear in the symbol table info, so this isn't
547 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
549 /* The symbol's address maps to a different name, so
550 it can't be a function-entry point. This happens
551 for labels, for example. */
553 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
554 symtab
.limit
->name
, func_name
));
561 symtab
.limit
->is_func
= TRUE
;
562 symtab
.limit
->is_bb_head
= TRUE
;
565 symtab
.limit
->is_static
= TRUE
;
567 /* Keep track of the minimum and maximum vma addresses used by all
568 symbols. When computing the max_vma, use the ending address of the
569 section containing the symbol, if available. */
570 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
572 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
573 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
576 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
578 /* If we see "main" without an initial '_', we assume names
579 are *not* prefixed by '_'. */
580 if (symtab
.limit
->name
[0] == 'm' && discard_underscores
581 && strcmp (symtab
.limit
->name
, "main") == 0)
582 discard_underscores
= 0;
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 /* If we see "main" without an initial '_', we assume names
744 are *not* prefixed by '_'. */
745 if (ltab
.limit
->name
[0] == 'm' && discard_underscores
746 && strcmp (ltab
.limit
->name
, "main") == 0)
747 discard_underscores
= 0;
749 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
750 (unsigned long) (ltab
.limit
- ltab
.base
),
752 (unsigned long) ltab
.limit
->addr
));
756 /* Update sentinels. */
757 sentinel
= sym_lookup (&symtab
, (bfd_vma
) 0);
760 && strcmp (sentinel
->name
, "<locore>") == 0
761 && min_vma
<= sentinel
->end_addr
)
762 sentinel
->end_addr
= min_vma
- 1;
764 sentinel
= sym_lookup (&symtab
, ~(bfd_vma
) 0);
767 && strcmp (sentinel
->name
, "<hicore>") == 0
768 && max_vma
>= sentinel
->addr
)
769 sentinel
->addr
= max_vma
+ 1;
771 /* Copy in function symbols. */
772 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
773 ltab
.limit
+= symtab
.len
;
775 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
778 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
779 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
783 /* Finalize ltab and make it symbol table. */
784 symtab_finalize (<ab
);
This page took 0.045828 seconds and 4 git commands to generate.