bfd/syms.c

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