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