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;
146 core_bfd = bfd_openr (aout_name, 0);
154 if (!bfd_check_format (core_bfd, bfd_object))
156 fprintf (stderr, _("%s: %s: not in a.out format\n"), whoami, aout_name);
160 /* Get core's text section. */
161 core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
164 core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
167 fprintf (stderr, _("%s: can't find .text section in %s\n"),
173 /* Read core's symbol table. */
175 /* This will probably give us more than we need, but that's ok. */
176 core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);
177 if (core_sym_bytes < 0)
179 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
180 bfd_errmsg (bfd_get_error ()));
184 core_syms = (asymbol **) xmalloc (core_sym_bytes);
185 core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
187 if (core_num_syms < 0)
189 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
190 bfd_errmsg (bfd_get_error ()));
197 switch (bfd_get_arch (core_bfd))
212 if (function_mapping_file)
213 read_function_mappings (function_mapping_file);
216 /* Read in the text space of an a.out file. */
219 core_get_text_space (cbfd)
222 core_text_space = (PTR) malloc ((unsigned int) core_text_sect->_raw_size);
224 if (!core_text_space)
226 fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
227 whoami, (unsigned long) core_text_sect->_raw_size);
231 if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
232 (bfd_vma) 0, core_text_sect->_raw_size))
234 bfd_perror ("bfd_get_section_contents");
235 free (core_text_space);
239 if (!core_text_space)
240 fprintf (stderr, _("%s: can't do -c\n"), whoami);
245 find_call (parent, p_lowpc, p_highpc)
250 switch (bfd_get_arch (core_bfd))
253 i386_find_call (parent, p_lowpc, p_highpc);
257 alpha_find_call (parent, p_lowpc, p_highpc);
261 vax_find_call (parent, p_lowpc, p_highpc);
265 sparc_find_call (parent, p_lowpc, p_highpc);
269 tahoe_find_call (parent, p_lowpc, p_highpc);
273 mips_find_call (parent, p_lowpc, p_highpc);
277 fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
278 whoami, bfd_printable_name(core_bfd));
280 /* Don't give the error more than once. */
281 ignore_direct_calls = FALSE;
285 /* Return class of symbol SYM. The returned class can be any of:
286 0 -> symbol is not interesting to us
287 'T' -> symbol is a global name
288 't' -> symbol is a local (static) name. */
299 if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
302 /* Must be a text symbol, and static text symbols
303 don't qualify if ignore_static_funcs set. */
304 if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
306 DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
311 bfd_get_symbol_info (core_bfd, sym, &syminfo);
315 return i; /* It's a global symbol. */
318 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
319 also be a data symbol. */
324 /* Not a static text symbol. */
325 DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
330 /* Do some more filtering on static function-names. */
331 if (ignore_static_funcs)
334 /* Can't zero-length name or funny characters in name, where
335 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
336 if (!sym->name || sym->name[0] == '\0')
339 for (name = sym->name; *name; ++name)
341 if (*name == '.' || *name == '$')
345 /* On systems where the C compiler adds an underscore to all
346 names, static names without underscores seem usually to be
347 labels in hand written assembler in the library. We don't want
348 these names. This is certainly necessary on a Sparc running
349 SunOS 4.1 (try profiling a program that does a lot of
350 division). I don't know whether it has harmful side effects on
351 other systems. Perhaps it should be made configurable. */
352 sym_prefix = bfd_get_symbol_leading_char (core_bfd);
354 if ((sym_prefix && sym_prefix != sym->name[0])
355 /* GCC may add special symbols to help gdb figure out the file
356 language. We want to ignore these, since sometimes they mask
357 the real function. (dj@ctron) */
358 || !strncmp (sym->name, "__gnu_compiled", 14)
359 || !strncmp (sym->name, "___gnu_compiled", 15))
364 /* If the object file supports marking of function symbols, then
365 we can zap anything that doesn't have BSF_FUNCTION set. */
366 if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)
369 return 't'; /* It's a static text symbol. */
372 /* Get whatever source info we can get regarding address ADDR. */
375 get_src_info (addr, filename, name, line_num)
377 const char **filename;
381 const char *fname = 0, *func_name = 0;
384 if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
385 addr - core_text_sect->vma,
386 &fname, &func_name, (unsigned int *) &l)
387 && fname && func_name && l)
389 DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
390 (unsigned long) addr, fname, l, func_name));
398 DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
399 (long) addr, fname ? fname : "<unknown>", l,
400 func_name ? func_name : "<unknown>"));
405 /* Read in symbol table from core.
406 One symbol per function is entered. */
409 core_create_function_syms ()
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 ()
597 char *prev_name, *prev_filename;
598 unsigned int prev_name_len, prev_filename_len;
599 bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
600 Sym *prev, dummy, *sentinel, *sym;
601 const char *filename;
605 /* Create symbols for functions as usual. This is necessary in
606 cases where parts of a program were not compiled with -g. For
607 those parts we still want to get info at the function level. */
608 core_create_function_syms ();
610 /* Pass 1: count the number of symbols. */
612 /* To find all line information, walk through all possible
613 text-space addresses (one by one!) and get the debugging
614 info for each address. When the debugging info changes,
615 it is time to create a new symbol.
617 Of course, this is rather slow and it would be better if
618 BFD would provide an iterator for enumerating all line infos. */
619 prev_name_len = PATH_MAX;
620 prev_filename_len = PATH_MAX;
621 prev_name = xmalloc (prev_name_len);
622 prev_filename = xmalloc (prev_filename_len);
626 bfd_vma vma_high = core_text_sect->vma + core_text_sect->_raw_size;
627 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
631 if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
632 || (prev_line_num == dummy.line_num
634 && strcmp (prev_name, dummy.name) == 0
635 && strcmp (prev_filename, filename) == 0))
639 prev_line_num = dummy.line_num;
641 len = strlen (dummy.name);
642 if (len >= prev_name_len)
644 prev_name_len = len + 1024;
646 prev_name = xmalloc (prev_name_len);
649 strcpy (prev_name, dummy.name);
650 len = strlen (filename);
652 if (len >= prev_filename_len)
654 prev_filename_len = len + 1024;
655 free (prev_filename);
656 prev_filename = xmalloc (prev_filename_len);
659 strcpy (prev_filename, filename);
661 min_vma = MIN (vma, min_vma);
662 max_vma = MAX (vma, max_vma);
666 free (prev_filename);
668 /* Make room for function symbols, too. */
669 ltab.len += symtab.len;
670 ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
671 ltab.limit = ltab.base;
673 /* Pass 2 - create symbols. */
675 /* We now set is_static as we go along, rather than by running
676 through the symbol table at the end.
678 The old way called symtab_finalize before the is_static pass,
679 causing a problem since symtab_finalize uses is_static as part of
680 its address conflict resolution algorithm. Since global symbols
681 were prefered over static symbols, and all line symbols were
682 global at that point, static function names that conflicted with
683 their own line numbers (static, but labeled as global) were
684 rejected in favor of the line num.
686 This was not the desired functionality. We always want to keep
687 our function symbols and discard any conflicting line symbols.
688 Perhaps symtab_finalize should be modified to make this
689 distinction as well, but the current fix works and the code is a
693 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
695 sym_init (ltab.limit);
697 if (!get_src_info (vma, &filename, <ab.limit->name, <ab.limit->line_num)
698 || (prev && prev->line_num == ltab.limit->line_num
699 && strcmp (prev->name, ltab.limit->name) == 0
700 && strcmp (prev->file->name, filename) == 0))
703 /* Make name pointer a malloc'ed string. */
704 ltab.limit->name = xstrdup (ltab.limit->name);
705 ltab.limit->file = source_file_lookup_path (filename);
707 ltab.limit->addr = vma;
709 /* Set is_static based on the enclosing function, using either:
710 1) the previous symbol, if it's from the same function, or
711 2) a symtab lookup. */
712 if (prev && ltab.limit->file == prev->file &&
713 strcmp (ltab.limit->name, prev->name) == 0)
715 ltab.limit->is_static = prev->is_static;
719 sym = sym_lookup(&symtab, ltab.limit->addr);
720 ltab.limit->is_static = sym->is_static;
725 /* If we see "main" without an initial '_', we assume names
726 are *not* prefixed by '_'. */
727 if (ltab.limit->name[0] == 'm' && discard_underscores
728 && strcmp (ltab.limit->name, "main") == 0)
729 discard_underscores = 0;
731 DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
732 (unsigned long) (ltab.limit - ltab.base),
734 (unsigned long) ltab.limit->addr));
738 /* Update sentinels. */
739 sentinel = sym_lookup (&symtab, (bfd_vma) 0);
742 && strcmp (sentinel->name, "<locore>") == 0
743 && min_vma <= sentinel->end_addr)
744 sentinel->end_addr = min_vma - 1;
746 sentinel = sym_lookup (&symtab, ~(bfd_vma) 0);
749 && strcmp (sentinel->name, "<hicore>") == 0
750 && max_vma >= sentinel->addr)
751 sentinel->addr = max_vma + 1;
753 /* Copy in function symbols. */
754 memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
755 ltab.limit += symtab.len;
757 if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
760 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
761 whoami, ltab.len, (long) (ltab.limit - ltab.base));
765 /* Finalize ltab and make it symbol table. */
766 symtab_finalize (<ab);