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
   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 .  flagword flags;
 301 .
 302 .  {* A pointer to the section to which this symbol is
 303 .     relative.  This will always be non NULL, there are special
 304 .     sections for undefined and absolute symbols.  *}
 305 .  struct bfd_section *section;
 306 .
 307 .  {* Back end special data.  *}
 308 .  union
 309 .    {
 310 .      void *p;
 311 .      bfd_vma i;
 312 .    }
 313 .  udata;
 314 .}
 315 .asymbol;
 316 .
 317 */
 318
 319 #include "sysdep.h"
 320 #include "bfd.h"
 321 #include "libbfd.h"
 322 #include "safe-ctype.h"
 323 #include "bfdlink.h"
 324 #include "aout/stab_gnu.h"
 325
 326 /*
 327 DOCDD
 328 INODE
 329 symbol handling functions,  , typedef asymbol, Symbols
 330 SUBSECTION
 331         Symbol handling functions
 332 */
 333
 334 /*
 335 FUNCTION
 336         bfd_get_symtab_upper_bound
 337
 338 DESCRIPTION
 339         Return the number of bytes required to store a vector of pointers
 340         to <<asymbols>> for all the symbols in the BFD @var{abfd},
 341         including a terminal NULL pointer. If there are no symbols in
 342         the BFD, then return 0.  If an error occurs, return -1.
 343
 344 .#define bfd_get_symtab_upper_bound(abfd) \
 345 .     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
 346 .
 347 */
 348
 349 /*
 350 FUNCTION
 351         bfd_is_local_label
 352
 353 SYNOPSIS
 354         bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
 355
 356 DESCRIPTION
 357         Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is
 358         a compiler generated local label, else return FALSE.
 359 */
 360
 361 bfd_boolean
 362 bfd_is_local_label (bfd *abfd, asymbol *sym)
 363 {
 364   /* The BSF_SECTION_SYM check is needed for IA-64, where every label that
 365      starts with '.' is local.  This would accidentally catch section names
 366      if we didn't reject them here.  */
 367   if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0)
 368     return FALSE;
 369   if (sym->name == NULL)
 370     return FALSE;
 371   return bfd_is_local_label_name (abfd, sym->name);
 372 }
 373
 374 /*
 375 FUNCTION
 376         bfd_is_local_label_name
 377
 378 SYNOPSIS
 379         bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
 380
 381 DESCRIPTION
 382         Return TRUE if a symbol with the name @var{name} in the BFD
 383         @var{abfd} is a compiler generated local label, else return
 384         FALSE.  This just checks whether the name has the form of a
 385         local label.
 386
 387 .#define bfd_is_local_label_name(abfd, name) \
 388 .  BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
 389 .
 390 */
 391
 392 /*
 393 FUNCTION
 394         bfd_is_target_special_symbol
 395
 396 SYNOPSIS
 397         bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
 398
 399 DESCRIPTION
 400         Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something
 401         special to the particular target represented by the BFD.  Such symbols
 402         should normally not be mentioned to the user.
 403
 404 .#define bfd_is_target_special_symbol(abfd, sym) \
 405 .  BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
 406 .
 407 */
 408
 409 /*
 410 FUNCTION
 411         bfd_canonicalize_symtab
 412
 413 DESCRIPTION
 414         Read the symbols from the BFD @var{abfd}, and fills in
 415         the vector @var{location} with pointers to the symbols and
 416         a trailing NULL.
 417         Return the actual number of symbol pointers, not
 418         including the NULL.
 419
 420 .#define bfd_canonicalize_symtab(abfd, location) \
 421 .  BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
 422 .
 423 */
 424
 425 /*
 426 FUNCTION
 427         bfd_set_symtab
 428
 429 SYNOPSIS
 430         bfd_boolean bfd_set_symtab
 431           (bfd *abfd, asymbol **location, unsigned int count);
 432
 433 DESCRIPTION
 434         Arrange that when the output BFD @var{abfd} is closed,
 435         the table @var{location} of @var{count} pointers to symbols
 436         will be written.
 437 */
 438
 439 bfd_boolean
 440 bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount)
 441 {
 442   if (abfd->format != bfd_object || bfd_read_p (abfd))
 443     {
 444       bfd_set_error (bfd_error_invalid_operation);
 445       return FALSE;
 446     }
 447
 448   bfd_get_outsymbols (abfd) = location;
 449   bfd_get_symcount (abfd) = symcount;
 450   return TRUE;
 451 }
 452
 453 /*
 454 FUNCTION
 455         bfd_print_symbol_vandf
 456
 457 SYNOPSIS
 458         void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
 459
 460 DESCRIPTION
 461         Print the value and flags of the @var{symbol} supplied to the
 462         stream @var{file}.
 463 */
 464 void
 465 bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol)
 466 {
 467   FILE *file = arg;
 468
 469   flagword type = symbol->flags;
 470
 471   if (symbol->section != NULL)
 472     bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma);
 473   else
 474     bfd_fprintf_vma (abfd, file, symbol->value);
 475
 476   /* This presumes that a symbol can not be both BSF_DEBUGGING and
 477      BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
 478      BSF_OBJECT.  */
 479   fprintf (file, " %c%c%c%c%c%c%c",
 480            ((type & BSF_LOCAL)
 481             ? (type & BSF_GLOBAL) ? '!' : 'l'
 482             : (type & BSF_GLOBAL) ? 'g' : ' '),
 483            (type & BSF_WEAK) ? 'w' : ' ',
 484            (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
 485            (type & BSF_WARNING) ? 'W' : ' ',
 486            (type & BSF_INDIRECT) ? 'I' : ' ',
 487            (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
 488            ((type & BSF_FUNCTION)
 489             ? 'F'
 490             : ((type & BSF_FILE)
 491                ? 'f'
 492                : ((type & BSF_OBJECT) ? 'O' : ' '))));
 493 }
 494
 495 /*
 496 FUNCTION
 497         bfd_make_empty_symbol
 498
 499 DESCRIPTION
 500         Create a new <<asymbol>> structure for the BFD @var{abfd}
 501         and return a pointer to it.
 502
 503         This routine is necessary because each back end has private
 504         information surrounding the <<asymbol>>. Building your own
 505         <<asymbol>> and pointing to it will not create the private
 506         information, and will cause problems later on.
 507
 508 .#define bfd_make_empty_symbol(abfd) \
 509 .  BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
 510 .
 511 */
 512
 513 /*
 514 FUNCTION
 515         _bfd_generic_make_empty_symbol
 516
 517 SYNOPSIS
 518         asymbol *_bfd_generic_make_empty_symbol (bfd *);
 519
 520 DESCRIPTION
 521         Create a new <<asymbol>> structure for the BFD @var{abfd}
 522         and return a pointer to it.  Used by core file routines,
 523         binary back-end and anywhere else where no private info
 524         is needed.
 525 */
 526
 527 asymbol *
 528 _bfd_generic_make_empty_symbol (bfd *abfd)
 529 {
 530   bfd_size_type amt = sizeof (asymbol);
 531   asymbol *new = bfd_zalloc (abfd, amt);
 532   if (new)
 533     new->the_bfd = abfd;
 534   return new;
 535 }
 536
 537 /*
 538 FUNCTION
 539         bfd_make_debug_symbol
 540
 541 DESCRIPTION
 542         Create a new <<asymbol>> structure for the BFD @var{abfd},
 543         to be used as a debugging symbol.  Further details of its use have
 544         yet to be worked out.
 545
 546 .#define bfd_make_debug_symbol(abfd,ptr,size) \
 547 .  BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
 548 .
 549 */
 550
 551 struct section_to_type
 552 {
 553   const char *section;
 554   char type;
 555 };
 556
 557 /* Map section names to POSIX/BSD single-character symbol types.
 558    This table is probably incomplete.  It is sorted for convenience of
 559    adding entries.  Since it is so short, a linear search is used.  */
 560 static const struct section_to_type stt[] =
 561 {
 562   {".bss", 'b'},
 563   {"code", 't'},                /* MRI .text */
 564   {".data", 'd'},
 565   {"*DEBUG*", 'N'},
 566   {".debug", 'N'},              /* MSVC's .debug (non-standard debug syms) */
 567   {".drectve", 'i'},            /* MSVC's .drective section */
 568   {".edata", 'e'},              /* MSVC's .edata (export) section */
 569   {".fini", 't'},               /* ELF fini section */
 570   {".idata", 'i'},              /* MSVC's .idata (import) section */
 571   {".init", 't'},               /* ELF init section */
 572   {".pdata", 'p'},              /* MSVC's .pdata (stack unwind) section */
 573   {".rdata", 'r'},              /* Read only data.  */
 574   {".rodata", 'r'},             /* Read only data.  */
 575   {".sbss", 's'},               /* Small BSS (uninitialized data).  */
 576   {".scommon", 'c'},            /* Small common.  */
 577   {".sdata", 'g'},              /* Small initialized data.  */
 578   {".text", 't'},
 579   {"vars", 'd'},                /* MRI .data */
 580   {"zerovars", 'b'},            /* MRI .bss */
 581   {0, 0}
 582 };
 583
 584 /* Return the single-character symbol type corresponding to
 585    section S, or '?' for an unknown COFF section.
 586
 587    Check for any leading string which matches, so .text5 returns
 588    't' as well as .text */
 589
 590 static char
 591 coff_section_type (const char *s)
 592 {
 593   const struct section_to_type *t;
 594
 595   for (t = &stt[0]; t->section; t++)
 596     if (!strncmp (s, t->section, strlen (t->section)))
 597       return t->type;
 598
 599   return '?';
 600 }
 601
 602 /* Return the single-character symbol type corresponding to section
 603    SECTION, or '?' for an unknown section.  This uses section flags to
 604    identify sections.
 605
 606    FIXME These types are unhandled: c, i, e, p.  If we handled these also,
 607    we could perhaps obsolete coff_section_type.  */
 608
 609 static char
 610 decode_section_type (const struct bfd_section *section)
 611 {
 612   if (section->flags & SEC_CODE)
 613     return 't';
 614   if (section->flags & SEC_DATA)
 615     {
 616       if (section->flags & SEC_READONLY)
 617         return 'r';
 618       else if (section->flags & SEC_SMALL_DATA)
 619         return 'g';
 620       else
 621         return 'd';
 622     }
 623   if ((section->flags & SEC_HAS_CONTENTS) == 0)
 624     {
 625       if (section->flags & SEC_SMALL_DATA)
 626         return 's';
 627       else
 628         return 'b';
 629     }
 630   if (section->flags & SEC_DEBUGGING)
 631     return 'N';
 632   if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
 633     return 'n';
 634
 635   return '?';
 636 }
 637
 638 /*
 639 FUNCTION
 640         bfd_decode_symclass
 641
 642 DESCRIPTION
 643         Return a character corresponding to the symbol
 644         class of @var{symbol}, or '?' for an unknown class.
 645
 646 SYNOPSIS
 647         int bfd_decode_symclass (asymbol *symbol);
 648 */
 649 int
 650 bfd_decode_symclass (asymbol *symbol)
 651 {
 652   char c;
 653
 654   if (symbol->section && bfd_is_com_section (symbol->section))
 655     return 'C';
 656   if (bfd_is_und_section (symbol->section))
 657     {
 658       if (symbol->flags & BSF_WEAK)
 659         {
 660           /* If weak, determine if it's specifically an object
 661              or non-object weak.  */
 662           if (symbol->flags & BSF_OBJECT)
 663             return 'v';
 664           else
 665             return 'w';
 666         }
 667       else
 668         return 'U';
 669     }
 670   if (bfd_is_ind_section (symbol->section))
 671     return 'I';
 672   if (symbol->flags & BSF_WEAK)
 673     {
 674       /* If weak, determine if it's specifically an object
 675          or non-object weak.  */
 676       if (symbol->flags & BSF_OBJECT)
 677         return 'V';
 678       else
 679         return 'W';
 680     }
 681   if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
 682     return '?';
 683
 684   if (bfd_is_abs_section (symbol->section))
 685     c = 'a';
 686   else if (symbol->section)
 687     {
 688       c = coff_section_type (symbol->section->name);
 689       if (c == '?')
 690         c = decode_section_type (symbol->section);
 691     }
 692   else
 693     return '?';
 694   if (symbol->flags & BSF_GLOBAL)
 695     c = TOUPPER (c);
 696   return c;
 697
 698   /* We don't have to handle these cases just yet, but we will soon:
 699      N_SETV: 'v';
 700      N_SETA: 'l';
 701      N_SETT: 'x';
 702      N_SETD: 'z';
 703      N_SETB: 's';
 704      N_INDR: 'i';
 705      */
 706 }
 707
 708 /*
 709 FUNCTION
 710         bfd_is_undefined_symclass
 711
 712 DESCRIPTION
 713         Returns non-zero if the class symbol returned by
 714         bfd_decode_symclass represents an undefined symbol.
 715         Returns zero otherwise.
 716
 717 SYNOPSIS
 718         bfd_boolean bfd_is_undefined_symclass (int symclass);
 719 */
 720
 721 bfd_boolean
 722 bfd_is_undefined_symclass (int symclass)
 723 {
 724   return symclass == 'U' || symclass == 'w' || symclass == 'v';
 725 }
 726
 727 /*
 728 FUNCTION
 729         bfd_symbol_info
 730
 731 DESCRIPTION
 732         Fill in the basic info about symbol that nm needs.
 733         Additional info may be added by the back-ends after
 734         calling this function.
 735
 736 SYNOPSIS
 737         void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
 738 */
 739
 740 void
 741 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
 742 {
 743   ret->type = bfd_decode_symclass (symbol);
 744
 745   if (bfd_is_undefined_symclass (ret->type))
 746     ret->value = 0;
 747   else
 748     ret->value = symbol->value + symbol->section->vma;
 749
 750   ret->name = symbol->name;
 751 }
 752
 753 /*
 754 FUNCTION
 755         bfd_copy_private_symbol_data
 756
 757 SYNOPSIS
 758         bfd_boolean bfd_copy_private_symbol_data
 759           (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
 760
 761 DESCRIPTION
 762         Copy private symbol information from @var{isym} in the BFD
 763         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
 764         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
 765         returns are:
 766
 767         o <<bfd_error_no_memory>> -
 768         Not enough memory exists to create private data for @var{osec}.
 769
 770 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
 771 .  BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
 772 .            (ibfd, isymbol, obfd, osymbol))
 773 .
 774 */
 775
 776 /* The generic version of the function which returns mini symbols.
 777    This is used when the backend does not provide a more efficient
 778    version.  It just uses BFD asymbol structures as mini symbols.  */
 779
 780 long
 781 _bfd_generic_read_minisymbols (bfd *abfd,
 782                                bfd_boolean dynamic,
 783                                void **minisymsp,
 784                                unsigned int *sizep)
 785 {
 786   long storage;
 787   asymbol **syms = NULL;
 788   long symcount;
 789
 790   if (dynamic)
 791     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 792   else
 793     storage = bfd_get_symtab_upper_bound (abfd);
 794   if (storage < 0)
 795     goto error_return;
 796   if (storage == 0)
 797     return 0;
 798
 799   syms = bfd_malloc (storage);
 800   if (syms == NULL)
 801     goto error_return;
 802
 803   if (dynamic)
 804     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
 805   else
 806     symcount = bfd_canonicalize_symtab (abfd, syms);
 807   if (symcount < 0)
 808     goto error_return;
 809
 810   *minisymsp = syms;
 811   *sizep = sizeof (asymbol *);
 812   return symcount;
 813
 814  error_return:
 815   bfd_set_error (bfd_error_no_symbols);
 816   if (syms != NULL)
 817     free (syms);
 818   return -1;
 819 }
 820
 821 /* The generic version of the function which converts a minisymbol to
 822    an asymbol.  We don't worry about the sym argument we are passed;
 823    we just return the asymbol the minisymbol points to.  */
 824
 825 asymbol *
 826 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 827                                    bfd_boolean dynamic ATTRIBUTE_UNUSED,
 828                                    const void *minisym,
 829                                    asymbol *sym ATTRIBUTE_UNUSED)
 830 {
 831   return *(asymbol **) minisym;
 832 }
 833
 834 /* Look through stabs debugging information in .stab and .stabstr
 835    sections to find the source file and line closest to a desired
 836    location.  This is used by COFF and ELF targets.  It sets *pfound
 837    to TRUE if it finds some information.  The *pinfo field is used to
 838    pass cached information in and out of this routine; this first time
 839    the routine is called for a BFD, *pinfo should be NULL.  The value
 840    placed in *pinfo should be saved with the BFD, and passed back each
 841    time this function is called.  */
 842
 843 /* We use a cache by default.  */
 844
 845 #define ENABLE_CACHING
 846
 847 /* We keep an array of indexentry structures to record where in the
 848    stabs section we should look to find line number information for a
 849    particular address.  */
 850
 851 struct indexentry
 852 {
 853   bfd_vma val;
 854   bfd_byte *stab;
 855   bfd_byte *str;
 856   char *directory_name;
 857   char *file_name;
 858   char *function_name;
 859 };
 860
 861 /* Compare two indexentry structures.  This is called via qsort.  */
 862
 863 static int
 864 cmpindexentry (const void *a, const void *b)
 865 {
 866   const struct indexentry *contestantA = a;
 867   const struct indexentry *contestantB = b;
 868
 869   if (contestantA->val < contestantB->val)
 870     return -1;
 871   else if (contestantA->val > contestantB->val)
 872     return 1;
 873   else
 874     return 0;
 875 }
 876
 877 /* A pointer to this structure is stored in *pinfo.  */
 878
 879 struct stab_find_info
 880 {
 881   /* The .stab section.  */
 882   asection *stabsec;
 883   /* The .stabstr section.  */
 884   asection *strsec;
 885   /* The contents of the .stab section.  */
 886   bfd_byte *stabs;
 887   /* The contents of the .stabstr section.  */
 888   bfd_byte *strs;
 889
 890   /* A table that indexes stabs by memory address.  */
 891   struct indexentry *indextable;
 892   /* The number of entries in indextable.  */
 893   int indextablesize;
 894
 895 #ifdef ENABLE_CACHING
 896   /* Cached values to restart quickly.  */
 897   struct indexentry *cached_indexentry;
 898   bfd_vma cached_offset;
 899   bfd_byte *cached_stab;
 900   char *cached_file_name;
 901 #endif
 902
 903   /* Saved ptr to malloc'ed filename.  */
 904   char *filename;
 905 };
 906
 907 bfd_boolean
 908 _bfd_stab_section_find_nearest_line (bfd *abfd,
 909                                      asymbol **symbols,
 910                                      asection *section,
 911                                      bfd_vma offset,
 912                                      bfd_boolean *pfound,
 913                                      const char **pfilename,
 914                                      const char **pfnname,
 915                                      unsigned int *pline,
 916                                      void **pinfo)
 917 {
 918   struct stab_find_info *info;
 919   bfd_size_type stabsize, strsize;
 920   bfd_byte *stab, *str;
 921   bfd_byte *last_stab = NULL;
 922   bfd_size_type stroff;
 923   struct indexentry *indexentry;
 924   char *file_name;
 925   char *directory_name;
 926   int saw_fun;
 927   bfd_boolean saw_line, saw_func;
 928
 929   *pfound = FALSE;
 930   *pfilename = bfd_get_filename (abfd);
 931   *pfnname = NULL;
 932   *pline = 0;
 933
 934   /* Stabs entries use a 12 byte format:
 935        4 byte string table index
 936        1 byte stab type
 937        1 byte stab other field
 938        2 byte stab desc field
 939        4 byte stab value
 940      FIXME: This will have to change for a 64 bit object format.
 941
 942      The stabs symbols are divided into compilation units.  For the
 943      first entry in each unit, the type of 0, the value is the length
 944      of the string table for this unit, and the desc field is the
 945      number of stabs symbols for this unit.  */
 946
 947 #define STRDXOFF (0)
 948 #define TYPEOFF (4)
 949 #define OTHEROFF (5)
 950 #define DESCOFF (6)
 951 #define VALOFF (8)
 952 #define STABSIZE (12)
 953
 954   info = *pinfo;
 955   if (info != NULL)
 956     {
 957       if (info->stabsec == NULL || info->strsec == NULL)
 958         {
 959           /* No stabs debugging information.  */
 960           return TRUE;
 961         }
 962
 963       stabsize = (info->stabsec->rawsize
 964                   ? info->stabsec->rawsize
 965                   : info->stabsec->size);
 966       strsize = (info->strsec->rawsize
 967                  ? info->strsec->rawsize
 968                  : info->strsec->size);
 969     }
 970   else
 971     {
 972       long reloc_size, reloc_count;
 973       arelent **reloc_vector;
 974       int i;
 975       char *name;
 976       char *function_name;
 977       bfd_size_type amt = sizeof *info;
 978
 979       info = bfd_zalloc (abfd, amt);
 980       if (info == NULL)
 981         return FALSE;
 982
 983       /* FIXME: When using the linker --split-by-file or
 984          --split-by-reloc options, it is possible for the .stab and
 985          .stabstr sections to be split.  We should handle that.  */
 986
 987       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
 988       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
 989
 990       if (info->stabsec == NULL || info->strsec == NULL)
 991         {
 992           /* Try SOM section names.  */
 993           info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$");
 994           info->strsec  = bfd_get_section_by_name (abfd, "$GDB_STRINGS$");
 995
 996           if (info->stabsec == NULL || info->strsec == NULL)
 997             {
 998               /* No stabs debugging information.  Set *pinfo so that we
 999                  can return quickly in the info != NULL case above.  */
1000               *pinfo = info;
1001               return TRUE;
1002             }
1003         }
1004
1005       stabsize = (info->stabsec->rawsize
1006                   ? info->stabsec->rawsize
1007                   : info->stabsec->size);
1008       strsize = (info->strsec->rawsize
1009                  ? info->strsec->rawsize
1010                  : info->strsec->size);
1011
1012       info->stabs = bfd_alloc (abfd, stabsize);
1013       info->strs = bfd_alloc (abfd, strsize);
1014       if (info->stabs == NULL || info->strs == NULL)
1015         return FALSE;
1016
1017       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1018                                       0, stabsize)
1019           || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1020                                          0, strsize))
1021         return FALSE;
1022
1023       /* If this is a relocatable object file, we have to relocate
1024          the entries in .stab.  This should always be simple 32 bit
1025          relocations against symbols defined in this object file, so
1026          this should be no big deal.  */
1027       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1028       if (reloc_size < 0)
1029         return FALSE;
1030       reloc_vector = bfd_malloc (reloc_size);
1031       if (reloc_vector == NULL && reloc_size != 0)
1032         return FALSE;
1033       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1034                                             symbols);
1035       if (reloc_count < 0)
1036         {
1037           if (reloc_vector != NULL)
1038             free (reloc_vector);
1039           return FALSE;
1040         }
1041       if (reloc_count > 0)
1042         {
1043           arelent **pr;
1044
1045           for (pr = reloc_vector; *pr != NULL; pr++)
1046             {
1047               arelent *r;
1048               unsigned long val;
1049               asymbol *sym;
1050
1051               r = *pr;
1052               /* Ignore R_*_NONE relocs.  */
1053               if (r->howto->dst_mask == 0)
1054                 continue;
1055
1056               if (r->howto->rightshift != 0
1057                   || r->howto->size != 2
1058                   || r->howto->bitsize != 32
1059                   || r->howto->pc_relative
1060                   || r->howto->bitpos != 0
1061                   || r->howto->dst_mask != 0xffffffff)
1062                 {
1063                   (*_bfd_error_handler)
1064                     (_("Unsupported .stab relocation"));
1065                   bfd_set_error (bfd_error_invalid_operation);
1066                   if (reloc_vector != NULL)
1067                     free (reloc_vector);
1068                   return FALSE;
1069                 }
1070
1071               val = bfd_get_32 (abfd, info->stabs + r->address);
1072               val &= r->howto->src_mask;
1073               sym = *r->sym_ptr_ptr;
1074               val += sym->value + sym->section->vma + r->addend;
1075               bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1076             }
1077         }
1078
1079       if (reloc_vector != NULL)
1080         free (reloc_vector);
1081
1082       /* First time through this function, build a table matching
1083          function VM addresses to stabs, then sort based on starting
1084          VM address.  Do this in two passes: once to count how many
1085          table entries we'll need, and a second to actually build the
1086          table.  */
1087
1088       info->indextablesize = 0;
1089       saw_fun = 1;
1090       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1091         {
1092           if (stab[TYPEOFF] == (bfd_byte) N_SO)
1093             {
1094               /* N_SO with null name indicates EOF */
1095               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1096                 continue;
1097
1098               /* if we did not see a function def, leave space for one.  */
1099               if (saw_fun == 0)
1100                 ++info->indextablesize;
1101
1102               saw_fun = 0;
1103
1104               /* two N_SO's in a row is a filename and directory. Skip */
1105               if (stab + STABSIZE < info->stabs + stabsize
1106                   && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1107                 {
1108                   stab += STABSIZE;
1109                 }
1110             }
1111           else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
1112             {
1113               saw_fun = 1;
1114               ++info->indextablesize;
1115             }
1116         }
1117
1118       if (saw_fun == 0)
1119         ++info->indextablesize;
1120
1121       if (info->indextablesize == 0)
1122         return TRUE;
1123       ++info->indextablesize;
1124
1125       amt = info->indextablesize;
1126       amt *= sizeof (struct indexentry);
1127       info->indextable = bfd_alloc (abfd, amt);
1128       if (info->indextable == NULL)
1129         return FALSE;
1130
1131       file_name = NULL;
1132       directory_name = NULL;
1133       saw_fun = 1;
1134
1135       for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1136            i < info->indextablesize && stab < info->stabs + stabsize;
1137            stab += STABSIZE)
1138         {
1139           switch (stab[TYPEOFF])
1140             {
1141             case 0:
1142               /* This is the first entry in a compilation unit.  */
1143               if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1144                 break;
1145               str += stroff;
1146               stroff = bfd_get_32 (abfd, stab + VALOFF);
1147               break;
1148
1149             case N_SO:
1150               /* The main file name.  */
1151
1152               /* The following code creates a new indextable entry with
1153                  a NULL function name if there were no N_FUNs in a file.
1154                  Note that a N_SO without a file name is an EOF and
1155                  there could be 2 N_SO following it with the new filename
1156                  and directory.  */
1157               if (saw_fun == 0)
1158                 {
1159                   info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1160                   info->indextable[i].stab = last_stab;
1161                   info->indextable[i].str = str;
1162                   info->indextable[i].directory_name = directory_name;
1163                   info->indextable[i].file_name = file_name;
1164                   info->indextable[i].function_name = NULL;
1165                   ++i;
1166                 }
1167               saw_fun = 0;
1168
1169               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1170               if (*file_name == '\0')
1171                 {
1172                   directory_name = NULL;
1173                   file_name = NULL;
1174                   saw_fun = 1;
1175                 }
1176               else
1177                 {
1178                   last_stab = stab;
1179                   if (stab + STABSIZE >= info->stabs + stabsize
1180                       || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
1181                     {
1182                       directory_name = NULL;
1183                     }
1184                   else
1185                     {
1186                       /* Two consecutive N_SOs are a directory and a
1187                          file name.  */
1188                       stab += STABSIZE;
1189                       directory_name = file_name;
1190                       file_name = ((char *) str
1191                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1192                     }
1193                 }
1194               break;
1195
1196             case N_SOL:
1197               /* The name of an include file.  */
1198               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1199               break;
1200
1201             case N_FUN:
1202               /* A function name.  */
1203               saw_fun = 1;
1204               name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1205
1206               if (*name == '\0')
1207                 name = NULL;
1208
1209               function_name = name;
1210
1211               if (name == NULL)
1212                 continue;
1213
1214               info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1215               info->indextable[i].stab = stab;
1216               info->indextable[i].str = str;
1217               info->indextable[i].directory_name = directory_name;
1218               info->indextable[i].file_name = file_name;
1219               info->indextable[i].function_name = function_name;
1220               ++i;
1221               break;
1222             }
1223         }
1224
1225       if (saw_fun == 0)
1226         {
1227           info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1228           info->indextable[i].stab = last_stab;
1229           info->indextable[i].str = str;
1230           info->indextable[i].directory_name = directory_name;
1231           info->indextable[i].file_name = file_name;
1232           info->indextable[i].function_name = NULL;
1233           ++i;
1234         }
1235
1236       info->indextable[i].val = (bfd_vma) -1;
1237       info->indextable[i].stab = info->stabs + stabsize;
1238       info->indextable[i].str = str;
1239       info->indextable[i].directory_name = NULL;
1240       info->indextable[i].file_name = NULL;
1241       info->indextable[i].function_name = NULL;
1242       ++i;
1243
1244       info->indextablesize = i;
1245       qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1246              cmpindexentry);
1247
1248       *pinfo = info;
1249     }
1250
1251   /* We are passed a section relative offset.  The offsets in the
1252      stabs information are absolute.  */
1253   offset += bfd_get_section_vma (abfd, section);
1254
1255 #ifdef ENABLE_CACHING
1256   if (info->cached_indexentry != NULL
1257       && offset >= info->cached_offset
1258       && offset < (info->cached_indexentry + 1)->val)
1259     {
1260       stab = info->cached_stab;
1261       indexentry = info->cached_indexentry;
1262       file_name = info->cached_file_name;
1263     }
1264   else
1265 #endif
1266     {
1267       long low, high;
1268       long mid = -1;
1269
1270       /* Cache non-existent or invalid.  Do binary search on
1271          indextable.  */
1272       indexentry = NULL;
1273
1274       low = 0;
1275       high = info->indextablesize - 1;
1276       while (low != high)
1277         {
1278           mid = (high + low) / 2;
1279           if (offset >= info->indextable[mid].val
1280               && offset < info->indextable[mid + 1].val)
1281             {
1282               indexentry = &info->indextable[mid];
1283               break;
1284             }
1285
1286           if (info->indextable[mid].val > offset)
1287             high = mid;
1288           else
1289             low = mid + 1;
1290         }
1291
1292       if (indexentry == NULL)
1293         return TRUE;
1294
1295       stab = indexentry->stab + STABSIZE;
1296       file_name = indexentry->file_name;
1297     }
1298
1299   directory_name = indexentry->directory_name;
1300   str = indexentry->str;
1301
1302   saw_line = FALSE;
1303   saw_func = FALSE;
1304   for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1305     {
1306       bfd_boolean done;
1307       bfd_vma val;
1308
1309       done = FALSE;
1310
1311       switch (stab[TYPEOFF])
1312         {
1313         case N_SOL:
1314           /* The name of an include file.  */
1315           val = bfd_get_32 (abfd, stab + VALOFF);
1316           if (val <= offset)
1317             {
1318               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1319               *pline = 0;
1320             }
1321           break;
1322
1323         case N_SLINE:
1324         case N_DSLINE:
1325         case N_BSLINE:
1326           /* A line number.  If the function was specified, then the value
1327              is relative to the start of the function.  Otherwise, the
1328              value is an absolute address.  */
1329           val = ((indexentry->function_name ? indexentry->val : 0)
1330                  + bfd_get_32 (abfd, stab + VALOFF));
1331           /* If this line starts before our desired offset, or if it's
1332              the first line we've been able to find, use it.  The
1333              !saw_line check works around a bug in GCC 2.95.3, which emits
1334              the first N_SLINE late.  */
1335           if (!saw_line || val <= offset)
1336             {
1337               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1338
1339 #ifdef ENABLE_CACHING
1340               info->cached_stab = stab;
1341               info->cached_offset = val;
1342               info->cached_file_name = file_name;
1343               info->cached_indexentry = indexentry;
1344 #endif
1345             }
1346           if (val > offset)
1347             done = TRUE;
1348           saw_line = TRUE;
1349           break;
1350
1351         case N_FUN:
1352         case N_SO:
1353           if (saw_func || saw_line)
1354             done = TRUE;
1355           saw_func = TRUE;
1356           break;
1357         }
1358
1359       if (done)
1360         break;
1361     }
1362
1363   *pfound = TRUE;
1364
1365   if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1366       || directory_name == NULL)
1367     *pfilename = file_name;
1368   else
1369     {
1370       size_t dirlen;
1371
1372       dirlen = strlen (directory_name);
1373       if (info->filename == NULL
1374           || strncmp (info->filename, directory_name, dirlen) != 0
1375           || strcmp (info->filename + dirlen, file_name) != 0)
1376         {
1377           size_t len;
1378
1379           if (info->filename != NULL)
1380             free (info->filename);
1381           len = strlen (file_name) + 1;
1382           info->filename = bfd_malloc (dirlen + len);
1383           if (info->filename == NULL)
1384             return FALSE;
1385           memcpy (info->filename, directory_name, dirlen);
1386           memcpy (info->filename + dirlen, file_name, len);
1387         }
1388
1389       *pfilename = info->filename;
1390     }
1391
1392   if (indexentry->function_name != NULL)
1393     {
1394       char *s;
1395
1396       /* This will typically be something like main:F(0,1), so we want
1397          to clobber the colon.  It's OK to change the name, since the
1398          string is in our own local storage anyhow.  */
1399       s = strchr (indexentry->function_name, ':');
1400       if (s != NULL)
1401         *s = '\0';
1402
1403       *pfnname = indexentry->function_name;
1404     }
1405
1406   return TRUE;
1407 }