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
   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      0x01
 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     0x02
 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_FORT_COMM>>,  <<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  0x08
 229 .
 230 .  {* The symbol denotes a function entry point.  Used in ELF,
 231 .     perhaps others someday.  *}
 232 .#define BSF_FUNCTION    0x10
 233 .
 234 .  {* Used by the linker.  *}
 235 .#define BSF_KEEP        0x20
 236 .#define BSF_KEEP_G      0x40
 237 .
 238 .  {* A weak global symbol, overridable without warnings by
 239 .     a regular global symbol of the same name.  *}
 240 .#define BSF_WEAK        0x80
 241 .
 242 .  {* This symbol was created to point to a section, e.g. ELF's
 243 .     STT_SECTION symbols.  *}
 244 .#define BSF_SECTION_SYM 0x100
 245 .
 246 .  {* The symbol used to be a common symbol, but now it is
 247 .     allocated.  *}
 248 .#define BSF_OLD_COMMON  0x200
 249 .
 250 .  {* The default value for common data.  *}
 251 .#define BFD_FORT_COMM_DEFAULT_VALUE 0
 252 .
 253 .  {* In some files the type of a symbol sometimes alters its
 254 .     location in an output file - ie in coff a <<ISFCN>> symbol
 255 .     which is also <<C_EXT>> symbol appears where it was
 256 .     declared and not at the end of a section.  This bit is set
 257 .     by the target BFD part to convey this information.  *}
 258 .#define BSF_NOT_AT_END    0x400
 259 .
 260 .  {* Signal that the symbol is the label of constructor section.  *}
 261 .#define BSF_CONSTRUCTOR   0x800
 262 .
 263 .  {* Signal that the symbol is a warning symbol.  The name is a
 264 .     warning.  The name of the next symbol is the one to warn about;
 265 .     if a reference is made to a symbol with the same name as the next
 266 .     symbol, a warning is issued by the linker.  *}
 267 .#define BSF_WARNING       0x1000
 268 .
 269 .  {* Signal that the symbol is indirect.  This symbol is an indirect
 270 .     pointer to the symbol with the same name as the next symbol.  *}
 271 .#define BSF_INDIRECT      0x2000
 272 .
 273 .  {* BSF_FILE marks symbols that contain a file name.  This is used
 274 .     for ELF STT_FILE symbols.  *}
 275 .#define BSF_FILE          0x4000
 276 .
 277 .  {* Symbol is from dynamic linking information.  *}
 278 .#define BSF_DYNAMIC       0x8000
 279 .
 280 .  {* The symbol denotes a data object.  Used in ELF, and perhaps
 281 .     others someday.  *}
 282 .#define BSF_OBJECT        0x10000
 283 .
 284 .  {* This symbol is a debugging symbol.  The value is the offset
 285 .     into the section of the data.  BSF_DEBUGGING should be set
 286 .     as well.  *}
 287 .#define BSF_DEBUGGING_RELOC 0x20000
 288 .
 289 .  {* This symbol is thread local.  Used in ELF.  *}
 290 .#define BSF_THREAD_LOCAL  0x40000
 291 .
 292 .  {* This symbol represents a complex relocation expression,
 293 .     with the expression tree serialized in the symbol name.  *}
 294 .#define BSF_RELC 0x80000
 295 .
 296 .  {* This symbol represents a signed complex relocation expression,
 297 .     with the expression tree serialized in the symbol name.  *}
 298 .#define BSF_SRELC 0x100000
 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           /* No stabs debugging information.  Set *pinfo so that we
 993              can return quickly in the info != NULL case above.  */
 994           *pinfo = info;
 995           return TRUE;
 996         }
 997
 998       stabsize = (info->stabsec->rawsize
 999                   ? info->stabsec->rawsize
1000                   : info->stabsec->size);
1001       strsize = (info->strsec->rawsize
1002                  ? info->strsec->rawsize
1003                  : info->strsec->size);
1004
1005       info->stabs = bfd_alloc (abfd, stabsize);
1006       info->strs = bfd_alloc (abfd, strsize);
1007       if (info->stabs == NULL || info->strs == NULL)
1008         return FALSE;
1009
1010       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1011                                       0, stabsize)
1012           || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1013                                          0, strsize))
1014         return FALSE;
1015
1016       /* If this is a relocatable object file, we have to relocate
1017          the entries in .stab.  This should always be simple 32 bit
1018          relocations against symbols defined in this object file, so
1019          this should be no big deal.  */
1020       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1021       if (reloc_size < 0)
1022         return FALSE;
1023       reloc_vector = bfd_malloc (reloc_size);
1024       if (reloc_vector == NULL && reloc_size != 0)
1025         return FALSE;
1026       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1027                                             symbols);
1028       if (reloc_count < 0)
1029         {
1030           if (reloc_vector != NULL)
1031             free (reloc_vector);
1032           return FALSE;
1033         }
1034       if (reloc_count > 0)
1035         {
1036           arelent **pr;
1037
1038           for (pr = reloc_vector; *pr != NULL; pr++)
1039             {
1040               arelent *r;
1041               unsigned long val;
1042               asymbol *sym;
1043
1044               r = *pr;
1045               /* Ignore R_*_NONE relocs.  */
1046               if (r->howto->dst_mask == 0)
1047                 continue;
1048
1049               if (r->howto->rightshift != 0
1050                   || r->howto->size != 2
1051                   || r->howto->bitsize != 32
1052                   || r->howto->pc_relative
1053                   || r->howto->bitpos != 0
1054                   || r->howto->dst_mask != 0xffffffff)
1055                 {
1056                   (*_bfd_error_handler)
1057                     (_("Unsupported .stab relocation"));
1058                   bfd_set_error (bfd_error_invalid_operation);
1059                   if (reloc_vector != NULL)
1060                     free (reloc_vector);
1061                   return FALSE;
1062                 }
1063
1064               val = bfd_get_32 (abfd, info->stabs + r->address);
1065               val &= r->howto->src_mask;
1066               sym = *r->sym_ptr_ptr;
1067               val += sym->value + sym->section->vma + r->addend;
1068               bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1069             }
1070         }
1071
1072       if (reloc_vector != NULL)
1073         free (reloc_vector);
1074
1075       /* First time through this function, build a table matching
1076          function VM addresses to stabs, then sort based on starting
1077          VM address.  Do this in two passes: once to count how many
1078          table entries we'll need, and a second to actually build the
1079          table.  */
1080
1081       info->indextablesize = 0;
1082       saw_fun = 1;
1083       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1084         {
1085           if (stab[TYPEOFF] == (bfd_byte) N_SO)
1086             {
1087               /* N_SO with null name indicates EOF */
1088               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1089                 continue;
1090
1091               /* if we did not see a function def, leave space for one.  */
1092               if (saw_fun == 0)
1093                 ++info->indextablesize;
1094
1095               saw_fun = 0;
1096
1097               /* two N_SO's in a row is a filename and directory. Skip */
1098               if (stab + STABSIZE < info->stabs + stabsize
1099                   && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1100                 {
1101                   stab += STABSIZE;
1102                 }
1103             }
1104           else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
1105             {
1106               saw_fun = 1;
1107               ++info->indextablesize;
1108             }
1109         }
1110
1111       if (saw_fun == 0)
1112         ++info->indextablesize;
1113
1114       if (info->indextablesize == 0)
1115         return TRUE;
1116       ++info->indextablesize;
1117
1118       amt = info->indextablesize;
1119       amt *= sizeof (struct indexentry);
1120       info->indextable = bfd_alloc (abfd, amt);
1121       if (info->indextable == NULL)
1122         return FALSE;
1123
1124       file_name = NULL;
1125       directory_name = NULL;
1126       saw_fun = 1;
1127
1128       for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1129            i < info->indextablesize && stab < info->stabs + stabsize;
1130            stab += STABSIZE)
1131         {
1132           switch (stab[TYPEOFF])
1133             {
1134             case 0:
1135               /* This is the first entry in a compilation unit.  */
1136               if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1137                 break;
1138               str += stroff;
1139               stroff = bfd_get_32 (abfd, stab + VALOFF);
1140               break;
1141
1142             case N_SO:
1143               /* The main file name.  */
1144
1145               /* The following code creates a new indextable entry with
1146                  a NULL function name if there were no N_FUNs in a file.
1147                  Note that a N_SO without a file name is an EOF and
1148                  there could be 2 N_SO following it with the new filename
1149                  and directory.  */
1150               if (saw_fun == 0)
1151                 {
1152                   info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1153                   info->indextable[i].stab = last_stab;
1154                   info->indextable[i].str = str;
1155                   info->indextable[i].directory_name = directory_name;
1156                   info->indextable[i].file_name = file_name;
1157                   info->indextable[i].function_name = NULL;
1158                   ++i;
1159                 }
1160               saw_fun = 0;
1161
1162               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1163               if (*file_name == '\0')
1164                 {
1165                   directory_name = NULL;
1166                   file_name = NULL;
1167                   saw_fun = 1;
1168                 }
1169               else
1170                 {
1171                   last_stab = stab;
1172                   if (stab + STABSIZE >= info->stabs + stabsize
1173                       || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
1174                     {
1175                       directory_name = NULL;
1176                     }
1177                   else
1178                     {
1179                       /* Two consecutive N_SOs are a directory and a
1180                          file name.  */
1181                       stab += STABSIZE;
1182                       directory_name = file_name;
1183                       file_name = ((char *) str
1184                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1185                     }
1186                 }
1187               break;
1188
1189             case N_SOL:
1190               /* The name of an include file.  */
1191               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1192               break;
1193
1194             case N_FUN:
1195               /* A function name.  */
1196               saw_fun = 1;
1197               name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1198
1199               if (*name == '\0')
1200                 name = NULL;
1201
1202               function_name = name;
1203
1204               if (name == NULL)
1205                 continue;
1206
1207               info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1208               info->indextable[i].stab = stab;
1209               info->indextable[i].str = str;
1210               info->indextable[i].directory_name = directory_name;
1211               info->indextable[i].file_name = file_name;
1212               info->indextable[i].function_name = function_name;
1213               ++i;
1214               break;
1215             }
1216         }
1217
1218       if (saw_fun == 0)
1219         {
1220           info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1221           info->indextable[i].stab = last_stab;
1222           info->indextable[i].str = str;
1223           info->indextable[i].directory_name = directory_name;
1224           info->indextable[i].file_name = file_name;
1225           info->indextable[i].function_name = NULL;
1226           ++i;
1227         }
1228
1229       info->indextable[i].val = (bfd_vma) -1;
1230       info->indextable[i].stab = info->stabs + stabsize;
1231       info->indextable[i].str = str;
1232       info->indextable[i].directory_name = NULL;
1233       info->indextable[i].file_name = NULL;
1234       info->indextable[i].function_name = NULL;
1235       ++i;
1236
1237       info->indextablesize = i;
1238       qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1239              cmpindexentry);
1240
1241       *pinfo = info;
1242     }
1243
1244   /* We are passed a section relative offset.  The offsets in the
1245      stabs information are absolute.  */
1246   offset += bfd_get_section_vma (abfd, section);
1247
1248 #ifdef ENABLE_CACHING
1249   if (info->cached_indexentry != NULL
1250       && offset >= info->cached_offset
1251       && offset < (info->cached_indexentry + 1)->val)
1252     {
1253       stab = info->cached_stab;
1254       indexentry = info->cached_indexentry;
1255       file_name = info->cached_file_name;
1256     }
1257   else
1258 #endif
1259     {
1260       long low, high;
1261       long mid = -1;
1262
1263       /* Cache non-existent or invalid.  Do binary search on
1264          indextable.  */
1265       indexentry = NULL;
1266
1267       low = 0;
1268       high = info->indextablesize - 1;
1269       while (low != high)
1270         {
1271           mid = (high + low) / 2;
1272           if (offset >= info->indextable[mid].val
1273               && offset < info->indextable[mid + 1].val)
1274             {
1275               indexentry = &info->indextable[mid];
1276               break;
1277             }
1278
1279           if (info->indextable[mid].val > offset)
1280             high = mid;
1281           else
1282             low = mid + 1;
1283         }
1284
1285       if (indexentry == NULL)
1286         return TRUE;
1287
1288       stab = indexentry->stab + STABSIZE;
1289       file_name = indexentry->file_name;
1290     }
1291
1292   directory_name = indexentry->directory_name;
1293   str = indexentry->str;
1294
1295   saw_line = FALSE;
1296   saw_func = FALSE;
1297   for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1298     {
1299       bfd_boolean done;
1300       bfd_vma val;
1301
1302       done = FALSE;
1303
1304       switch (stab[TYPEOFF])
1305         {
1306         case N_SOL:
1307           /* The name of an include file.  */
1308           val = bfd_get_32 (abfd, stab + VALOFF);
1309           if (val <= offset)
1310             {
1311               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1312               *pline = 0;
1313             }
1314           break;
1315
1316         case N_SLINE:
1317         case N_DSLINE:
1318         case N_BSLINE:
1319           /* A line number.  If the function was specified, then the value
1320              is relative to the start of the function.  Otherwise, the
1321              value is an absolute address.  */
1322           val = ((indexentry->function_name ? indexentry->val : 0)
1323                  + bfd_get_32 (abfd, stab + VALOFF));
1324           /* If this line starts before our desired offset, or if it's
1325              the first line we've been able to find, use it.  The
1326              !saw_line check works around a bug in GCC 2.95.3, which emits
1327              the first N_SLINE late.  */
1328           if (!saw_line || val <= offset)
1329             {
1330               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1331
1332 #ifdef ENABLE_CACHING
1333               info->cached_stab = stab;
1334               info->cached_offset = val;
1335               info->cached_file_name = file_name;
1336               info->cached_indexentry = indexentry;
1337 #endif
1338             }
1339           if (val > offset)
1340             done = TRUE;
1341           saw_line = TRUE;
1342           break;
1343
1344         case N_FUN:
1345         case N_SO:
1346           if (saw_func || saw_line)
1347             done = TRUE;
1348           saw_func = TRUE;
1349           break;
1350         }
1351
1352       if (done)
1353         break;
1354     }
1355
1356   *pfound = TRUE;
1357
1358   if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1359       || directory_name == NULL)
1360     *pfilename = file_name;
1361   else
1362     {
1363       size_t dirlen;
1364
1365       dirlen = strlen (directory_name);
1366       if (info->filename == NULL
1367           || strncmp (info->filename, directory_name, dirlen) != 0
1368           || strcmp (info->filename + dirlen, file_name) != 0)
1369         {
1370           size_t len;
1371
1372           if (info->filename != NULL)
1373             free (info->filename);
1374           len = strlen (file_name) + 1;
1375           info->filename = bfd_malloc (dirlen + len);
1376           if (info->filename == NULL)
1377             return FALSE;
1378           memcpy (info->filename, directory_name, dirlen);
1379           memcpy (info->filename + dirlen, file_name, len);
1380         }
1381
1382       *pfilename = info->filename;
1383     }
1384
1385   if (indexentry->function_name != NULL)
1386     {
1387       char *s;
1388
1389       /* This will typically be something like main:F(0,1), so we want
1390          to clobber the colon.  It's OK to change the name, since the
1391          string is in our own local storage anyhow.  */
1392       s = strchr (indexentry->function_name, ':');
1393       if (s != NULL)
1394         *s = '\0';
1395
1396       *pfnname = indexentry->function_name;
1397     }
1398
1399   return TRUE;
1400 }