9 asection
*core_text_sect
;
15 /* For mapping symbols to specific .o files during file ordering. */
21 struct function_map
*symbol_map
;
24 extern void i386_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
25 extern void alpha_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
26 extern void vax_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
27 extern void tahoe_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
28 extern void sparc_find_call
PARAMS ((Sym
*, bfd_vma
, bfd_vma
));
31 DEFUN (read_function_mappings
, (filename
), const char *filename
)
33 FILE *file
= fopen (filename
, "r");
39 fprintf (stderr
, "%s: could not open %s.\n", whoami
, filename
);
43 /* First parse the mapping file so we know how big we need to
44 make our tables. We also do some sanity checks at this
50 matches
= fscanf (file
, "%[^\n:]", dummy
);
53 fprintf (stderr
, "%s: unable to parse mapping file %s.\n",
58 /* Just skip messages about files with no symbols. */
59 if (!strncmp (dummy
, "No symbols in ", 14))
65 /* Don't care what else is on this line at this point. */
66 fscanf (file
, "%[^\n]\n", dummy
);
70 /* Now we know how big we need to make our table. */
71 symbol_map
= ((struct function_map
*)
72 xmalloc (count
* sizeof (struct function_map
)));
74 /* Rewind the input file so we can read it again. */
77 /* Read each entry and put it into the table. */
84 matches
= fscanf (file
, "%[^\n:]", dummy
);
87 fprintf (stderr
, "%s: unable to parse mapping file %s.\n",
92 /* Just skip messages about files with no symbols. */
93 if (!strncmp (dummy
, "No symbols in ", 14))
99 /* dummy has the filename, go ahead and copy it. */
100 symbol_map
[count
].file_name
= xmalloc (strlen (dummy
) + 1);
101 strcpy (symbol_map
[count
].file_name
, dummy
);
103 /* Now we need the function name. */
104 fscanf (file
, "%[^\n]\n", dummy
);
105 tmp
= strrchr (dummy
, ' ') + 1;
106 symbol_map
[count
].function_name
= xmalloc (strlen (tmp
) + 1);
107 strcpy (symbol_map
[count
].function_name
, tmp
);
111 /* Record the size of the map table for future reference. */
112 symbol_map_count
= count
;
116 DEFUN (core_init
, (a_out_name
), const char *a_out_name
)
118 core_bfd
= bfd_openr (a_out_name
, 0);
126 if (!bfd_check_format (core_bfd
, bfd_object
))
128 fprintf (stderr
, "%s: %s: not in a.out format\n", whoami
, a_out_name
);
132 /* get core's text section: */
133 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
136 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
139 fprintf (stderr
, "%s: can't find .text section in %s\n",
145 /* read core's symbol table: */
147 /* this will probably give us more than we need, but that's ok: */
148 core_num_syms
= bfd_get_symtab_upper_bound (core_bfd
);
149 if (core_num_syms
< 0)
151 fprintf (stderr
, "%s: %s: %s\n", whoami
, a_out_name
,
152 bfd_errmsg (bfd_get_error ()));
156 core_syms
= (asymbol
**) xmalloc (core_num_syms
);
157 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
158 if (core_num_syms
< 0)
160 fprintf (stderr
, "%s: %s: %s\n", whoami
, a_out_name
,
161 bfd_errmsg (bfd_get_error ()));
168 switch (bfd_get_arch (core_bfd
))
183 if (function_mapping_file
)
184 read_function_mappings (function_mapping_file
);
189 * Read in the text space of an a.out file
192 DEFUN (core_get_text_space
, (core_bfd
), bfd
* core_bfd
)
194 core_text_space
= (PTR
) malloc (core_text_sect
->_raw_size
);
196 if (!core_text_space
)
198 fprintf (stderr
, "%s: ran out room for %ld bytes of text space\n",
199 whoami
, core_text_sect
->_raw_size
);
202 if (!bfd_get_section_contents (core_bfd
, core_text_sect
, core_text_space
,
203 0, core_text_sect
->_raw_size
))
205 bfd_perror ("bfd_get_section_contents");
206 free (core_text_space
);
209 if (!core_text_space
)
211 fprintf (stderr
, "%s: can't do -c\n", whoami
);
217 DEFUN (find_call
, (parent
, p_lowpc
, p_highpc
),
218 Sym
* parent AND bfd_vma p_lowpc AND bfd_vma p_highpc
)
220 switch (bfd_get_arch (core_bfd
))
223 i386_find_call (parent
, p_lowpc
, p_highpc
);
227 alpha_find_call (parent
, p_lowpc
, p_highpc
);
231 vax_find_call (parent
, p_lowpc
, p_highpc
);
235 sparc_find_call (parent
, p_lowpc
, p_highpc
);
239 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
243 fprintf (stderr
, "%s: -c not supported on architecture %s\n",
244 whoami
, bfd_printable_name(core_bfd
));
246 /* Don't give the error more than once. */
247 ignore_direct_calls
= FALSE
;
252 * Return class of symbol SYM. The returned class can be any of:
253 * 0 -> symbol is not interesting to us
254 * 'T' -> symbol is a global name
255 * 't' -> symbol is a local (static) name
258 DEFUN (core_sym_class
, (sym
), asymbol
* sym
)
265 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
271 * Must be a text symbol, and static text symbols don't qualify if
272 * ignore_static_funcs set.
274 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
276 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
281 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
286 return i
; /* it's a global symbol */
291 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
292 also be a data symbol. */
298 /* not a static text symbol */
299 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
304 /* do some more filtering on static function-names: */
306 if (ignore_static_funcs
)
311 * Can't zero-length name or funny characters in name, where
312 * `funny' includes: `.' (.o file names) and `$' (Pascal labels).
314 if (!sym
->name
|| sym
->name
[0] == '\0')
319 for (name
= sym
->name
; *name
; ++name
)
321 if (*name
== '.' || *name
== '$')
327 * On systems where the C compiler adds an underscore to all
328 * names, static names without underscores seem usually to be
329 * labels in hand written assembler in the library. We don't want
330 * these names. This is certainly necessary on a Sparc running
331 * SunOS 4.1 (try profiling a program that does a lot of
332 * division). I don't know whether it has harmful side effects on
333 * other systems. Perhaps it should be made configurable.
335 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
336 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
338 * GCC may add special symbols to help gdb figure out the file
339 * language. We want to ignore these, since sometimes they mask
340 * the real function. (dj@ctron)
342 || !strncmp (sym
->name
, "__gnu_compiled", 14)
343 || !strncmp (sym
->name
, "___gnu_compiled", 15))
348 /* If the object file supports marking of function symbols, then we can
349 zap anything that doesn't have BSF_FUNCTION set. */
350 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
353 return 't'; /* it's a static text symbol */
358 * Get whatever source info we can get regarding address ADDR:
361 DEFUN (get_src_info
, (addr
, filename
, name
, line_num
),
362 bfd_vma addr AND
const char **filename AND
const char **name
365 const char *fname
= 0, *func_name
= 0;
368 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
369 addr
- core_text_sect
->vma
,
370 &fname
, &func_name
, (unsigned int *) &l
)
371 && fname
&& func_name
&& l
)
373 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
374 addr
, fname
, l
, func_name
));
382 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
383 (long) addr
, fname
? fname
: "<unknown>", l
,
384 func_name
? func_name
: "<unknown>"));
391 * Read in symbol table from core. One symbol per function is
395 DEFUN (core_create_function_syms
, (core_bfd
), bfd
* core_bfd
)
397 bfd_vma min_vma
= ~0, max_vma
= 0;
399 long i
, j
, found
, skip
;
401 /* pass 1 - determine upper bound on number of function names: */
403 for (i
= 0; i
< core_num_syms
; ++i
)
405 if (!core_sym_class (core_syms
[i
]))
410 /* This should be replaced with a binary search or hashed
413 Don't create a symtab entry for a function that has
414 a mapping to a file, unless it's the first function
417 for (j
= 0; j
< symbol_map_count
; j
++)
418 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
420 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
421 symbol_map
[j
- 1].file_name
))
431 fprintf (stderr
, "%s: file `%s' has no symbols\n", whoami
, a_out_name
);
435 /* the "+ 2" is for the sentinels: */
436 symtab
.base
= (Sym
*) xmalloc ((symtab
.len
+ 2) * sizeof (Sym
));
438 /* pass 2 - create symbols: */
440 symtab
.limit
= symtab
.base
;
441 for (i
= 0; i
< core_num_syms
; ++i
)
443 class = core_sym_class (core_syms
[i
]);
447 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
448 core_syms
[i
]->value
, core_syms
[i
]->name
));
451 /* This should be replaced with a binary search or hashed
456 for (j
= 0; j
< symbol_map_count
; j
++)
457 if (!strcmp (core_syms
[i
]->name
, symbol_map
[j
].function_name
))
459 if (j
> 0 && ! strcmp (symbol_map
[j
].file_name
,
460 symbol_map
[j
- 1].file_name
))
470 sym_init (symtab
.limit
);
472 /* symbol offsets are always section-relative: */
474 symtab
.limit
->addr
= core_syms
[i
]->value
+ core_syms
[i
]->section
->vma
;
476 && !strcmp (core_syms
[i
]->name
, symbol_map
[found
].function_name
))
478 symtab
.limit
->name
= symbol_map
[found
].file_name
;
479 symtab
.limit
->mapped
= 1;
483 symtab
.limit
->name
= core_syms
[i
]->name
;
484 symtab
.limit
->mapped
= 0;
487 /* Lookup filename and line number, if we can */
490 const char *filename
, *func_name
;
492 if (get_src_info (symtab
.limit
->addr
, &filename
, &func_name
,
493 &symtab
.limit
->line_num
))
495 symtab
.limit
->file
= source_file_lookup_path (filename
);
497 /* FIXME: Checking __osf__ here does not work with a cross
501 * Suppress symbols that are not function names. This is
502 * useful to suppress code-labels and aliases.
504 * This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
505 * labels do not appear in the symbol table info, so this isn't
509 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
512 * The symbol's address maps to a different name, so
513 * it can't be a function-entry point. This happens
514 * for labels, for example.
517 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
518 symtab
.limit
->name
, func_name
));
525 symtab
.limit
->is_func
= TRUE
;
526 symtab
.limit
->is_bb_head
= TRUE
;
529 symtab
.limit
->is_static
= TRUE
;
532 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
533 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
536 * If we see "main" without an initial '_', we assume names
537 * are *not* prefixed by '_'.
539 if (symtab
.limit
->name
[0] == 'm' && discard_underscores
540 && strcmp (symtab
.limit
->name
, "main") == 0)
542 discard_underscores
= 0;
545 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
546 (long) (symtab
.limit
- symtab
.base
),
547 symtab
.limit
->name
, symtab
.limit
->addr
));
551 /* create sentinels: */
553 sym_init (symtab
.limit
);
554 symtab
.limit
->name
= "<locore>";
555 symtab
.limit
->addr
= 0;
556 symtab
.limit
->end_addr
= min_vma
- 1;
559 sym_init (symtab
.limit
);
560 symtab
.limit
->name
= "<hicore>";
561 symtab
.limit
->addr
= max_vma
+ 1;
562 symtab
.limit
->end_addr
= ~0;
565 symtab
.len
= symtab
.limit
- symtab
.base
;
566 symtab_finalize (&symtab
);
571 * Read in symbol table from core. One symbol per line of source code
575 DEFUN (core_create_line_syms
, (core_bfd
), bfd
* core_bfd
)
577 char prev_name
[PATH_MAX
], prev_filename
[PATH_MAX
];
578 bfd_vma vma
, min_vma
= ~0, max_vma
= 0;
580 Sym
*prev
, dummy
, *sentinel
, *sym
;
581 const char *filename
;
585 * Create symbols for functions as usual. This is necessary in
586 * cases where parts of a program were not compiled with -g. For
587 * those parts we still want to get info at the function level:
589 core_create_function_syms (core_bfd
);
591 /* pass 1 - counter number of symbols: */
594 * To find all line information, walk through all possible
595 * text-space addresses (one by one!) and get the debugging
596 * info for each address. When the debugging info changes,
597 * it is time to create a new symbol.
599 * Of course, this is rather slow and it would be better if
600 * bfd would provide an iterator for enumerating all line infos
604 prev_filename
[0] = '\0';
606 for (offset
= 0; offset
< core_text_sect
->_raw_size
; offset
+= min_insn_size
)
608 vma
= core_text_sect
->vma
+ offset
;
609 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
610 || (prev_line_num
== dummy
.line_num
&&
611 strcmp (prev_name
, dummy
.name
) == 0
612 && strcmp (prev_filename
, filename
) == 0))
618 prev_line_num
= dummy
.line_num
;
619 strcpy (prev_name
, dummy
.name
);
620 strcpy (prev_filename
, filename
);
622 min_vma
= MIN (vma
, min_vma
);
623 max_vma
= MAX (vma
, max_vma
);
626 /* make room for function symbols, too: */
627 ltab
.len
+= symtab
.len
;
628 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
629 ltab
.limit
= ltab
.base
;
631 /* pass 2 - create symbols: */
633 /* We now set is_static as we go along, rather than by running
634 through the symbol table at the end.
636 The old way called symtab_finalize before the is_static pass,
637 causing a problem since symtab_finalize uses is_static as part of
638 its address conflict resolution algorithm. Since global symbols
639 were prefered over static symbols, and all line symbols were
640 global at that point, static function names that conflicted with
641 their own line numbers (static, but labeled as global) were
642 rejected in favor of the line num.
644 This was not the desired functionality. We always want to keep
645 our function symbols and discard any conflicting line symbols.
646 Perhaps symtab_finalize should be modified to make this
647 distinction as well, but the current fix works and the code is a
651 for (offset
= 0; offset
< core_text_sect
->_raw_size
; offset
+= min_insn_size
)
653 sym_init (ltab
.limit
);
654 if (!get_src_info (core_text_sect
->vma
+ offset
, &filename
,
655 <ab
.limit
->name
, <ab
.limit
->line_num
)
656 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
657 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
658 && strcmp (prev
->file
->name
, filename
) == 0))
663 /* make name pointer a malloc'ed string: */
664 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
665 ltab
.limit
->file
= source_file_lookup_path (filename
);
667 ltab
.limit
->addr
= core_text_sect
->vma
+ offset
;
669 /* Set is_static based on the enclosing function, using either:
670 * 1) the previous symbol, if it's from the same function, or
674 if (prev
&& ltab
.limit
->file
== prev
->file
&&
675 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
677 ltab
.limit
->is_static
= prev
->is_static
;
681 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
682 ltab
.limit
->is_static
= sym
->is_static
;
688 * If we see "main" without an initial '_', we assume names
689 * are *not* prefixed by '_'.
691 if (ltab
.limit
->name
[0] == 'm' && discard_underscores
692 && strcmp (ltab
.limit
->name
, "main") == 0)
694 discard_underscores
= 0;
697 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %d %s 0x%lx\n",
698 ltab
.limit
- ltab
.base
, ltab
.limit
->name
,
703 /* update sentinels: */
705 sentinel
= sym_lookup (&symtab
, 0);
706 if (strcmp (sentinel
->name
, "<locore>") == 0
707 && min_vma
<= sentinel
->end_addr
)
709 sentinel
->end_addr
= min_vma
- 1;
712 sentinel
= sym_lookup (&symtab
, ~0);
713 if (strcmp (sentinel
->name
, "<hicore>") == 0 && max_vma
>= sentinel
->addr
)
715 sentinel
->addr
= max_vma
+ 1;
718 /* copy in function symbols: */
719 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
720 ltab
.limit
+= symtab
.len
;
722 if (ltab
.limit
- ltab
.base
!= ltab
.len
)
725 "%s: somebody miscounted: ltab.len=%d instead of %ld\n",
726 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
730 /* finalize ltab and make it symbol table: */
732 symtab_finalize (<ab
);