gprof/corefile.c

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