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