bfd/syms.c

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