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