daily update
[binutils.git] / gprof / corefile.c
blob6b10d177488d28a1e57e660c0554cde55a5eaf66
1 /* corefile.c
3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
4 2010 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 #include "gprof.h"
24 #include "libiberty.h"
25 #include "search_list.h"
26 #include "source.h"
27 #include "symtab.h"
28 #include "hist.h"
29 #include "corefile.h"
30 #include "safe-ctype.h"
32 bfd *core_bfd;
33 static int core_num_syms;
34 static asymbol **core_syms;
35 asection *core_text_sect;
36 void * core_text_space;
38 static int min_insn_size;
39 int offset_to_code;
41 /* For mapping symbols to specific .o files during file ordering. */
42 struct function_map * symbol_map;
43 unsigned int symbol_map_count;
45 static void read_function_mappings (const char *);
46 static int core_sym_class (asymbol *);
47 static bfd_boolean get_src_info
48 (bfd_vma, const char **, const char **, int *);
50 extern void i386_find_call (Sym *, bfd_vma, bfd_vma);
51 extern void alpha_find_call (Sym *, bfd_vma, bfd_vma);
52 extern void vax_find_call (Sym *, bfd_vma, bfd_vma);
53 extern void tahoe_find_call (Sym *, bfd_vma, bfd_vma);
54 extern void sparc_find_call (Sym *, bfd_vma, bfd_vma);
55 extern void mips_find_call (Sym *, bfd_vma, bfd_vma);
57 static void
58 parse_error (const char *filename)
60 fprintf (stderr, _("%s: unable to parse mapping file %s.\n"), whoami, filename);
61 done (1);
64 /* Compare two function_map structs based on function name.
65 We want to sort in ascending order. */
67 static int
68 cmp_symbol_map (const void * l, const void * r)
70 return strcmp (((struct function_map *) l)->function_name,
71 ((struct function_map *) r)->function_name);
74 static void
75 read_function_mappings (const char *filename)
77 FILE * file = fopen (filename, "r");
78 char dummy[1024];
79 int count = 0;
80 unsigned int i;
82 if (!file)
84 fprintf (stderr, _("%s: could not open %s.\n"), whoami, filename);
85 done (1);
88 /* First parse the mapping file so we know how big we need to
89 make our tables. We also do some sanity checks at this
90 time. */
91 while (!feof (file))
93 int matches;
95 matches = fscanf (file, "%[^\n:]", dummy);
96 if (!matches)
97 parse_error (filename);
99 /* Just skip messages about files with no symbols. */
100 if (!strncmp (dummy, "No symbols in ", 14))
102 matches = fscanf (file, "\n");
103 if (matches == EOF)
104 parse_error (filename);
105 continue;
108 /* Don't care what else is on this line at this point. */
109 matches = fscanf (file, "%[^\n]\n", dummy);
110 if (!matches)
111 parse_error (filename);
112 count++;
115 /* Now we know how big we need to make our table. */
116 symbol_map = ((struct function_map *)
117 xmalloc (count * sizeof (struct function_map)));
119 /* Rewind the input file so we can read it again. */
120 rewind (file);
122 /* Read each entry and put it into the table. */
123 count = 0;
124 while (!feof (file))
126 int matches;
127 char *tmp;
129 matches = fscanf (file, "%[^\n:]", dummy);
130 if (!matches)
131 parse_error (filename);
133 /* Just skip messages about files with no symbols. */
134 if (!strncmp (dummy, "No symbols in ", 14))
136 matches = fscanf (file, "\n");
137 if (matches == EOF)
138 parse_error (filename);
139 continue;
142 /* dummy has the filename, go ahead and copy it. */
143 symbol_map[count].file_name = (char *) xmalloc (strlen (dummy) + 1);
144 strcpy (symbol_map[count].file_name, dummy);
146 /* Now we need the function name. */
147 matches = fscanf (file, "%[^\n]\n", dummy);
148 if (!matches)
149 parse_error (filename);
150 tmp = strrchr (dummy, ' ') + 1;
151 symbol_map[count].function_name = (char *) xmalloc (strlen (tmp) + 1);
152 strcpy (symbol_map[count].function_name, tmp);
153 count++;
156 /* Record the size of the map table for future reference. */
157 symbol_map_count = count;
159 for (i = 0; i < symbol_map_count; ++i)
160 if (i == 0 || strcmp (symbol_map[i].file_name, symbol_map[i - 1].file_name))
161 symbol_map[i].is_first = 1;
163 qsort (symbol_map, symbol_map_count, sizeof (struct function_map), cmp_symbol_map);
166 void
167 core_init (const char * aout_name)
169 int core_sym_bytes;
170 asymbol *synthsyms;
171 long synth_count;
173 core_bfd = bfd_openr (aout_name, 0);
175 if (!core_bfd)
177 perror (aout_name);
178 done (1);
181 if (!bfd_check_format (core_bfd, bfd_object))
183 fprintf (stderr, _("%s: %s: not in executable format\n"), whoami, aout_name);
184 done (1);
187 /* Get core's text section. */
188 core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
189 if (!core_text_sect)
191 core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
192 if (!core_text_sect)
194 fprintf (stderr, _("%s: can't find .text section in %s\n"),
195 whoami, aout_name);
196 done (1);
200 /* Read core's symbol table. */
202 /* This will probably give us more than we need, but that's ok. */
203 core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);
204 if (core_sym_bytes < 0)
206 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
207 bfd_errmsg (bfd_get_error ()));
208 done (1);
211 core_syms = (asymbol **) xmalloc (core_sym_bytes);
212 core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
214 if (core_num_syms < 0)
216 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
217 bfd_errmsg (bfd_get_error ()));
218 done (1);
221 synth_count = bfd_get_synthetic_symtab (core_bfd, core_num_syms, core_syms,
222 0, NULL, &synthsyms);
223 if (synth_count > 0)
225 asymbol **symp;
226 long new_size;
227 long i;
229 new_size = (core_num_syms + synth_count + 1) * sizeof (*core_syms);
230 core_syms = (asymbol **) xrealloc (core_syms, new_size);
231 symp = core_syms + core_num_syms;
232 core_num_syms += synth_count;
233 for (i = 0; i < synth_count; i++)
234 *symp++ = synthsyms + i;
235 *symp = 0;
238 min_insn_size = 1;
239 offset_to_code = 0;
241 switch (bfd_get_arch (core_bfd))
243 case bfd_arch_vax:
244 case bfd_arch_tahoe:
245 offset_to_code = 2;
246 break;
248 case bfd_arch_alpha:
249 min_insn_size = 4;
250 break;
252 default:
253 break;
256 if (function_mapping_file)
257 read_function_mappings (function_mapping_file);
260 /* Read in the text space of an a.out file. */
262 void
263 core_get_text_space (bfd *cbfd)
265 core_text_space = malloc (bfd_get_section_size (core_text_sect));
267 if (!core_text_space)
269 fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
270 whoami, (unsigned long) bfd_get_section_size (core_text_sect));
271 done (1);
274 if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
275 0, bfd_get_section_size (core_text_sect)))
277 bfd_perror ("bfd_get_section_contents");
278 free (core_text_space);
279 core_text_space = 0;
282 if (!core_text_space)
283 fprintf (stderr, _("%s: can't do -c\n"), whoami);
287 void
288 find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
290 if (core_text_space == 0)
291 return;
293 hist_clip_symbol_address (&p_lowpc, &p_highpc);
295 switch (bfd_get_arch (core_bfd))
297 case bfd_arch_i386:
298 i386_find_call (parent, p_lowpc, p_highpc);
299 break;
301 case bfd_arch_alpha:
302 alpha_find_call (parent, p_lowpc, p_highpc);
303 break;
305 case bfd_arch_vax:
306 vax_find_call (parent, p_lowpc, p_highpc);
307 break;
309 case bfd_arch_sparc:
310 sparc_find_call (parent, p_lowpc, p_highpc);
311 break;
313 case bfd_arch_tahoe:
314 tahoe_find_call (parent, p_lowpc, p_highpc);
315 break;
317 case bfd_arch_mips:
318 mips_find_call (parent, p_lowpc, p_highpc);
319 break;
321 default:
322 fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
323 whoami, bfd_printable_name(core_bfd));
325 /* Don't give the error more than once. */
326 ignore_direct_calls = FALSE;
330 /* Return class of symbol SYM. The returned class can be any of:
331 0 -> symbol is not interesting to us
332 'T' -> symbol is a global name
333 't' -> symbol is a local (static) name. */
335 static int
336 core_sym_class (asymbol *sym)
338 symbol_info syminfo;
339 const char *name;
340 char sym_prefix;
341 int i;
343 if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
344 return 0;
346 /* Must be a text symbol, and static text symbols
347 don't qualify if ignore_static_funcs set. */
348 if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
350 DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
351 sym->name));
352 return 0;
355 bfd_get_symbol_info (core_bfd, sym, &syminfo);
356 i = syminfo.type;
358 if (i == 'T')
359 return i; /* It's a global symbol. */
361 if (i == 'W')
362 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
363 also be a data symbol. */
364 return 'T';
366 if (i != 't')
368 /* Not a static text symbol. */
369 DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
370 sym->name, i));
371 return 0;
374 /* Do some more filtering on static function-names. */
375 if (ignore_static_funcs)
376 return 0;
378 /* Can't zero-length name or funny characters in name, where
379 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
380 if (!sym->name || sym->name[0] == '\0')
381 return 0;
383 for (name = sym->name; *name; ++name)
385 if (*name == '$')
386 return 0;
388 if (*name == '.')
390 /* Allow GCC cloned functions. */
391 if (strlen (name) > 7 && strncmp (name, ".clone.", 7) == 0)
392 name += 6;
394 /* Do not discard nested subprograms (those
395 which end with .NNN, where N are digits). */
396 for (name++; *name; name++)
397 if (! ISDIGIT (*name))
398 return 0;
400 break;
404 /* On systems where the C compiler adds an underscore to all
405 names, static names without underscores seem usually to be
406 labels in hand written assembler in the library. We don't want
407 these names. This is certainly necessary on a Sparc running
408 SunOS 4.1 (try profiling a program that does a lot of
409 division). I don't know whether it has harmful side effects on
410 other systems. Perhaps it should be made configurable. */
411 sym_prefix = bfd_get_symbol_leading_char (core_bfd);
413 if ((sym_prefix && sym_prefix != sym->name[0])
414 /* GCC may add special symbols to help gdb figure out the file
415 language. We want to ignore these, since sometimes they mask
416 the real function. (dj@ctron) */
417 || !strncmp (sym->name, "__gnu_compiled", 14)
418 || !strncmp (sym->name, "___gnu_compiled", 15))
420 return 0;
423 /* If the object file supports marking of function symbols, then
424 we can zap anything that doesn't have BSF_FUNCTION set. */
425 if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)
426 return 0;
428 return 't'; /* It's a static text symbol. */
431 /* Get whatever source info we can get regarding address ADDR. */
433 static bfd_boolean
434 get_src_info (bfd_vma addr, const char **filename, const char **name, int *line_num)
436 const char *fname = 0, *func_name = 0;
437 int l = 0;
439 if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
440 addr - core_text_sect->vma,
441 &fname, &func_name, (unsigned int *) &l)
442 && fname && func_name && l)
444 DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
445 (unsigned long) addr, fname, l, func_name));
446 *filename = fname;
447 *name = func_name;
448 *line_num = l;
449 return TRUE;
451 else
453 DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
454 (unsigned long) addr,
455 fname ? fname : "<unknown>", l,
456 func_name ? func_name : "<unknown>"));
457 return FALSE;
461 /* Return number of symbols in a symbol-table file. */
463 static int
464 num_of_syms_in (FILE * f)
466 const int BUFSIZE = 1024;
467 char * buf = (char *) xmalloc (BUFSIZE);
468 char * address = (char *) xmalloc (BUFSIZE);
469 char type;
470 char * name = (char *) xmalloc (BUFSIZE);
471 int num = 0;
473 while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
475 if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
476 if (type == 't' || type == 'T')
477 ++num;
480 free (buf);
481 free (address);
482 free (name);
484 return num;
487 /* Read symbol table from a file. */
489 void
490 core_create_syms_from (const char * sym_table_file)
492 const int BUFSIZE = 1024;
493 char * buf = (char *) xmalloc (BUFSIZE);
494 char * address = (char *) xmalloc (BUFSIZE);
495 char type;
496 char * name = (char *) xmalloc (BUFSIZE);
497 bfd_vma min_vma = ~(bfd_vma) 0;
498 bfd_vma max_vma = 0;
499 FILE * f;
501 f = fopen (sym_table_file, "r");
502 if (!f)
504 fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
505 done (1);
508 /* Pass 1 - determine upper bound on number of function names. */
509 symtab.len = num_of_syms_in (f);
511 if (symtab.len == 0)
513 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
514 done (1);
517 symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
519 /* Pass 2 - create symbols. */
520 symtab.limit = symtab.base;
522 if (fseek (f, 0, SEEK_SET) != 0)
524 perror (sym_table_file);
525 done (1);
528 while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
530 if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
531 if (type != 't' && type != 'T')
532 continue;
534 sym_init (symtab.limit);
536 sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
538 symtab.limit->name = (char *) xmalloc (strlen (name) + 1);
539 strcpy ((char *) symtab.limit->name, name);
540 symtab.limit->mapped = 0;
541 symtab.limit->is_func = TRUE;
542 symtab.limit->is_bb_head = TRUE;
543 symtab.limit->is_static = (type == 't');
544 min_vma = MIN (symtab.limit->addr, min_vma);
545 max_vma = MAX (symtab.limit->addr, max_vma);
547 ++symtab.limit;
549 fclose (f);
551 symtab.len = symtab.limit - symtab.base;
552 symtab_finalize (&symtab);
554 free (buf);
555 free (address);
556 free (name);
559 static int
560 search_mapped_symbol (const void * l, const void * r)
562 return strcmp ((const char *) l, ((const struct function_map *) r)->function_name);
565 /* Read in symbol table from core.
566 One symbol per function is entered. */
568 void
569 core_create_function_syms (void)
571 bfd_vma min_vma = ~ (bfd_vma) 0;
572 bfd_vma max_vma = 0;
573 int cxxclass;
574 long i;
575 struct function_map * found;
577 /* Pass 1 - determine upper bound on number of function names. */
578 symtab.len = 0;
580 for (i = 0; i < core_num_syms; ++i)
582 if (!core_sym_class (core_syms[i]))
583 continue;
585 /* Don't create a symtab entry for a function that has
586 a mapping to a file, unless it's the first function
587 in the file. */
588 found = (struct function_map *) bsearch (core_syms[i]->name, symbol_map,
589 symbol_map_count,
590 sizeof (struct function_map),
591 search_mapped_symbol);
592 if (found == NULL || found->is_first)
593 ++symtab.len;
596 if (symtab.len == 0)
598 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
599 done (1);
602 symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
604 /* Pass 2 - create symbols. */
605 symtab.limit = symtab.base;
607 for (i = 0; i < core_num_syms; ++i)
609 asection *sym_sec;
611 cxxclass = core_sym_class (core_syms[i]);
613 if (!cxxclass)
615 DBG (AOUTDEBUG,
616 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
617 (unsigned long) core_syms[i]->value,
618 core_syms[i]->name));
619 continue;
622 found = (struct function_map *) bsearch (core_syms[i]->name, symbol_map,
623 symbol_map_count,
624 sizeof (struct function_map), search_mapped_symbol);
625 if (found && ! found->is_first)
626 continue;
628 sym_init (symtab.limit);
630 /* Symbol offsets are always section-relative. */
631 sym_sec = core_syms[i]->section;
632 symtab.limit->addr = core_syms[i]->value;
633 if (sym_sec)
634 symtab.limit->addr += bfd_get_section_vma (sym_sec->owner, sym_sec);
636 if (found)
638 symtab.limit->name = found->file_name;
639 symtab.limit->mapped = 1;
641 else
643 symtab.limit->name = core_syms[i]->name;
644 symtab.limit->mapped = 0;
647 /* Lookup filename and line number, if we can. */
649 const char * filename;
650 const char * func_name;
652 if (get_src_info (symtab.limit->addr, & filename, & func_name,
653 & symtab.limit->line_num))
655 symtab.limit->file = source_file_lookup_path (filename);
657 /* FIXME: Checking __osf__ here does not work with a cross
658 gprof. */
659 #ifdef __osf__
660 /* Suppress symbols that are not function names. This is
661 useful to suppress code-labels and aliases.
663 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
664 labels do not appear in the symbol table info, so this isn't
665 necessary. */
667 if (strcmp (symtab.limit->name, func_name) != 0)
669 /* The symbol's address maps to a different name, so
670 it can't be a function-entry point. This happens
671 for labels, for example. */
672 DBG (AOUTDEBUG,
673 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
674 symtab.limit->name, func_name));
675 continue;
677 #endif
681 symtab.limit->is_func = (core_syms[i]->flags & BSF_FUNCTION) != 0;
682 symtab.limit->is_bb_head = TRUE;
684 if (cxxclass == 't')
685 symtab.limit->is_static = TRUE;
687 /* Keep track of the minimum and maximum vma addresses used by all
688 symbols. When computing the max_vma, use the ending address of the
689 section containing the symbol, if available. */
690 min_vma = MIN (symtab.limit->addr, min_vma);
691 if (sym_sec)
692 max_vma = MAX (bfd_get_section_vma (sym_sec->owner, sym_sec)
693 + bfd_section_size (sym_sec->owner, sym_sec) - 1,
694 max_vma);
695 else
696 max_vma = MAX (symtab.limit->addr, max_vma);
698 DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
699 (long) (symtab.limit - symtab.base),
700 symtab.limit->name,
701 (unsigned long) symtab.limit->addr));
702 ++symtab.limit;
705 symtab.len = symtab.limit - symtab.base;
706 symtab_finalize (&symtab);
709 /* Read in symbol table from core.
710 One symbol per line of source code is entered. */
712 void
713 core_create_line_syms (void)
715 char *prev_name, *prev_filename;
716 unsigned int prev_name_len, prev_filename_len;
717 bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
718 Sym *prev, dummy, *sym;
719 const char *filename;
720 int prev_line_num;
721 Sym_Table ltab;
722 bfd_vma vma_high;
724 /* Create symbols for functions as usual. This is necessary in
725 cases where parts of a program were not compiled with -g. For
726 those parts we still want to get info at the function level. */
727 core_create_function_syms ();
729 /* Pass 1: count the number of symbols. */
731 /* To find all line information, walk through all possible
732 text-space addresses (one by one!) and get the debugging
733 info for each address. When the debugging info changes,
734 it is time to create a new symbol.
736 Of course, this is rather slow and it would be better if
737 BFD would provide an iterator for enumerating all line infos. */
738 prev_name_len = PATH_MAX;
739 prev_filename_len = PATH_MAX;
740 prev_name = (char *) xmalloc (prev_name_len);
741 prev_filename = (char *) xmalloc (prev_filename_len);
742 ltab.len = 0;
743 prev_line_num = 0;
745 vma_high = core_text_sect->vma + bfd_get_section_size (core_text_sect);
746 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
748 unsigned int len;
750 if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
751 || (prev_line_num == dummy.line_num
752 && prev_name != NULL
753 && strcmp (prev_name, dummy.name) == 0
754 && strcmp (prev_filename, filename) == 0))
755 continue;
757 ++ltab.len;
758 prev_line_num = dummy.line_num;
760 len = strlen (dummy.name);
761 if (len >= prev_name_len)
763 prev_name_len = len + 1024;
764 free (prev_name);
765 prev_name = (char *) xmalloc (prev_name_len);
768 strcpy (prev_name, dummy.name);
769 len = strlen (filename);
771 if (len >= prev_filename_len)
773 prev_filename_len = len + 1024;
774 free (prev_filename);
775 prev_filename = (char *) xmalloc (prev_filename_len);
778 strcpy (prev_filename, filename);
780 min_vma = MIN (vma, min_vma);
781 max_vma = MAX (vma, max_vma);
784 free (prev_name);
785 free (prev_filename);
787 /* Make room for function symbols, too. */
788 ltab.len += symtab.len;
789 ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
790 ltab.limit = ltab.base;
792 /* Pass 2 - create symbols. */
794 /* We now set is_static as we go along, rather than by running
795 through the symbol table at the end.
797 The old way called symtab_finalize before the is_static pass,
798 causing a problem since symtab_finalize uses is_static as part of
799 its address conflict resolution algorithm. Since global symbols
800 were prefered over static symbols, and all line symbols were
801 global at that point, static function names that conflicted with
802 their own line numbers (static, but labeled as global) were
803 rejected in favor of the line num.
805 This was not the desired functionality. We always want to keep
806 our function symbols and discard any conflicting line symbols.
807 Perhaps symtab_finalize should be modified to make this
808 distinction as well, but the current fix works and the code is a
809 lot cleaner now. */
810 prev = 0;
812 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
814 sym_init (ltab.limit);
816 if (!get_src_info (vma, &filename, &ltab.limit->name, &ltab.limit->line_num)
817 || (prev && prev->line_num == ltab.limit->line_num
818 && strcmp (prev->name, ltab.limit->name) == 0
819 && strcmp (prev->file->name, filename) == 0))
820 continue;
822 /* Make name pointer a malloc'ed string. */
823 ltab.limit->name = xstrdup (ltab.limit->name);
824 ltab.limit->file = source_file_lookup_path (filename);
826 ltab.limit->addr = vma;
828 /* Set is_static based on the enclosing function, using either:
829 1) the previous symbol, if it's from the same function, or
830 2) a symtab lookup. */
831 if (prev && ltab.limit->file == prev->file &&
832 strcmp (ltab.limit->name, prev->name) == 0)
834 ltab.limit->is_static = prev->is_static;
836 else
838 sym = sym_lookup(&symtab, ltab.limit->addr);
839 if (sym)
840 ltab.limit->is_static = sym->is_static;
843 prev = ltab.limit;
845 DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
846 (unsigned long) (ltab.limit - ltab.base),
847 ltab.limit->name,
848 (unsigned long) ltab.limit->addr));
849 ++ltab.limit;
852 /* Copy in function symbols. */
853 memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
854 ltab.limit += symtab.len;
856 if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
858 fprintf (stderr,
859 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
860 whoami, ltab.len, (long) (ltab.limit - ltab.base));
861 done (1);
864 /* Finalize ltab and make it symbol table. */
865 symtab_finalize (&ltab);
866 free (symtab.base);
867 symtab = ltab;