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 any leading string which matches, so .text5 returns
 599    't' as well as .text */
 600
 601 static char
 602 coff_section_type (const char *s)
 603 {
 604   const struct section_to_type *t;
 605
 606   for (t = &stt[0]; t->section; t++)
 607     if (!strncmp (s, t->section, strlen (t->section)))
 608       return t->type;
 609
 610   return '?';
 611 }
 612
 613 /* Return the single-character symbol type corresponding to section
 614    SECTION, or '?' for an unknown section.  This uses section flags to
 615    identify sections.
 616
 617    FIXME These types are unhandled: c, i, e, p.  If we handled these also,
 618    we could perhaps obsolete coff_section_type.  */
 619
 620 static char
 621 decode_section_type (const struct bfd_section *section)
 622 {
 623   if (section->flags & SEC_CODE)
 624     return 't';
 625   if (section->flags & SEC_DATA)
 626     {
 627       if (section->flags & SEC_READONLY)
 628         return 'r';
 629       else if (section->flags & SEC_SMALL_DATA)
 630         return 'g';
 631       else
 632         return 'd';
 633     }
 634   if ((section->flags & SEC_HAS_CONTENTS) == 0)
 635     {
 636       if (section->flags & SEC_SMALL_DATA)
 637         return 's';
 638       else
 639         return 'b';
 640     }
 641   if (section->flags & SEC_DEBUGGING)
 642     return 'N';
 643   if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
 644     return 'n';
 645
 646   return '?';
 647 }
 648
 649 /*
 650 FUNCTION
 651         bfd_decode_symclass
 652
 653 DESCRIPTION
 654         Return a character corresponding to the symbol
 655         class of @var{symbol}, or '?' for an unknown class.
 656
 657 SYNOPSIS
 658         int bfd_decode_symclass (asymbol *symbol);
 659 */
 660 int
 661 bfd_decode_symclass (asymbol *symbol)
 662 {
 663   char c;
 664
 665   if (symbol->section && bfd_is_com_section (symbol->section))
 666     return 'C';
 667   if (bfd_is_und_section (symbol->section))
 668     {
 669       if (symbol->flags & BSF_WEAK)
 670         {
 671           /* If weak, determine if it's specifically an object
 672              or non-object weak.  */
 673           if (symbol->flags & BSF_OBJECT)
 674             return 'v';
 675           else
 676             return 'w';
 677         }
 678       else
 679         return 'U';
 680     }
 681   if (bfd_is_ind_section (symbol->section))
 682     return 'I';
 683   if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION)
 684     return 'i';
 685   if (symbol->flags & BSF_WEAK)
 686     {
 687       /* If weak, determine if it's specifically an object
 688          or non-object weak.  */
 689       if (symbol->flags & BSF_OBJECT)
 690         return 'V';
 691       else
 692         return 'W';
 693     }
 694   if (symbol->flags & BSF_GNU_UNIQUE)
 695     return 'u';
 696   if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
 697     return '?';
 698
 699   if (bfd_is_abs_section (symbol->section))
 700     c = 'a';
 701   else if (symbol->section)
 702     {
 703       c = coff_section_type (symbol->section->name);
 704       if (c == '?')
 705         c = decode_section_type (symbol->section);
 706     }
 707   else
 708     return '?';
 709   if (symbol->flags & BSF_GLOBAL)
 710     c = TOUPPER (c);
 711   return c;
 712
 713   /* We don't have to handle these cases just yet, but we will soon:
 714      N_SETV: 'v';
 715      N_SETA: 'l';
 716      N_SETT: 'x';
 717      N_SETD: 'z';
 718      N_SETB: 's';
 719      N_INDR: 'i';
 720      */
 721 }
 722
 723 /*
 724 FUNCTION
 725         bfd_is_undefined_symclass
 726
 727 DESCRIPTION
 728         Returns non-zero if the class symbol returned by
 729         bfd_decode_symclass represents an undefined symbol.
 730         Returns zero otherwise.
 731
 732 SYNOPSIS
 733         bfd_boolean bfd_is_undefined_symclass (int symclass);
 734 */
 735
 736 bfd_boolean
 737 bfd_is_undefined_symclass (int symclass)
 738 {
 739   return symclass == 'U' || symclass == 'w' || symclass == 'v';
 740 }
 741
 742 /*
 743 FUNCTION
 744         bfd_symbol_info
 745
 746 DESCRIPTION
 747         Fill in the basic info about symbol that nm needs.
 748         Additional info may be added by the back-ends after
 749         calling this function.
 750
 751 SYNOPSIS
 752         void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
 753 */
 754
 755 void
 756 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
 757 {
 758   ret->type = bfd_decode_symclass (symbol);
 759
 760   if (bfd_is_undefined_symclass (ret->type))
 761     ret->value = 0;
 762   else
 763     ret->value = symbol->value + symbol->section->vma;
 764
 765   ret->name = symbol->name;
 766 }
 767
 768 /*
 769 FUNCTION
 770         bfd_copy_private_symbol_data
 771
 772 SYNOPSIS
 773         bfd_boolean bfd_copy_private_symbol_data
 774           (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
 775
 776 DESCRIPTION
 777         Copy private symbol information from @var{isym} in the BFD
 778         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
 779         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
 780         returns are:
 781
 782         o <<bfd_error_no_memory>> -
 783         Not enough memory exists to create private data for @var{osec}.
 784
 785 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
 786 .       BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
 787 .                 (ibfd, isymbol, obfd, osymbol))
 788 .
 789 */
 790
 791 /* The generic version of the function which returns mini symbols.
 792    This is used when the backend does not provide a more efficient
 793    version.  It just uses BFD asymbol structures as mini symbols.  */
 794
 795 long
 796 _bfd_generic_read_minisymbols (bfd *abfd,
 797                                bfd_boolean dynamic,
 798                                void **minisymsp,
 799                                unsigned int *sizep)
 800 {
 801   long storage;
 802   asymbol **syms = NULL;
 803   long symcount;
 804
 805   if (dynamic)
 806     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 807   else
 808     storage = bfd_get_symtab_upper_bound (abfd);
 809   if (storage < 0)
 810     goto error_return;
 811   if (storage == 0)
 812     return 0;
 813
 814   syms = (asymbol **) bfd_malloc (storage);
 815   if (syms == NULL)
 816     goto error_return;
 817
 818   if (dynamic)
 819     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
 820   else
 821     symcount = bfd_canonicalize_symtab (abfd, syms);
 822   if (symcount < 0)
 823     goto error_return;
 824
 825   if (symcount == 0)
 826     /* We return 0 above when storage is 0.  Exit in the same state
 827        here, so as to not complicate callers with having to deal with
 828        freeing memory for zero symcount.  */
 829     free (syms);
 830   else
 831     {
 832       *minisymsp = syms;
 833       *sizep = sizeof (asymbol *);
 834     }
 835   return symcount;
 836
 837  error_return:
 838   bfd_set_error (bfd_error_no_symbols);
 839   if (syms != NULL)
 840     free (syms);
 841   return -1;
 842 }
 843
 844 /* The generic version of the function which converts a minisymbol to
 845    an asymbol.  We don't worry about the sym argument we are passed;
 846    we just return the asymbol the minisymbol points to.  */
 847
 848 asymbol *
 849 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 850                                    bfd_boolean dynamic ATTRIBUTE_UNUSED,
 851                                    const void *minisym,
 852                                    asymbol *sym ATTRIBUTE_UNUSED)
 853 {
 854   return *(asymbol **) minisym;
 855 }
 856
 857 /* Look through stabs debugging information in .stab and .stabstr
 858    sections to find the source file and line closest to a desired
 859    location.  This is used by COFF and ELF targets.  It sets *pfound
 860    to TRUE if it finds some information.  The *pinfo field is used to
 861    pass cached information in and out of this routine; this first time
 862    the routine is called for a BFD, *pinfo should be NULL.  The value
 863    placed in *pinfo should be saved with the BFD, and passed back each
 864    time this function is called.  */
 865
 866 /* We use a cache by default.  */
 867
 868 #define ENABLE_CACHING
 869
 870 /* We keep an array of indexentry structures to record where in the
 871    stabs section we should look to find line number information for a
 872    particular address.  */
 873
 874 struct indexentry
 875 {
 876   bfd_vma val;
 877   bfd_byte *stab;
 878   bfd_byte *str;
 879   char *directory_name;
 880   char *file_name;
 881   char *function_name;
 882 };
 883
 884 /* Compare two indexentry structures.  This is called via qsort.  */
 885
 886 static int
 887 cmpindexentry (const void *a, const void *b)
 888 {
 889   const struct indexentry *contestantA = (const struct indexentry *) a;
 890   const struct indexentry *contestantB = (const struct indexentry *) b;
 891
 892   if (contestantA->val < contestantB->val)
 893     return -1;
 894   else if (contestantA->val > contestantB->val)
 895     return 1;
 896   else
 897     return 0;
 898 }
 899
 900 /* A pointer to this structure is stored in *pinfo.  */
 901
 902 struct stab_find_info
 903 {
 904   /* The .stab section.  */
 905   asection *stabsec;
 906   /* The .stabstr section.  */
 907   asection *strsec;
 908   /* The contents of the .stab section.  */
 909   bfd_byte *stabs;
 910   /* The contents of the .stabstr section.  */
 911   bfd_byte *strs;
 912
 913   /* A table that indexes stabs by memory address.  */
 914   struct indexentry *indextable;
 915   /* The number of entries in indextable.  */
 916   int indextablesize;
 917
 918 #ifdef ENABLE_CACHING
 919   /* Cached values to restart quickly.  */
 920   struct indexentry *cached_indexentry;
 921   bfd_vma cached_offset;
 922   bfd_byte *cached_stab;
 923   char *cached_file_name;
 924 #endif
 925
 926   /* Saved ptr to malloc'ed filename.  */
 927   char *filename;
 928 };
 929
 930 bfd_boolean
 931 _bfd_stab_section_find_nearest_line (bfd *abfd,
 932                                      asymbol **symbols,
 933                                      asection *section,
 934                                      bfd_vma offset,
 935                                      bfd_boolean *pfound,
 936                                      const char **pfilename,
 937                                      const char **pfnname,
 938                                      unsigned int *pline,
 939                                      void **pinfo)
 940 {
 941   struct stab_find_info *info;
 942   bfd_size_type stabsize, strsize;
 943   bfd_byte *stab, *str;
 944   bfd_byte *nul_fun, *nul_str;
 945   bfd_size_type stroff;
 946   struct indexentry *indexentry;
 947   char *file_name;
 948   char *directory_name;
 949   bfd_boolean saw_line, saw_func;
 950
 951   *pfound = FALSE;
 952   *pfilename = bfd_get_filename (abfd);
 953   *pfnname = NULL;
 954   *pline = 0;
 955
 956   /* Stabs entries use a 12 byte format:
 957        4 byte string table index
 958        1 byte stab type
 959        1 byte stab other field
 960        2 byte stab desc field
 961        4 byte stab value
 962      FIXME: This will have to change for a 64 bit object format.
 963
 964      The stabs symbols are divided into compilation units.  For the
 965      first entry in each unit, the type of 0, the value is the length
 966      of the string table for this unit, and the desc field is the
 967      number of stabs symbols for this unit.  */
 968
 969 #define STRDXOFF (0)
 970 #define TYPEOFF (4)
 971 #define OTHEROFF (5)
 972 #define DESCOFF (6)
 973 #define VALOFF (8)
 974 #define STABSIZE (12)
 975
 976   info = (struct stab_find_info *) *pinfo;
 977   if (info != NULL)
 978     {
 979       if (info->stabsec == NULL || info->strsec == NULL)
 980         {
 981           /* No stabs debugging information.  */
 982           return TRUE;
 983         }
 984
 985       stabsize = (info->stabsec->rawsize
 986                   ? info->stabsec->rawsize
 987                   : info->stabsec->size);
 988       strsize = (info->strsec->rawsize
 989                  ? info->strsec->rawsize
 990                  : info->strsec->size);
 991     }
 992   else
 993     {
 994       long reloc_size, reloc_count;
 995       arelent **reloc_vector;
 996       int i;
 997       char *function_name;
 998       bfd_size_type amt = sizeof *info;
 999
1000       info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
1001       if (info == NULL)
1002         return FALSE;
1003
1004       /* FIXME: When using the linker --split-by-file or
1005          --split-by-reloc options, it is possible for the .stab and
1006          .stabstr sections to be split.  We should handle that.  */
1007
1008       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
1009       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
1010
1011       if (info->stabsec == NULL || info->strsec == NULL)
1012         {
1013           /* Try SOM section names.  */
1014           info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$");
1015           info->strsec  = bfd_get_section_by_name (abfd, "$GDB_STRINGS$");
1016
1017           if (info->stabsec == NULL || info->strsec == NULL)
1018             {
1019               /* No stabs debugging information.  Set *pinfo so that we
1020                  can return quickly in the info != NULL case above.  */
1021               *pinfo = info;
1022               return TRUE;
1023             }
1024         }
1025
1026       stabsize = (info->stabsec->rawsize
1027                   ? info->stabsec->rawsize
1028                   : info->stabsec->size);
1029       stabsize = (stabsize / STABSIZE) * STABSIZE;
1030       strsize = (info->strsec->rawsize
1031                  ? info->strsec->rawsize
1032                  : info->strsec->size);
1033
1034       info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
1035       info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
1036       if (info->stabs == NULL || info->strs == NULL)
1037         return FALSE;
1038
1039       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1040                                       0, stabsize)
1041           || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1042                                          0, strsize))
1043         return FALSE;
1044
1045       /* Stab strings ought to be nul terminated.  Ensure the last one
1046          is, to prevent running off the end of the buffer.  */
1047       info->strs[strsize - 1] = 0;
1048
1049       /* If this is a relocatable object file, we have to relocate
1050          the entries in .stab.  This should always be simple 32 bit
1051          relocations against symbols defined in this object file, so
1052          this should be no big deal.  */
1053       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1054       if (reloc_size < 0)
1055         return FALSE;
1056       reloc_vector = (arelent **) bfd_malloc (reloc_size);
1057       if (reloc_vector == NULL && reloc_size != 0)
1058         return FALSE;
1059       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1060                                             symbols);
1061       if (reloc_count < 0)
1062         {
1063           if (reloc_vector != NULL)
1064             free (reloc_vector);
1065           return FALSE;
1066         }
1067       if (reloc_count > 0)
1068         {
1069           arelent **pr;
1070
1071           for (pr = reloc_vector; *pr != NULL; pr++)
1072             {
1073               arelent *r;
1074               unsigned long val;
1075               asymbol *sym;
1076
1077               r = *pr;
1078               /* Ignore R_*_NONE relocs.  */
1079               if (r->howto->dst_mask == 0)
1080                 continue;
1081
1082               if (r->howto->rightshift != 0
1083                   || r->howto->size != 2
1084                   || r->howto->bitsize != 32
1085                   || r->howto->pc_relative
1086                   || r->howto->bitpos != 0
1087                   || r->howto->dst_mask != 0xffffffff
1088                   || r->address * bfd_octets_per_byte (abfd) + 4 > stabsize)
1089                 {
1090                   _bfd_error_handler
1091                     (_("unsupported .stab relocation"));
1092                   bfd_set_error (bfd_error_invalid_operation);
1093                   if (reloc_vector != NULL)
1094                     free (reloc_vector);
1095                   return FALSE;
1096                 }
1097
1098               val = bfd_get_32 (abfd, info->stabs
1099                                 + r->address * bfd_octets_per_byte (abfd));
1100               val &= r->howto->src_mask;
1101               sym = *r->sym_ptr_ptr;
1102               val += sym->value + sym->section->vma + r->addend;
1103               bfd_put_32 (abfd, (bfd_vma) val, info->stabs
1104                           + r->address * bfd_octets_per_byte (abfd));
1105             }
1106         }
1107
1108       if (reloc_vector != NULL)
1109         free (reloc_vector);
1110
1111       /* First time through this function, build a table matching
1112          function VM addresses to stabs, then sort based on starting
1113          VM address.  Do this in two passes: once to count how many
1114          table entries we'll need, and a second to actually build the
1115          table.  */
1116
1117       info->indextablesize = 0;
1118       nul_fun = NULL;
1119       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1120         {
1121           if (stab[TYPEOFF] == (bfd_byte) N_SO)
1122             {
1123               /* if we did not see a function def, leave space for one.  */
1124               if (nul_fun != NULL)
1125                 ++info->indextablesize;
1126
1127               /* N_SO with null name indicates EOF */
1128               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1129                 nul_fun = NULL;
1130               else
1131                 {
1132                   nul_fun = stab;
1133
1134                   /* two N_SO's in a row is a filename and directory. Skip */
1135                   if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
1136                       && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1137                     stab += STABSIZE;
1138                 }
1139             }
1140           else if (stab[TYPEOFF] == (bfd_byte) N_FUN
1141                    && bfd_get_32 (abfd, stab + STRDXOFF) != 0)
1142             {
1143               nul_fun = NULL;
1144               ++info->indextablesize;
1145             }
1146         }
1147
1148       if (nul_fun != NULL)
1149         ++info->indextablesize;
1150
1151       if (info->indextablesize == 0)
1152         return TRUE;
1153       ++info->indextablesize;
1154
1155       amt = info->indextablesize;
1156       amt *= sizeof (struct indexentry);
1157       info->indextable = (struct indexentry *) bfd_alloc (abfd, amt);
1158       if (info->indextable == NULL)
1159         return FALSE;
1160
1161       file_name = NULL;
1162       directory_name = NULL;
1163       nul_fun = NULL;
1164       stroff = 0;
1165
1166       for (i = 0, stab = info->stabs, nul_str = str = info->strs;
1167            i < info->indextablesize && stab < info->stabs + stabsize;
1168            stab += STABSIZE)
1169         {
1170           switch (stab[TYPEOFF])
1171             {
1172             case 0:
1173               /* This is the first entry in a compilation unit.  */
1174               if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1175                 break;
1176               str += stroff;
1177               stroff = bfd_get_32 (abfd, stab + VALOFF);
1178               break;
1179
1180             case N_SO:
1181               /* The main file name.  */
1182
1183               /* The following code creates a new indextable entry with
1184                  a NULL function name if there were no N_FUNs in a file.
1185                  Note that a N_SO without a file name is an EOF and
1186                  there could be 2 N_SO following it with the new filename
1187                  and directory.  */
1188               if (nul_fun != NULL)
1189                 {
1190                   info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF);
1191                   info->indextable[i].stab = nul_fun;
1192                   info->indextable[i].str = nul_str;
1193                   info->indextable[i].directory_name = directory_name;
1194                   info->indextable[i].file_name = file_name;
1195                   info->indextable[i].function_name = NULL;
1196                   ++i;
1197                 }
1198
1199               directory_name = NULL;
1200               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1201               if (file_name == (char *) str)
1202                 {
1203                   file_name = NULL;
1204                   nul_fun = NULL;
1205                 }
1206               else
1207                 {
1208                   nul_fun = stab;
1209                   nul_str = str;
1210                   if (file_name >= (char *) info->strs + strsize
1211                       || file_name < (char *) str)
1212                     file_name = NULL;
1213                   if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
1214                       && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1215                     {
1216                       /* Two consecutive N_SOs are a directory and a
1217                          file name.  */
1218                       stab += STABSIZE;
1219                       directory_name = file_name;
1220                       file_name = ((char *) str
1221                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1222                       if (file_name >= (char *) info->strs + strsize
1223                           || file_name < (char *) str)
1224                         file_name = NULL;
1225                     }
1226                 }
1227               break;
1228
1229             case N_SOL:
1230               /* The name of an include file.  */
1231               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1232               /* PR 17512: file: 0c680a1f.  */
1233               /* PR 17512: file: 5da8aec4.  */
1234               if (file_name >= (char *) info->strs + strsize
1235                   || file_name < (char *) str)
1236                 file_name = NULL;
1237               break;
1238
1239             case N_FUN:
1240               /* A function name.  */
1241               function_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1242               if (function_name == (char *) str)
1243                 continue;
1244               if (function_name >= (char *) info->strs + strsize
1245                   || function_name < (char *) str)
1246                 function_name = NULL;
1247
1248               nul_fun = NULL;
1249               info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1250               info->indextable[i].stab = stab;
1251               info->indextable[i].str = str;
1252               info->indextable[i].directory_name = directory_name;
1253               info->indextable[i].file_name = file_name;
1254               info->indextable[i].function_name = function_name;
1255               ++i;
1256               break;
1257             }
1258         }
1259
1260       if (nul_fun != NULL)
1261         {
1262           info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF);
1263           info->indextable[i].stab = nul_fun;
1264           info->indextable[i].str = nul_str;
1265           info->indextable[i].directory_name = directory_name;
1266           info->indextable[i].file_name = file_name;
1267           info->indextable[i].function_name = NULL;
1268           ++i;
1269         }
1270
1271       info->indextable[i].val = (bfd_vma) -1;
1272       info->indextable[i].stab = info->stabs + stabsize;
1273       info->indextable[i].str = str;
1274       info->indextable[i].directory_name = NULL;
1275       info->indextable[i].file_name = NULL;
1276       info->indextable[i].function_name = NULL;
1277       ++i;
1278
1279       info->indextablesize = i;
1280       qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1281              cmpindexentry);
1282
1283       *pinfo = info;
1284     }
1285
1286   /* We are passed a section relative offset.  The offsets in the
1287      stabs information are absolute.  */
1288   offset += bfd_get_section_vma (abfd, section);
1289
1290 #ifdef ENABLE_CACHING
1291   if (info->cached_indexentry != NULL
1292       && offset >= info->cached_offset
1293       && offset < (info->cached_indexentry + 1)->val)
1294     {
1295       stab = info->cached_stab;
1296       indexentry = info->cached_indexentry;
1297       file_name = info->cached_file_name;
1298     }
1299   else
1300 #endif
1301     {
1302       long low, high;
1303       long mid = -1;
1304
1305       /* Cache non-existent or invalid.  Do binary search on
1306          indextable.  */
1307       indexentry = NULL;
1308
1309       low = 0;
1310       high = info->indextablesize - 1;
1311       while (low != high)
1312         {
1313           mid = (high + low) / 2;
1314           if (offset >= info->indextable[mid].val
1315               && offset < info->indextable[mid + 1].val)
1316             {
1317               indexentry = &info->indextable[mid];
1318               break;
1319             }
1320
1321           if (info->indextable[mid].val > offset)
1322             high = mid;
1323           else
1324             low = mid + 1;
1325         }
1326
1327       if (indexentry == NULL)
1328         return TRUE;
1329
1330       stab = indexentry->stab + STABSIZE;
1331       file_name = indexentry->file_name;
1332     }
1333
1334   directory_name = indexentry->directory_name;
1335   str = indexentry->str;
1336
1337   saw_line = FALSE;
1338   saw_func = FALSE;
1339   for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1340     {
1341       bfd_boolean done;
1342       bfd_vma val;
1343
1344       done = FALSE;
1345
1346       switch (stab[TYPEOFF])
1347         {
1348         case N_SOL:
1349           /* The name of an include file.  */
1350           val = bfd_get_32 (abfd, stab + VALOFF);
1351           if (val <= offset)
1352             {
1353               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1354               if (file_name >= (char *) info->strs + strsize
1355                   || file_name < (char *) str)
1356                 file_name = NULL;
1357               *pline = 0;
1358             }
1359           break;
1360
1361         case N_SLINE:
1362         case N_DSLINE:
1363         case N_BSLINE:
1364           /* A line number.  If the function was specified, then the value
1365              is relative to the start of the function.  Otherwise, the
1366              value is an absolute address.  */
1367           val = ((indexentry->function_name ? indexentry->val : 0)
1368                  + bfd_get_32 (abfd, stab + VALOFF));
1369           /* If this line starts before our desired offset, or if it's
1370              the first line we've been able to find, use it.  The
1371              !saw_line check works around a bug in GCC 2.95.3, which emits
1372              the first N_SLINE late.  */
1373           if (!saw_line || val <= offset)
1374             {
1375               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1376
1377 #ifdef ENABLE_CACHING
1378               info->cached_stab = stab;
1379               info->cached_offset = val;
1380               info->cached_file_name = file_name;
1381               info->cached_indexentry = indexentry;
1382 #endif
1383             }
1384           if (val > offset)
1385             done = TRUE;
1386           saw_line = TRUE;
1387           break;
1388
1389         case N_FUN:
1390         case N_SO:
1391           if (saw_func || saw_line)
1392             done = TRUE;
1393           saw_func = TRUE;
1394           break;
1395         }
1396
1397       if (done)
1398         break;
1399     }
1400
1401   *pfound = TRUE;
1402
1403   if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1404       || directory_name == NULL)
1405     *pfilename = file_name;
1406   else
1407     {
1408       size_t dirlen;
1409
1410       dirlen = strlen (directory_name);
1411       if (info->filename == NULL
1412           || filename_ncmp (info->filename, directory_name, dirlen) != 0
1413           || filename_cmp (info->filename + dirlen, file_name) != 0)
1414         {
1415           size_t len;
1416
1417           /* Don't free info->filename here.  objdump and other
1418              apps keep a copy of a previously returned file name
1419              pointer.  */
1420           len = strlen (file_name) + 1;
1421           info->filename = (char *) bfd_alloc (abfd, dirlen + len);
1422           if (info->filename == NULL)
1423             return FALSE;
1424           memcpy (info->filename, directory_name, dirlen);
1425           memcpy (info->filename + dirlen, file_name, len);
1426         }
1427
1428       *pfilename = info->filename;
1429     }
1430
1431   if (indexentry->function_name != NULL)
1432     {
1433       char *s;
1434
1435       /* This will typically be something like main:F(0,1), so we want
1436          to clobber the colon.  It's OK to change the name, since the
1437          string is in our own local storage anyhow.  */
1438       s = strchr (indexentry->function_name, ':');
1439       if (s != NULL)
1440         *s = '\0';
1441
1442       *pfnname = indexentry->function_name;
1443     }
1444
1445   return TRUE;
1446 }
1447
1448 long
1449 _bfd_nosymbols_canonicalize_symtab (bfd *abfd ATTRIBUTE_UNUSED,
1450                                     asymbol **location ATTRIBUTE_UNUSED)
1451 {
1452   return 0;
1453 }
1454
1455 void
1456 _bfd_nosymbols_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
1457                              void *afile ATTRIBUTE_UNUSED,
1458                              asymbol *symbol ATTRIBUTE_UNUSED,
1459                              bfd_print_symbol_type how ATTRIBUTE_UNUSED)
1460 {
1461 }
1462
1463 void
1464 _bfd_nosymbols_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1465                                 asymbol *sym ATTRIBUTE_UNUSED,
1466                                 symbol_info *ret ATTRIBUTE_UNUSED)
1467 {
1468 }
1469
1470 const char *
1471 _bfd_nosymbols_get_symbol_version_string (bfd *abfd,
1472                                           asymbol *symbol ATTRIBUTE_UNUSED,
1473                                           bfd_boolean *hidden ATTRIBUTE_UNUSED)
1474 {
1475   return (const char *) _bfd_ptr_bfd_null_error (abfd);
1476 }
1477
1478 bfd_boolean
1479 _bfd_nosymbols_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
1480                                         const char *name ATTRIBUTE_UNUSED)
1481 {
1482   return FALSE;
1483 }
1484
1485 alent *
1486 _bfd_nosymbols_get_lineno (bfd *abfd, asymbol *sym ATTRIBUTE_UNUSED)
1487 {
1488   return (alent *) _bfd_ptr_bfd_null_error (abfd);
1489 }
1490
1491 bfd_boolean
1492 _bfd_nosymbols_find_nearest_line
1493     (bfd *abfd,
1494      asymbol **symbols ATTRIBUTE_UNUSED,
1495      asection *section ATTRIBUTE_UNUSED,
1496      bfd_vma offset ATTRIBUTE_UNUSED,
1497      const char **filename_ptr ATTRIBUTE_UNUSED,
1498      const char **functionname_ptr ATTRIBUTE_UNUSED,
1499      unsigned int *line_ptr ATTRIBUTE_UNUSED,
1500      unsigned int *discriminator_ptr ATTRIBUTE_UNUSED)
1501 {
1502   return _bfd_bool_bfd_false_error (abfd);
1503 }
1504
1505 bfd_boolean
1506 _bfd_nosymbols_find_line (bfd *abfd,
1507                           asymbol **symbols ATTRIBUTE_UNUSED,
1508                           asymbol *symbol ATTRIBUTE_UNUSED,
1509                           const char **filename_ptr ATTRIBUTE_UNUSED,
1510                           unsigned int *line_ptr ATTRIBUTE_UNUSED)
1511 {
1512   return _bfd_bool_bfd_false_error (abfd);
1513 }
1514
1515 bfd_boolean
1516 _bfd_nosymbols_find_inliner_info
1517     (bfd *abfd,
1518      const char **filename_ptr ATTRIBUTE_UNUSED,
1519      const char **functionname_ptr ATTRIBUTE_UNUSED,
1520      unsigned int *line_ptr ATTRIBUTE_UNUSED)
1521 {
1522   return _bfd_bool_bfd_false_error (abfd);
1523 }
1524
1525 asymbol *
1526 _bfd_nosymbols_bfd_make_debug_symbol (bfd *abfd,
1527                                       void *ptr ATTRIBUTE_UNUSED,
1528                                       unsigned long sz ATTRIBUTE_UNUSED)
1529 {
1530   return (asymbol *) _bfd_ptr_bfd_null_error (abfd);
1531 }
1532
1533 long
1534 _bfd_nosymbols_read_minisymbols (bfd *abfd,
1535                                  bfd_boolean dynamic ATTRIBUTE_UNUSED,
1536                                  void **minisymsp ATTRIBUTE_UNUSED,
1537                                  unsigned int *sizep ATTRIBUTE_UNUSED)
1538 {
1539   return _bfd_long_bfd_n1_error (abfd);
1540 }
1541
1542 asymbol *
1543 _bfd_nosymbols_minisymbol_to_symbol (bfd *abfd,
1544                                      bfd_boolean dynamic ATTRIBUTE_UNUSED,
1545                                      const void *minisym ATTRIBUTE_UNUSED,
1546                                      asymbol *sym ATTRIBUTE_UNUSED)
1547 {
1548   return (asymbol *) _bfd_ptr_bfd_null_error (abfd);
1549 }
1550
1551 long
1552 _bfd_nodynamic_get_synthetic_symtab (bfd *abfd,
1553                                      long symcount ATTRIBUTE_UNUSED,
1554                                      asymbol **syms ATTRIBUTE_UNUSED,
1555                                      long dynsymcount ATTRIBUTE_UNUSED,
1556                                      asymbol **dynsyms ATTRIBUTE_UNUSED,
1557                                      asymbol **ret ATTRIBUTE_UNUSED)
1558 {
1559   return _bfd_long_bfd_n1_error (abfd);
1560 }