contrib/binutils-2.25/gprof/corefile.c

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