contrib/binutils-2.21/gprof/corefile.c

   1 /* corefile.c
   2
   3    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
   4    2010, 2011  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   int core_has_func_syms = 0;
 577
 578   switch (core_bfd->xvec->flavour)
 579     {
 580     default:
 581       break;
 582     case bfd_target_coff_flavour:
 583     case bfd_target_ecoff_flavour:
 584     case bfd_target_xcoff_flavour:
 585     case bfd_target_elf_flavour:
 586     case bfd_target_nlm_flavour:
 587     case bfd_target_som_flavour:
 588       core_has_func_syms = 1;
 589     }
 590
 591   /* Pass 1 - determine upper bound on number of function names.  */
 592   symtab.len = 0;
 593
 594   for (i = 0; i < core_num_syms; ++i)
 595     {
 596       if (!core_sym_class (core_syms[i]))
 597         continue;
 598
 599       /* Don't create a symtab entry for a function that has
 600          a mapping to a file, unless it's the first function
 601          in the file.  */
 602       found = (struct function_map *) bsearch (core_syms[i]->name, symbol_map,
 603                                                symbol_map_count,
 604                                                sizeof (struct function_map),
 605                                                search_mapped_symbol);
 606       if (found == NULL || found->is_first)
 607         ++symtab.len;
 608     }
 609
 610   if (symtab.len == 0)
 611     {
 612       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
 613       done (1);
 614     }
 615
 616   symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
 617
 618   /* Pass 2 - create symbols.  */
 619   symtab.limit = symtab.base;
 620
 621   for (i = 0; i < core_num_syms; ++i)
 622     {
 623       asection *sym_sec;
 624
 625       cxxclass = core_sym_class (core_syms[i]);
 626
 627       if (!cxxclass)
 628         {
 629           DBG (AOUTDEBUG,
 630                printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
 631                        (unsigned long) core_syms[i]->value,
 632                        core_syms[i]->name));
 633           continue;
 634         }
 635
 636       found = (struct function_map *) bsearch (core_syms[i]->name, symbol_map,
 637                                                symbol_map_count,
 638                        sizeof (struct function_map), search_mapped_symbol);
 639       if (found && ! found->is_first)
 640         continue;
 641
 642       sym_init (symtab.limit);
 643
 644       /* Symbol offsets are always section-relative.  */
 645       sym_sec = core_syms[i]->section;
 646       symtab.limit->addr = core_syms[i]->value;
 647       if (sym_sec)
 648         symtab.limit->addr += bfd_get_section_vma (sym_sec->owner, sym_sec);
 649
 650       if (found)
 651         {
 652           symtab.limit->name = found->file_name;
 653           symtab.limit->mapped = 1;
 654         }
 655       else
 656         {
 657           symtab.limit->name = core_syms[i]->name;
 658           symtab.limit->mapped = 0;
 659         }
 660
 661       /* Lookup filename and line number, if we can.  */
 662       {
 663         const char * filename;
 664         const char * func_name;
 665
 666         if (get_src_info (symtab.limit->addr, & filename, & func_name,
 667                           & symtab.limit->line_num))
 668           {
 669             symtab.limit->file = source_file_lookup_path (filename);
 670
 671             /* FIXME: Checking __osf__ here does not work with a cross
 672                gprof.  */
 673 #ifdef __osf__
 674             /* Suppress symbols that are not function names.  This is
 675                useful to suppress code-labels and aliases.
 676
 677                This is known to be useful under DEC's OSF/1.  Under SunOS 4.x,
 678                labels do not appear in the symbol table info, so this isn't
 679                necessary.  */
 680
 681             if (strcmp (symtab.limit->name, func_name) != 0)
 682               {
 683                 /* The symbol's address maps to a different name, so
 684                    it can't be a function-entry point.  This happens
 685                    for labels, for example.  */
 686                 DBG (AOUTDEBUG,
 687                      printf ("[core_create_function_syms: rej %s (maps to %s)\n",
 688                              symtab.limit->name, func_name));
 689                 continue;
 690               }
 691 #endif
 692           }
 693       }
 694
 695       symtab.limit->is_func = (!core_has_func_syms
 696                                || (core_syms[i]->flags & BSF_FUNCTION) != 0);
 697       symtab.limit->is_bb_head = TRUE;
 698
 699       if (cxxclass == 't')
 700         symtab.limit->is_static = TRUE;
 701
 702       /* Keep track of the minimum and maximum vma addresses used by all
 703          symbols.  When computing the max_vma, use the ending address of the
 704          section containing the symbol, if available.  */
 705       min_vma = MIN (symtab.limit->addr, min_vma);
 706       if (sym_sec)
 707         max_vma = MAX (bfd_get_section_vma (sym_sec->owner, sym_sec)
 708                        + bfd_section_size (sym_sec->owner, sym_sec) - 1,
 709                        max_vma);
 710       else
 711         max_vma = MAX (symtab.limit->addr, max_vma);
 712
 713       DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
 714                               (long) (symtab.limit - symtab.base),
 715                               symtab.limit->name,
 716                               (unsigned long) symtab.limit->addr));
 717       ++symtab.limit;
 718     }
 719
 720   symtab.len = symtab.limit - symtab.base;
 721   symtab_finalize (&symtab);
 722 }
 723
 724 /* Read in symbol table from core.
 725    One symbol per line of source code is entered.  */
 726
 727 void
 728 core_create_line_syms (void)
 729 {
 730   char *prev_name, *prev_filename;
 731   unsigned int prev_name_len, prev_filename_len;
 732   bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
 733   Sym *prev, dummy, *sym;
 734   const char *filename;
 735   int prev_line_num;
 736   Sym_Table ltab;
 737   bfd_vma vma_high;
 738
 739   /* Create symbols for functions as usual.  This is necessary in
 740      cases where parts of a program were not compiled with -g.  For
 741      those parts we still want to get info at the function level.  */
 742   core_create_function_syms ();
 743
 744   /* Pass 1: count the number of symbols.  */
 745
 746   /* To find all line information, walk through all possible
 747      text-space addresses (one by one!) and get the debugging
 748      info for each address.  When the debugging info changes,
 749      it is time to create a new symbol.
 750
 751      Of course, this is rather slow and it would be better if
 752      BFD would provide an iterator for enumerating all line infos.  */
 753   prev_name_len = PATH_MAX;
 754   prev_filename_len = PATH_MAX;
 755   prev_name = (char *) xmalloc (prev_name_len);
 756   prev_filename = (char *) xmalloc (prev_filename_len);
 757   ltab.len = 0;
 758   prev_line_num = 0;
 759
 760   vma_high = core_text_sect->vma + bfd_get_section_size (core_text_sect);
 761   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 762     {
 763       unsigned int len;
 764
 765       if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
 766           || (prev_line_num == dummy.line_num
 767               && prev_name != NULL
 768               && strcmp (prev_name, dummy.name) == 0
 769               && strcmp (prev_filename, filename) == 0))
 770         continue;
 771
 772       ++ltab.len;
 773       prev_line_num = dummy.line_num;
 774
 775       len = strlen (dummy.name);
 776       if (len >= prev_name_len)
 777         {
 778           prev_name_len = len + 1024;
 779           free (prev_name);
 780           prev_name = (char *) xmalloc (prev_name_len);
 781         }
 782
 783       strcpy (prev_name, dummy.name);
 784       len = strlen (filename);
 785
 786       if (len >= prev_filename_len)
 787         {
 788           prev_filename_len = len + 1024;
 789           free (prev_filename);
 790           prev_filename = (char *) xmalloc (prev_filename_len);
 791         }
 792
 793       strcpy (prev_filename, filename);
 794
 795       min_vma = MIN (vma, min_vma);
 796       max_vma = MAX (vma, max_vma);
 797     }
 798
 799   free (prev_name);
 800   free (prev_filename);
 801
 802   /* Make room for function symbols, too.  */
 803   ltab.len += symtab.len;
 804   ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
 805   ltab.limit = ltab.base;
 806
 807   /* Pass 2 - create symbols.  */
 808
 809   /* We now set is_static as we go along, rather than by running
 810      through the symbol table at the end.
 811
 812      The old way called symtab_finalize before the is_static pass,
 813      causing a problem since symtab_finalize uses is_static as part of
 814      its address conflict resolution algorithm.  Since global symbols
 815      were prefered over static symbols, and all line symbols were
 816      global at that point, static function names that conflicted with
 817      their own line numbers (static, but labeled as global) were
 818      rejected in favor of the line num.
 819
 820      This was not the desired functionality.  We always want to keep
 821      our function symbols and discard any conflicting line symbols.
 822      Perhaps symtab_finalize should be modified to make this
 823      distinction as well, but the current fix works and the code is a
 824      lot cleaner now.  */
 825   prev = 0;
 826
 827   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 828     {
 829       sym_init (ltab.limit);
 830
 831       if (!get_src_info (vma, &filename, &ltab.limit->name, &ltab.limit->line_num)
 832           || (prev && prev->line_num == ltab.limit->line_num
 833               && strcmp (prev->name, ltab.limit->name) == 0
 834               && strcmp (prev->file->name, filename) == 0))
 835         continue;
 836
 837       /* Make name pointer a malloc'ed string.  */
 838       ltab.limit->name = xstrdup (ltab.limit->name);
 839       ltab.limit->file = source_file_lookup_path (filename);
 840
 841       ltab.limit->addr = vma;
 842
 843       /* Set is_static based on the enclosing function, using either:
 844          1) the previous symbol, if it's from the same function, or
 845          2) a symtab lookup.  */
 846       if (prev && ltab.limit->file == prev->file &&
 847           strcmp (ltab.limit->name, prev->name) == 0)
 848         {
 849           ltab.limit->is_static = prev->is_static;
 850         }
 851       else
 852         {
 853           sym = sym_lookup(&symtab, ltab.limit->addr);
 854           if (sym)
 855             ltab.limit->is_static = sym->is_static;
 856         }
 857
 858       prev = ltab.limit;
 859
 860       DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
 861                               (unsigned long) (ltab.limit - ltab.base),
 862                               ltab.limit->name,
 863                               (unsigned long) ltab.limit->addr));
 864       ++ltab.limit;
 865     }
 866
 867   /* Copy in function symbols.  */
 868   memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
 869   ltab.limit += symtab.len;
 870
 871   if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
 872     {
 873       fprintf (stderr,
 874                _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
 875                whoami, ltab.len, (long) (ltab.limit - ltab.base));
 876       done (1);
 877     }
 878
 879   /* Finalize ltab and make it symbol table.  */
 880   symtab_finalize (&ltab);
 881   free (symtab.base);
 882   symtab = ltab;
 883 }