bfd/syms.c

   1 /* Generic symbol-table support for the BFD library.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5    Written by Cygnus Support.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 /*
  25 SECTION
  26         Symbols
  27
  28         BFD tries to maintain as much symbol information as it can when
  29         it moves information from file to file. BFD passes information
  30         to applications though the <<asymbol>> structure. When the
  31         application requests the symbol table, BFD reads the table in
  32         the native form and translates parts of it into the internal
  33         format. To maintain more than the information passed to
  34         applications, some targets keep some information ``behind the
  35         scenes'' in a structure only the particular back end knows
  36         about. For example, the coff back end keeps the original
  37         symbol table structure as well as the canonical structure when
  38         a BFD is read in. On output, the coff back end can reconstruct
  39         the output symbol table so that no information is lost, even
  40         information unique to coff which BFD doesn't know or
  41         understand. If a coff symbol table were read, but were written
  42         through an a.out back end, all the coff specific information
  43         would be lost. The symbol table of a BFD
  44         is not necessarily read in until a canonicalize request is
  45         made. Then the BFD back end fills in a table provided by the
  46         application with pointers to the canonical information.  To
  47         output symbols, the application provides BFD with a table of
  48         pointers to pointers to <<asymbol>>s. This allows applications
  49         like the linker to output a symbol as it was read, since the ``behind
  50         the scenes'' information will be still available.
  51 @menu
  52 @* Reading Symbols::
  53 @* Writing Symbols::
  54 @* Mini Symbols::
  55 @* typedef asymbol::
  56 @* symbol handling functions::
  57 @end menu
  58
  59 INODE
  60 Reading Symbols, Writing Symbols, Symbols, Symbols
  61 SUBSECTION
  62         Reading symbols
  63
  64         There are two stages to reading a symbol table from a BFD:
  65         allocating storage, and the actual reading process. This is an
  66         excerpt from an application which reads the symbol table:
  67
  68 |         long storage_needed;
  69 |         asymbol **symbol_table;
  70 |         long number_of_symbols;
  71 |         long i;
  72 |
  73 |         storage_needed = bfd_get_symtab_upper_bound (abfd);
  74 |
  75 |         if (storage_needed < 0)
  76 |           FAIL
  77 |
  78 |         if (storage_needed == 0)
  79 |           return;
  80 |
  81 |         symbol_table = xmalloc (storage_needed);
  82 |           ...
  83 |         number_of_symbols =
  84 |            bfd_canonicalize_symtab (abfd, symbol_table);
  85 |
  86 |         if (number_of_symbols < 0)
  87 |           FAIL
  88 |
  89 |         for (i = 0; i < number_of_symbols; i++)
  90 |           process_symbol (symbol_table[i]);
  91
  92         All storage for the symbols themselves is in an objalloc
  93         connected to the BFD; it is freed when the BFD is closed.
  94
  95 INODE
  96 Writing Symbols, Mini Symbols, Reading Symbols, Symbols
  97 SUBSECTION
  98         Writing symbols
  99
 100         Writing of a symbol table is automatic when a BFD open for
 101         writing is closed. The application attaches a vector of
 102         pointers to pointers to symbols to the BFD being written, and
 103         fills in the symbol count. The close and cleanup code reads
 104         through the table provided and performs all the necessary
 105         operations. The BFD output code must always be provided with an
 106         ``owned'' symbol: one which has come from another BFD, or one
 107         which has been created using <<bfd_make_empty_symbol>>.  Here is an
 108         example showing the creation of a symbol table with only one element:
 109
 110 |       #include "bfd.h"
 111 |       int main (void)
 112 |       {
 113 |         bfd *abfd;
 114 |         asymbol *ptrs[2];
 115 |         asymbol *new;
 116 |
 117 |         abfd = bfd_openw ("foo","a.out-sunos-big");
 118 |         bfd_set_format (abfd, bfd_object);
 119 |         new = bfd_make_empty_symbol (abfd);
 120 |         new->name = "dummy_symbol";
 121 |         new->section = bfd_make_section_old_way (abfd, ".text");
 122 |         new->flags = BSF_GLOBAL;
 123 |         new->value = 0x12345;
 124 |
 125 |         ptrs[0] = new;
 126 |         ptrs[1] = 0;
 127 |
 128 |         bfd_set_symtab (abfd, ptrs, 1);
 129 |         bfd_close (abfd);
 130 |         return 0;
 131 |       }
 132 |
 133 |       ./makesym
 134 |       nm foo
 135 |       00012345 A dummy_symbol
 136
 137         Many formats cannot represent arbitrary symbol information; for
 138         instance, the <<a.out>> object format does not allow an
 139         arbitrary number of sections. A symbol pointing to a section
 140         which is not one  of <<.text>>, <<.data>> or <<.bss>> cannot
 141         be described.
 142
 143 INODE
 144 Mini Symbols, typedef asymbol, Writing Symbols, Symbols
 145 SUBSECTION
 146         Mini Symbols
 147
 148         Mini symbols provide read-only access to the symbol table.
 149         They use less memory space, but require more time to access.
 150         They can be useful for tools like nm or objdump, which may
 151         have to handle symbol tables of extremely large executables.
 152
 153         The <<bfd_read_minisymbols>> function will read the symbols
 154         into memory in an internal form.  It will return a <<void *>>
 155         pointer to a block of memory, a symbol count, and the size of
 156         each symbol.  The pointer is allocated using <<malloc>>, and
 157         should be freed by the caller when it is no longer needed.
 158
 159         The function <<bfd_minisymbol_to_symbol>> will take a pointer
 160         to a minisymbol, and a pointer to a structure returned by
 161         <<bfd_make_empty_symbol>>, and return a <<asymbol>> structure.
 162         The return value may or may not be the same as the value from
 163         <<bfd_make_empty_symbol>> which was passed in.
 164
 165 */
 166
 167 /*
 168 DOCDD
 169 INODE
 170 typedef asymbol, symbol handling functions, Mini Symbols, Symbols
 171
 172 */
 173 /*
 174 SUBSECTION
 175         typedef asymbol
 176
 177         An <<asymbol>> has the form:
 178
 179 */
 180
 181 /*
 182 CODE_FRAGMENT
 183
 184 .
 185 .typedef struct bfd_symbol
 186 .{
 187 .  {* A pointer to the BFD which owns the symbol. This information
 188 .     is necessary so that a back end can work out what additional
 189 .     information (invisible to the application writer) is carried
 190 .     with the symbol.
 191 .
 192 .     This field is *almost* redundant, since you can use section->owner
 193 .     instead, except that some symbols point to the global sections
 194 .     bfd_{abs,com,und}_section.  This could be fixed by making
 195 .     these globals be per-bfd (or per-target-flavor).  FIXME.  *}
 196 .  struct bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field.  *}
 197 .
 198 .  {* The text of the symbol. The name is left alone, and not copied; the
 199 .     application may not alter it.  *}
 200 .  const char *name;
 201 .
 202 .  {* The value of the symbol.  This really should be a union of a
 203 .     numeric value with a pointer, since some flags indicate that
 204 .     a pointer to another symbol is stored here.  *}
 205 .  symvalue value;
 206 .
 207 .  {* Attributes of a symbol.  *}
 208 .#define BSF_NO_FLAGS           0x00
 209 .
 210 .  {* The symbol has local scope; <<static>> in <<C>>. The value
 211 .     is the offset into the section of the data.  *}
 212 .#define BSF_LOCAL              (1 << 0)
 213 .
 214 .  {* The symbol has global scope; initialized data in <<C>>. The
 215 .     value is the offset into the section of the data.  *}
 216 .#define BSF_GLOBAL             (1 << 1)
 217 .
 218 .  {* The symbol has global scope and is exported. The value is
 219 .     the offset into the section of the data.  *}
 220 .#define BSF_EXPORT     BSF_GLOBAL {* No real difference.  *}
 221 .
 222 .  {* A normal C symbol would be one of:
 223 .     <<BSF_LOCAL>>, <<BSF_COMMON>>,  <<BSF_UNDEFINED>> or
 224 .     <<BSF_GLOBAL>>.  *}
 225 .
 226 .  {* The symbol is a debugging record. The value has an arbitrary
 227 .     meaning, unless BSF_DEBUGGING_RELOC is also set.  *}
 228 .#define BSF_DEBUGGING          (1 << 2)
 229 .
 230 .  {* The symbol denotes a function entry point.  Used in ELF,
 231 .     perhaps others someday.  *}
 232 .#define BSF_FUNCTION           (1 << 3)
 233 .
 234 .  {* Used by the linker.  *}
 235 .#define BSF_KEEP               (1 << 5)
 236 .#define BSF_KEEP_G             (1 << 6)
 237 .
 238 .  {* A weak global symbol, overridable without warnings by
 239 .     a regular global symbol of the same name.  *}
 240 .#define BSF_WEAK               (1 << 7)
 241 .
 242 .  {* This symbol was created to point to a section, e.g. ELF's
 243 .     STT_SECTION symbols.  *}
 244 .#define BSF_SECTION_SYM        (1 << 8)
 245 .
 246 .  {* The symbol used to be a common symbol, but now it is
 247 .     allocated.  *}
 248 .#define BSF_OLD_COMMON         (1 << 9)
 249 .
 250 .  {* In some files the type of a symbol sometimes alters its
 251 .     location in an output file - ie in coff a <<ISFCN>> symbol
 252 .     which is also <<C_EXT>> symbol appears where it was
 253 .     declared and not at the end of a section.  This bit is set
 254 .     by the target BFD part to convey this information.  *}
 255 .#define BSF_NOT_AT_END         (1 << 10)
 256 .
 257 .  {* Signal that the symbol is the label of constructor section.  *}
 258 .#define BSF_CONSTRUCTOR        (1 << 11)
 259 .
 260 .  {* Signal that the symbol is a warning symbol.  The name is a
 261 .     warning.  The name of the next symbol is the one to warn about;
 262 .     if a reference is made to a symbol with the same name as the next
 263 .     symbol, a warning is issued by the linker.  *}
 264 .#define BSF_WARNING            (1 << 12)
 265 .
 266 .  {* Signal that the symbol is indirect.  This symbol is an indirect
 267 .     pointer to the symbol with the same name as the next symbol.  *}
 268 .#define BSF_INDIRECT           (1 << 13)
 269 .
 270 .  {* BSF_FILE marks symbols that contain a file name.  This is used
 271 .     for ELF STT_FILE symbols.  *}
 272 .#define BSF_FILE               (1 << 14)
 273 .
 274 .  {* Symbol is from dynamic linking information.  *}
 275 .#define BSF_DYNAMIC            (1 << 15)
 276 .
 277 .  {* The symbol denotes a data object.  Used in ELF, and perhaps
 278 .     others someday.  *}
 279 .#define BSF_OBJECT             (1 << 16)
 280 .
 281 .  {* This symbol is a debugging symbol.  The value is the offset
 282 .     into the section of the data.  BSF_DEBUGGING should be set
 283 .     as well.  *}
 284 .#define BSF_DEBUGGING_RELOC    (1 << 17)
 285 .
 286 .  {* This symbol is thread local.  Used in ELF.  *}
 287 .#define BSF_THREAD_LOCAL       (1 << 18)
 288 .
 289 .  {* This symbol represents a complex relocation expression,
 290 .     with the expression tree serialized in the symbol name.  *}
 291 .#define BSF_RELC               (1 << 19)
 292 .
 293 .  {* This symbol represents a signed complex relocation expression,
 294 .     with the expression tree serialized in the symbol name.  *}
 295 .#define BSF_SRELC              (1 << 20)
 296 .
 297 .  {* This symbol was created by bfd_get_synthetic_symtab.  *}
 298 .#define BSF_SYNTHETIC          (1 << 21)
 299 .
 300 .  {* This symbol is an indirect code object.  Unrelated to BSF_INDIRECT.
 301 .     The dynamic linker will compute the value of this symbol by
 302 .     calling the function that it points to.  BSF_FUNCTION must
 303 .     also be also set.  *}
 304 .#define BSF_GNU_INDIRECT_FUNCTION (1 << 22)
 305 .
 306 .  flagword flags;
 307 .
 308 .  {* A pointer to the section to which this symbol is
 309 .     relative.  This will always be non NULL, there are special
 310 .     sections for undefined and absolute symbols.  *}
 311 .  struct bfd_section *section;
 312 .
 313 .  {* Back end special data.  *}
 314 .  union
 315 .    {
 316 .      void *p;
 317 .      bfd_vma i;
 318 .    }
 319 .  udata;
 320 .}
 321 .asymbol;
 322 .
 323 */
 324
 325 #include "sysdep.h"
 326 #include "bfd.h"
 327 #include "libbfd.h"
 328 #include "safe-ctype.h"
 329 #include "bfdlink.h"
 330 #include "aout/stab_gnu.h"
 331
 332 /*
 333 DOCDD
 334 INODE
 335 symbol handling functions,  , typedef asymbol, Symbols
 336 SUBSECTION
 337         Symbol handling functions
 338 */
 339
 340 /*
 341 FUNCTION
 342         bfd_get_symtab_upper_bound
 343
 344 DESCRIPTION
 345         Return the number of bytes required to store a vector of pointers
 346         to <<asymbols>> for all the symbols in the BFD @var{abfd},
 347         including a terminal NULL pointer. If there are no symbols in
 348         the BFD, then return 0.  If an error occurs, return -1.
 349
 350 .#define bfd_get_symtab_upper_bound(abfd) \
 351 .     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
 352 .
 353 */
 354
 355 /*
 356 FUNCTION
 357         bfd_is_local_label
 358
 359 SYNOPSIS
 360         bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
 361
 362 DESCRIPTION
 363         Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is
 364         a compiler generated local label, else return FALSE.
 365 */
 366
 367 bfd_boolean
 368 bfd_is_local_label (bfd *abfd, asymbol *sym)
 369 {
 370   /* The BSF_SECTION_SYM check is needed for IA-64, where every label that
 371      starts with '.' is local.  This would accidentally catch section names
 372      if we didn't reject them here.  */
 373   if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0)
 374     return FALSE;
 375   if (sym->name == NULL)
 376     return FALSE;
 377   return bfd_is_local_label_name (abfd, sym->name);
 378 }
 379
 380 /*
 381 FUNCTION
 382         bfd_is_local_label_name
 383
 384 SYNOPSIS
 385         bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
 386
 387 DESCRIPTION
 388         Return TRUE if a symbol with the name @var{name} in the BFD
 389         @var{abfd} is a compiler generated local label, else return
 390         FALSE.  This just checks whether the name has the form of a
 391         local label.
 392
 393 .#define bfd_is_local_label_name(abfd, name) \
 394 .  BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
 395 .
 396 */
 397
 398 /*
 399 FUNCTION
 400         bfd_is_target_special_symbol
 401
 402 SYNOPSIS
 403         bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
 404
 405 DESCRIPTION
 406         Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something
 407         special to the particular target represented by the BFD.  Such symbols
 408         should normally not be mentioned to the user.
 409
 410 .#define bfd_is_target_special_symbol(abfd, sym) \
 411 .  BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
 412 .
 413 */
 414
 415 /*
 416 FUNCTION
 417         bfd_canonicalize_symtab
 418
 419 DESCRIPTION
 420         Read the symbols from the BFD @var{abfd}, and fills in
 421         the vector @var{location} with pointers to the symbols and
 422         a trailing NULL.
 423         Return the actual number of symbol pointers, not
 424         including the NULL.
 425
 426 .#define bfd_canonicalize_symtab(abfd, location) \
 427 .  BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
 428 .
 429 */
 430
 431 /*
 432 FUNCTION
 433         bfd_set_symtab
 434
 435 SYNOPSIS
 436         bfd_boolean bfd_set_symtab
 437           (bfd *abfd, asymbol **location, unsigned int count);
 438
 439 DESCRIPTION
 440         Arrange that when the output BFD @var{abfd} is closed,
 441         the table @var{location} of @var{count} pointers to symbols
 442         will be written.
 443 */
 444
 445 bfd_boolean
 446 bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount)
 447 {
 448   if (abfd->format != bfd_object || bfd_read_p (abfd))
 449     {
 450       bfd_set_error (bfd_error_invalid_operation);
 451       return FALSE;
 452     }
 453
 454   bfd_get_outsymbols (abfd) = location;
 455   bfd_get_symcount (abfd) = symcount;
 456   return TRUE;
 457 }
 458
 459 /*
 460 FUNCTION
 461         bfd_print_symbol_vandf
 462
 463 SYNOPSIS
 464         void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
 465
 466 DESCRIPTION
 467         Print the value and flags of the @var{symbol} supplied to the
 468         stream @var{file}.
 469 */
 470 void
 471 bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol)
 472 {
 473   FILE *file = arg;
 474
 475   flagword type = symbol->flags;
 476
 477   if (symbol->section != NULL)
 478     bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma);
 479   else
 480     bfd_fprintf_vma (abfd, file, symbol->value);
 481
 482   /* This presumes that a symbol can not be both BSF_DEBUGGING and
 483      BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
 484      BSF_OBJECT.  */
 485   fprintf (file, " %c%c%c%c%c%c%c",
 486            ((type & BSF_LOCAL)
 487             ? (type & BSF_GLOBAL) ? '!' : 'l'
 488             : (type & BSF_GLOBAL) ? 'g' : ' '),
 489            (type & BSF_WEAK) ? 'w' : ' ',
 490            (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
 491            (type & BSF_WARNING) ? 'W' : ' ',
 492            (type & BSF_INDIRECT) ? 'I' : (type & BSF_GNU_INDIRECT_FUNCTION) ? 'i' : ' ',
 493            (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
 494            ((type & BSF_FUNCTION)
 495             ? 'F'
 496             : ((type & BSF_FILE)
 497                ? 'f'
 498                : ((type & BSF_OBJECT) ? 'O' : ' '))));
 499 }
 500
 501 /*
 502 FUNCTION
 503         bfd_make_empty_symbol
 504
 505 DESCRIPTION
 506         Create a new <<asymbol>> structure for the BFD @var{abfd}
 507         and return a pointer to it.
 508
 509         This routine is necessary because each back end has private
 510         information surrounding the <<asymbol>>. Building your own
 511         <<asymbol>> and pointing to it will not create the private
 512         information, and will cause problems later on.
 513
 514 .#define bfd_make_empty_symbol(abfd) \
 515 .  BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
 516 .
 517 */
 518
 519 /*
 520 FUNCTION
 521         _bfd_generic_make_empty_symbol
 522
 523 SYNOPSIS
 524         asymbol *_bfd_generic_make_empty_symbol (bfd *);
 525
 526 DESCRIPTION
 527         Create a new <<asymbol>> structure for the BFD @var{abfd}
 528         and return a pointer to it.  Used by core file routines,
 529         binary back-end and anywhere else where no private info
 530         is needed.
 531 */
 532
 533 asymbol *
 534 _bfd_generic_make_empty_symbol (bfd *abfd)
 535 {
 536   bfd_size_type amt = sizeof (asymbol);
 537   asymbol *new = bfd_zalloc (abfd, amt);
 538   if (new)
 539     new->the_bfd = abfd;
 540   return new;
 541 }
 542
 543 /*
 544 FUNCTION
 545         bfd_make_debug_symbol
 546
 547 DESCRIPTION
 548         Create a new <<asymbol>> structure for the BFD @var{abfd},
 549         to be used as a debugging symbol.  Further details of its use have
 550         yet to be worked out.
 551
 552 .#define bfd_make_debug_symbol(abfd,ptr,size) \
 553 .  BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
 554 .
 555 */
 556
 557 struct section_to_type
 558 {
 559   const char *section;
 560   char type;
 561 };
 562
 563 /* Map section names to POSIX/BSD single-character symbol types.
 564    This table is probably incomplete.  It is sorted for convenience of
 565    adding entries.  Since it is so short, a linear search is used.  */
 566 static const struct section_to_type stt[] =
 567 {
 568   {".bss", 'b'},
 569   {"code", 't'},                /* MRI .text */
 570   {".data", 'd'},
 571   {"*DEBUG*", 'N'},
 572   {".debug", 'N'},              /* MSVC's .debug (non-standard debug syms) */
 573   {".drectve", 'i'},            /* MSVC's .drective section */
 574   {".edata", 'e'},              /* MSVC's .edata (export) section */
 575   {".fini", 't'},               /* ELF fini section */
 576   {".idata", 'i'},              /* MSVC's .idata (import) section */
 577   {".init", 't'},               /* ELF init section */
 578   {".pdata", 'p'},              /* MSVC's .pdata (stack unwind) section */
 579   {".rdata", 'r'},              /* Read only data.  */
 580   {".rodata", 'r'},             /* Read only data.  */
 581   {".sbss", 's'},               /* Small BSS (uninitialized data).  */
 582   {".scommon", 'c'},            /* Small common.  */
 583   {".sdata", 'g'},              /* Small initialized data.  */
 584   {".text", 't'},
 585   {"vars", 'd'},                /* MRI .data */
 586   {"zerovars", 'b'},            /* MRI .bss */
 587   {0, 0}
 588 };
 589
 590 /* Return the single-character symbol type corresponding to
 591    section S, or '?' for an unknown COFF section.
 592
 593    Check for any leading string which matches, so .text5 returns
 594    't' as well as .text */
 595
 596 static char
 597 coff_section_type (const char *s)
 598 {
 599   const struct section_to_type *t;
 600
 601   for (t = &stt[0]; t->section; t++)
 602     if (!strncmp (s, t->section, strlen (t->section)))
 603       return t->type;
 604
 605   return '?';
 606 }
 607
 608 /* Return the single-character symbol type corresponding to section
 609    SECTION, or '?' for an unknown section.  This uses section flags to
 610    identify sections.
 611
 612    FIXME These types are unhandled: c, i, e, p.  If we handled these also,
 613    we could perhaps obsolete coff_section_type.  */
 614
 615 static char
 616 decode_section_type (const struct bfd_section *section)
 617 {
 618   if (section->flags & SEC_CODE)
 619     return 't';
 620   if (section->flags & SEC_DATA)
 621     {
 622       if (section->flags & SEC_READONLY)
 623         return 'r';
 624       else if (section->flags & SEC_SMALL_DATA)
 625         return 'g';
 626       else
 627         return 'd';
 628     }
 629   if ((section->flags & SEC_HAS_CONTENTS) == 0)
 630     {
 631       if (section->flags & SEC_SMALL_DATA)
 632         return 's';
 633       else
 634         return 'b';
 635     }
 636   if (section->flags & SEC_DEBUGGING)
 637     return 'N';
 638   if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
 639     return 'n';
 640
 641   return '?';
 642 }
 643
 644 /*
 645 FUNCTION
 646         bfd_decode_symclass
 647
 648 DESCRIPTION
 649         Return a character corresponding to the symbol
 650         class of @var{symbol}, or '?' for an unknown class.
 651
 652 SYNOPSIS
 653         int bfd_decode_symclass (asymbol *symbol);
 654 */
 655 int
 656 bfd_decode_symclass (asymbol *symbol)
 657 {
 658   char c;
 659
 660   if (symbol->section && bfd_is_com_section (symbol->section))
 661     return 'C';
 662   if (bfd_is_und_section (symbol->section))
 663     {
 664       if (symbol->flags & BSF_WEAK)
 665         {
 666           /* If weak, determine if it's specifically an object
 667              or non-object weak.  */
 668           if (symbol->flags & BSF_OBJECT)
 669             return 'v';
 670           else
 671             return 'w';
 672         }
 673       else
 674         return 'U';
 675     }
 676   if (bfd_is_ind_section (symbol->section))
 677     return 'I';
 678   if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION)
 679     return 'i';
 680   if (symbol->flags & BSF_WEAK)
 681     {
 682       /* If weak, determine if it's specifically an object
 683          or non-object weak.  */
 684       if (symbol->flags & BSF_OBJECT)
 685         return 'V';
 686       else
 687         return 'W';
 688     }
 689   if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
 690     return '?';
 691
 692   if (bfd_is_abs_section (symbol->section))
 693     c = 'a';
 694   else if (symbol->section)
 695     {
 696       c = coff_section_type (symbol->section->name);
 697       if (c == '?')
 698         c = decode_section_type (symbol->section);
 699     }
 700   else
 701     return '?';
 702   if (symbol->flags & BSF_GLOBAL)
 703     c = TOUPPER (c);
 704   return c;
 705
 706   /* We don't have to handle these cases just yet, but we will soon:
 707      N_SETV: 'v';
 708      N_SETA: 'l';
 709      N_SETT: 'x';
 710      N_SETD: 'z';
 711      N_SETB: 's';
 712      N_INDR: 'i';
 713      */
 714 }
 715
 716 /*
 717 FUNCTION
 718         bfd_is_undefined_symclass
 719
 720 DESCRIPTION
 721         Returns non-zero if the class symbol returned by
 722         bfd_decode_symclass represents an undefined symbol.
 723         Returns zero otherwise.
 724
 725 SYNOPSIS
 726         bfd_boolean bfd_is_undefined_symclass (int symclass);
 727 */
 728
 729 bfd_boolean
 730 bfd_is_undefined_symclass (int symclass)
 731 {
 732   return symclass == 'U' || symclass == 'w' || symclass == 'v';
 733 }
 734
 735 /*
 736 FUNCTION
 737         bfd_symbol_info
 738
 739 DESCRIPTION
 740         Fill in the basic info about symbol that nm needs.
 741         Additional info may be added by the back-ends after
 742         calling this function.
 743
 744 SYNOPSIS
 745         void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
 746 */
 747
 748 void
 749 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
 750 {
 751   ret->type = bfd_decode_symclass (symbol);
 752
 753   if (bfd_is_undefined_symclass (ret->type))
 754     ret->value = 0;
 755   else
 756     ret->value = symbol->value + symbol->section->vma;
 757
 758   ret->name = symbol->name;
 759 }
 760
 761 /*
 762 FUNCTION
 763         bfd_copy_private_symbol_data
 764
 765 SYNOPSIS
 766         bfd_boolean bfd_copy_private_symbol_data
 767           (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
 768
 769 DESCRIPTION
 770         Copy private symbol information from @var{isym} in the BFD
 771         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
 772         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
 773         returns are:
 774
 775         o <<bfd_error_no_memory>> -
 776         Not enough memory exists to create private data for @var{osec}.
 777
 778 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
 779 .  BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
 780 .            (ibfd, isymbol, obfd, osymbol))
 781 .
 782 */
 783
 784 /* The generic version of the function which returns mini symbols.
 785    This is used when the backend does not provide a more efficient
 786    version.  It just uses BFD asymbol structures as mini symbols.  */
 787
 788 long
 789 _bfd_generic_read_minisymbols (bfd *abfd,
 790                                bfd_boolean dynamic,
 791                                void **minisymsp,
 792                                unsigned int *sizep)
 793 {
 794   long storage;
 795   asymbol **syms = NULL;
 796   long symcount;
 797
 798   if (dynamic)
 799     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 800   else
 801     storage = bfd_get_symtab_upper_bound (abfd);
 802   if (storage < 0)
 803     goto error_return;
 804   if (storage == 0)
 805     return 0;
 806
 807   syms = bfd_malloc (storage);
 808   if (syms == NULL)
 809     goto error_return;
 810
 811   if (dynamic)
 812     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
 813   else
 814     symcount = bfd_canonicalize_symtab (abfd, syms);
 815   if (symcount < 0)
 816     goto error_return;
 817
 818   *minisymsp = syms;
 819   *sizep = sizeof (asymbol *);
 820   return symcount;
 821
 822  error_return:
 823   bfd_set_error (bfd_error_no_symbols);
 824   if (syms != NULL)
 825     free (syms);
 826   return -1;
 827 }
 828
 829 /* The generic version of the function which converts a minisymbol to
 830    an asymbol.  We don't worry about the sym argument we are passed;
 831    we just return the asymbol the minisymbol points to.  */
 832
 833 asymbol *
 834 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 835                                    bfd_boolean dynamic ATTRIBUTE_UNUSED,
 836                                    const void *minisym,
 837                                    asymbol *sym ATTRIBUTE_UNUSED)
 838 {
 839   return *(asymbol **) minisym;
 840 }
 841
 842 /* Look through stabs debugging information in .stab and .stabstr
 843    sections to find the source file and line closest to a desired
 844    location.  This is used by COFF and ELF targets.  It sets *pfound
 845    to TRUE if it finds some information.  The *pinfo field is used to
 846    pass cached information in and out of this routine; this first time
 847    the routine is called for a BFD, *pinfo should be NULL.  The value
 848    placed in *pinfo should be saved with the BFD, and passed back each
 849    time this function is called.  */
 850
 851 /* We use a cache by default.  */
 852
 853 #define ENABLE_CACHING
 854
 855 /* We keep an array of indexentry structures to record where in the
 856    stabs section we should look to find line number information for a
 857    particular address.  */
 858
 859 struct indexentry
 860 {
 861   bfd_vma val;
 862   bfd_byte *stab;
 863   bfd_byte *str;
 864   char *directory_name;
 865   char *file_name;
 866   char *function_name;
 867 };
 868
 869 /* Compare two indexentry structures.  This is called via qsort.  */
 870
 871 static int
 872 cmpindexentry (const void *a, const void *b)
 873 {
 874   const struct indexentry *contestantA = a;
 875   const struct indexentry *contestantB = b;
 876
 877   if (contestantA->val < contestantB->val)
 878     return -1;
 879   else if (contestantA->val > contestantB->val)
 880     return 1;
 881   else
 882     return 0;
 883 }
 884
 885 /* A pointer to this structure is stored in *pinfo.  */
 886
 887 struct stab_find_info
 888 {
 889   /* The .stab section.  */
 890   asection *stabsec;
 891   /* The .stabstr section.  */
 892   asection *strsec;
 893   /* The contents of the .stab section.  */
 894   bfd_byte *stabs;
 895   /* The contents of the .stabstr section.  */
 896   bfd_byte *strs;
 897
 898   /* A table that indexes stabs by memory address.  */
 899   struct indexentry *indextable;
 900   /* The number of entries in indextable.  */
 901   int indextablesize;
 902
 903 #ifdef ENABLE_CACHING
 904   /* Cached values to restart quickly.  */
 905   struct indexentry *cached_indexentry;
 906   bfd_vma cached_offset;
 907   bfd_byte *cached_stab;
 908   char *cached_file_name;
 909 #endif
 910
 911   /* Saved ptr to malloc'ed filename.  */
 912   char *filename;
 913 };
 914
 915 bfd_boolean
 916 _bfd_stab_section_find_nearest_line (bfd *abfd,
 917                                      asymbol **symbols,
 918                                      asection *section,
 919                                      bfd_vma offset,
 920                                      bfd_boolean *pfound,
 921                                      const char **pfilename,
 922                                      const char **pfnname,
 923                                      unsigned int *pline,
 924                                      void **pinfo)
 925 {
 926   struct stab_find_info *info;
 927   bfd_size_type stabsize, strsize;
 928   bfd_byte *stab, *str;
 929   bfd_byte *last_stab = NULL;
 930   bfd_size_type stroff;
 931   struct indexentry *indexentry;
 932   char *file_name;
 933   char *directory_name;
 934   int saw_fun;
 935   bfd_boolean saw_line, saw_func;
 936
 937   *pfound = FALSE;
 938   *pfilename = bfd_get_filename (abfd);
 939   *pfnname = NULL;
 940   *pline = 0;
 941
 942   /* Stabs entries use a 12 byte format:
 943        4 byte string table index
 944        1 byte stab type
 945        1 byte stab other field
 946        2 byte stab desc field
 947        4 byte stab value
 948      FIXME: This will have to change for a 64 bit object format.
 949
 950      The stabs symbols are divided into compilation units.  For the
 951      first entry in each unit, the type of 0, the value is the length
 952      of the string table for this unit, and the desc field is the
 953      number of stabs symbols for this unit.  */
 954
 955 #define STRDXOFF (0)
 956 #define TYPEOFF (4)
 957 #define OTHEROFF (5)
 958 #define DESCOFF (6)
 959 #define VALOFF (8)
 960 #define STABSIZE (12)
 961
 962   info = *pinfo;
 963   if (info != NULL)
 964     {
 965       if (info->stabsec == NULL || info->strsec == NULL)
 966         {
 967           /* No stabs debugging information.  */
 968           return TRUE;
 969         }
 970
 971       stabsize = (info->stabsec->rawsize
 972                   ? info->stabsec->rawsize
 973                   : info->stabsec->size);
 974       strsize = (info->strsec->rawsize
 975                  ? info->strsec->rawsize
 976                  : info->strsec->size);
 977     }
 978   else
 979     {
 980       long reloc_size, reloc_count;
 981       arelent **reloc_vector;
 982       int i;
 983       char *name;
 984       char *function_name;
 985       bfd_size_type amt = sizeof *info;
 986
 987       info = bfd_zalloc (abfd, amt);
 988       if (info == NULL)
 989         return FALSE;
 990
 991       /* FIXME: When using the linker --split-by-file or
 992          --split-by-reloc options, it is possible for the .stab and
 993          .stabstr sections to be split.  We should handle that.  */
 994
 995       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
 996       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
 997
 998       if (info->stabsec == NULL || info->strsec == NULL)
 999         {
1000           /* Try SOM section names.  */
1001           info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$");
1002           info->strsec  = bfd_get_section_by_name (abfd, "$GDB_STRINGS$");
1003
1004           if (info->stabsec == NULL || info->strsec == NULL)
1005             {
1006               /* No stabs debugging information.  Set *pinfo so that we
1007                  can return quickly in the info != NULL case above.  */
1008               *pinfo = info;
1009               return TRUE;
1010             }
1011         }
1012
1013       stabsize = (info->stabsec->rawsize
1014                   ? info->stabsec->rawsize
1015                   : info->stabsec->size);
1016       strsize = (info->strsec->rawsize
1017                  ? info->strsec->rawsize
1018                  : info->strsec->size);
1019
1020       info->stabs = bfd_alloc (abfd, stabsize);
1021       info->strs = bfd_alloc (abfd, strsize);
1022       if (info->stabs == NULL || info->strs == NULL)
1023         return FALSE;
1024
1025       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1026                                       0, stabsize)
1027           || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1028                                          0, strsize))
1029         return FALSE;
1030
1031       /* If this is a relocatable object file, we have to relocate
1032          the entries in .stab.  This should always be simple 32 bit
1033          relocations against symbols defined in this object file, so
1034          this should be no big deal.  */
1035       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1036       if (reloc_size < 0)
1037         return FALSE;
1038       reloc_vector = bfd_malloc (reloc_size);
1039       if (reloc_vector == NULL && reloc_size != 0)
1040         return FALSE;
1041       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1042                                             symbols);
1043       if (reloc_count < 0)
1044         {
1045           if (reloc_vector != NULL)
1046             free (reloc_vector);
1047           return FALSE;
1048         }
1049       if (reloc_count > 0)
1050         {
1051           arelent **pr;
1052
1053           for (pr = reloc_vector; *pr != NULL; pr++)
1054             {
1055               arelent *r;
1056               unsigned long val;
1057               asymbol *sym;
1058
1059               r = *pr;
1060               /* Ignore R_*_NONE relocs.  */
1061               if (r->howto->dst_mask == 0)
1062                 continue;
1063
1064               if (r->howto->rightshift != 0
1065                   || r->howto->size != 2
1066                   || r->howto->bitsize != 32
1067                   || r->howto->pc_relative
1068                   || r->howto->bitpos != 0
1069                   || r->howto->dst_mask != 0xffffffff)
1070                 {
1071                   (*_bfd_error_handler)
1072                     (_("Unsupported .stab relocation"));
1073                   bfd_set_error (bfd_error_invalid_operation);
1074                   if (reloc_vector != NULL)
1075                     free (reloc_vector);
1076                   return FALSE;
1077                 }
1078
1079               val = bfd_get_32 (abfd, info->stabs + r->address);
1080               val &= r->howto->src_mask;
1081               sym = *r->sym_ptr_ptr;
1082               val += sym->value + sym->section->vma + r->addend;
1083               bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1084             }
1085         }
1086
1087       if (reloc_vector != NULL)
1088         free (reloc_vector);
1089
1090       /* First time through this function, build a table matching
1091          function VM addresses to stabs, then sort based on starting
1092          VM address.  Do this in two passes: once to count how many
1093          table entries we'll need, and a second to actually build the
1094          table.  */
1095
1096       info->indextablesize = 0;
1097       saw_fun = 1;
1098       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1099         {
1100           if (stab[TYPEOFF] == (bfd_byte) N_SO)
1101             {
1102               /* N_SO with null name indicates EOF */
1103               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1104                 continue;
1105
1106               /* if we did not see a function def, leave space for one.  */
1107               if (saw_fun == 0)
1108                 ++info->indextablesize;
1109
1110               saw_fun = 0;
1111
1112               /* two N_SO's in a row is a filename and directory. Skip */
1113               if (stab + STABSIZE < info->stabs + stabsize
1114                   && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1115                 {
1116                   stab += STABSIZE;
1117                 }
1118             }
1119           else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
1120             {
1121               saw_fun = 1;
1122               ++info->indextablesize;
1123             }
1124         }
1125
1126       if (saw_fun == 0)
1127         ++info->indextablesize;
1128
1129       if (info->indextablesize == 0)
1130         return TRUE;
1131       ++info->indextablesize;
1132
1133       amt = info->indextablesize;
1134       amt *= sizeof (struct indexentry);
1135       info->indextable = bfd_alloc (abfd, amt);
1136       if (info->indextable == NULL)
1137         return FALSE;
1138
1139       file_name = NULL;
1140       directory_name = NULL;
1141       saw_fun = 1;
1142
1143       for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1144            i < info->indextablesize && stab < info->stabs + stabsize;
1145            stab += STABSIZE)
1146         {
1147           switch (stab[TYPEOFF])
1148             {
1149             case 0:
1150               /* This is the first entry in a compilation unit.  */
1151               if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1152                 break;
1153               str += stroff;
1154               stroff = bfd_get_32 (abfd, stab + VALOFF);
1155               break;
1156
1157             case N_SO:
1158               /* The main file name.  */
1159
1160               /* The following code creates a new indextable entry with
1161                  a NULL function name if there were no N_FUNs in a file.
1162                  Note that a N_SO without a file name is an EOF and
1163                  there could be 2 N_SO following it with the new filename
1164                  and directory.  */
1165               if (saw_fun == 0)
1166                 {
1167                   info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1168                   info->indextable[i].stab = last_stab;
1169                   info->indextable[i].str = str;
1170                   info->indextable[i].directory_name = directory_name;
1171                   info->indextable[i].file_name = file_name;
1172                   info->indextable[i].function_name = NULL;
1173                   ++i;
1174                 }
1175               saw_fun = 0;
1176
1177               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1178               if (*file_name == '\0')
1179                 {
1180                   directory_name = NULL;
1181                   file_name = NULL;
1182                   saw_fun = 1;
1183                 }
1184               else
1185                 {
1186                   last_stab = stab;
1187                   if (stab + STABSIZE >= info->stabs + stabsize
1188                       || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
1189                     {
1190                       directory_name = NULL;
1191                     }
1192                   else
1193                     {
1194                       /* Two consecutive N_SOs are a directory and a
1195                          file name.  */
1196                       stab += STABSIZE;
1197                       directory_name = file_name;
1198                       file_name = ((char *) str
1199                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1200                     }
1201                 }
1202               break;
1203
1204             case N_SOL:
1205               /* The name of an include file.  */
1206               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1207               break;
1208
1209             case N_FUN:
1210               /* A function name.  */
1211               saw_fun = 1;
1212               name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1213
1214               if (*name == '\0')
1215                 name = NULL;
1216
1217               function_name = name;
1218
1219               if (name == NULL)
1220                 continue;
1221
1222               info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1223               info->indextable[i].stab = stab;
1224               info->indextable[i].str = str;
1225               info->indextable[i].directory_name = directory_name;
1226               info->indextable[i].file_name = file_name;
1227               info->indextable[i].function_name = function_name;
1228               ++i;
1229               break;
1230             }
1231         }
1232
1233       if (saw_fun == 0)
1234         {
1235           info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1236           info->indextable[i].stab = last_stab;
1237           info->indextable[i].str = str;
1238           info->indextable[i].directory_name = directory_name;
1239           info->indextable[i].file_name = file_name;
1240           info->indextable[i].function_name = NULL;
1241           ++i;
1242         }
1243
1244       info->indextable[i].val = (bfd_vma) -1;
1245       info->indextable[i].stab = info->stabs + stabsize;
1246       info->indextable[i].str = str;
1247       info->indextable[i].directory_name = NULL;
1248       info->indextable[i].file_name = NULL;
1249       info->indextable[i].function_name = NULL;
1250       ++i;
1251
1252       info->indextablesize = i;
1253       qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1254              cmpindexentry);
1255
1256       *pinfo = info;
1257     }
1258
1259   /* We are passed a section relative offset.  The offsets in the
1260      stabs information are absolute.  */
1261   offset += bfd_get_section_vma (abfd, section);
1262
1263 #ifdef ENABLE_CACHING
1264   if (info->cached_indexentry != NULL
1265       && offset >= info->cached_offset
1266       && offset < (info->cached_indexentry + 1)->val)
1267     {
1268       stab = info->cached_stab;
1269       indexentry = info->cached_indexentry;
1270       file_name = info->cached_file_name;
1271     }
1272   else
1273 #endif
1274     {
1275       long low, high;
1276       long mid = -1;
1277
1278       /* Cache non-existent or invalid.  Do binary search on
1279          indextable.  */
1280       indexentry = NULL;
1281
1282       low = 0;
1283       high = info->indextablesize - 1;
1284       while (low != high)
1285         {
1286           mid = (high + low) / 2;
1287           if (offset >= info->indextable[mid].val
1288               && offset < info->indextable[mid + 1].val)
1289             {
1290               indexentry = &info->indextable[mid];
1291               break;
1292             }
1293
1294           if (info->indextable[mid].val > offset)
1295             high = mid;
1296           else
1297             low = mid + 1;
1298         }
1299
1300       if (indexentry == NULL)
1301         return TRUE;
1302
1303       stab = indexentry->stab + STABSIZE;
1304       file_name = indexentry->file_name;
1305     }
1306
1307   directory_name = indexentry->directory_name;
1308   str = indexentry->str;
1309
1310   saw_line = FALSE;
1311   saw_func = FALSE;
1312   for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1313     {
1314       bfd_boolean done;
1315       bfd_vma val;
1316
1317       done = FALSE;
1318
1319       switch (stab[TYPEOFF])
1320         {
1321         case N_SOL:
1322           /* The name of an include file.  */
1323           val = bfd_get_32 (abfd, stab + VALOFF);
1324           if (val <= offset)
1325             {
1326               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1327               *pline = 0;
1328             }
1329           break;
1330
1331         case N_SLINE:
1332         case N_DSLINE:
1333         case N_BSLINE:
1334           /* A line number.  If the function was specified, then the value
1335              is relative to the start of the function.  Otherwise, the
1336              value is an absolute address.  */
1337           val = ((indexentry->function_name ? indexentry->val : 0)
1338                  + bfd_get_32 (abfd, stab + VALOFF));
1339           /* If this line starts before our desired offset, or if it's
1340              the first line we've been able to find, use it.  The
1341              !saw_line check works around a bug in GCC 2.95.3, which emits
1342              the first N_SLINE late.  */
1343           if (!saw_line || val <= offset)
1344             {
1345               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1346
1347 #ifdef ENABLE_CACHING
1348               info->cached_stab = stab;
1349               info->cached_offset = val;
1350               info->cached_file_name = file_name;
1351               info->cached_indexentry = indexentry;
1352 #endif
1353             }
1354           if (val > offset)
1355             done = TRUE;
1356           saw_line = TRUE;
1357           break;
1358
1359         case N_FUN:
1360         case N_SO:
1361           if (saw_func || saw_line)
1362             done = TRUE;
1363           saw_func = TRUE;
1364           break;
1365         }
1366
1367       if (done)
1368         break;
1369     }
1370
1371   *pfound = TRUE;
1372
1373   if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1374       || directory_name == NULL)
1375     *pfilename = file_name;
1376   else
1377     {
1378       size_t dirlen;
1379
1380       dirlen = strlen (directory_name);
1381       if (info->filename == NULL
1382           || strncmp (info->filename, directory_name, dirlen) != 0
1383           || strcmp (info->filename + dirlen, file_name) != 0)
1384         {
1385           size_t len;
1386
1387           /* Don't free info->filename here.  objdump and other
1388              apps keep a copy of a previously returned file name
1389              pointer.  */
1390           len = strlen (file_name) + 1;
1391           info->filename = bfd_alloc (abfd, dirlen + len);
1392           if (info->filename == NULL)
1393             return FALSE;
1394           memcpy (info->filename, directory_name, dirlen);
1395           memcpy (info->filename + dirlen, file_name, len);
1396         }
1397
1398       *pfilename = info->filename;
1399     }
1400
1401   if (indexentry->function_name != NULL)
1402     {
1403       char *s;
1404
1405       /* This will typically be something like main:F(0,1), so we want
1406          to clobber the colon.  It's OK to change the name, since the
1407          string is in our own local storage anyhow.  */
1408       s = strchr (indexentry->function_name, ':');
1409       if (s != NULL)
1410         *s = '\0';
1411
1412       *pfnname = indexentry->function_name;
1413     }
1414
1415   return TRUE;
1416 }