bfd/syms.c

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