3 Copyright 2000, 2001, 2002 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 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
)
459 class = core_sym_class (core_syms
[i
]);
464 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
465 (unsigned long) core_syms
[i
]->value
,
466 core_syms
[i
]->name
));
470 /* This should be replaced with a binary search or hashed
475 for (j
= 0; j
< symbol_map_count
; j
++)
476 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
478 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
479 symbol_map
[j
- 1].file_name
))
489 sym_init (symtab
.limit
);
491 /* Symbol offsets are always section-relative. */
492 symtab
.limit
->addr
= core_syms
[i
]->value
+ core_syms
[i
]->section
->vma
;
495 && !strcmp (core_syms
[i
]->name
, symbol_map
[found
].function_name
))
497 symtab
.limit
->name
= symbol_map
[found
].file_name
;
498 symtab
.limit
->mapped
= 1;
502 symtab
.limit
->name
= core_syms
[i
]->name
;
503 symtab
.limit
->mapped
= 0;
506 /* Lookup filename and line number, if we can. */
508 const char *filename
, *func_name
;
510 if (get_src_info (symtab
.limit
->addr
, &filename
, &func_name
,
511 &symtab
.limit
->line_num
))
513 symtab
.limit
->file
= source_file_lookup_path (filename
);
515 /* FIXME: Checking __osf__ here does not work with a cross
518 /* Suppress symbols that are not function names. This is
519 useful to suppress code-labels and aliases.
521 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
522 labels do not appear in the symbol table info, so this isn't
525 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
527 /* The symbol's address maps to a different name, so
528 it can't be a function-entry point. This happens
529 for labels, for example. */
531 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
532 symtab
.limit
->name
, func_name
));
539 symtab
.limit
->is_func
= true;
540 symtab
.limit
->is_bb_head
= true;
543 symtab
.limit
->is_static
= true;
545 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
546 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
548 /* If we see "main" without an initial '_', we assume names
549 are *not* prefixed by '_'. */
550 if (symtab
.limit
->name
[0] == 'm' && discard_underscores
551 && strcmp (symtab
.limit
->name
, "main") == 0)
552 discard_underscores
= 0;
554 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
555 (long) (symtab
.limit
- symtab
.base
),
557 (unsigned long) symtab
.limit
->addr
));
561 /* Create sentinels. */
562 sym_init (symtab
.limit
);
563 symtab
.limit
->name
= "<locore>";
564 symtab
.limit
->addr
= 0;
565 symtab
.limit
->end_addr
= min_vma
- 1;
568 sym_init (symtab
.limit
);
569 symtab
.limit
->name
= "<hicore>";
570 symtab
.limit
->addr
= max_vma
+ 1;
571 symtab
.limit
->end_addr
= ~(bfd_vma
) 0;
574 symtab
.len
= symtab
.limit
- symtab
.base
;
575 symtab_finalize (&symtab
);
578 /* Read in symbol table from core.
579 One symbol per line of source code is entered. */
582 core_create_line_syms (cbfd
)
585 char *prev_name
, *prev_filename
;
586 unsigned int prev_name_len
, prev_filename_len
;
587 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
589 Sym
*prev
, dummy
, *sentinel
, *sym
;
590 const char *filename
;
594 /* Create symbols for functions as usual. This is necessary in
595 cases where parts of a program were not compiled with -g. For
596 those parts we still want to get info at the function level. */
597 core_create_function_syms (cbfd
);
599 /* Pass 1 - counter number of symbols. */
601 /* To find all line information, walk through all possible
602 text-space addresses (one by one!) and get the debugging
603 info for each address. When the debugging info changes,
604 it is time to create a new symbol.
606 Of course, this is rather slow and it would be better if
607 bfd would provide an iterator for enumerating all line infos. */
608 prev_name_len
= PATH_MAX
;
609 prev_filename_len
= PATH_MAX
;
610 prev_name
= xmalloc (prev_name_len
);
611 prev_filename
= xmalloc (prev_filename_len
);
615 for (offset
= 0; offset
< core_text_sect
->_raw_size
; offset
+= min_insn_size
)
619 vma
= core_text_sect
->vma
+ offset
;
621 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
622 || (prev_line_num
== dummy
.line_num
624 && strcmp (prev_name
, dummy
.name
) == 0
625 && strcmp (prev_filename
, filename
) == 0))
629 prev_line_num
= dummy
.line_num
;
631 len
= strlen (dummy
.name
);
632 if (len
>= prev_name_len
)
634 prev_name_len
= len
+ 1024;
636 prev_name
= xmalloc (prev_name_len
);
639 strcpy (prev_name
, dummy
.name
);
640 len
= strlen (filename
);
642 if (len
>= prev_filename_len
)
644 prev_filename_len
= len
+ 1024;
645 free (prev_filename
);
646 prev_filename
= xmalloc (prev_filename_len
);
649 strcpy (prev_filename
, filename
);
651 min_vma
= MIN (vma
, min_vma
);
652 max_vma
= MAX (vma
, max_vma
);
656 free (prev_filename
);
658 /* Make room for function symbols, too. */
659 ltab
.len
+= symtab
.len
;
660 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
661 ltab
.limit
= ltab
.base
;
663 /* Pass 2 - create symbols. */
665 /* We now set is_static as we go along, rather than by running
666 through the symbol table at the end.
668 The old way called symtab_finalize before the is_static pass,
669 causing a problem since symtab_finalize uses is_static as part of
670 its address conflict resolution algorithm. Since global symbols
671 were prefered over static symbols, and all line symbols were
672 global at that point, static function names that conflicted with
673 their own line numbers (static, but labeled as global) were
674 rejected in favor of the line num.
676 This was not the desired functionality. We always want to keep
677 our function symbols and discard any conflicting line symbols.
678 Perhaps symtab_finalize should be modified to make this
679 distinction as well, but the current fix works and the code is a
683 for (offset
= 0; offset
< core_text_sect
->_raw_size
; offset
+= min_insn_size
)
685 sym_init (ltab
.limit
);
687 if (!get_src_info (core_text_sect
->vma
+ offset
, &filename
,
688 <ab
.limit
->name
, <ab
.limit
->line_num
)
689 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
690 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
691 && strcmp (prev
->file
->name
, filename
) == 0))
694 /* Make name pointer a malloc'ed string. */
695 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
696 ltab
.limit
->file
= source_file_lookup_path (filename
);
698 ltab
.limit
->addr
= core_text_sect
->vma
+ offset
;
700 /* Set is_static based on the enclosing function, using either:
701 1) the previous symbol, if it's from the same function, or
702 2) a symtab lookup. */
703 if (prev
&& ltab
.limit
->file
== prev
->file
&&
704 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
706 ltab
.limit
->is_static
= prev
->is_static
;
710 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
711 ltab
.limit
->is_static
= sym
->is_static
;
716 /* If we see "main" without an initial '_', we assume names
717 are *not* prefixed by '_'. */
718 if (ltab
.limit
->name
[0] == 'm' && discard_underscores
719 && strcmp (ltab
.limit
->name
, "main") == 0)
720 discard_underscores
= 0;
722 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
723 (unsigned long) (ltab
.limit
- ltab
.base
),
725 (unsigned long) ltab
.limit
->addr
));
729 /* Update sentinels. */
730 sentinel
= sym_lookup (&symtab
, (bfd_vma
) 0);
732 if (strcmp (sentinel
->name
, "<locore>") == 0
733 && min_vma
<= sentinel
->end_addr
)
734 sentinel
->end_addr
= min_vma
- 1;
736 sentinel
= sym_lookup (&symtab
, ~(bfd_vma
) 0);
738 if (strcmp (sentinel
->name
, "<hicore>") == 0 && max_vma
>= sentinel
->addr
)
739 sentinel
->addr
= max_vma
+ 1;
741 /* Copy in function symbols. */
742 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
743 ltab
.limit
+= symtab
.len
;
745 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
748 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
749 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
753 /* Finalize ltab and make it symbol table. */
754 symtab_finalize (<ab
);
This page took 0.045271 seconds and 4 git commands to generate.