* mips.c: New file.
[external/binutils.git] / gprof / corefile.c
1 /* corefile.c
2
3    Copyright 2000, 2001, 2002 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 2 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., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA.  */
21 \f
22 #include "libiberty.h"
23 #include "gprof.h"
24 #include "corefile.h"
25 #include "symtab.h"
26
27 bfd *core_bfd;
28 int core_num_syms;
29 asymbol **core_syms;
30 asection *core_text_sect;
31 PTR core_text_space;
32
33 int min_insn_size;
34 int offset_to_code;
35
36 /* For mapping symbols to specific .o files during file ordering.  */
37 struct function_map
38 {
39   char *function_name;
40   char *file_name;
41 };
42
43 struct function_map *symbol_map;
44 unsigned int symbol_map_count;
45
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));
52
53 static void
54 DEFUN (read_function_mappings, (filename), const char *filename)
55 {
56   FILE *file = fopen (filename, "r");
57   char dummy[1024];
58   int count = 0;
59
60   if (!file)
61     {
62       fprintf (stderr, _("%s: could not open %s.\n"), whoami, filename);
63       done (1);
64     }
65
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
68      time.  */
69   while (!feof (file))
70     {
71       int matches;
72
73       matches = fscanf (file, "%[^\n:]", dummy);
74       if (!matches)
75         {
76           fprintf (stderr, _("%s: unable to parse mapping file %s.\n"),
77                    whoami, filename);
78           done (1);
79         }
80
81       /* Just skip messages about files with no symbols.  */
82       if (!strncmp (dummy, "No symbols in ", 14))
83         {
84           fscanf (file, "\n");
85           continue;
86         }
87
88       /* Don't care what else is on this line at this point.  */
89       fscanf (file, "%[^\n]\n", dummy);
90       count++;
91     }
92
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)));
96
97   /* Rewind the input file so we can read it again.  */
98   rewind (file);
99
100   /* Read each entry and put it into the table.  */
101   count = 0;
102   while (!feof (file))
103     {
104       int matches;
105       char *tmp;
106
107       matches = fscanf (file, "%[^\n:]", dummy);
108       if (!matches)
109         {
110           fprintf (stderr, _("%s: unable to parse mapping file %s.\n"),
111                    whoami, filename);
112           done (1);
113         }
114
115       /* Just skip messages about files with no symbols.  */
116       if (!strncmp (dummy, "No symbols in ", 14))
117         {
118           fscanf (file, "\n");
119           continue;
120         }
121
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);
125
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);
131       count++;
132     }
133
134   /* Record the size of the map table for future reference.  */
135   symbol_map_count = count;
136 }
137
138
139 void
140 DEFUN (core_init, (a_out_name), const char *a_out_name)
141 {
142   core_bfd = bfd_openr (a_out_name, 0);
143
144   if (!core_bfd)
145     {
146       perror (a_out_name);
147       done (1);
148     }
149
150   if (!bfd_check_format (core_bfd, bfd_object))
151     {
152       fprintf (stderr, _("%s: %s: not in a.out format\n"), whoami, a_out_name);
153       done (1);
154     }
155
156   /* Get core's text section.  */
157   core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
158   if (!core_text_sect)
159     {
160       core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
161       if (!core_text_sect)
162         {
163           fprintf (stderr, _("%s: can't find .text section in %s\n"),
164                    whoami, a_out_name);
165           done (1);
166         }
167     }
168
169   /* Read core's symbol table.  */
170
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)
174     {
175       fprintf (stderr, "%s: %s: %s\n", whoami, a_out_name,
176                bfd_errmsg (bfd_get_error ()));
177       done (1);
178     }
179
180   core_syms = (asymbol **) xmalloc (core_num_syms);
181   core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
182
183   if (core_num_syms < 0)
184     {
185       fprintf (stderr, "%s: %s: %s\n", whoami, a_out_name,
186                bfd_errmsg (bfd_get_error ()));
187       done (1);
188     }
189
190   min_insn_size = 1;
191   offset_to_code = 0;
192
193   switch (bfd_get_arch (core_bfd))
194     {
195     case bfd_arch_vax:
196     case bfd_arch_tahoe:
197       offset_to_code = 2;
198       break;
199
200     case bfd_arch_alpha:
201       min_insn_size = 4;
202       break;
203
204     default:
205       break;
206     }
207
208   if (function_mapping_file)
209     read_function_mappings (function_mapping_file);
210 }
211
212 /* Read in the text space of an a.out file.  */
213
214 void
215 DEFUN (core_get_text_space, (core_bfd), bfd * core_bfd)
216 {
217   core_text_space = (PTR) malloc (core_text_sect->_raw_size);
218
219   if (!core_text_space)
220     {
221       fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
222                whoami, (unsigned long) core_text_sect->_raw_size);
223       done (1);
224     }
225
226   if (!bfd_get_section_contents (core_bfd, core_text_sect, core_text_space,
227                                  0, core_text_sect->_raw_size))
228     {
229       bfd_perror ("bfd_get_section_contents");
230       free (core_text_space);
231       core_text_space = 0;
232     }
233
234   if (!core_text_space)
235     fprintf (stderr, _("%s: can't do -c\n"), whoami);
236 }
237
238
239 void
240 DEFUN (find_call, (parent, p_lowpc, p_highpc),
241        Sym * parent AND bfd_vma p_lowpc AND bfd_vma p_highpc)
242 {
243   switch (bfd_get_arch (core_bfd))
244     {
245     case bfd_arch_i386:
246       i386_find_call (parent, p_lowpc, p_highpc);
247       break;
248
249     case bfd_arch_alpha:
250       alpha_find_call (parent, p_lowpc, p_highpc);
251       break;
252
253     case bfd_arch_vax:
254       vax_find_call (parent, p_lowpc, p_highpc);
255       break;
256
257     case bfd_arch_sparc:
258       sparc_find_call (parent, p_lowpc, p_highpc);
259       break;
260
261     case bfd_arch_tahoe:
262       tahoe_find_call (parent, p_lowpc, p_highpc);
263       break;
264
265     case bfd_arch_mips:
266       mips_find_call (parent, p_lowpc, p_highpc);
267       break;
268
269     default:
270       fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
271                whoami, bfd_printable_name(core_bfd));
272
273       /* Don't give the error more than once.  */
274       ignore_direct_calls = FALSE;
275     }
276 }
277
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.  */
282
283 static int
284 DEFUN (core_sym_class, (sym), asymbol * sym)
285 {
286   symbol_info syminfo;
287   const char *name;
288   char sym_prefix;
289   int i;
290
291   if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
292     return 0;
293
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))
297     {
298       DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
299                               sym->name));
300       return 0;
301     }
302
303   bfd_get_symbol_info (core_bfd, sym, &syminfo);
304   i = syminfo.type;
305
306   if (i == 'T')
307     return i;                   /* It's a global symbol.  */
308
309   if (i == 'W')
310     /* Treat weak symbols as text symbols.  FIXME: a weak symbol may
311        also be a data symbol.  */
312     return 'T';
313
314   if (i != 't')
315     {
316       /* Not a static text symbol.  */
317       DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
318                               sym->name, i));
319       return 0;
320     }
321
322   /* Do some more filtering on static function-names.  */
323   if (ignore_static_funcs)
324     return 0;
325
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')
329     return 0;
330
331   for (name = sym->name; *name; ++name)
332     {
333       if (*name == '.' || *name == '$')
334         return 0;
335     }
336
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);
345
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))
352     {
353       return 0;
354     }
355
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)
359     return 0;
360
361   return 't';                   /* It's a static text symbol.  */
362 }
363
364 /* Get whatever source info we can get regarding address ADDR.  */
365
366 static bool
367 DEFUN (get_src_info, (addr, filename, name, line_num),
368        bfd_vma addr AND const char **filename AND const char **name
369        AND int *line_num)
370 {
371   const char *fname = 0, *func_name = 0;
372   int l = 0;
373
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)
378     {
379       DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
380                               (unsigned long) addr, fname, l, func_name));
381       *filename = fname;
382       *name = func_name;
383       *line_num = l;
384       return TRUE;
385     }
386   else
387     {
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>"));
391       return FALSE;
392     }
393 }
394
395 /* Read in symbol table from core.
396    One symbol per function is entered.  */
397
398 void
399 core_create_function_syms (core_bfd)
400      bfd *core_bfd ATTRIBUTE_UNUSED;
401 {
402   bfd_vma min_vma = ~0, max_vma = 0;
403   int class;
404   long i, found, skip;
405   unsigned int j;
406
407   /* Pass 1 - determine upper bound on number of function names.  */
408   symtab.len = 0;
409
410   for (i = 0; i < core_num_syms; ++i)
411     {
412       if (!core_sym_class (core_syms[i]))
413         continue;
414
415       /* This should be replaced with a binary search or hashed
416          search.  Gross.
417
418          Don't create a symtab entry for a function that has
419          a mapping to a file, unless it's the first function
420          in the file.  */
421       skip = 0;
422       for (j = 0; j < symbol_map_count; j++)
423         if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
424           {
425             if (j > 0 && ! strcmp (symbol_map [j].file_name,
426                                    symbol_map [j - 1].file_name))
427               skip = 1;
428             break;
429           }
430
431       if (!skip)
432         ++symtab.len;
433     }
434
435   if (symtab.len == 0)
436     {
437       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
438       done (1);
439     }
440
441   /* The "+ 2" is for the sentinels.  */
442   symtab.base = (Sym *) xmalloc ((symtab.len + 2) * sizeof (Sym));
443
444   /* Pass 2 - create symbols.  */
445   symtab.limit = symtab.base;
446
447   for (i = 0; i < core_num_syms; ++i)
448     {
449       class = core_sym_class (core_syms[i]);
450
451       if (!class)
452         {
453           DBG (AOUTDEBUG,
454                printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
455                        (unsigned long) core_syms[i]->value,
456                        core_syms[i]->name));
457           continue;
458         }
459
460       /* This should be replaced with a binary search or hashed
461          search.  Gross.   */
462       skip = 0;
463       found = 0;
464
465       for (j = 0; j < symbol_map_count; j++)
466         if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
467           {
468             if (j > 0 && ! strcmp (symbol_map [j].file_name,
469                                    symbol_map [j - 1].file_name))
470               skip = 1;
471             else
472               found = j;
473             break;
474           }
475
476       if (skip)
477         continue;
478
479       sym_init (symtab.limit);
480
481       /* Symbol offsets are always section-relative.  */
482       symtab.limit->addr = core_syms[i]->value + core_syms[i]->section->vma;
483
484       if (symbol_map_count
485           && !strcmp (core_syms[i]->name, symbol_map[found].function_name))
486         {
487           symtab.limit->name = symbol_map[found].file_name;
488           symtab.limit->mapped = 1;
489         }
490       else
491         {
492           symtab.limit->name = core_syms[i]->name;
493           symtab.limit->mapped = 0;
494         }
495
496       /* Lookup filename and line number, if we can.  */
497       {
498         const char *filename, *func_name;
499
500         if (get_src_info (symtab.limit->addr, &filename, &func_name,
501                           &symtab.limit->line_num))
502           {
503             symtab.limit->file = source_file_lookup_path (filename);
504
505             /* FIXME: Checking __osf__ here does not work with a cross
506                gprof.  */
507 #ifdef __osf__
508             /* Suppress symbols that are not function names.  This is
509                useful to suppress code-labels and aliases.
510
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
513                necessary.  */
514
515             if (strcmp (symtab.limit->name, func_name) != 0)
516               {
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.  */
520                 DBG (AOUTDEBUG,
521                      printf ("[core_create_function_syms: rej %s (maps to %s)\n",
522                              symtab.limit->name, func_name));
523                 continue;
524               }
525 #endif
526           }
527       }
528
529       symtab.limit->is_func = TRUE;
530       symtab.limit->is_bb_head = TRUE;
531
532       if (class == 't')
533         symtab.limit->is_static = TRUE;
534
535       min_vma = MIN (symtab.limit->addr, min_vma);
536       max_vma = MAX (symtab.limit->addr, max_vma);
537
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;
543
544       DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
545                               (long) (symtab.limit - symtab.base),
546                               symtab.limit->name,
547                               (unsigned long) symtab.limit->addr));
548       ++symtab.limit;
549     }
550
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;
556   ++symtab.limit;
557
558   sym_init (symtab.limit);
559   symtab.limit->name = "<hicore>";
560   symtab.limit->addr = max_vma + 1;
561   symtab.limit->end_addr = ~0;
562   ++symtab.limit;
563
564   symtab.len = symtab.limit - symtab.base;
565   symtab_finalize (&symtab);
566 }
567
568 /* Read in symbol table from core.
569    One symbol per line of source code is entered.  */
570
571 void
572 DEFUN (core_create_line_syms, (core_bfd), bfd * core_bfd)
573 {
574   char *prev_name, *prev_filename;
575   int prev_name_len, prev_filename_len;
576   bfd_vma vma, min_vma = ~0, max_vma = 0;
577   bfd_vma offset;
578   Sym *prev, dummy, *sentinel, *sym;
579   const char *filename;
580   int prev_line_num;
581   Sym_Table ltab;
582
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);
587
588   /* Pass 1 - counter number of symbols.  */
589
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.
594
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);
601   ltab.len = 0;
602   prev_line_num = 0;
603
604   for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
605     {
606       int len;
607
608       vma = core_text_sect->vma + offset;
609
610       if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
611           || (prev_line_num == dummy.line_num
612               && prev_name != NULL
613               && strcmp (prev_name, dummy.name) == 0
614               && strcmp (prev_filename, filename) == 0))
615         continue;
616
617       ++ltab.len;
618       prev_line_num = dummy.line_num;
619
620       len = strlen (dummy.name);
621       if (len >= prev_name_len)
622         {
623           prev_name_len = len + 1024;
624           free (prev_name);
625           prev_name = xmalloc (prev_name_len);
626         }
627
628       strcpy (prev_name, dummy.name);
629       len = strlen (filename);
630
631       if (len >= prev_filename_len)
632         {
633           prev_filename_len = len + 1024;
634           free (prev_filename);
635           prev_filename = xmalloc (prev_filename_len);
636         }
637
638       strcpy (prev_filename, filename);
639
640       min_vma = MIN (vma, min_vma);
641       max_vma = MAX (vma, max_vma);
642     }
643
644   free (prev_name);
645   free (prev_filename);
646
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;
651
652   /* Pass 2 - create symbols.  */
653
654   /* We now set is_static as we go along, rather than by running
655      through the symbol table at the end.
656
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.
664
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
669      lot cleaner now.  */
670   prev = 0;
671
672   for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
673     {
674       sym_init (ltab.limit);
675
676       if (!get_src_info (core_text_sect->vma + offset, &filename,
677                          &ltab.limit->name, &ltab.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))
681         continue;
682
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);
686
687       ltab.limit->addr = core_text_sect->vma + offset;
688
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)
694         {
695           ltab.limit->is_static = prev->is_static;
696         }
697       else
698         {
699           sym = sym_lookup(&symtab, ltab.limit->addr);
700           ltab.limit->is_static = sym->is_static;
701         }
702
703       prev = ltab.limit;
704
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;
710
711       DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
712                               (unsigned long) (ltab.limit - ltab.base),
713                               ltab.limit->name,
714                               (unsigned long) ltab.limit->addr));
715       ++ltab.limit;
716     }
717
718   /* Update sentinels.  */
719   sentinel = sym_lookup (&symtab, 0);
720
721   if (strcmp (sentinel->name, "<locore>") == 0
722       && min_vma <= sentinel->end_addr)
723     sentinel->end_addr = min_vma - 1;
724
725   sentinel = sym_lookup (&symtab, ~0);
726
727   if (strcmp (sentinel->name, "<hicore>") == 0 && max_vma >= sentinel->addr)
728     sentinel->addr = max_vma + 1;
729
730   /* Copy in function symbols.  */
731   memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
732   ltab.limit += symtab.len;
733
734   if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
735     {
736       fprintf (stderr,
737                _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
738                whoami, ltab.len, (long) (ltab.limit - ltab.base));
739       done (1);
740     }
741
742   /* Finalize ltab and make it symbol table.  */
743   symtab_finalize (&ltab);
744   free (symtab.base);
745   symtab = ltab;
746 }