bfd/syms.c

   1 /* Generic symbol-table support for the BFD library.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004
   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 02110-1301, 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 = 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         All storage for the symbols themselves is in an objalloc
  92         connected to the BFD; it is freed when the BFD is closed.
  93
  94 INODE
  95 Writing Symbols, Mini Symbols, Reading Symbols, Symbols
  96 SUBSECTION
  97         Writing symbols
  98
  99         Writing of a symbol table is automatic when a BFD open for
 100         writing is closed. The application attaches a vector of
 101         pointers to pointers to symbols to the BFD being written, and
 102         fills in the symbol count. The close and cleanup code reads
 103         through the table provided and performs all the necessary
 104         operations. The BFD output code must always be provided with an
 105         ``owned'' symbol: one which has come from another BFD, or one
 106         which has been created using <<bfd_make_empty_symbol>>.  Here is an
 107         example showing the creation of a symbol table with only one element:
 108
 109 |       #include "bfd.h"
 110 |       int main (void)
 111 |       {
 112 |         bfd *abfd;
 113 |         asymbol *ptrs[2];
 114 |         asymbol *new;
 115 |
 116 |         abfd = bfd_openw ("foo","a.out-sunos-big");
 117 |         bfd_set_format (abfd, bfd_object);
 118 |         new = bfd_make_empty_symbol (abfd);
 119 |         new->name = "dummy_symbol";
 120 |         new->section = bfd_make_section_old_way (abfd, ".text");
 121 |         new->flags = BSF_GLOBAL;
 122 |         new->value = 0x12345;
 123 |
 124 |         ptrs[0] = new;
 125 |         ptrs[1] = 0;
 126 |
 127 |         bfd_set_symtab (abfd, ptrs, 1);
 128 |         bfd_close (abfd);
 129 |         return 0;
 130 |       }
 131 |
 132 |       ./makesym
 133 |       nm foo
 134 |       00012345 A dummy_symbol
 135
 136         Many formats cannot represent arbitrary symbol information; for
 137         instance, the <<a.out>> object format does not allow an
 138         arbitrary number of sections. A symbol pointing to a section
 139         which is not one  of <<.text>>, <<.data>> or <<.bss>> cannot
 140         be described.
 141
 142 INODE
 143 Mini Symbols, typedef asymbol, Writing Symbols, Symbols
 144 SUBSECTION
 145         Mini Symbols
 146
 147         Mini symbols provide read-only access to the symbol table.
 148         They use less memory space, but require more time to access.
 149         They can be useful for tools like nm or objdump, which may
 150         have to handle symbol tables of extremely large executables.
 151
 152         The <<bfd_read_minisymbols>> function will read the symbols
 153         into memory in an internal form.  It will return a <<void *>>
 154         pointer to a block of memory, a symbol count, and the size of
 155         each symbol.  The pointer is allocated using <<malloc>>, and
 156         should be freed by the caller when it is no longer needed.
 157
 158         The function <<bfd_minisymbol_to_symbol>> will take a pointer
 159         to a minisymbol, and a pointer to a structure returned by
 160         <<bfd_make_empty_symbol>>, and return a <<asymbol>> structure.
 161         The return value may or may not be the same as the value from
 162         <<bfd_make_empty_symbol>> which was passed in.
 163
 164 */
 165
 166 /*
 167 DOCDD
 168 INODE
 169 typedef asymbol, symbol handling functions, Mini Symbols, Symbols
 170
 171 */
 172 /*
 173 SUBSECTION
 174         typedef asymbol
 175
 176         An <<asymbol>> has the form:
 177
 178 */
 179
 180 /*
 181 CODE_FRAGMENT
 182
 183 .
 184 .typedef struct bfd_symbol
 185 .{
 186 .  {* A pointer to the BFD which owns the symbol. This information
 187 .     is necessary so that a back end can work out what additional
 188 .     information (invisible to the application writer) is carried
 189 .     with the symbol.
 190 .
 191 .     This field is *almost* redundant, since you can use section->owner
 192 .     instead, except that some symbols point to the global sections
 193 .     bfd_{abs,com,und}_section.  This could be fixed by making
 194 .     these globals be per-bfd (or per-target-flavor).  FIXME.  *}
 195 .  struct bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field.  *}
 196 .
 197 .  {* The text of the symbol. The name is left alone, and not copied; the
 198 .     application may not alter it.  *}
 199 .  const char *name;
 200 .
 201 .  {* The value of the symbol.  This really should be a union of a
 202 .     numeric value with a pointer, since some flags indicate that
 203 .     a pointer to another symbol is stored here.  *}
 204 .  symvalue value;
 205 .
 206 .  {* Attributes of a symbol.  *}
 207 .#define BSF_NO_FLAGS    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 arbitrary
 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 bfd_section *section;
 297 .
 298 .  {* Back end special data.  *}
 299 .  union
 300 .    {
 301 .      void *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 /*
 318 DOCDD
 319 INODE
 320 symbol handling functions,  , typedef asymbol, Symbols
 321 SUBSECTION
 322         Symbol handling functions
 323 */
 324
 325 /*
 326 FUNCTION
 327         bfd_get_symtab_upper_bound
 328
 329 DESCRIPTION
 330         Return the number of bytes required to store a vector of pointers
 331         to <<asymbols>> for all the symbols in the BFD @var{abfd},
 332         including a terminal NULL pointer. If there are no symbols in
 333         the BFD, then return 0.  If an error occurs, return -1.
 334
 335 .#define bfd_get_symtab_upper_bound(abfd) \
 336 .     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
 337 .
 338 */
 339
 340 /*
 341 FUNCTION
 342         bfd_is_local_label
 343
 344 SYNOPSIS
 345         bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
 346
 347 DESCRIPTION
 348         Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is
 349         a compiler generated local label, else return FALSE.
 350 */
 351
 352 bfd_boolean
 353 bfd_is_local_label (bfd *abfd, asymbol *sym)
 354 {
 355   /* The BSF_SECTION_SYM check is needed for IA-64, where every label that
 356      starts with '.' is local.  This would accidentally catch section names
 357      if we didn't reject them here.  */
 358   if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0)
 359     return FALSE;
 360   if (sym->name == NULL)
 361     return FALSE;
 362   return bfd_is_local_label_name (abfd, sym->name);
 363 }
 364
 365 /*
 366 FUNCTION
 367         bfd_is_local_label_name
 368
 369 SYNOPSIS
 370         bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
 371
 372 DESCRIPTION
 373         Return TRUE if a symbol with the name @var{name} in the BFD
 374         @var{abfd} is a compiler generated local label, else return
 375         FALSE.  This just checks whether the name has the form of a
 376         local label.
 377
 378 .#define bfd_is_local_label_name(abfd, name) \
 379 .  BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
 380 .
 381 */
 382
 383 /*
 384 FUNCTION
 385         bfd_is_target_special_symbol
 386
 387 SYNOPSIS
 388         bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
 389
 390 DESCRIPTION
 391         Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something
 392         special to the particular target represented by the BFD.  Such symbols
 393         should normally not be mentioned to the user.
 394
 395 .#define bfd_is_target_special_symbol(abfd, sym) \
 396 .  BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
 397 .
 398 */
 399
 400 /*
 401 FUNCTION
 402         bfd_canonicalize_symtab
 403
 404 DESCRIPTION
 405         Read the symbols from the BFD @var{abfd}, and fills in
 406         the vector @var{location} with pointers to the symbols and
 407         a trailing NULL.
 408         Return the actual number of symbol pointers, not
 409         including the NULL.
 410
 411 .#define bfd_canonicalize_symtab(abfd, location) \
 412 .  BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
 413 .
 414 */
 415
 416 /*
 417 FUNCTION
 418         bfd_set_symtab
 419
 420 SYNOPSIS
 421         bfd_boolean bfd_set_symtab
 422           (bfd *abfd, asymbol **location, unsigned int count);
 423
 424 DESCRIPTION
 425         Arrange that when the output BFD @var{abfd} is closed,
 426         the table @var{location} of @var{count} pointers to symbols
 427         will be written.
 428 */
 429
 430 bfd_boolean
 431 bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount)
 432 {
 433   if (abfd->format != bfd_object || bfd_read_p (abfd))
 434     {
 435       bfd_set_error (bfd_error_invalid_operation);
 436       return FALSE;
 437     }
 438
 439   bfd_get_outsymbols (abfd) = location;
 440   bfd_get_symcount (abfd) = symcount;
 441   return TRUE;
 442 }
 443
 444 /*
 445 FUNCTION
 446         bfd_print_symbol_vandf
 447
 448 SYNOPSIS
 449         void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
 450
 451 DESCRIPTION
 452         Print the value and flags of the @var{symbol} supplied to the
 453         stream @var{file}.
 454 */
 455 void
 456 bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol)
 457 {
 458   FILE *file = arg;
 459
 460   flagword type = symbol->flags;
 461
 462   if (symbol->section != NULL)
 463     bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma);
 464   else
 465     bfd_fprintf_vma (abfd, file, symbol->value);
 466
 467   /* This presumes that a symbol can not be both BSF_DEBUGGING and
 468      BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
 469      BSF_OBJECT.  */
 470   fprintf (file, " %c%c%c%c%c%c%c",
 471            ((type & BSF_LOCAL)
 472             ? (type & BSF_GLOBAL) ? '!' : 'l'
 473             : (type & BSF_GLOBAL) ? 'g' : ' '),
 474            (type & BSF_WEAK) ? 'w' : ' ',
 475            (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
 476            (type & BSF_WARNING) ? 'W' : ' ',
 477            (type & BSF_INDIRECT) ? 'I' : ' ',
 478            (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
 479            ((type & BSF_FUNCTION)
 480             ? 'F'
 481             : ((type & BSF_FILE)
 482                ? 'f'
 483                : ((type & BSF_OBJECT) ? 'O' : ' '))));
 484 }
 485
 486 /*
 487 FUNCTION
 488         bfd_make_empty_symbol
 489
 490 DESCRIPTION
 491         Create a new <<asymbol>> structure for the BFD @var{abfd}
 492         and return a pointer to it.
 493
 494         This routine is necessary because each back end has private
 495         information surrounding the <<asymbol>>. Building your own
 496         <<asymbol>> and pointing to it will not create the private
 497         information, and will cause problems later on.
 498
 499 .#define bfd_make_empty_symbol(abfd) \
 500 .  BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
 501 .
 502 */
 503
 504 /*
 505 FUNCTION
 506         _bfd_generic_make_empty_symbol
 507
 508 SYNOPSIS
 509         asymbol *_bfd_generic_make_empty_symbol (bfd *);
 510
 511 DESCRIPTION
 512         Create a new <<asymbol>> structure for the BFD @var{abfd}
 513         and return a pointer to it.  Used by core file routines,
 514         binary back-end and anywhere else where no private info
 515         is needed.
 516 */
 517
 518 asymbol *
 519 _bfd_generic_make_empty_symbol (bfd *abfd)
 520 {
 521   bfd_size_type amt = sizeof (asymbol);
 522   asymbol *new = bfd_zalloc (abfd, amt);
 523   if (new)
 524     new->the_bfd = abfd;
 525   return new;
 526 }
 527
 528 /*
 529 FUNCTION
 530         bfd_make_debug_symbol
 531
 532 DESCRIPTION
 533         Create a new <<asymbol>> structure for the BFD @var{abfd},
 534         to be used as a debugging symbol.  Further details of its use have
 535         yet to be worked out.
 536
 537 .#define bfd_make_debug_symbol(abfd,ptr,size) \
 538 .  BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
 539 .
 540 */
 541
 542 struct section_to_type
 543 {
 544   const char *section;
 545   char type;
 546 };
 547
 548 /* Map section names to POSIX/BSD single-character symbol types.
 549    This table is probably incomplete.  It is sorted for convenience of
 550    adding entries.  Since it is so short, a linear search is used.  */
 551 static const struct section_to_type stt[] =
 552 {
 553   {".bss", 'b'},
 554   {"code", 't'},                /* MRI .text */
 555   {".data", 'd'},
 556   {"*DEBUG*", 'N'},
 557   {".debug", 'N'},              /* MSVC's .debug (non-standard debug syms) */
 558   {".drectve", 'i'},            /* MSVC's .drective section */
 559   {".edata", 'e'},              /* MSVC's .edata (export) section */
 560   {".fini", 't'},               /* ELF fini section */
 561   {".idata", 'i'},              /* MSVC's .idata (import) section */
 562   {".init", 't'},               /* ELF init section */
 563   {".pdata", 'p'},              /* MSVC's .pdata (stack unwind) section */
 564   {".rdata", 'r'},              /* Read only data.  */
 565   {".rodata", 'r'},             /* Read only data.  */
 566   {".sbss", 's'},               /* Small BSS (uninitialized data).  */
 567   {".scommon", 'c'},            /* Small common.  */
 568   {".sdata", 'g'},              /* Small initialized data.  */
 569   {".text", 't'},
 570   {"vars", 'd'},                /* MRI .data */
 571   {"zerovars", 'b'},            /* MRI .bss */
 572   {0, 0}
 573 };
 574
 575 /* Return the single-character symbol type corresponding to
 576    section S, or '?' for an unknown COFF section.
 577
 578    Check for any leading string which matches, so .text5 returns
 579    't' as well as .text */
 580
 581 static char
 582 coff_section_type (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 (const struct bfd_section *section)
 602 {
 603   if (section->flags & SEC_CODE)
 604     return 't';
 605   if (section->flags & SEC_DATA)
 606     {
 607       if (section->flags & SEC_READONLY)
 608         return 'r';
 609       else if (section->flags & SEC_SMALL_DATA)
 610         return 'g';
 611       else
 612         return 'd';
 613     }
 614   if ((section->flags & SEC_HAS_CONTENTS) == 0)
 615     {
 616       if (section->flags & SEC_SMALL_DATA)
 617         return 's';
 618       else
 619         return 'b';
 620     }
 621   if (section->flags & SEC_DEBUGGING)
 622     return 'N';
 623   if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
 624     return 'n';
 625
 626   return '?';
 627 }
 628
 629 /*
 630 FUNCTION
 631         bfd_decode_symclass
 632
 633 DESCRIPTION
 634         Return a character corresponding to the symbol
 635         class of @var{symbol}, or '?' for an unknown class.
 636
 637 SYNOPSIS
 638         int bfd_decode_symclass (asymbol *symbol);
 639 */
 640 int
 641 bfd_decode_symclass (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         bfd_boolean bfd_is_undefined_symclass (int symclass);
 710 */
 711
 712 bfd_boolean
 713 bfd_is_undefined_symclass (int symclass)
 714 {
 715   return symclass == 'U' || symclass == 'w' || symclass == 'v';
 716 }
 717
 718 /*
 719 FUNCTION
 720         bfd_symbol_info
 721
 722 DESCRIPTION
 723         Fill in the basic info about symbol that nm needs.
 724         Additional info may be added by the back-ends after
 725         calling this function.
 726
 727 SYNOPSIS
 728         void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
 729 */
 730
 731 void
 732 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
 733 {
 734   ret->type = bfd_decode_symclass (symbol);
 735
 736   if (bfd_is_undefined_symclass (ret->type))
 737     ret->value = 0;
 738   else
 739     ret->value = symbol->value + symbol->section->vma;
 740
 741   ret->name = symbol->name;
 742 }
 743
 744 /*
 745 FUNCTION
 746         bfd_copy_private_symbol_data
 747
 748 SYNOPSIS
 749         bfd_boolean bfd_copy_private_symbol_data
 750           (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
 751
 752 DESCRIPTION
 753         Copy private symbol information from @var{isym} in the BFD
 754         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
 755         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
 756         returns are:
 757
 758         o <<bfd_error_no_memory>> -
 759         Not enough memory exists to create private data for @var{osec}.
 760
 761 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
 762 .  BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
 763 .            (ibfd, isymbol, obfd, osymbol))
 764 .
 765 */
 766
 767 /* The generic version of the function which returns mini symbols.
 768    This is used when the backend does not provide a more efficient
 769    version.  It just uses BFD asymbol structures as mini symbols.  */
 770
 771 long
 772 _bfd_generic_read_minisymbols (bfd *abfd,
 773                                bfd_boolean dynamic,
 774                                void **minisymsp,
 775                                unsigned int *sizep)
 776 {
 777   long storage;
 778   asymbol **syms = NULL;
 779   long symcount;
 780
 781   if (dynamic)
 782     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 783   else
 784     storage = bfd_get_symtab_upper_bound (abfd);
 785   if (storage < 0)
 786     goto error_return;
 787   if (storage == 0)
 788     return 0;
 789
 790   syms = bfd_malloc (storage);
 791   if (syms == NULL)
 792     goto error_return;
 793
 794   if (dynamic)
 795     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
 796   else
 797     symcount = bfd_canonicalize_symtab (abfd, syms);
 798   if (symcount < 0)
 799     goto error_return;
 800
 801   *minisymsp = syms;
 802   *sizep = sizeof (asymbol *);
 803   return symcount;
 804
 805  error_return:
 806   bfd_set_error (bfd_error_no_symbols);
 807   if (syms != NULL)
 808     free (syms);
 809   return -1;
 810 }
 811
 812 /* The generic version of the function which converts a minisymbol to
 813    an asymbol.  We don't worry about the sym argument we are passed;
 814    we just return the asymbol the minisymbol points to.  */
 815
 816 asymbol *
 817 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 818                                    bfd_boolean dynamic ATTRIBUTE_UNUSED,
 819                                    const void *minisym,
 820                                    asymbol *sym ATTRIBUTE_UNUSED)
 821 {
 822   return *(asymbol **) minisym;
 823 }
 824
 825 /* Look through stabs debugging information in .stab and .stabstr
 826    sections to find the source file and line closest to a desired
 827    location.  This is used by COFF and ELF targets.  It sets *pfound
 828    to TRUE if it finds some information.  The *pinfo field is used to
 829    pass cached information in and out of this routine; this first time
 830    the routine is called for a BFD, *pinfo should be NULL.  The value
 831    placed in *pinfo should be saved with the BFD, and passed back each
 832    time this function is called.  */
 833
 834 /* We use a cache by default.  */
 835
 836 #define ENABLE_CACHING
 837
 838 /* We keep an array of indexentry structures to record where in the
 839    stabs section we should look to find line number information for a
 840    particular address.  */
 841
 842 struct indexentry
 843 {
 844   bfd_vma val;
 845   bfd_byte *stab;
 846   bfd_byte *str;
 847   char *directory_name;
 848   char *file_name;
 849   char *function_name;
 850 };
 851
 852 /* Compare two indexentry structures.  This is called via qsort.  */
 853
 854 static int
 855 cmpindexentry (const void *a, const void *b)
 856 {
 857   const struct indexentry *contestantA = a;
 858   const struct indexentry *contestantB = b;
 859
 860   if (contestantA->val < contestantB->val)
 861     return -1;
 862   else if (contestantA->val > contestantB->val)
 863     return 1;
 864   else
 865     return 0;
 866 }
 867
 868 /* A pointer to this structure is stored in *pinfo.  */
 869
 870 struct stab_find_info
 871 {
 872   /* The .stab section.  */
 873   asection *stabsec;
 874   /* The .stabstr section.  */
 875   asection *strsec;
 876   /* The contents of the .stab section.  */
 877   bfd_byte *stabs;
 878   /* The contents of the .stabstr section.  */
 879   bfd_byte *strs;
 880
 881   /* A table that indexes stabs by memory address.  */
 882   struct indexentry *indextable;
 883   /* The number of entries in indextable.  */
 884   int indextablesize;
 885
 886 #ifdef ENABLE_CACHING
 887   /* Cached values to restart quickly.  */
 888   struct indexentry *cached_indexentry;
 889   bfd_vma cached_offset;
 890   bfd_byte *cached_stab;
 891   char *cached_file_name;
 892 #endif
 893
 894   /* Saved ptr to malloc'ed filename.  */
 895   char *filename;
 896 };
 897
 898 bfd_boolean
 899 _bfd_stab_section_find_nearest_line (bfd *abfd,
 900                                      asymbol **symbols,
 901                                      asection *section,
 902                                      bfd_vma offset,
 903                                      bfd_boolean *pfound,
 904                                      const char **pfilename,
 905                                      const char **pfnname,
 906                                      unsigned int *pline,
 907                                      void **pinfo)
 908 {
 909   struct stab_find_info *info;
 910   bfd_size_type stabsize, strsize;
 911   bfd_byte *stab, *str;
 912   bfd_byte *last_stab = NULL;
 913   bfd_size_type stroff;
 914   struct indexentry *indexentry;
 915   char *file_name;
 916   char *directory_name;
 917   int saw_fun;
 918   bfd_boolean saw_line, saw_func;
 919
 920   *pfound = FALSE;
 921   *pfilename = bfd_get_filename (abfd);
 922   *pfnname = NULL;
 923   *pline = 0;
 924
 925   /* Stabs entries use a 12 byte format:
 926        4 byte string table index
 927        1 byte stab type
 928        1 byte stab other field
 929        2 byte stab desc field
 930        4 byte stab value
 931      FIXME: This will have to change for a 64 bit object format.
 932
 933      The stabs symbols are divided into compilation units.  For the
 934      first entry in each unit, the type of 0, the value is the length
 935      of the string table for this unit, and the desc field is the
 936      number of stabs symbols for this unit.  */
 937
 938 #define STRDXOFF (0)
 939 #define TYPEOFF (4)
 940 #define OTHEROFF (5)
 941 #define DESCOFF (6)
 942 #define VALOFF (8)
 943 #define STABSIZE (12)
 944
 945   info = *pinfo;
 946   if (info != NULL)
 947     {
 948       if (info->stabsec == NULL || info->strsec == NULL)
 949         {
 950           /* No stabs debugging information.  */
 951           return TRUE;
 952         }
 953
 954       stabsize = (info->stabsec->rawsize
 955                   ? info->stabsec->rawsize
 956                   : info->stabsec->size);
 957       strsize = (info->strsec->rawsize
 958                  ? info->strsec->rawsize
 959                  : info->strsec->size);
 960     }
 961   else
 962     {
 963       long reloc_size, reloc_count;
 964       arelent **reloc_vector;
 965       int i;
 966       char *name;
 967       char *function_name;
 968       bfd_size_type amt = sizeof *info;
 969
 970       info = bfd_zalloc (abfd, amt);
 971       if (info == NULL)
 972         return FALSE;
 973
 974       /* FIXME: When using the linker --split-by-file or
 975          --split-by-reloc options, it is possible for the .stab and
 976          .stabstr sections to be split.  We should handle that.  */
 977
 978       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
 979       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
 980
 981       if (info->stabsec == NULL || info->strsec == NULL)
 982         {
 983           /* No stabs debugging information.  Set *pinfo so that we
 984              can return quickly in the info != NULL case above.  */
 985           *pinfo = info;
 986           return TRUE;
 987         }
 988
 989       stabsize = (info->stabsec->rawsize
 990                   ? info->stabsec->rawsize
 991                   : info->stabsec->size);
 992       strsize = (info->strsec->rawsize
 993                  ? info->strsec->rawsize
 994                  : info->strsec->size);
 995
 996       info->stabs = bfd_alloc (abfd, stabsize);
 997       info->strs = 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                                       0, stabsize)
1003           || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1004                                          0, strsize))
1005         return FALSE;
1006
1007       /* If this is a relocatable 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 = bfd_malloc (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               /* Ignore R_*_NONE relocs.  */
1037               if (r->howto->dst_mask == 0)
1038                 continue;
1039
1040               if (r->howto->rightshift != 0
1041                   || r->howto->size != 2
1042                   || r->howto->bitsize != 32
1043                   || r->howto->pc_relative
1044                   || r->howto->bitpos != 0
1045                   || r->howto->dst_mask != 0xffffffff)
1046                 {
1047                   (*_bfd_error_handler)
1048                     (_("Unsupported .stab relocation"));
1049                   bfd_set_error (bfd_error_invalid_operation);
1050                   if (reloc_vector != NULL)
1051                     free (reloc_vector);
1052                   return FALSE;
1053                 }
1054
1055               val = bfd_get_32 (abfd, info->stabs + r->address);
1056               val &= r->howto->src_mask;
1057               sym = *r->sym_ptr_ptr;
1058               val += sym->value + sym->section->vma + r->addend;
1059               bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1060             }
1061         }
1062
1063       if (reloc_vector != NULL)
1064         free (reloc_vector);
1065
1066       /* First time through this function, build a table matching
1067          function VM addresses to stabs, then sort based on starting
1068          VM address.  Do this in two passes: once to count how many
1069          table entries we'll need, and a second to actually build the
1070          table.  */
1071
1072       info->indextablesize = 0;
1073       saw_fun = 1;
1074       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1075         {
1076           if (stab[TYPEOFF] == (bfd_byte) N_SO)
1077             {
1078               /* N_SO with null name indicates EOF */
1079               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1080                 continue;
1081
1082               /* if we did not see a function def, leave space for one.  */
1083               if (saw_fun == 0)
1084                 ++info->indextablesize;
1085
1086               saw_fun = 0;
1087
1088               /* two N_SO's in a row is a filename and directory. Skip */
1089               if (stab + STABSIZE < info->stabs + stabsize
1090                   && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1091                 {
1092                   stab += STABSIZE;
1093                 }
1094             }
1095           else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
1096             {
1097               saw_fun = 1;
1098               ++info->indextablesize;
1099             }
1100         }
1101
1102       if (saw_fun == 0)
1103         ++info->indextablesize;
1104
1105       if (info->indextablesize == 0)
1106         return TRUE;
1107       ++info->indextablesize;
1108
1109       amt = info->indextablesize;
1110       amt *= sizeof (struct indexentry);
1111       info->indextable = bfd_alloc (abfd, amt);
1112       if (info->indextable == NULL)
1113         return FALSE;
1114
1115       file_name = NULL;
1116       directory_name = NULL;
1117       saw_fun = 1;
1118
1119       for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1120            i < info->indextablesize && stab < info->stabs + stabsize;
1121            stab += STABSIZE)
1122         {
1123           switch (stab[TYPEOFF])
1124             {
1125             case 0:
1126               /* This is the first entry in a compilation unit.  */
1127               if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1128                 break;
1129               str += stroff;
1130               stroff = bfd_get_32 (abfd, stab + VALOFF);
1131               break;
1132
1133             case N_SO:
1134               /* The main file name.  */
1135
1136               /* The following code creates a new indextable entry with
1137                  a NULL function name if there were no N_FUNs in a file.
1138                  Note that a N_SO without a file name is an EOF and
1139                  there could be 2 N_SO following it with the new filename
1140                  and directory.  */
1141               if (saw_fun == 0)
1142                 {
1143                   info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1144                   info->indextable[i].stab = last_stab;
1145                   info->indextable[i].str = str;
1146                   info->indextable[i].directory_name = directory_name;
1147                   info->indextable[i].file_name = file_name;
1148                   info->indextable[i].function_name = NULL;
1149                   ++i;
1150                 }
1151               saw_fun = 0;
1152
1153               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1154               if (*file_name == '\0')
1155                 {
1156                   directory_name = NULL;
1157                   file_name = NULL;
1158                   saw_fun = 1;
1159                 }
1160               else
1161                 {
1162                   last_stab = stab;
1163                   if (stab + STABSIZE >= info->stabs + stabsize
1164                       || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
1165                     {
1166                       directory_name = NULL;
1167                     }
1168                   else
1169                     {
1170                       /* Two consecutive N_SOs are a directory and a
1171                          file name.  */
1172                       stab += STABSIZE;
1173                       directory_name = file_name;
1174                       file_name = ((char *) str
1175                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1176                     }
1177                 }
1178               break;
1179
1180             case N_SOL:
1181               /* The name of an include file.  */
1182               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1183               break;
1184
1185             case N_FUN:
1186               /* A function name.  */
1187               saw_fun = 1;
1188               name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1189
1190               if (*name == '\0')
1191                 name = NULL;
1192
1193               function_name = name;
1194
1195               if (name == NULL)
1196                 continue;
1197
1198               info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1199               info->indextable[i].stab = stab;
1200               info->indextable[i].str = str;
1201               info->indextable[i].directory_name = directory_name;
1202               info->indextable[i].file_name = file_name;
1203               info->indextable[i].function_name = function_name;
1204               ++i;
1205               break;
1206             }
1207         }
1208
1209       if (saw_fun == 0)
1210         {
1211           info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1212           info->indextable[i].stab = last_stab;
1213           info->indextable[i].str = str;
1214           info->indextable[i].directory_name = directory_name;
1215           info->indextable[i].file_name = file_name;
1216           info->indextable[i].function_name = NULL;
1217           ++i;
1218         }
1219
1220       info->indextable[i].val = (bfd_vma) -1;
1221       info->indextable[i].stab = info->stabs + stabsize;
1222       info->indextable[i].str = str;
1223       info->indextable[i].directory_name = NULL;
1224       info->indextable[i].file_name = NULL;
1225       info->indextable[i].function_name = NULL;
1226       ++i;
1227
1228       info->indextablesize = i;
1229       qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1230              cmpindexentry);
1231
1232       *pinfo = info;
1233     }
1234
1235   /* We are passed a section relative offset.  The offsets in the
1236      stabs information are absolute.  */
1237   offset += bfd_get_section_vma (abfd, section);
1238
1239 #ifdef ENABLE_CACHING
1240   if (info->cached_indexentry != NULL
1241       && offset >= info->cached_offset
1242       && offset < (info->cached_indexentry + 1)->val)
1243     {
1244       stab = info->cached_stab;
1245       indexentry = info->cached_indexentry;
1246       file_name = info->cached_file_name;
1247     }
1248   else
1249 #endif
1250     {
1251       long low, high;
1252       long mid = -1;
1253
1254       /* Cache non-existent or invalid.  Do binary search on
1255          indextable.  */
1256       indexentry = NULL;
1257
1258       low = 0;
1259       high = info->indextablesize - 1;
1260       while (low != high)
1261         {
1262           mid = (high + low) / 2;
1263           if (offset >= info->indextable[mid].val
1264               && offset < info->indextable[mid + 1].val)
1265             {
1266               indexentry = &info->indextable[mid];
1267               break;
1268             }
1269
1270           if (info->indextable[mid].val > offset)
1271             high = mid;
1272           else
1273             low = mid + 1;
1274         }
1275
1276       if (indexentry == NULL)
1277         return TRUE;
1278
1279       stab = indexentry->stab + STABSIZE;
1280       file_name = indexentry->file_name;
1281     }
1282
1283   directory_name = indexentry->directory_name;
1284   str = indexentry->str;
1285
1286   saw_line = FALSE;
1287   saw_func = FALSE;
1288   for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1289     {
1290       bfd_boolean done;
1291       bfd_vma val;
1292
1293       done = FALSE;
1294
1295       switch (stab[TYPEOFF])
1296         {
1297         case N_SOL:
1298           /* The name of an include file.  */
1299           val = bfd_get_32 (abfd, stab + VALOFF);
1300           if (val <= offset)
1301             {
1302               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1303               *pline = 0;
1304             }
1305           break;
1306
1307         case N_SLINE:
1308         case N_DSLINE:
1309         case N_BSLINE:
1310           /* A line number.  If the function was specified, then the value
1311              is relative to the start of the function.  Otherwise, the
1312              value is an absolute address.  */
1313           val = ((indexentry->function_name ? indexentry->val : 0)
1314                  + bfd_get_32 (abfd, stab + VALOFF));
1315           /* If this line starts before our desired offset, or if it's
1316              the first line we've been able to find, use it.  The
1317              !saw_line check works around a bug in GCC 2.95.3, which emits
1318              the first N_SLINE late.  */
1319           if (!saw_line || val <= offset)
1320             {
1321               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1322
1323 #ifdef ENABLE_CACHING
1324               info->cached_stab = stab;
1325               info->cached_offset = val;
1326               info->cached_file_name = file_name;
1327               info->cached_indexentry = indexentry;
1328 #endif
1329             }
1330           if (val > offset)
1331             done = TRUE;
1332           saw_line = TRUE;
1333           break;
1334
1335         case N_FUN:
1336         case N_SO:
1337           if (saw_func || saw_line)
1338             done = TRUE;
1339           saw_func = TRUE;
1340           break;
1341         }
1342
1343       if (done)
1344         break;
1345     }
1346
1347   *pfound = TRUE;
1348
1349   if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1350       || directory_name == NULL)
1351     *pfilename = file_name;
1352   else
1353     {
1354       size_t dirlen;
1355
1356       dirlen = strlen (directory_name);
1357       if (info->filename == NULL
1358           || strncmp (info->filename, directory_name, dirlen) != 0
1359           || strcmp (info->filename + dirlen, file_name) != 0)
1360         {
1361           size_t len;
1362
1363           if (info->filename != NULL)
1364             free (info->filename);
1365           len = strlen (file_name) + 1;
1366           info->filename = bfd_malloc (dirlen + len);
1367           if (info->filename == NULL)
1368             return FALSE;
1369           memcpy (info->filename, directory_name, dirlen);
1370           memcpy (info->filename + dirlen, file_name, len);
1371         }
1372
1373       *pfilename = info->filename;
1374     }
1375
1376   if (indexentry->function_name != NULL)
1377     {
1378       char *s;
1379
1380       /* This will typically be something like main:F(0,1), so we want
1381          to clobber the colon.  It's OK to change the name, since the
1382          string is in our own local storage anyhow.  */
1383       s = strchr (indexentry->function_name, ':');
1384       if (s != NULL)
1385         *s = '\0';
1386
1387       *pfnname = indexentry->function_name;
1388     }
1389
1390   return TRUE;
1391 }