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"
30 asection *core_text_sect;
36 /* For mapping symbols to specific .o files during file ordering. */
43 struct function_map *symbol_map;
44 unsigned int symbol_map_count;
46 extern void i386_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
47 extern void alpha_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
48 extern void vax_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
49 extern void tahoe_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
50 extern void sparc_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
51 extern void mips_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
54 DEFUN (read_function_mappings, (filename), const char *filename)
56 FILE *file = fopen (filename, "r");
62 fprintf (stderr, _("%s: could not open %s.\n"), whoami, filename);
66 /* First parse the mapping file so we know how big we need to
67 make our tables. We also do some sanity checks at this
73 matches = fscanf (file, "%[^\n:]", dummy);
76 fprintf (stderr, _("%s: unable to parse mapping file %s.\n"),
81 /* Just skip messages about files with no symbols. */
82 if (!strncmp (dummy, "No symbols in ", 14))
88 /* Don't care what else is on this line at this point. */
89 fscanf (file, "%[^\n]\n", dummy);
93 /* Now we know how big we need to make our table. */
94 symbol_map = ((struct function_map *)
95 xmalloc (count * sizeof (struct function_map)));
97 /* Rewind the input file so we can read it again. */
100 /* Read each entry and put it into the table. */
107 matches = fscanf (file, "%[^\n:]", dummy);
110 fprintf (stderr, _("%s: unable to parse mapping file %s.\n"),
115 /* Just skip messages about files with no symbols. */
116 if (!strncmp (dummy, "No symbols in ", 14))
122 /* dummy has the filename, go ahead and copy it. */
123 symbol_map[count].file_name = xmalloc (strlen (dummy) + 1);
124 strcpy (symbol_map[count].file_name, dummy);
126 /* Now we need the function name. */
127 fscanf (file, "%[^\n]\n", dummy);
128 tmp = strrchr (dummy, ' ') + 1;
129 symbol_map[count].function_name = xmalloc (strlen (tmp) + 1);
130 strcpy (symbol_map[count].function_name, tmp);
134 /* Record the size of the map table for future reference. */
135 symbol_map_count = count;
140 DEFUN (core_init, (a_out_name), const char *a_out_name)
142 core_bfd = bfd_openr (a_out_name, 0);
150 if (!bfd_check_format (core_bfd, bfd_object))
152 fprintf (stderr, _("%s: %s: not in a.out format\n"), whoami, a_out_name);
156 /* Get core's text section. */
157 core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
160 core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
163 fprintf (stderr, _("%s: can't find .text section in %s\n"),
169 /* Read core's symbol table. */
171 /* This will probably give us more than we need, but that's ok. */
172 core_num_syms = bfd_get_symtab_upper_bound (core_bfd);
173 if (core_num_syms < 0)
175 fprintf (stderr, "%s: %s: %s\n", whoami, a_out_name,
176 bfd_errmsg (bfd_get_error ()));
180 core_syms = (asymbol **) xmalloc (core_num_syms);
181 core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
183 if (core_num_syms < 0)
185 fprintf (stderr, "%s: %s: %s\n", whoami, a_out_name,
186 bfd_errmsg (bfd_get_error ()));
193 switch (bfd_get_arch (core_bfd))
208 if (function_mapping_file)
209 read_function_mappings (function_mapping_file);
212 /* Read in the text space of an a.out file. */
215 DEFUN (core_get_text_space, (core_bfd), bfd * core_bfd)
217 core_text_space = (PTR) malloc (core_text_sect->_raw_size);
219 if (!core_text_space)
221 fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
222 whoami, (unsigned long) core_text_sect->_raw_size);
226 if (!bfd_get_section_contents (core_bfd, core_text_sect, core_text_space,
227 0, core_text_sect->_raw_size))
229 bfd_perror ("bfd_get_section_contents");
230 free (core_text_space);
234 if (!core_text_space)
235 fprintf (stderr, _("%s: can't do -c\n"), whoami);
240 DEFUN (find_call, (parent, p_lowpc, p_highpc),
241 Sym * parent AND bfd_vma p_lowpc AND bfd_vma p_highpc)
243 switch (bfd_get_arch (core_bfd))
246 i386_find_call (parent, p_lowpc, p_highpc);
250 alpha_find_call (parent, p_lowpc, p_highpc);
254 vax_find_call (parent, p_lowpc, p_highpc);
258 sparc_find_call (parent, p_lowpc, p_highpc);
262 tahoe_find_call (parent, p_lowpc, p_highpc);
266 mips_find_call (parent, p_lowpc, p_highpc);
270 fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
271 whoami, bfd_printable_name(core_bfd));
273 /* Don't give the error more than once. */
274 ignore_direct_calls = FALSE;
278 /* Return class of symbol SYM. The returned class can be any of:
279 0 -> symbol is not interesting to us
280 'T' -> symbol is a global name
281 't' -> symbol is a local (static) name. */
284 DEFUN (core_sym_class, (sym), asymbol * sym)
291 if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
294 /* Must be a text symbol, and static text symbols
295 don't qualify if ignore_static_funcs set. */
296 if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
298 DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
303 bfd_get_symbol_info (core_bfd, sym, &syminfo);
307 return i; /* It's a global symbol. */
310 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
311 also be a data symbol. */
316 /* Not a static text symbol. */
317 DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
322 /* Do some more filtering on static function-names. */
323 if (ignore_static_funcs)
326 /* Can't zero-length name or funny characters in name, where
327 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
328 if (!sym->name || sym->name[0] == '\0')
331 for (name = sym->name; *name; ++name)
333 if (*name == '.' || *name == '$')
337 /* On systems where the C compiler adds an underscore to all
338 names, static names without underscores seem usually to be
339 labels in hand written assembler in the library. We don't want
340 these names. This is certainly necessary on a Sparc running
341 SunOS 4.1 (try profiling a program that does a lot of
342 division). I don't know whether it has harmful side effects on
343 other systems. Perhaps it should be made configurable. */
344 sym_prefix = bfd_get_symbol_leading_char (core_bfd);
346 if ((sym_prefix && sym_prefix != sym->name[0])
347 /* GCC may add special symbols to help gdb figure out the file
348 language. We want to ignore these, since sometimes they mask
349 the real function. (dj@ctron) */
350 || !strncmp (sym->name, "__gnu_compiled", 14)
351 || !strncmp (sym->name, "___gnu_compiled", 15))
356 /* If the object file supports marking of function symbols, then
357 we can zap anything that doesn't have BSF_FUNCTION set. */
358 if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)
361 return 't'; /* It's a static text symbol. */
364 /* Get whatever source info we can get regarding address ADDR. */
367 DEFUN (get_src_info, (addr, filename, name, line_num),
368 bfd_vma addr AND const char **filename AND const char **name
371 const char *fname = 0, *func_name = 0;
374 if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
375 addr - core_text_sect->vma,
376 &fname, &func_name, (unsigned int *) &l)
377 && fname && func_name && l)
379 DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
380 (unsigned long) addr, fname, l, func_name));
388 DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
389 (long) addr, fname ? fname : "<unknown>", l,
390 func_name ? func_name : "<unknown>"));
395 /* Read in symbol table from core.
396 One symbol per function is entered. */
399 core_create_function_syms (core_bfd)
400 bfd *core_bfd ATTRIBUTE_UNUSED;
402 bfd_vma min_vma = ~0, max_vma = 0;
407 /* Pass 1 - determine upper bound on number of function names. */
410 for (i = 0; i < core_num_syms; ++i)
412 if (!core_sym_class (core_syms[i]))
415 /* This should be replaced with a binary search or hashed
418 Don't create a symtab entry for a function that has
419 a mapping to a file, unless it's the first function
422 for (j = 0; j < symbol_map_count; j++)
423 if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
425 if (j > 0 && ! strcmp (symbol_map [j].file_name,
426 symbol_map [j - 1].file_name))
437 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
441 /* The "+ 2" is for the sentinels. */
442 symtab.base = (Sym *) xmalloc ((symtab.len + 2) * sizeof (Sym));
444 /* Pass 2 - create symbols. */
445 symtab.limit = symtab.base;
447 for (i = 0; i < core_num_syms; ++i)
449 class = core_sym_class (core_syms[i]);
454 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
455 (unsigned long) core_syms[i]->value,
456 core_syms[i]->name));
460 /* This should be replaced with a binary search or hashed
465 for (j = 0; j < symbol_map_count; j++)
466 if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
468 if (j > 0 && ! strcmp (symbol_map [j].file_name,
469 symbol_map [j - 1].file_name))
479 sym_init (symtab.limit);
481 /* Symbol offsets are always section-relative. */
482 symtab.limit->addr = core_syms[i]->value + core_syms[i]->section->vma;
485 && !strcmp (core_syms[i]->name, symbol_map[found].function_name))
487 symtab.limit->name = symbol_map[found].file_name;
488 symtab.limit->mapped = 1;
492 symtab.limit->name = core_syms[i]->name;
493 symtab.limit->mapped = 0;
496 /* Lookup filename and line number, if we can. */
498 const char *filename, *func_name;
500 if (get_src_info (symtab.limit->addr, &filename, &func_name,
501 &symtab.limit->line_num))
503 symtab.limit->file = source_file_lookup_path (filename);
505 /* FIXME: Checking __osf__ here does not work with a cross
508 /* Suppress symbols that are not function names. This is
509 useful to suppress code-labels and aliases.
511 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
512 labels do not appear in the symbol table info, so this isn't
515 if (strcmp (symtab.limit->name, func_name) != 0)
517 /* The symbol's address maps to a different name, so
518 it can't be a function-entry point. This happens
519 for labels, for example. */
521 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
522 symtab.limit->name, func_name));
529 symtab.limit->is_func = TRUE;
530 symtab.limit->is_bb_head = TRUE;
533 symtab.limit->is_static = TRUE;
535 min_vma = MIN (symtab.limit->addr, min_vma);
536 max_vma = MAX (symtab.limit->addr, max_vma);
538 /* If we see "main" without an initial '_', we assume names
539 are *not* prefixed by '_'. */
540 if (symtab.limit->name[0] == 'm' && discard_underscores
541 && strcmp (symtab.limit->name, "main") == 0)
542 discard_underscores = 0;
544 DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
545 (long) (symtab.limit - symtab.base),
547 (unsigned long) symtab.limit->addr));
551 /* Create sentinels. */
552 sym_init (symtab.limit);
553 symtab.limit->name = "<locore>";
554 symtab.limit->addr = 0;
555 symtab.limit->end_addr = min_vma - 1;
558 sym_init (symtab.limit);
559 symtab.limit->name = "<hicore>";
560 symtab.limit->addr = max_vma + 1;
561 symtab.limit->end_addr = ~0;
564 symtab.len = symtab.limit - symtab.base;
565 symtab_finalize (&symtab);
568 /* Read in symbol table from core.
569 One symbol per line of source code is entered. */
572 DEFUN (core_create_line_syms, (core_bfd), bfd * core_bfd)
574 char *prev_name, *prev_filename;
575 int prev_name_len, prev_filename_len;
576 bfd_vma vma, min_vma = ~0, max_vma = 0;
578 Sym *prev, dummy, *sentinel, *sym;
579 const char *filename;
583 /* Create symbols for functions as usual. This is necessary in
584 cases where parts of a program were not compiled with -g. For
585 those parts we still want to get info at the function level. */
586 core_create_function_syms (core_bfd);
588 /* Pass 1 - counter number of symbols. */
590 /* To find all line information, walk through all possible
591 text-space addresses (one by one!) and get the debugging
592 info for each address. When the debugging info changes,
593 it is time to create a new symbol.
595 Of course, this is rather slow and it would be better if
596 bfd would provide an iterator for enumerating all line infos. */
597 prev_name_len = PATH_MAX;
598 prev_filename_len = PATH_MAX;
599 prev_name = xmalloc (prev_name_len);
600 prev_filename = xmalloc (prev_filename_len);
604 for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
608 vma = core_text_sect->vma + offset;
610 if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
611 || (prev_line_num == dummy.line_num
613 && strcmp (prev_name, dummy.name) == 0
614 && strcmp (prev_filename, filename) == 0))
618 prev_line_num = dummy.line_num;
620 len = strlen (dummy.name);
621 if (len >= prev_name_len)
623 prev_name_len = len + 1024;
625 prev_name = xmalloc (prev_name_len);
628 strcpy (prev_name, dummy.name);
629 len = strlen (filename);
631 if (len >= prev_filename_len)
633 prev_filename_len = len + 1024;
634 free (prev_filename);
635 prev_filename = xmalloc (prev_filename_len);
638 strcpy (prev_filename, filename);
640 min_vma = MIN (vma, min_vma);
641 max_vma = MAX (vma, max_vma);
645 free (prev_filename);
647 /* Make room for function symbols, too. */
648 ltab.len += symtab.len;
649 ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
650 ltab.limit = ltab.base;
652 /* Pass 2 - create symbols. */
654 /* We now set is_static as we go along, rather than by running
655 through the symbol table at the end.
657 The old way called symtab_finalize before the is_static pass,
658 causing a problem since symtab_finalize uses is_static as part of
659 its address conflict resolution algorithm. Since global symbols
660 were prefered over static symbols, and all line symbols were
661 global at that point, static function names that conflicted with
662 their own line numbers (static, but labeled as global) were
663 rejected in favor of the line num.
665 This was not the desired functionality. We always want to keep
666 our function symbols and discard any conflicting line symbols.
667 Perhaps symtab_finalize should be modified to make this
668 distinction as well, but the current fix works and the code is a
672 for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
674 sym_init (ltab.limit);
676 if (!get_src_info (core_text_sect->vma + offset, &filename,
677 <ab.limit->name, <ab.limit->line_num)
678 || (prev && prev->line_num == ltab.limit->line_num
679 && strcmp (prev->name, ltab.limit->name) == 0
680 && strcmp (prev->file->name, filename) == 0))
683 /* Make name pointer a malloc'ed string. */
684 ltab.limit->name = xstrdup (ltab.limit->name);
685 ltab.limit->file = source_file_lookup_path (filename);
687 ltab.limit->addr = core_text_sect->vma + offset;
689 /* Set is_static based on the enclosing function, using either:
690 1) the previous symbol, if it's from the same function, or
691 2) a symtab lookup. */
692 if (prev && ltab.limit->file == prev->file &&
693 strcmp (ltab.limit->name, prev->name) == 0)
695 ltab.limit->is_static = prev->is_static;
699 sym = sym_lookup(&symtab, ltab.limit->addr);
700 ltab.limit->is_static = sym->is_static;
705 /* If we see "main" without an initial '_', we assume names
706 are *not* prefixed by '_'. */
707 if (ltab.limit->name[0] == 'm' && discard_underscores
708 && strcmp (ltab.limit->name, "main") == 0)
709 discard_underscores = 0;
711 DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
712 (unsigned long) (ltab.limit - ltab.base),
714 (unsigned long) ltab.limit->addr));
718 /* Update sentinels. */
719 sentinel = sym_lookup (&symtab, 0);
721 if (strcmp (sentinel->name, "<locore>") == 0
722 && min_vma <= sentinel->end_addr)
723 sentinel->end_addr = min_vma - 1;
725 sentinel = sym_lookup (&symtab, ~0);
727 if (strcmp (sentinel->name, "<hicore>") == 0 && max_vma >= sentinel->addr)
728 sentinel->addr = max_vma + 1;
730 /* Copy in function symbols. */
731 memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
732 ltab.limit += symtab.len;
734 if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
737 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
738 whoami, ltab.len, (long) (ltab.limit - ltab.base));
742 /* Finalize ltab and make it symbol table. */
743 symtab_finalize (<ab);