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