1 /* corefile.c
2
3 Copyright (C) 1999-2022 Free Software Foundation, Inc.
4
5 This file is part of GNU Binutils.
6
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 3 of the License, or
10 (at your option) any later version.
11
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.
16
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., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 #include "gprof.h"
23 #include "libiberty.h"
24 #include "filenames.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"
31 #include <limits.h> /* For UINT_MAX. */
32
33 #include <stdlib.h>
34
35 bfd *core_bfd;
36 static int core_num_syms;
37 static asymbol **core_syms;
38 asection *core_text_sect;
39 void * core_text_space;
40
41 static int min_insn_size;
42 int offset_to_code;
43
44 /* For mapping symbols to specific .o files during file ordering. */
45 struct function_map * symbol_map;
46 unsigned int symbol_map_count;
47
48 static void read_function_mappings (const char *);
49 static int core_sym_class (asymbol *);
50 static bool get_src_info
51 (bfd_vma, const char **, const char **, int *);
52
53 extern void i386_find_call (Sym *, bfd_vma, bfd_vma);
54 extern void alpha_find_call (Sym *, bfd_vma, bfd_vma);
55 extern void vax_find_call (Sym *, bfd_vma, bfd_vma);
56 extern void sparc_find_call (Sym *, bfd_vma, bfd_vma);
57 extern void mips_find_call (Sym *, bfd_vma, bfd_vma);
58 extern void aarch64_find_call (Sym *, bfd_vma, bfd_vma);
59
60 static void
parse_error(const char * filename)61 parse_error (const char *filename)
62 {
63 fprintf (stderr, _("%s: unable to parse mapping file %s.\n"), whoami, filename);
64 done (1);
65 }
66
67 /* Compare two function_map structs based on function name.
68 We want to sort in ascending order. */
69
70 static int
cmp_symbol_map(const void * l,const void * r)71 cmp_symbol_map (const void * l, const void * r)
72 {
73 return strcmp (((struct function_map *) l)->function_name,
74 ((struct function_map *) r)->function_name);
75 }
76
77 #define BUFSIZE (1024)
78 /* This is BUFSIZE - 1 as a string. Suitable for use in fprintf/sscanf format strings. */
79 #define STR_BUFSIZE "1023"
80
81 static void
read_function_mappings(const char * filename)82 read_function_mappings (const char *filename)
83 {
84 FILE * file = fopen (filename, "r");
85 char dummy[BUFSIZE];
86 int count = 0;
87 unsigned int i;
88
89 if (!file)
90 {
91 fprintf (stderr, _("%s: could not open %s.\n"), whoami, filename);
92 done (1);
93 }
94
95 /* First parse the mapping file so we know how big we need to
96 make our tables. We also do some sanity checks at this
97 time. */
98 while (!feof (file))
99 {
100 int matches;
101
102 matches = fscanf (file, "%" STR_BUFSIZE "[^\n:]", dummy);
103 if (!matches)
104 parse_error (filename);
105
106 /* Just skip messages about files with no symbols. */
107 if (!strncmp (dummy, "No symbols in ", 14))
108 {
109 matches = fscanf (file, "\n");
110 if (matches == EOF)
111 parse_error (filename);
112 continue;
113 }
114
115 /* Don't care what else is on this line at this point. */
116 matches = fscanf (file, "%" STR_BUFSIZE "[^\n]\n", dummy);
117 if (!matches)
118 parse_error (filename);
119 count++;
120 }
121
122 /* Now we know how big we need to make our table. */
123 symbol_map = ((struct function_map *)
124 xmalloc (count * sizeof (struct function_map)));
125
126 /* Rewind the input file so we can read it again. */
127 rewind (file);
128
129 /* Read each entry and put it into the table. */
130 count = 0;
131 while (!feof (file))
132 {
133 int matches;
134 char *tmp;
135
136 matches = fscanf (file, "%" STR_BUFSIZE "[^\n:]", dummy);
137 if (!matches)
138 parse_error (filename);
139
140 /* Just skip messages about files with no symbols. */
141 if (!strncmp (dummy, "No symbols in ", 14))
142 {
143 matches = fscanf (file, "\n");
144 if (matches == EOF)
145 parse_error (filename);
146 continue;
147 }
148
149 /* dummy has the filename, go ahead and copy it. */
150 symbol_map[count].file_name = (char *) xmalloc (strlen (dummy) + 1);
151 strcpy (symbol_map[count].file_name, dummy);
152
153 /* Now we need the function name. */
154 matches = fscanf (file, "%" STR_BUFSIZE "[^\n]\n", dummy);
155 if (!matches)
156 parse_error (filename);
157 tmp = strrchr (dummy, ' ') + 1;
158 symbol_map[count].function_name = (char *) xmalloc (strlen (tmp) + 1);
159 strcpy (symbol_map[count].function_name, tmp);
160 count++;
161 }
162
163 /* Record the size of the map table for future reference. */
164 symbol_map_count = count;
165
166 for (i = 0; i < symbol_map_count; ++i)
167 if (i == 0
168 || filename_cmp (symbol_map[i].file_name, symbol_map[i - 1].file_name))
169 symbol_map[i].is_first = 1;
170
171 qsort (symbol_map, symbol_map_count, sizeof (struct function_map), cmp_symbol_map);
172
173 fclose (file);
174 }
175
176 void
core_init(const char * aout_name)177 core_init (const char * aout_name)
178 {
179 int core_sym_bytes;
180 asymbol *synthsyms;
181 long synth_count;
182
183 core_bfd = bfd_openr (aout_name, 0);
184
185 if (!core_bfd)
186 {
187 perror (aout_name);
188 done (1);
189 }
190
191 core_bfd->flags |= BFD_DECOMPRESS;
192
193 if (!bfd_check_format (core_bfd, bfd_object))
194 {
195 fprintf (stderr, _("%s: %s: not in executable format\n"), whoami, aout_name);
196 done (1);
197 }
198
199 /* Get core's text section. */
200 core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
201 if (!core_text_sect)
202 {
203 core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
204 if (!core_text_sect)
205 {
206 fprintf (stderr, _("%s: can't find .text section in %s\n"),
207 whoami, aout_name);
208 done (1);
209 }
210 }
211
212 /* Read core's symbol table. */
213
214 /* This will probably give us more than we need, but that's ok. */
215 core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);
216 if (core_sym_bytes < 0)
217 {
218 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
219 bfd_errmsg (bfd_get_error ()));
220 done (1);
221 }
222
223 core_syms = (asymbol **) xmalloc (core_sym_bytes);
224 core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
225
226 if (core_num_syms < 0)
227 {
228 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
229 bfd_errmsg (bfd_get_error ()));
230 done (1);
231 }
232
233 synth_count = bfd_get_synthetic_symtab (core_bfd, core_num_syms, core_syms,
234 0, NULL, &synthsyms);
235 if (synth_count > 0)
236 {
237 asymbol **symp;
238 long new_size;
239 long i;
240
241 new_size = (core_num_syms + synth_count + 1) * sizeof (*core_syms);
242 core_syms = (asymbol **) xrealloc (core_syms, new_size);
243 symp = core_syms + core_num_syms;
244 core_num_syms += synth_count;
245 for (i = 0; i < synth_count; i++)
246 *symp++ = synthsyms + i;
247 *symp = 0;
248 }
249
250 min_insn_size = 1;
251 offset_to_code = 0;
252
253 switch (bfd_get_arch (core_bfd))
254 {
255 case bfd_arch_vax:
256 offset_to_code = 2;
257 break;
258
259 case bfd_arch_alpha:
260 min_insn_size = 4;
261 break;
262
263 default:
264 break;
265 }
266
267 if (function_mapping_file)
268 read_function_mappings (function_mapping_file);
269 }
270
271 /* Read in the text space of an a.out file. */
272
273 void
core_get_text_space(bfd * cbfd)274 core_get_text_space (bfd *cbfd)
275 {
276 core_text_space = malloc (bfd_section_size (core_text_sect));
277
278 if (!core_text_space)
279 {
280 fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
281 whoami, (unsigned long) bfd_section_size (core_text_sect));
282 done (1);
283 }
284
285 if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
286 0, bfd_section_size (core_text_sect)))
287 {
288 bfd_perror ("bfd_get_section_contents");
289 free (core_text_space);
290 core_text_space = 0;
291 }
292
293 if (!core_text_space)
294 fprintf (stderr, _("%s: can't do -c\n"), whoami);
295 }
296
297
298 void
find_call(Sym * parent,bfd_vma p_lowpc,bfd_vma p_highpc)299 find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
300 {
301 if (core_text_space == 0)
302 return;
303
304 hist_clip_symbol_address (&p_lowpc, &p_highpc);
305
306 switch (bfd_get_arch (core_bfd))
307 {
308 case bfd_arch_i386:
309 i386_find_call (parent, p_lowpc, p_highpc);
310 break;
311
312 case bfd_arch_alpha:
313 alpha_find_call (parent, p_lowpc, p_highpc);
314 break;
315
316 case bfd_arch_vax:
317 vax_find_call (parent, p_lowpc, p_highpc);
318 break;
319
320 case bfd_arch_sparc:
321 sparc_find_call (parent, p_lowpc, p_highpc);
322 break;
323
324 case bfd_arch_mips:
325 mips_find_call (parent, p_lowpc, p_highpc);
326 break;
327
328 case bfd_arch_aarch64:
329 aarch64_find_call (parent, p_lowpc, p_highpc);
330 break;
331
332 default:
333 fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
334 whoami, bfd_printable_name(core_bfd));
335
336 /* Don't give the error more than once. */
337 ignore_direct_calls = false;
338 }
339 }
340
341 /* Return class of symbol SYM. The returned class can be any of:
342 0 -> symbol is not interesting to us
343 'T' -> symbol is a global name
344 't' -> symbol is a local (static) name. */
345
346 static int
core_sym_class(asymbol * sym)347 core_sym_class (asymbol *sym)
348 {
349 symbol_info syminfo;
350 const char *name;
351 char sym_prefix;
352 int i;
353
354 if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
355 return 0;
356
357 /* Must be a text symbol, and static text symbols
358 don't qualify if ignore_static_funcs set. */
359 if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
360 {
361 DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
362 sym->name));
363 return 0;
364 }
365
366 bfd_get_symbol_info (core_bfd, sym, &syminfo);
367 i = syminfo.type;
368
369 if (i == 'T')
370 return i; /* It's a global symbol. */
371
372 if (i == 'W')
373 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
374 also be a data symbol. */
375 return 'T';
376
377 if (i != 't')
378 {
379 /* Not a static text symbol. */
380 DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
381 sym->name, i));
382 return 0;
383 }
384
385 /* Do some more filtering on static function-names. */
386 if (ignore_static_funcs)
387 return 0;
388
389 /* Can't zero-length name or funny characters in name, where
390 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
391 if (!sym->name || sym->name[0] == '\0')
392 return 0;
393
394 for (name = sym->name; *name; ++name)
395 {
396 if (*name == '$')
397 return 0;
398
399 while (*name == '.')
400 {
401 /* Allow both nested subprograms (which end with ".NNN", where N is
402 a digit) and GCC cloned functions (which contain ".clone").
403 Allow for multiple iterations of both - apparently GCC can clone
404 clones and subprograms. */
405 int digit_seen = 0;
406 #define CLONE_NAME ".clone."
407 #define CLONE_NAME_LEN strlen (CLONE_NAME)
408 #define CONSTPROP_NAME ".constprop."
409 #define CONSTPROP_NAME_LEN strlen (CONSTPROP_NAME)
410
411 if (strlen (name) > CLONE_NAME_LEN
412 && strncmp (name, CLONE_NAME, CLONE_NAME_LEN) == 0)
413 name += CLONE_NAME_LEN - 1;
414
415 else if (strlen (name) > CONSTPROP_NAME_LEN
416 && strncmp (name, CONSTPROP_NAME, CONSTPROP_NAME_LEN) == 0)
417 name += CONSTPROP_NAME_LEN - 1;
418
419 for (name++; *name; name++)
420 if (digit_seen && *name == '.')
421 break;
422 else if (ISDIGIT (*name))
423 digit_seen = 1;
424 else
425 return 0;
426 }
427 }
428
429 /* On systems where the C compiler adds an underscore to all
430 names, static names without underscores seem usually to be
431 labels in hand written assembler in the library. We don't want
432 these names. This is certainly necessary on a Sparc running
433 SunOS 4.1 (try profiling a program that does a lot of
434 division). I don't know whether it has harmful side effects on
435 other systems. Perhaps it should be made configurable. */
436 sym_prefix = bfd_get_symbol_leading_char (core_bfd);
437
438 if ((sym_prefix && sym_prefix != sym->name[0])
439 /* GCC may add special symbols to help gdb figure out the file
440 language. We want to ignore these, since sometimes they mask
441 the real function. (dj@ctron) */
442 || !strncmp (sym->name, "__gnu_compiled", 14)
443 || !strncmp (sym->name, "___gnu_compiled", 15))
444 {
445 return 0;
446 }
447
448 /* If the object file supports marking of function symbols, then
449 we can zap anything that doesn't have BSF_FUNCTION set. */
450 if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)
451 return 0;
452
453 return 't'; /* It's a static text symbol. */
454 }
455
456 /* Get whatever source info we can get regarding address ADDR. */
457
458 static bool
get_src_info(bfd_vma addr,const char ** filename,const char ** name,int * line_num)459 get_src_info (bfd_vma addr, const char **filename, const char **name,
460 int *line_num)
461 {
462 const char *fname = 0, *func_name = 0;
463 int l = 0;
464
465 if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
466 addr - core_text_sect->vma,
467 &fname, &func_name, (unsigned int *) &l)
468 && fname && func_name && l)
469 {
470 DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
471 (unsigned long) addr, fname, l, func_name));
472 *filename = fname;
473 *name = func_name;
474 *line_num = l;
475 return true;
476 }
477 else
478 {
479 DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
480 (unsigned long) addr,
481 fname ? fname : "<unknown>", l,
482 func_name ? func_name : "<unknown>"));
483 return false;
484 }
485 }
486
487 static char buf[BUFSIZE];
488 static char address[BUFSIZE];
489 static char name[BUFSIZE];
490
491 /* Return number of symbols in a symbol-table file. */
492
493 static unsigned int
num_of_syms_in(FILE * f)494 num_of_syms_in (FILE * f)
495 {
496 char type;
497 unsigned int num = 0;
498
499 while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
500 {
501 if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) == 3)
502 if (type == 't' || type == 'T')
503 {
504 /* PR 20499 - prevent integer overflow computing argument to xmalloc. */
505 if (++num >= UINT_MAX / sizeof (Sym))
506 return -1U;
507 }
508 }
509
510 return num;
511 }
512
513 /* Read symbol table from a file. */
514
515 void
core_create_syms_from(const char * sym_table_file)516 core_create_syms_from (const char * sym_table_file)
517 {
518 char type;
519 bfd_vma min_vma = ~(bfd_vma) 0;
520 bfd_vma max_vma = 0;
521 FILE * f;
522
523 f = fopen (sym_table_file, "r");
524 if (!f)
525 {
526 fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
527 done (1);
528 }
529
530 /* Pass 1 - determine upper bound on number of function names. */
531 symtab.len = num_of_syms_in (f);
532
533 if (symtab.len == 0)
534 {
535 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
536 done (1);
537 }
538 else if (symtab.len == -1U)
539 {
540 fprintf (stderr, _("%s: file `%s' has too many symbols\n"),
541 whoami, sym_table_file);
542 done (1);
543 }
544
545 symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
546
547 /* Pass 2 - create symbols. */
548 symtab.limit = symtab.base;
549
550 if (fseek (f, 0, SEEK_SET) != 0)
551 {
552 perror (sym_table_file);
553 done (1);
554 }
555
556 while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
557 {
558 if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) != 3)
559 continue;
560 if (type != 't' && type != 'T')
561 continue;
562
563 sym_init (symtab.limit);
564
565 sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
566
567 symtab.limit->name = (char *) xmalloc (strlen (name) + 1);
568 strcpy ((char *) symtab.limit->name, name);
569 symtab.limit->mapped = 0;
570 symtab.limit->is_func = true;
571 symtab.limit->is_bb_head = true;
572 symtab.limit->is_static = (type == 't');
573 min_vma = MIN (symtab.limit->addr, min_vma);
574 max_vma = MAX (symtab.limit->addr, max_vma);
575
576 ++symtab.limit;
577 }
578 fclose (f);
579
580 symtab.len = symtab.limit - symtab.base;
581 symtab_finalize (&symtab);
582 }
583
584 static int
search_mapped_symbol(const void * l,const void * r)585 search_mapped_symbol (const void * l, const void * r)
586 {
587 return strcmp ((const char *) l, ((const struct function_map *) r)->function_name);
588 }
589
590 /* Read in symbol table from core.
591 One symbol per function is entered. */
592
593 void
core_create_function_syms(void)594 core_create_function_syms (void)
595 {
596 bfd_vma min_vma = ~ (bfd_vma) 0;
597 bfd_vma max_vma = 0;
598 int cxxclass;
599 long i;
600 struct function_map * found = NULL;
601 int core_has_func_syms = 0;
602
603 switch (core_bfd->xvec->flavour)
604 {
605 default:
606 break;
607 case bfd_target_coff_flavour:
608 case bfd_target_ecoff_flavour:
609 case bfd_target_xcoff_flavour:
610 case bfd_target_elf_flavour:
611 case bfd_target_som_flavour:
612 core_has_func_syms = 1;
613 }
614
615 /* Pass 1 - determine upper bound on number of function names. */
616 symtab.len = 0;
617
618 for (i = 0; i < core_num_syms; ++i)
619 {
620 if (!core_sym_class (core_syms[i]))
621 continue;
622
623 /* Don't create a symtab entry for a function that has
624 a mapping to a file, unless it's the first function
625 in the file. */
626 if (symbol_map_count != 0)
627 {
628 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
629 is NULL. */
630 found = (struct function_map *) bsearch
631 (core_syms[i]->name, symbol_map, symbol_map_count,
632 sizeof (struct function_map), search_mapped_symbol);
633 }
634 if (found == NULL || found->is_first)
635 ++symtab.len;
636 }
637
638 if (symtab.len == 0)
639 {
640 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
641 done (1);
642 }
643
644 symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
645
646 /* Pass 2 - create symbols. */
647 symtab.limit = symtab.base;
648
649 for (i = 0; i < core_num_syms; ++i)
650 {
651 asection *sym_sec;
652
653 cxxclass = core_sym_class (core_syms[i]);
654
655 if (!cxxclass)
656 {
657 DBG (AOUTDEBUG,
658 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
659 (unsigned long) core_syms[i]->value,
660 core_syms[i]->name));
661 continue;
662 }
663
664 if (symbol_map_count != 0)
665 {
666 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
667 is NULL. */
668 found = (struct function_map *) bsearch
669 (core_syms[i]->name, symbol_map, symbol_map_count,
670 sizeof (struct function_map), search_mapped_symbol);
671 }
672 if (found && ! found->is_first)
673 continue;
674
675 sym_init (symtab.limit);
676
677 /* Symbol offsets are always section-relative. */
678 sym_sec = core_syms[i]->section;
679 symtab.limit->addr = core_syms[i]->value;
680 if (sym_sec)
681 symtab.limit->addr += bfd_section_vma (sym_sec);
682
683 if (found)
684 {
685 symtab.limit->name = found->file_name;
686 symtab.limit->mapped = 1;
687 }
688 else
689 {
690 symtab.limit->name = core_syms[i]->name;
691 symtab.limit->mapped = 0;
692 }
693
694 /* Lookup filename and line number, if we can. */
695 {
696 const char * filename;
697 const char * func_name;
698
699 if (get_src_info (symtab.limit->addr, & filename, & func_name,
700 & symtab.limit->line_num))
701 {
702 symtab.limit->file = source_file_lookup_path (filename);
703
704 /* FIXME: Checking __osf__ here does not work with a cross
705 gprof. */
706 #ifdef __osf__
707 /* Suppress symbols that are not function names. This is
708 useful to suppress code-labels and aliases.
709
710 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
711 labels do not appear in the symbol table info, so this isn't
712 necessary. */
713
714 if (strcmp (symtab.limit->name, func_name) != 0)
715 {
716 /* The symbol's address maps to a different name, so
717 it can't be a function-entry point. This happens
718 for labels, for example. */
719 DBG (AOUTDEBUG,
720 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
721 symtab.limit->name, func_name));
722 continue;
723 }
724 #endif
725 }
726 }
727
728 symtab.limit->is_func = (!core_has_func_syms
729 || (core_syms[i]->flags & BSF_FUNCTION) != 0);
730 symtab.limit->is_bb_head = true;
731
732 if (cxxclass == 't')
733 symtab.limit->is_static = true;
734
735 /* Keep track of the minimum and maximum vma addresses used by all
736 symbols. When computing the max_vma, use the ending address of the
737 section containing the symbol, if available. */
738 min_vma = MIN (symtab.limit->addr, min_vma);
739 if (sym_sec)
740 max_vma = MAX (bfd_section_vma (sym_sec)
741 + bfd_section_size (sym_sec) - 1,
742 max_vma);
743 else
744 max_vma = MAX (symtab.limit->addr, max_vma);
745
746 DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
747 (long) (symtab.limit - symtab.base),
748 symtab.limit->name,
749 (unsigned long) symtab.limit->addr));
750 ++symtab.limit;
751 }
752
753 symtab.len = symtab.limit - symtab.base;
754 symtab_finalize (&symtab);
755 }
756
757 /* Read in symbol table from core.
758 One symbol per line of source code is entered. */
759
760 void
core_create_line_syms(void)761 core_create_line_syms (void)
762 {
763 char *prev_name, *prev_filename;
764 unsigned int prev_name_len, prev_filename_len;
765 bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
766 Sym *prev, dummy, *sym;
767 const char *filename;
768 int prev_line_num;
769 Sym_Table ltab;
770 bfd_vma vma_high;
771
772 /* Create symbols for functions as usual. This is necessary in
773 cases where parts of a program were not compiled with -g. For
774 those parts we still want to get info at the function level. */
775 core_create_function_syms ();
776
777 /* Pass 1: count the number of symbols. */
778
779 /* To find all line information, walk through all possible
780 text-space addresses (one by one!) and get the debugging
781 info for each address. When the debugging info changes,
782 it is time to create a new symbol.
783
784 Of course, this is rather slow and it would be better if
785 BFD would provide an iterator for enumerating all line infos. */
786 prev_name_len = 1024;
787 prev_filename_len = 1024;
788 prev_name = (char *) xmalloc (prev_name_len);
789 prev_filename = (char *) xmalloc (prev_filename_len);
790 ltab.len = 0;
791 prev_line_num = 0;
792
793 vma_high = core_text_sect->vma + bfd_section_size (core_text_sect);
794 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
795 {
796 unsigned int len;
797
798 if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
799 || (prev_line_num == dummy.line_num
800 && prev_name != NULL
801 && strcmp (prev_name, dummy.name) == 0
802 && filename_cmp (prev_filename, filename) == 0))
803 continue;
804
805 ++ltab.len;
806 prev_line_num = dummy.line_num;
807
808 len = strlen (dummy.name);
809 if (len >= prev_name_len)
810 {
811 prev_name_len = len + 1024;
812 free (prev_name);
813 prev_name = (char *) xmalloc (prev_name_len);
814 }
815
816 strcpy (prev_name, dummy.name);
817 len = strlen (filename);
818
819 if (len >= prev_filename_len)
820 {
821 prev_filename_len = len + 1024;
822 free (prev_filename);
823 prev_filename = (char *) xmalloc (prev_filename_len);
824 }
825
826 strcpy (prev_filename, filename);
827
828 min_vma = MIN (vma, min_vma);
829 max_vma = MAX (vma, max_vma);
830 }
831
832 free (prev_name);
833 free (prev_filename);
834
835 /* Make room for function symbols, too. */
836 ltab.len += symtab.len;
837 ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
838 ltab.limit = ltab.base;
839
840 /* Pass 2 - create symbols. */
841
842 /* We now set is_static as we go along, rather than by running
843 through the symbol table at the end.
844
845 The old way called symtab_finalize before the is_static pass,
846 causing a problem since symtab_finalize uses is_static as part of
847 its address conflict resolution algorithm. Since global symbols
848 were preferred over static symbols, and all line symbols were
849 global at that point, static function names that conflicted with
850 their own line numbers (static, but labeled as global) were
851 rejected in favor of the line num.
852
853 This was not the desired functionality. We always want to keep
854 our function symbols and discard any conflicting line symbols.
855 Perhaps symtab_finalize should be modified to make this
856 distinction as well, but the current fix works and the code is a
857 lot cleaner now. */
858 prev = 0;
859
860 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
861 {
862 sym_init (ltab.limit);
863
864 if (!get_src_info (vma, &filename, <ab.limit->name, <ab.limit->line_num)
865 || (prev && prev->line_num == ltab.limit->line_num
866 && strcmp (prev->name, ltab.limit->name) == 0
867 && filename_cmp (prev->file->name, filename) == 0))
868 continue;
869
870 /* Make name pointer a malloc'ed string. */
871 ltab.limit->name = xstrdup (ltab.limit->name);
872 ltab.limit->file = source_file_lookup_path (filename);
873
874 ltab.limit->addr = vma;
875
876 /* Set is_static based on the enclosing function, using either:
877 1) the previous symbol, if it's from the same function, or
878 2) a symtab lookup. */
879 if (prev && ltab.limit->file == prev->file &&
880 strcmp (ltab.limit->name, prev->name) == 0)
881 {
882 ltab.limit->is_static = prev->is_static;
883 }
884 else
885 {
886 sym = sym_lookup(&symtab, ltab.limit->addr);
887 if (sym)
888 ltab.limit->is_static = sym->is_static;
889 }
890
891 prev = ltab.limit;
892
893 DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
894 (unsigned long) (ltab.limit - ltab.base),
895 ltab.limit->name,
896 (unsigned long) ltab.limit->addr));
897 ++ltab.limit;
898 }
899
900 /* Copy in function symbols. */
901 memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
902 ltab.limit += symtab.len;
903
904 if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
905 {
906 fprintf (stderr,
907 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
908 whoami, ltab.len, (long) (ltab.limit - ltab.base));
909 done (1);
910 }
911
912 /* Finalize ltab and make it symbol table. */
913 symtab_finalize (<ab);
914 free (symtab.base);
915 symtab = ltab;
916 }
917