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 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   if (syms != NULL)
 810     free (syms);
 811   return -1;
 812 }
 813
 814 /* The generic version of the function which converts a minisymbol to
 815    an asymbol.  We don't worry about the sym argument we are passed;
 816    we just return the asymbol the minisymbol points to.  */
 817
 818 /*ARGSUSED*/
 819 asymbol *
 820 _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
 821      bfd *abfd ATTRIBUTE_UNUSED;
 822      boolean dynamic ATTRIBUTE_UNUSED;
 823      const PTR minisym;
 824      asymbol *sym ATTRIBUTE_UNUSED;
 825 {
 826   return *(asymbol **) minisym;
 827 }
 828
 829 /* Look through stabs debugging information in .stab and .stabstr
 830    sections to find the source file and line closest to a desired
 831    location.  This is used by COFF and ELF targets.  It sets *pfound
 832    to true if it finds some information.  The *pinfo field is used to
 833    pass cached information in and out of this routine; this first time
 834    the routine is called for a BFD, *pinfo should be NULL.  The value
 835    placed in *pinfo should be saved with the BFD, and passed back each
 836    time this function is called.  */
 837
 838 /* We use a cache by default.  */
 839
 840 #define ENABLE_CACHING
 841
 842 /* We keep an array of indexentry structures to record where in the
 843    stabs section we should look to find line number information for a
 844    particular address.  */
 845
 846 struct indexentry
 847 {
 848   bfd_vma val;
 849   bfd_byte *stab;
 850   bfd_byte *str;
 851   char *directory_name;
 852   char *file_name;
 853   char *function_name;
 854 };
 855
 856 /* Compare two indexentry structures.  This is called via qsort.  */
 857
 858 static int
 859 cmpindexentry (a, b)
 860      const PTR a;
 861      const PTR b;
 862 {
 863   const struct indexentry *contestantA = (const struct indexentry *) a;
 864   const struct indexentry *contestantB = (const struct indexentry *) b;
 865
 866   if (contestantA->val < contestantB->val)
 867     return -1;
 868   else if (contestantA->val > contestantB->val)
 869     return 1;
 870   else
 871     return 0;
 872 }
 873
 874 /* A pointer to this structure is stored in *pinfo.  */
 875
 876 struct stab_find_info
 877 {
 878   /* The .stab section.  */
 879   asection *stabsec;
 880   /* The .stabstr section.  */
 881   asection *strsec;
 882   /* The contents of the .stab section.  */
 883   bfd_byte *stabs;
 884   /* The contents of the .stabstr section.  */
 885   bfd_byte *strs;
 886
 887   /* A table that indexes stabs by memory address.  */
 888   struct indexentry *indextable;
 889   /* The number of entries in indextable.  */
 890   int indextablesize;
 891
 892 #ifdef ENABLE_CACHING
 893   /* Cached values to restart quickly.  */
 894   struct indexentry *cached_indexentry;
 895   bfd_vma cached_offset;
 896   bfd_byte *cached_stab;
 897   char *cached_file_name;
 898 #endif
 899
 900   /* Saved ptr to malloc'ed filename.  */
 901   char *filename;
 902 };
 903
 904 boolean
 905 _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
 906                                      pfilename, pfnname, pline, pinfo)
 907      bfd *abfd;
 908      asymbol **symbols;
 909      asection *section;
 910      bfd_vma offset;
 911      boolean *pfound;
 912      const char **pfilename;
 913      const char **pfnname;
 914      unsigned int *pline;
 915      PTR *pinfo;
 916 {
 917   struct stab_find_info *info;
 918   bfd_size_type stabsize, strsize;
 919   bfd_byte *stab, *str;
 920   bfd_byte *last_stab = NULL;
 921   bfd_size_type stroff;
 922   struct indexentry *indexentry;
 923   char *file_name;
 924   char *directory_name;
 925   int saw_fun;
 926   boolean saw_line, saw_func;
 927
 928   *pfound = false;
 929   *pfilename = bfd_get_filename (abfd);
 930   *pfnname = NULL;
 931   *pline = 0;
 932
 933   /* Stabs entries use a 12 byte format:
 934        4 byte string table index
 935        1 byte stab type
 936        1 byte stab other field
 937        2 byte stab desc field
 938        4 byte stab value
 939      FIXME: This will have to change for a 64 bit object format.
 940
 941      The stabs symbols are divided into compilation units.  For the
 942      first entry in each unit, the type of 0, the value is the length
 943      of the string table for this unit, and the desc field is the
 944      number of stabs symbols for this unit.  */
 945
 946 #define STRDXOFF (0)
 947 #define TYPEOFF (4)
 948 #define OTHEROFF (5)
 949 #define DESCOFF (6)
 950 #define VALOFF (8)
 951 #define STABSIZE (12)
 952
 953   info = (struct stab_find_info *) *pinfo;
 954   if (info != NULL)
 955     {
 956       if (info->stabsec == NULL || info->strsec == NULL)
 957         {
 958           /* No stabs debugging information.  */
 959           return true;
 960         }
 961
 962       stabsize = info->stabsec->_raw_size;
 963       strsize = info->strsec->_raw_size;
 964     }
 965   else
 966     {
 967       long reloc_size, reloc_count;
 968       arelent **reloc_vector;
 969       int i;
 970       char *name;
 971       char *function_name;
 972       bfd_size_type amt = sizeof *info;
 973
 974       info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
 975       if (info == NULL)
 976         return false;
 977
 978       /* FIXME: When using the linker --split-by-file or
 979          --split-by-reloc options, it is possible for the .stab and
 980          .stabstr sections to be split.  We should handle that.  */
 981
 982       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
 983       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
 984
 985       if (info->stabsec == NULL || info->strsec == NULL)
 986         {
 987           /* No stabs debugging information.  Set *pinfo so that we
 988              can return quickly in the info != NULL case above.  */
 989           *pinfo = (PTR) info;
 990           return true;
 991         }
 992
 993       stabsize = info->stabsec->_raw_size;
 994       strsize = info->strsec->_raw_size;
 995
 996       info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
 997       info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
 998       if (info->stabs == NULL || info->strs == NULL)
 999         return false;
1000
1001       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1002                                       (bfd_vma) 0, stabsize)
1003           || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1004                                          (bfd_vma) 0, strsize))
1005         return false;
1006
1007       /* If this is a relocateable object file, we have to relocate
1008          the entries in .stab.  This should always be simple 32 bit
1009          relocations against symbols defined in this object file, so
1010          this should be no big deal.  */
1011       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1012       if (reloc_size < 0)
1013         return false;
1014       reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
1015       if (reloc_vector == NULL && reloc_size != 0)
1016         return false;
1017       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1018                                             symbols);
1019       if (reloc_count < 0)
1020         {
1021           if (reloc_vector != NULL)
1022             free (reloc_vector);
1023           return false;
1024         }
1025       if (reloc_count > 0)
1026         {
1027           arelent **pr;
1028
1029           for (pr = reloc_vector; *pr != NULL; pr++)
1030             {
1031               arelent *r;
1032               unsigned long val;
1033               asymbol *sym;
1034
1035               r = *pr;
1036               if (r->howto->rightshift != 0
1037                   || r->howto->size != 2
1038                   || r->howto->bitsize != 32
1039                   || r->howto->pc_relative
1040                   || r->howto->bitpos != 0
1041                   || r->howto->dst_mask != 0xffffffff)
1042                 {
1043                   (*_bfd_error_handler)
1044                     (_("Unsupported .stab relocation"));
1045                   bfd_set_error (bfd_error_invalid_operation);
1046                   if (reloc_vector != NULL)
1047                     free (reloc_vector);
1048                   return false;
1049                 }
1050
1051               val = bfd_get_32 (abfd, info->stabs + r->address);
1052               val &= r->howto->src_mask;
1053               sym = *r->sym_ptr_ptr;
1054               val += sym->value + sym->section->vma + r->addend;
1055               bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1056             }
1057         }
1058
1059       if (reloc_vector != NULL)
1060         free (reloc_vector);
1061
1062       /* First time through this function, build a table matching
1063          function VM addresses to stabs, then sort based on starting
1064          VM address.  Do this in two passes: once to count how many
1065          table entries we'll need, and a second to actually build the
1066          table.  */
1067
1068       info->indextablesize = 0;
1069       saw_fun = 1;
1070       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1071         {
1072           if (stab[TYPEOFF] == N_SO)
1073             {
1074               /* N_SO with null name indicates EOF */
1075               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1076                 continue;
1077
1078               /* if we did not see a function def, leave space for one.  */
1079               if (saw_fun == 0)
1080                 ++info->indextablesize;
1081
1082               saw_fun = 0;
1083
1084               /* two N_SO's in a row is a filename and directory. Skip */
1085               if (stab + STABSIZE < info->stabs + stabsize
1086                   && *(stab + STABSIZE + TYPEOFF) == N_SO)
1087                 {
1088                   stab += STABSIZE;
1089                 }
1090             }
1091           else if (stab[TYPEOFF] == N_FUN)
1092             {
1093               saw_fun = 1;
1094               ++info->indextablesize;
1095             }
1096         }
1097
1098       if (saw_fun == 0)
1099         ++info->indextablesize;
1100
1101       if (info->indextablesize == 0)
1102         return true;
1103       ++info->indextablesize;
1104
1105       amt = info->indextablesize;
1106       amt *= sizeof (struct indexentry);
1107       info->indextable = (struct indexentry *) bfd_alloc (abfd, amt);
1108       if (info->indextable == NULL)
1109         return false;
1110
1111       file_name = NULL;
1112       directory_name = NULL;
1113       saw_fun = 1;
1114
1115       for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1116            i < info->indextablesize && stab < info->stabs + stabsize;
1117            stab += STABSIZE)
1118         {
1119           switch (stab[TYPEOFF])
1120             {
1121             case 0:
1122               /* This is the first entry in a compilation unit.  */
1123               if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1124                 break;
1125               str += stroff;
1126               stroff = bfd_get_32 (abfd, stab + VALOFF);
1127               break;
1128
1129             case N_SO:
1130               /* The main file name.  */
1131
1132               /* The following code creates a new indextable entry with
1133                  a NULL function name if there were no N_FUNs in a file.
1134                  Note that a N_SO without a file name is an EOF and
1135                  there could be 2 N_SO following it with the new filename
1136                  and directory.  */
1137               if (saw_fun == 0)
1138                 {
1139                   info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1140                   info->indextable[i].stab = last_stab;
1141                   info->indextable[i].str = str;
1142                   info->indextable[i].directory_name = directory_name;
1143                   info->indextable[i].file_name = file_name;
1144                   info->indextable[i].function_name = NULL;
1145                   ++i;
1146                 }
1147               saw_fun = 0;
1148
1149               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1150               if (*file_name == '\0')
1151                 {
1152                   directory_name = NULL;
1153                   file_name = NULL;
1154                   saw_fun = 1;
1155                 }
1156               else
1157                 {
1158                   last_stab = stab;
1159                   if (stab + STABSIZE >= info->stabs + stabsize
1160                       || *(stab + STABSIZE + TYPEOFF) != N_SO)
1161                     {
1162                       directory_name = NULL;
1163                     }
1164                   else
1165                     {
1166                       /* Two consecutive N_SOs are a directory and a
1167                          file name.  */
1168                       stab += STABSIZE;
1169                       directory_name = file_name;
1170                       file_name = ((char *) str
1171                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1172                     }
1173                 }
1174               break;
1175
1176             case N_SOL:
1177               /* The name of an include file.  */
1178               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1179               break;
1180
1181             case N_FUN:
1182               /* A function name.  */
1183               saw_fun = 1;
1184               name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1185
1186               if (*name == '\0')
1187                 name = NULL;
1188
1189               function_name = name;
1190
1191               if (name == NULL)
1192                 continue;
1193
1194               info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1195               info->indextable[i].stab = stab;
1196               info->indextable[i].str = str;
1197               info->indextable[i].directory_name = directory_name;
1198               info->indextable[i].file_name = file_name;
1199               info->indextable[i].function_name = function_name;
1200               ++i;
1201               break;
1202             }
1203         }
1204
1205       if (saw_fun == 0)
1206         {
1207           info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1208           info->indextable[i].stab = last_stab;
1209           info->indextable[i].str = str;
1210           info->indextable[i].directory_name = directory_name;
1211           info->indextable[i].file_name = file_name;
1212           info->indextable[i].function_name = NULL;
1213           ++i;
1214         }
1215
1216       info->indextable[i].val = (bfd_vma) -1;
1217       info->indextable[i].stab = info->stabs + stabsize;
1218       info->indextable[i].str = str;
1219       info->indextable[i].directory_name = NULL;
1220       info->indextable[i].file_name = NULL;
1221       info->indextable[i].function_name = NULL;
1222       ++i;
1223
1224       info->indextablesize = i;
1225       qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1226              cmpindexentry);
1227
1228       *pinfo = (PTR) info;
1229     }
1230
1231   /* We are passed a section relative offset.  The offsets in the
1232      stabs information are absolute.  */
1233   offset += bfd_get_section_vma (abfd, section);
1234
1235 #ifdef ENABLE_CACHING
1236   if (info->cached_indexentry != NULL
1237       && offset >= info->cached_offset
1238       && offset < (info->cached_indexentry + 1)->val)
1239     {
1240       stab = info->cached_stab;
1241       indexentry = info->cached_indexentry;
1242       file_name = info->cached_file_name;
1243     }
1244   else
1245 #endif
1246     {
1247       /* Cache non-existant or invalid.  Do binary search on
1248          indextable.  */
1249
1250       long low, high;
1251       long mid = -1;
1252
1253       indexentry = NULL;
1254
1255       low = 0;
1256       high = info->indextablesize - 1;
1257       while (low != high)
1258         {
1259           mid = (high + low) / 2;
1260           if (offset >= info->indextable[mid].val
1261               && offset < info->indextable[mid + 1].val)
1262             {
1263               indexentry = &info->indextable[mid];
1264               break;
1265             }
1266
1267           if (info->indextable[mid].val > offset)
1268             high = mid;
1269           else
1270             low = mid + 1;
1271         }
1272
1273       if (indexentry == NULL)
1274         return true;
1275
1276       stab = indexentry->stab + STABSIZE;
1277       file_name = indexentry->file_name;
1278     }
1279
1280   directory_name = indexentry->directory_name;
1281   str = indexentry->str;
1282
1283   saw_line = false;
1284   saw_func = false;
1285   for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1286     {
1287       boolean done;
1288       bfd_vma val;
1289
1290       done = false;
1291
1292       switch (stab[TYPEOFF])
1293         {
1294         case N_SOL:
1295           /* The name of an include file.  */
1296           val = bfd_get_32 (abfd, stab + VALOFF);
1297           if (val <= offset)
1298             {
1299               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1300               *pline = 0;
1301             }
1302           break;
1303
1304         case N_SLINE:
1305         case N_DSLINE:
1306         case N_BSLINE:
1307           /* A line number.  The value is relative to the start of the
1308              current function.  */
1309           val = indexentry->val + bfd_get_32 (abfd, stab + VALOFF);
1310           /* If this line starts before our desired offset, or if it's
1311              the first line we've been able to find, use it.  The
1312              !saw_line check works around a bug in GCC 2.95.3, which emits
1313              the first N_SLINE late.  */
1314           if (!saw_line || val <= offset)
1315             {
1316               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1317
1318 #ifdef ENABLE_CACHING
1319               info->cached_stab = stab;
1320               info->cached_offset = val;
1321               info->cached_file_name = file_name;
1322               info->cached_indexentry = indexentry;
1323 #endif
1324             }
1325           if (val > offset)
1326             done = true;
1327           saw_line = true;
1328           break;
1329
1330         case N_FUN:
1331         case N_SO:
1332           if (saw_func || saw_line)
1333             done = true;
1334           saw_func = true;
1335           break;
1336         }
1337
1338       if (done)
1339         break;
1340     }
1341
1342   *pfound = true;
1343
1344   if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1345       || directory_name == NULL)
1346     *pfilename = file_name;
1347   else
1348     {
1349       size_t dirlen;
1350
1351       dirlen = strlen (directory_name);
1352       if (info->filename == NULL
1353           || strncmp (info->filename, directory_name, dirlen) != 0
1354           || strcmp (info->filename + dirlen, file_name) != 0)
1355         {
1356           size_t len;
1357
1358           if (info->filename != NULL)
1359             free (info->filename);
1360           len = strlen (file_name) + 1;
1361           info->filename = (char *) bfd_malloc ((bfd_size_type) dirlen + len);
1362           if (info->filename == NULL)
1363             return false;
1364           memcpy (info->filename, directory_name, dirlen);
1365           memcpy (info->filename + dirlen, file_name, len);
1366         }
1367
1368       *pfilename = info->filename;
1369     }
1370
1371   if (indexentry->function_name != NULL)
1372     {
1373       char *s;
1374
1375       /* This will typically be something like main:F(0,1), so we want
1376          to clobber the colon.  It's OK to change the name, since the
1377          string is in our own local storage anyhow.  */
1378
1379       s = strchr (indexentry->function_name, ':');
1380       if (s != NULL)
1381         *s = '\0';
1382
1383       *pfnname = indexentry->function_name;
1384     }
1385
1386   return true;
1387 }