3 Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22 #include "libiberty.h"
24 #include "search_list.h"
32 asection
*core_text_sect
;
38 /* For mapping symbols to specific .o files during file ordering. */
39 struct function_map
*symbol_map
;
40 unsigned int symbol_map_count
;
42 static void read_function_mappings
PARAMS ((const char *));
43 static int core_sym_class
PARAMS ((asymbol
*));
44 static bfd_boolean get_src_info
45 PARAMS ((bfd_vma
, const char **, const char **, int *));
47 extern void i386_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
48 extern void alpha_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
49 extern void vax_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
50 extern void tahoe_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
51 extern void sparc_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
52 extern void mips_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
55 read_function_mappings (filename
)
58 FILE *file
= fopen (filename
, "r");
64 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, filename
);
68 /* First parse the mapping file so we know how big we need to
69 make our tables. We also do some sanity checks at this
75 matches
= fscanf (file
, "%[^\n:]", dummy
);
78 fprintf (stderr
, _("%s: unable to parse mapping file %s.\n"),
83 /* Just skip messages about files with no symbols. */
84 if (!strncmp (dummy
, "No symbols in ", 14))
90 /* Don't care what else is on this line at this point. */
91 fscanf (file
, "%[^\n]\n", dummy
);
95 /* Now we know how big we need to make our table. */
96 symbol_map
= ((struct function_map
*)
97 xmalloc (count
* sizeof (struct function_map
)));
99 /* Rewind the input file so we can read it again. */
102 /* Read each entry and put it into the table. */
109 matches
= fscanf (file
, "%[^\n:]", dummy
);
112 fprintf (stderr
, _("%s: unable to parse mapping file %s.\n"),
117 /* Just skip messages about files with no symbols. */
118 if (!strncmp (dummy
, "No symbols in ", 14))
124 /* dummy has the filename, go ahead and copy it. */
125 symbol_map
[count
].file_name
= xmalloc (strlen (dummy
) + 1);
126 strcpy (symbol_map
[count
].file_name
, dummy
);
128 /* Now we need the function name. */
129 fscanf (file
, "%[^\n]\n", dummy
);
130 tmp
= strrchr (dummy
, ' ') + 1;
131 symbol_map
[count
].function_name
= xmalloc (strlen (tmp
) + 1);
132 strcpy (symbol_map
[count
].function_name
, tmp
);
136 /* Record the size of the map table for future reference. */
137 symbol_map_count
= count
;
142 core_init (aout_name
)
143 const char *aout_name
;
145 core_bfd
= bfd_openr (aout_name
, 0);
153 if (!bfd_check_format (core_bfd
, bfd_object
))
155 fprintf (stderr
, _("%s: %s: not in a.out format\n"), whoami
, aout_name
);
159 /* Get core's text section. */
160 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
163 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
166 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
172 /* Read core's symbol table. */
174 /* This will probably give us more than we need, but that's ok. */
175 core_num_syms
= bfd_get_symtab_upper_bound (core_bfd
);
176 if (core_num_syms
< 0)
178 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
179 bfd_errmsg (bfd_get_error ()));
183 core_syms
= (asymbol
**) xmalloc (core_num_syms
);
184 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
186 if (core_num_syms
< 0)
188 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
189 bfd_errmsg (bfd_get_error ()));
196 switch (bfd_get_arch (core_bfd
))
211 if (function_mapping_file
)
212 read_function_mappings (function_mapping_file
);
215 /* Read in the text space of an a.out file. */
218 core_get_text_space (cbfd
)
221 core_text_space
= (PTR
) malloc ((unsigned int) core_text_sect
->_raw_size
);
223 if (!core_text_space
)
225 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
226 whoami
, (unsigned long) core_text_sect
->_raw_size
);
230 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
231 (bfd_vma
) 0, core_text_sect
->_raw_size
))
233 bfd_perror ("bfd_get_section_contents");
234 free (core_text_space
);
238 if (!core_text_space
)
239 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
244 find_call (parent
, p_lowpc
, p_highpc
)
249 switch (bfd_get_arch (core_bfd
))
252 i386_find_call (parent
, p_lowpc
, p_highpc
);
256 alpha_find_call (parent
, p_lowpc
, p_highpc
);
260 vax_find_call (parent
, p_lowpc
, p_highpc
);
264 sparc_find_call (parent
, p_lowpc
, p_highpc
);
268 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
272 mips_find_call (parent
, p_lowpc
, p_highpc
);
276 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
277 whoami
, bfd_printable_name(core_bfd
));
279 /* Don't give the error more than once. */
280 ignore_direct_calls
= FALSE
;
284 /* Return class of symbol SYM. The returned class can be any of:
285 0 -> symbol is not interesting to us
286 'T' -> symbol is a global name
287 't' -> symbol is a local (static) name. */
298 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
301 /* Must be a text symbol, and static text symbols
302 don't qualify if ignore_static_funcs set. */
303 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
305 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
310 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
314 return i
; /* It's a global symbol. */
317 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
318 also be a data symbol. */
323 /* Not a static text symbol. */
324 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
329 /* Do some more filtering on static function-names. */
330 if (ignore_static_funcs
)
333 /* Can't zero-length name or funny characters in name, where
334 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
335 if (!sym
->name
|| sym
->name
[0] == '\0')
338 for (name
= sym
->name
; *name
; ++name
)
340 if (*name
== '.' || *name
== '$')
344 /* On systems where the C compiler adds an underscore to all
345 names, static names without underscores seem usually to be
346 labels in hand written assembler in the library. We don't want
347 these names. This is certainly necessary on a Sparc running
348 SunOS 4.1 (try profiling a program that does a lot of
349 division). I don't know whether it has harmful side effects on
350 other systems. Perhaps it should be made configurable. */
351 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
353 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
354 /* GCC may add special symbols to help gdb figure out the file
355 language. We want to ignore these, since sometimes they mask
356 the real function. (dj@ctron) */
357 || !strncmp (sym
->name
, "__gnu_compiled", 14)
358 || !strncmp (sym
->name
, "___gnu_compiled", 15))
363 /* If the object file supports marking of function symbols, then
364 we can zap anything that doesn't have BSF_FUNCTION set. */
365 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
368 return 't'; /* It's a static text symbol. */
371 /* Get whatever source info we can get regarding address ADDR. */
374 get_src_info (addr
, filename
, name
, line_num
)
376 const char **filename
;
380 const char *fname
= 0, *func_name
= 0;
383 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
384 addr
- core_text_sect
->vma
,
385 &fname
, &func_name
, (unsigned int *) &l
)
386 && fname
&& func_name
&& l
)
388 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
389 (unsigned long) addr
, fname
, l
, func_name
));
397 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
398 (long) addr
, fname
? fname
: "<unknown>", l
,
399 func_name
? func_name
: "<unknown>"));
404 /* Read in symbol table from core.
405 One symbol per function is entered. */
408 core_create_function_syms (cbfd
)
409 bfd
*cbfd ATTRIBUTE_UNUSED
;
411 bfd_vma min_vma
= ~(bfd_vma
) 0;
417 /* Pass 1 - determine upper bound on number of function names. */
420 for (i
= 0; i
< core_num_syms
; ++i
)
422 if (!core_sym_class (core_syms
[i
]))
425 /* This should be replaced with a binary search or hashed
428 Don't create a symtab entry for a function that has
429 a mapping to a file, unless it's the first function
432 for (j
= 0; j
< symbol_map_count
; j
++)
433 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
435 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
436 symbol_map
[j
- 1].file_name
))
447 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
451 /* The "+ 2" is for the sentinels. */
452 symtab
.base
= (Sym
*) xmalloc ((symtab
.len
+ 2) * sizeof (Sym
));
454 /* Pass 2 - create symbols. */
455 symtab
.limit
= symtab
.base
;
457 for (i
= 0; i
< core_num_syms
; ++i
)
461 class = core_sym_class (core_syms
[i
]);
466 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
467 (unsigned long) core_syms
[i
]->value
,
468 core_syms
[i
]->name
));
472 /* This should be replaced with a binary search or hashed
477 for (j
= 0; j
< symbol_map_count
; j
++)
478 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
480 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
481 symbol_map
[j
- 1].file_name
))
491 sym_init (symtab
.limit
);
493 /* Symbol offsets are always section-relative. */
494 sym_sec
= core_syms
[i
]->section
;
495 symtab
.limit
->addr
= core_syms
[i
]->value
;
497 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
500 && !strcmp (core_syms
[i
]->name
, symbol_map
[found
].function_name
))
502 symtab
.limit
->name
= symbol_map
[found
].file_name
;
503 symtab
.limit
->mapped
= 1;
507 symtab
.limit
->name
= core_syms
[i
]->name
;
508 symtab
.limit
->mapped
= 0;
511 /* Lookup filename and line number, if we can. */
513 const char *filename
, *func_name
;
515 if (get_src_info (symtab
.limit
->addr
, &filename
, &func_name
,
516 &symtab
.limit
->line_num
))
518 symtab
.limit
->file
= source_file_lookup_path (filename
);
520 /* FIXME: Checking __osf__ here does not work with a cross
523 /* Suppress symbols that are not function names. This is
524 useful to suppress code-labels and aliases.
526 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
527 labels do not appear in the symbol table info, so this isn't
530 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
532 /* The symbol's address maps to a different name, so
533 it can't be a function-entry point. This happens
534 for labels, for example. */
536 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
537 symtab
.limit
->name
, func_name
));
544 symtab
.limit
->is_func
= TRUE
;
545 symtab
.limit
->is_bb_head
= TRUE
;
548 symtab
.limit
->is_static
= TRUE
;
550 /* Keep track of the minimum and maximum vma addresses used by all
551 symbols. When computing the max_vma, use the ending address of the
552 section containing the symbol, if available. */
553 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
555 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
556 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
559 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
561 /* If we see "main" without an initial '_', we assume names
562 are *not* prefixed by '_'. */
563 if (symtab
.limit
->name
[0] == 'm' && discard_underscores
564 && strcmp (symtab
.limit
->name
, "main") == 0)
565 discard_underscores
= 0;
567 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
568 (long) (symtab
.limit
- symtab
.base
),
570 (unsigned long) symtab
.limit
->addr
));
574 /* Create sentinels. */
575 sym_init (symtab
.limit
);
576 symtab
.limit
->name
= "<locore>";
577 symtab
.limit
->addr
= 0;
578 symtab
.limit
->end_addr
= min_vma
- 1;
581 sym_init (symtab
.limit
);
582 symtab
.limit
->name
= "<hicore>";
583 symtab
.limit
->addr
= max_vma
+ 1;
584 symtab
.limit
->end_addr
= ~(bfd_vma
) 0;
587 symtab
.len
= symtab
.limit
- symtab
.base
;
588 symtab_finalize (&symtab
);
591 /* Read in symbol table from core.
592 One symbol per line of source code is entered. */
595 core_create_line_syms (cbfd
)
598 char *prev_name
, *prev_filename
;
599 unsigned int prev_name_len
, prev_filename_len
;
600 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
602 Sym
*prev
, dummy
, *sentinel
, *sym
;
603 const char *filename
;
607 /* Create symbols for functions as usual. This is necessary in
608 cases where parts of a program were not compiled with -g. For
609 those parts we still want to get info at the function level. */
610 core_create_function_syms (cbfd
);
612 /* Pass 1 - counter number of symbols. */
614 /* To find all line information, walk through all possible
615 text-space addresses (one by one!) and get the debugging
616 info for each address. When the debugging info changes,
617 it is time to create a new symbol.
619 Of course, this is rather slow and it would be better if
620 bfd would provide an iterator for enumerating all line infos. */
621 prev_name_len
= PATH_MAX
;
622 prev_filename_len
= PATH_MAX
;
623 prev_name
= xmalloc (prev_name_len
);
624 prev_filename
= xmalloc (prev_filename_len
);
628 for (offset
= 0; offset
< core_text_sect
->_raw_size
; offset
+= min_insn_size
)
632 vma
= core_text_sect
->vma
+ offset
;
634 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
635 || (prev_line_num
== dummy
.line_num
637 && strcmp (prev_name
, dummy
.name
) == 0
638 && strcmp (prev_filename
, filename
) == 0))
642 prev_line_num
= dummy
.line_num
;
644 len
= strlen (dummy
.name
);
645 if (len
>= prev_name_len
)
647 prev_name_len
= len
+ 1024;
649 prev_name
= xmalloc (prev_name_len
);
652 strcpy (prev_name
, dummy
.name
);
653 len
= strlen (filename
);
655 if (len
>= prev_filename_len
)
657 prev_filename_len
= len
+ 1024;
658 free (prev_filename
);
659 prev_filename
= xmalloc (prev_filename_len
);
662 strcpy (prev_filename
, filename
);
664 min_vma
= MIN (vma
, min_vma
);
665 max_vma
= MAX (vma
, max_vma
);
669 free (prev_filename
);
671 /* Make room for function symbols, too. */
672 ltab
.len
+= symtab
.len
;
673 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
674 ltab
.limit
= ltab
.base
;
676 /* Pass 2 - create symbols. */
678 /* We now set is_static as we go along, rather than by running
679 through the symbol table at the end.
681 The old way called symtab_finalize before the is_static pass,
682 causing a problem since symtab_finalize uses is_static as part of
683 its address conflict resolution algorithm. Since global symbols
684 were prefered over static symbols, and all line symbols were
685 global at that point, static function names that conflicted with
686 their own line numbers (static, but labeled as global) were
687 rejected in favor of the line num.
689 This was not the desired functionality. We always want to keep
690 our function symbols and discard any conflicting line symbols.
691 Perhaps symtab_finalize should be modified to make this
692 distinction as well, but the current fix works and the code is a
696 for (offset
= 0; offset
< core_text_sect
->_raw_size
; offset
+= min_insn_size
)
698 sym_init (ltab
.limit
);
700 if (!get_src_info (core_text_sect
->vma
+ offset
, &filename
,
701 <ab
.limit
->name
, <ab
.limit
->line_num
)
702 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
703 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
704 && strcmp (prev
->file
->name
, filename
) == 0))
707 /* Make name pointer a malloc'ed string. */
708 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
709 ltab
.limit
->file
= source_file_lookup_path (filename
);
711 ltab
.limit
->addr
= core_text_sect
->vma
+ offset
;
713 /* Set is_static based on the enclosing function, using either:
714 1) the previous symbol, if it's from the same function, or
715 2) a symtab lookup. */
716 if (prev
&& ltab
.limit
->file
== prev
->file
&&
717 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
719 ltab
.limit
->is_static
= prev
->is_static
;
723 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
724 ltab
.limit
->is_static
= sym
->is_static
;
729 /* If we see "main" without an initial '_', we assume names
730 are *not* prefixed by '_'. */
731 if (ltab
.limit
->name
[0] == 'm' && discard_underscores
732 && strcmp (ltab
.limit
->name
, "main") == 0)
733 discard_underscores
= 0;
735 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
736 (unsigned long) (ltab
.limit
- ltab
.base
),
738 (unsigned long) ltab
.limit
->addr
));
742 /* Update sentinels. */
743 sentinel
= sym_lookup (&symtab
, (bfd_vma
) 0);
746 && strcmp (sentinel
->name
, "<locore>") == 0
747 && min_vma
<= sentinel
->end_addr
)
748 sentinel
->end_addr
= min_vma
- 1;
750 sentinel
= sym_lookup (&symtab
, ~(bfd_vma
) 0);
753 && strcmp (sentinel
->name
, "<hicore>") == 0
754 && max_vma
>= sentinel
->addr
)
755 sentinel
->addr
= max_vma
+ 1;
757 /* Copy in function symbols. */
758 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
759 ltab
.limit
+= symtab
.len
;
761 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
764 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
765 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
769 /* Finalize ltab and make it symbol table. */
770 symtab_finalize (<ab
);
This page took 0.044472 seconds and 4 git commands to generate.