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 = (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       /* 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 cxxclass;
 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 = (struct function_map *) bsearch (core_syms[i]->name, symbol_map,
 581                                                symbol_map_count,
 582                                                sizeof (struct function_map),
 583                                                search_mapped_symbol);
 584       if (found == NULL || found->is_first)
 585         ++symtab.len;
 586     }
 587
 588   if (symtab.len == 0)
 589     {
 590       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
 591       done (1);
 592     }
 593
 594   symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
 595
 596   /* Pass 2 - create symbols.  */
 597   symtab.limit = symtab.base;
 598
 599   for (i = 0; i < core_num_syms; ++i)
 600     {
 601       asection *sym_sec;
 602
 603       cxxclass = core_sym_class (core_syms[i]);
 604
 605       if (!cxxclass)
 606         {
 607           DBG (AOUTDEBUG,
 608                printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
 609                        (unsigned long) core_syms[i]->value,
 610                        core_syms[i]->name));
 611           continue;
 612         }
 613
 614       found = (struct function_map *) bsearch (core_syms[i]->name, symbol_map,
 615                                                symbol_map_count,
 616                        sizeof (struct function_map), search_mapped_symbol);
 617       if (found && ! found->is_first)
 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 (found)
 629         {
 630           symtab.limit->name = found->file_name;
 631           symtab.limit->mapped = 1;
 632         }
 633       else
 634         {
 635           symtab.limit->name = core_syms[i]->name;
 636           symtab.limit->mapped = 0;
 637         }
 638
 639       /* Lookup filename and line number, if we can.  */
 640       {
 641         const char * filename;
 642         const char * 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 (cxxclass == '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 (void)
 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 = (char *) xmalloc (prev_name_len);
 733   prev_filename = (char *) 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 = (char *) 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 = (char *) 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 }