gprof/corefile.c

   1 /* corefile.c
   2
   3    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
   4    2010  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 = (char *) 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 = (char *) 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 = (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;
 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       if (*name == '.')
 389         {
 390           /* Allow GCC cloned functions.  */
 391           if (strlen (name) > 7 && strncmp (name, ".clone.", 7) == 0)
 392             name += 6;
 393
 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;
 399
 400           break;
 401         }
 402     }
 403
 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);
 412
 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))
 419     {
 420       return 0;
 421     }
 422
 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;
 427
 428   return 't';                   /* It's a static text symbol.  */
 429 }
 430
 431 /* Get whatever source info we can get regarding address ADDR.  */
 432
 433 static bfd_boolean
 434 get_src_info (bfd_vma addr, const char **filename, const char **name, int *line_num)
 435 {
 436   const char *fname = 0, *func_name = 0;
 437   int l = 0;
 438
 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)
 443     {
 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;
 450     }
 451   else
 452     {
 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;
 458     }
 459 }
 460
 461 /* Return number of symbols in a symbol-table file.  */
 462
 463 static int
 464 num_of_syms_in (FILE * f)
 465 {
 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;
 472
 473   while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
 474     {
 475       if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
 476         if (type == 't' || type == 'T')
 477           ++num;
 478     }
 479
 480   free (buf);
 481   free (address);
 482   free (name);
 483
 484   return num;
 485 }
 486
 487 /* Read symbol table from a file.  */
 488
 489 void
 490 core_create_syms_from (const char * sym_table_file)
 491 {
 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;
 500
 501   f = fopen (sym_table_file, "r");
 502   if (!f)
 503     {
 504       fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
 505       done (1);
 506     }
 507
 508   /* Pass 1 - determine upper bound on number of function names.  */
 509   symtab.len = num_of_syms_in (f);
 510
 511   if (symtab.len == 0)
 512     {
 513       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
 514       done (1);
 515     }
 516
 517   symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
 518
 519   /* Pass 2 - create symbols.  */
 520   symtab.limit = symtab.base;
 521
 522   if (fseek (f, 0, SEEK_SET) != 0)
 523     {
 524       perror (sym_table_file);
 525       done (1);
 526     }
 527
 528   while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
 529     {
 530       if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
 531         if (type != 't' && type != 'T')
 532           continue;
 533
 534       sym_init (symtab.limit);
 535
 536       sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
 537
 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);
 546
 547       ++symtab.limit;
 548     }
 549   fclose (f);
 550
 551   symtab.len = symtab.limit - symtab.base;
 552   symtab_finalize (&symtab);
 553
 554   free (buf);
 555   free (address);
 556   free (name);
 557 }
 558
 559 static int
 560 search_mapped_symbol (const void * l, const void * r)
 561 {
 562     return strcmp ((const char *) l, ((const struct function_map *) r)->function_name);
 563 }
 564
 565 /* Read in symbol table from core.
 566    One symbol per function is entered.  */
 567
 568 void
 569 core_create_function_syms (void)
 570 {
 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;
 576
 577   /* Pass 1 - determine upper bound on number of function names.  */
 578   symtab.len = 0;
 579
 580   for (i = 0; i < core_num_syms; ++i)
 581     {
 582       if (!core_sym_class (core_syms[i]))
 583         continue;
 584
 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;
 594     }
 595
 596   if (symtab.len == 0)
 597     {
 598       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
 599       done (1);
 600     }
 601
 602   symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
 603
 604   /* Pass 2 - create symbols.  */
 605   symtab.limit = symtab.base;
 606
 607   for (i = 0; i < core_num_syms; ++i)
 608     {
 609       asection *sym_sec;
 610
 611       cxxclass = core_sym_class (core_syms[i]);
 612
 613       if (!cxxclass)
 614         {
 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;
 620         }
 621
 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;
 627
 628       sym_init (symtab.limit);
 629
 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);
 635
 636       if (found)
 637         {
 638           symtab.limit->name = found->file_name;
 639           symtab.limit->mapped = 1;
 640         }
 641       else
 642         {
 643           symtab.limit->name = core_syms[i]->name;
 644           symtab.limit->mapped = 0;
 645         }
 646
 647       /* Lookup filename and line number, if we can.  */
 648       {
 649         const char * filename;
 650         const char * func_name;
 651
 652         if (get_src_info (symtab.limit->addr, & filename, & func_name,
 653                           & symtab.limit->line_num))
 654           {
 655             symtab.limit->file = source_file_lookup_path (filename);
 656
 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.
 662
 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.  */
 666
 667             if (strcmp (symtab.limit->name, func_name) != 0)
 668               {
 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;
 676               }
 677 #endif
 678           }
 679       }
 680
 681       symtab.limit->is_func = (core_syms[i]->flags & BSF_FUNCTION) != 0;
 682       symtab.limit->is_bb_head = TRUE;
 683
 684       if (cxxclass == 't')
 685         symtab.limit->is_static = TRUE;
 686
 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);
 697
 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;
 703     }
 704
 705   symtab.len = symtab.limit - symtab.base;
 706   symtab_finalize (&symtab);
 707 }
 708
 709 /* Read in symbol table from core.
 710    One symbol per line of source code is entered.  */
 711
 712 void
 713 core_create_line_syms (void)
 714 {
 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;
 723
 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 ();
 728
 729   /* Pass 1: count the number of symbols.  */
 730
 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.
 735
 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;
 744
 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)
 747     {
 748       unsigned int len;
 749
 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;
 756
 757       ++ltab.len;
 758       prev_line_num = dummy.line_num;
 759
 760       len = strlen (dummy.name);
 761       if (len >= prev_name_len)
 762         {
 763           prev_name_len = len + 1024;
 764           free (prev_name);
 765           prev_name = (char *) xmalloc (prev_name_len);
 766         }
 767
 768       strcpy (prev_name, dummy.name);
 769       len = strlen (filename);
 770
 771       if (len >= prev_filename_len)
 772         {
 773           prev_filename_len = len + 1024;
 774           free (prev_filename);
 775           prev_filename = (char *) xmalloc (prev_filename_len);
 776         }
 777
 778       strcpy (prev_filename, filename);
 779
 780       min_vma = MIN (vma, min_vma);
 781       max_vma = MAX (vma, max_vma);
 782     }
 783
 784   free (prev_name);
 785   free (prev_filename);
 786
 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;
 791
 792   /* Pass 2 - create symbols.  */
 793
 794   /* We now set is_static as we go along, rather than by running
 795      through the symbol table at the end.
 796
 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.
 804
 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;
 811
 812   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 813     {
 814       sym_init (ltab.limit);
 815
 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;
 821
 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);
 825
 826       ltab.limit->addr = vma;
 827
 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)
 833         {
 834           ltab.limit->is_static = prev->is_static;
 835         }
 836       else
 837         {
 838           sym = sym_lookup(&symtab, ltab.limit->addr);
 839           if (sym)
 840             ltab.limit->is_static = sym->is_static;
 841         }
 842
 843       prev = ltab.limit;
 844
 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;
 850     }
 851
 852   /* Copy in function symbols.  */
 853   memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
 854   ltab.limit += symtab.len;
 855
 856   if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
 857     {
 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);
 862     }
 863
 864   /* Finalize ltab and make it symbol table.  */
 865   symtab_finalize (&ltab);
 866   free (symtab.base);
 867   symtab = ltab;
 868 }