gprof/corefile.c

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