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
   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         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] = (asymbol *)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 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         bfd_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 bfd_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         bfd_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         bfd_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 bfd_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
 455   flagword type = symbol->flags;
 456
 457   if (symbol->section != (asection *) NULL)
 458     bfd_fprintf_vma (abfd, file,
 459                      symbol->value + symbol->section->vma);
 460   else
 461     bfd_fprintf_vma (abfd, file, symbol->value);
 462
 463   /* This presumes that a symbol can not be both BSF_DEBUGGING and
 464      BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
 465      BSF_OBJECT.  */
 466   fprintf (file, " %c%c%c%c%c%c%c",
 467            ((type & BSF_LOCAL)
 468             ? (type & BSF_GLOBAL) ? '!' : 'l'
 469             : (type & BSF_GLOBAL) ? 'g' : ' '),
 470            (type & BSF_WEAK) ? 'w' : ' ',
 471            (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
 472            (type & BSF_WARNING) ? 'W' : ' ',
 473            (type & BSF_INDIRECT) ? 'I' : ' ',
 474            (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
 475            ((type & BSF_FUNCTION)
 476             ? 'F'
 477             : ((type & BSF_FILE)
 478                ? 'f'
 479                : ((type & BSF_OBJECT) ? 'O' : ' '))));
 480 }
 481
 482 /*
 483 FUNCTION
 484         bfd_make_empty_symbol
 485
 486 DESCRIPTION
 487         Create a new <<asymbol>> structure for the BFD @var{abfd}
 488         and return a pointer to it.
 489
 490         This routine is necessary because each back end has private
 491         information surrounding the <<asymbol>>. Building your own
 492         <<asymbol>> and pointing to it will not create the private
 493         information, and will cause problems later on.
 494
 495 .#define bfd_make_empty_symbol(abfd) \
 496 .     BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
 497 .
 498 */
 499
 500 /*
 501 FUNCTION
 502         _bfd_generic_make_empty_symbol
 503
 504 SYNOPSIS
 505         asymbol * _bfd_generic_make_empty_symbol (bfd *);
 506
 507 DESCRIPTION
 508         Create a new <<asymbol>> structure for the BFD @var{abfd}
 509         and return a pointer to it.  Used by core file routines,
 510         binary back-end and anywhere else where no private info
 511         is needed.
 512 */
 513
 514 asymbol *
 515 _bfd_generic_make_empty_symbol (abfd)
 516      bfd *abfd;
 517 {
 518   bfd_size_type amt = sizeof (asymbol);
 519   asymbol *new = (asymbol *) bfd_zalloc (abfd, amt);
 520   if (new)
 521     new->the_bfd = abfd;
 522   return new;
 523 }
 524
 525 /*
 526 FUNCTION
 527         bfd_make_debug_symbol
 528
 529 DESCRIPTION
 530         Create a new <<asymbol>> structure for the BFD @var{abfd},
 531         to be used as a debugging symbol.  Further details of its use have
 532         yet to be worked out.
 533
 534 .#define bfd_make_debug_symbol(abfd,ptr,size) \
 535 .        BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
 536 .
 537 */
 538
 539 struct section_to_type
 540 {
 541   const char *section;
 542   char type;
 543 };
 544
 545 /* Map section names to POSIX/BSD single-character symbol types.
 546    This table is probably incomplete.  It is sorted for convenience of
 547    adding entries.  Since it is so short, a linear search is used.  */
 548 static const struct section_to_type stt[] =
 549 {
 550   {".bss", 'b'},
 551   {"code", 't'},                /* MRI .text */
 552   {".data", 'd'},
 553   {"*DEBUG*", 'N'},
 554   {".debug", 'N'},              /* MSVC's .debug (non-standard debug syms) */
 555   {".drectve", 'i'},            /* MSVC's .drective section */
 556   {".edata", 'e'},              /* MSVC's .edata (export) section */
 557   {".fini", 't'},               /* ELF fini section */
 558   {".idata", 'i'},              /* MSVC's .idata (import) section */
 559   {".init", 't'},               /* ELF init section */
 560   {".pdata", 'p'},              /* MSVC's .pdata (stack unwind) section */
 561   {".rdata", 'r'},              /* Read only data.  */
 562   {".rodata", 'r'},             /* Read only data.  */
 563   {".sbss", 's'},               /* Small BSS (uninitialized data).  */
 564   {".scommon", 'c'},            /* Small common.  */
 565   {".sdata", 'g'},              /* Small initialized data.  */
 566   {".text", 't'},
 567   {"vars", 'd'},                /* MRI .data */
 568   {"zerovars", 'b'},            /* MRI .bss */
 569   {0, 0}
 570 };
 571
 572 /* Return the single-character symbol type corresponding to
 573    section S, or '?' for an unknown COFF section.
 574
 575    Check for any leading string which matches, so .text5 returns
 576    't' as well as .text */
 577
 578 static char
 579 coff_section_type (s)
 580      const char *s;
 581 {
 582   const struct section_to_type *t;
 583
 584   for (t = &stt[0]; t->section; t++)
 585     if (!strncmp (s, t->section, strlen (t->section)))
 586       return t->type;
 587
 588   return '?';
 589 }
 590
 591 /* Return the single-character symbol type corresponding to section
 592    SECTION, or '?' for an unknown section.  This uses section flags to
 593    identify sections.
 594
 595    FIXME These types are unhandled: c, i, e, p.  If we handled these also,
 596    we could perhaps obsolete coff_section_type.  */
 597
 598 static char
 599 decode_section_type (section)
 600      const struct sec *section;
 601 {
 602   if (section->flags & SEC_CODE)
 603     return 't';
 604   if (section->flags & SEC_DATA)
 605     {
 606       if (section->flags & SEC_READONLY)
 607         return 'r';
 608       else if (section->flags & SEC_SMALL_DATA)
 609         return 'g';
 610       else
 611         return 'd';
 612     }
 613   if ((section->flags & SEC_HAS_CONTENTS) == 0)
 614     {
 615       if (section->flags & SEC_SMALL_DATA)
 616         return 's';
 617       else
 618         return 'b';
 619     }
 620   if (section->flags & SEC_DEBUGGING)
 621     return 'N';
 622   if ((section->flags & SEC_HAS_CONTENTS) &&
 623       (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 (symbol)
 642      asymbol *symbol;
 643 {
 644   char c;
 645
 646   if (bfd_is_com_section (symbol->section))
 647     return 'C';
 648   if (bfd_is_und_section (symbol->section))
 649     {
 650       if (symbol->flags & BSF_WEAK)
 651         {
 652           /* If weak, determine if it's specifically an object
 653              or non-object weak.  */
 654           if (symbol->flags & BSF_OBJECT)
 655             return 'v';
 656           else
 657             return 'w';
 658         }
 659       else
 660         return 'U';
 661     }
 662   if (bfd_is_ind_section (symbol->section))
 663     return 'I';
 664   if (symbol->flags & BSF_WEAK)
 665     {
 666       /* If weak, determine if it's specifically an object
 667          or non-object weak.  */
 668       if (symbol->flags & BSF_OBJECT)
 669         return 'V';
 670       else
 671         return 'W';
 672     }
 673   if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
 674     return '?';
 675
 676   if (bfd_is_abs_section (symbol->section))
 677     c = 'a';
 678   else if (symbol->section)
 679     {
 680       c = coff_section_type (symbol->section->name);
 681       if (c == '?')
 682         c = decode_section_type (symbol->section);
 683     }
 684   else
 685     return '?';
 686   if (symbol->flags & BSF_GLOBAL)
 687     c = TOUPPER (c);
 688   return c;
 689
 690   /* We don't have to handle these cases just yet, but we will soon:
 691      N_SETV: 'v';
 692      N_SETA: 'l';
 693      N_SETT: 'x';
 694      N_SETD: 'z';
 695      N_SETB: 's';
 696      N_INDR: 'i';
 697      */
 698 }
 699
 700 /*
 701 FUNCTION
 702         bfd_is_undefined_symclass
 703
 704 DESCRIPTION
 705         Returns non-zero if the class symbol returned by
 706         bfd_decode_symclass represents an undefined symbol.
 707         Returns zero otherwise.
 708
 709 SYNOPSIS
 710         bfd_boolean bfd_is_undefined_symclass (int symclass);
 711 */
 712
 713 bfd_boolean
 714 bfd_is_undefined_symclass (symclass)
 715      int symclass;
 716 {
 717   return symclass == 'U' || symclass == 'w' || symclass == 'v';
 718 }
 719
 720 /*
 721 FUNCTION
 722         bfd_symbol_info
 723
 724 DESCRIPTION
 725         Fill in the basic info about symbol that nm needs.
 726         Additional info may be added by the back-ends after
 727         calling this function.
 728
 729 SYNOPSIS
 730         void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
 731 */
 732
 733 void
 734 bfd_symbol_info (symbol, ret)
 735      asymbol *symbol;
 736      symbol_info *ret;
 737 {
 738   ret->type = bfd_decode_symclass (symbol);
 739
 740   if (bfd_is_undefined_symclass (ret->type))
 741     ret->value = 0;
 742   else
 743     ret->value = symbol->value + symbol->section->vma;
 744
 745   ret->name = symbol->name;
 746 }
 747
 748 /*
 749 FUNCTION
 750         bfd_copy_private_symbol_data
 751
 752 SYNOPSIS
 753         bfd_boolean bfd_copy_private_symbol_data (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
 754
 755 DESCRIPTION
 756         Copy private symbol information from @var{isym} in the BFD
 757         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
 758         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
 759         returns are:
 760
 761         o <<bfd_error_no_memory>> -
 762         Not enough memory exists to create private data for @var{osec}.
 763
 764 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
 765 .     BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
 766 .               (ibfd, isymbol, obfd, osymbol))
 767 .
 768 */
 769
 770 /* The generic version of the function which returns mini symbols.
 771    This is used when the backend does not provide a more efficient
 772    version.  It just uses BFD asymbol structures as mini symbols.  */
 773
 774 long
 775 _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep)
 776      bfd *abfd;
 777      bfd_boolean dynamic;
 778      PTR *minisymsp;
 779      unsigned int *sizep;
 780 {
 781   long storage;
 782   asymbol **syms = NULL;
 783   long symcount;
 784
 785   if (dynamic)
 786     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 787   else
 788     storage = bfd_get_symtab_upper_bound (abfd);
 789   if (storage < 0)
 790     goto error_return;
 791   if (storage == 0)
 792     return 0;
 793
 794   syms = (asymbol **) bfd_malloc ((bfd_size_type) storage);
 795   if (syms == NULL)
 796     goto error_return;
 797
 798   if (dynamic)
 799     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
 800   else
 801     symcount = bfd_canonicalize_symtab (abfd, syms);
 802   if (symcount < 0)
 803     goto error_return;
 804
 805   *minisymsp = (PTR) syms;
 806   *sizep = sizeof (asymbol *);
 807   return symcount;
 808
 809  error_return:
 810   bfd_set_error (bfd_error_no_symbols);
 811   if (syms != NULL)
 812     free (syms);
 813   return -1;
 814 }
 815
 816 /* The generic version of the function which converts a minisymbol to
 817    an asymbol.  We don't worry about the sym argument we are passed;
 818    we just return the asymbol the minisymbol points to.  */
 819
 820 asymbol *
 821 _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
 822      bfd *abfd ATTRIBUTE_UNUSED;
 823      bfd_boolean dynamic ATTRIBUTE_UNUSED;
 824      const PTR minisym;
 825      asymbol *sym ATTRIBUTE_UNUSED;
 826 {
 827   return *(asymbol **) minisym;
 828 }
 829
 830 /* Look through stabs debugging information in .stab and .stabstr
 831    sections to find the source file and line closest to a desired
 832    location.  This is used by COFF and ELF targets.  It sets *pfound
 833    to TRUE if it finds some information.  The *pinfo field is used to
 834    pass cached information in and out of this routine; this first time
 835    the routine is called for a BFD, *pinfo should be NULL.  The value
 836    placed in *pinfo should be saved with the BFD, and passed back each
 837    time this function is called.  */
 838
 839 /* We use a cache by default.  */
 840
 841 #define ENABLE_CACHING
 842
 843 /* We keep an array of indexentry structures to record where in the
 844    stabs section we should look to find line number information for a
 845    particular address.  */
 846
 847 struct indexentry
 848 {
 849   bfd_vma val;
 850   bfd_byte *stab;
 851   bfd_byte *str;
 852   char *directory_name;
 853   char *file_name;
 854   char *function_name;
 855 };
 856
 857 /* Compare two indexentry structures.  This is called via qsort.  */
 858
 859 static int
 860 cmpindexentry (a, b)
 861      const PTR a;
 862      const PTR b;
 863 {
 864   const struct indexentry *contestantA = (const struct indexentry *) a;
 865   const struct indexentry *contestantB = (const struct indexentry *) b;
 866
 867   if (contestantA->val < contestantB->val)
 868     return -1;
 869   else if (contestantA->val > contestantB->val)
 870     return 1;
 871   else
 872     return 0;
 873 }
 874
 875 /* A pointer to this structure is stored in *pinfo.  */
 876
 877 struct stab_find_info
 878 {
 879   /* The .stab section.  */
 880   asection *stabsec;
 881   /* The .stabstr section.  */
 882   asection *strsec;
 883   /* The contents of the .stab section.  */
 884   bfd_byte *stabs;
 885   /* The contents of the .stabstr section.  */
 886   bfd_byte *strs;
 887
 888   /* A table that indexes stabs by memory address.  */
 889   struct indexentry *indextable;
 890   /* The number of entries in indextable.  */
 891   int indextablesize;
 892
 893 #ifdef ENABLE_CACHING
 894   /* Cached values to restart quickly.  */
 895   struct indexentry *cached_indexentry;
 896   bfd_vma cached_offset;
 897   bfd_byte *cached_stab;
 898   char *cached_file_name;
 899 #endif
 900
 901   /* Saved ptr to malloc'ed filename.  */
 902   char *filename;
 903 };
 904
 905 bfd_boolean
 906 _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
 907                                      pfilename, pfnname, pline, pinfo)
 908      bfd *abfd;
 909      asymbol **symbols;
 910      asection *section;
 911      bfd_vma offset;
 912      bfd_boolean *pfound;
 913      const char **pfilename;
 914      const char **pfnname;
 915      unsigned int *pline;
 916      PTR *pinfo;
 917 {
 918   struct stab_find_info *info;
 919   bfd_size_type stabsize, strsize;
 920   bfd_byte *stab, *str;
 921   bfd_byte *last_stab = NULL;
 922   bfd_size_type stroff;
 923   struct indexentry *indexentry;
 924   char *file_name;
 925   char *directory_name;
 926   int saw_fun;
 927   bfd_boolean saw_line, saw_func;
 928
 929   *pfound = FALSE;
 930   *pfilename = bfd_get_filename (abfd);
 931   *pfnname = NULL;
 932   *pline = 0;
 933
 934   /* Stabs entries use a 12 byte format:
 935        4 byte string table index
 936        1 byte stab type
 937        1 byte stab other field
 938        2 byte stab desc field
 939        4 byte stab value
 940      FIXME: This will have to change for a 64 bit object format.
 941
 942      The stabs symbols are divided into compilation units.  For the
 943      first entry in each unit, the type of 0, the value is the length
 944      of the string table for this unit, and the desc field is the
 945      number of stabs symbols for this unit.  */
 946
 947 #define STRDXOFF (0)
 948 #define TYPEOFF (4)
 949 #define OTHEROFF (5)
 950 #define DESCOFF (6)
 951 #define VALOFF (8)
 952 #define STABSIZE (12)
 953
 954   info = (struct stab_find_info *) *pinfo;
 955   if (info != NULL)
 956     {
 957       if (info->stabsec == NULL || info->strsec == NULL)
 958         {
 959           /* No stabs debugging information.  */
 960           return TRUE;
 961         }
 962
 963       stabsize = info->stabsec->_raw_size;
 964       strsize = info->strsec->_raw_size;
 965     }
 966   else
 967     {
 968       long reloc_size, reloc_count;
 969       arelent **reloc_vector;
 970       int i;
 971       char *name;
 972       char *function_name;
 973       bfd_size_type amt = sizeof *info;
 974
 975       info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
 976       if (info == NULL)
 977         return FALSE;
 978
 979       /* FIXME: When using the linker --split-by-file or
 980          --split-by-reloc options, it is possible for the .stab and
 981          .stabstr sections to be split.  We should handle that.  */
 982
 983       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
 984       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
 985
 986       if (info->stabsec == NULL || info->strsec == NULL)
 987         {
 988           /* No stabs debugging information.  Set *pinfo so that we
 989              can return quickly in the info != NULL case above.  */
 990           *pinfo = (PTR) info;
 991           return TRUE;
 992         }
 993
 994       stabsize = info->stabsec->_raw_size;
 995       strsize = info->strsec->_raw_size;
 996
 997       info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
 998       info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
 999       if (info->stabs == NULL || info->strs == NULL)
1000         return FALSE;
1001
1002       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1003                                       (bfd_vma) 0, stabsize)
1004           || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1005                                          (bfd_vma) 0, strsize))
1006         return FALSE;
1007
1008       /* If this is a relocatable object file, we have to relocate
1009          the entries in .stab.  This should always be simple 32 bit
1010          relocations against symbols defined in this object file, so
1011          this should be no big deal.  */
1012       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1013       if (reloc_size < 0)
1014         return FALSE;
1015       reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
1016       if (reloc_vector == NULL && reloc_size != 0)
1017         return FALSE;
1018       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1019                                             symbols);
1020       if (reloc_count < 0)
1021         {
1022           if (reloc_vector != NULL)
1023             free (reloc_vector);
1024           return FALSE;
1025         }
1026       if (reloc_count > 0)
1027         {
1028           arelent **pr;
1029
1030           for (pr = reloc_vector; *pr != NULL; pr++)
1031             {
1032               arelent *r;
1033               unsigned long val;
1034               asymbol *sym;
1035
1036               r = *pr;
1037               if (r->howto->rightshift != 0
1038                   || r->howto->size != 2
1039                   || r->howto->bitsize != 32
1040                   || r->howto->pc_relative
1041                   || r->howto->bitpos != 0
1042                   || r->howto->dst_mask != 0xffffffff)
1043                 {
1044                   (*_bfd_error_handler)
1045                     (_("Unsupported .stab relocation"));
1046                   bfd_set_error (bfd_error_invalid_operation);
1047                   if (reloc_vector != NULL)
1048                     free (reloc_vector);
1049                   return FALSE;
1050                 }
1051
1052               val = bfd_get_32 (abfd, info->stabs + r->address);
1053               val &= r->howto->src_mask;
1054               sym = *r->sym_ptr_ptr;
1055               val += sym->value + sym->section->vma + r->addend;
1056               bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1057             }
1058         }
1059
1060       if (reloc_vector != NULL)
1061         free (reloc_vector);
1062
1063       /* First time through this function, build a table matching
1064          function VM addresses to stabs, then sort based on starting
1065          VM address.  Do this in two passes: once to count how many
1066          table entries we'll need, and a second to actually build the
1067          table.  */
1068
1069       info->indextablesize = 0;
1070       saw_fun = 1;
1071       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1072         {
1073           if (stab[TYPEOFF] == (bfd_byte) N_SO)
1074             {
1075               /* N_SO with null name indicates EOF */
1076               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1077                 continue;
1078
1079               /* if we did not see a function def, leave space for one.  */
1080               if (saw_fun == 0)
1081                 ++info->indextablesize;
1082
1083               saw_fun = 0;
1084
1085               /* two N_SO's in a row is a filename and directory. Skip */
1086               if (stab + STABSIZE < info->stabs + stabsize
1087                   && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1088                 {
1089                   stab += STABSIZE;
1090                 }
1091             }
1092           else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
1093             {
1094               saw_fun = 1;
1095               ++info->indextablesize;
1096             }
1097         }
1098
1099       if (saw_fun == 0)
1100         ++info->indextablesize;
1101
1102       if (info->indextablesize == 0)
1103         return TRUE;
1104       ++info->indextablesize;
1105
1106       amt = info->indextablesize;
1107       amt *= sizeof (struct indexentry);
1108       info->indextable = (struct indexentry *) bfd_alloc (abfd, amt);
1109       if (info->indextable == NULL)
1110         return FALSE;
1111
1112       file_name = NULL;
1113       directory_name = NULL;
1114       saw_fun = 1;
1115
1116       for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1117            i < info->indextablesize && stab < info->stabs + stabsize;
1118            stab += STABSIZE)
1119         {
1120           switch (stab[TYPEOFF])
1121             {
1122             case 0:
1123               /* This is the first entry in a compilation unit.  */
1124               if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1125                 break;
1126               str += stroff;
1127               stroff = bfd_get_32 (abfd, stab + VALOFF);
1128               break;
1129
1130             case N_SO:
1131               /* The main file name.  */
1132
1133               /* The following code creates a new indextable entry with
1134                  a NULL function name if there were no N_FUNs in a file.
1135                  Note that a N_SO without a file name is an EOF and
1136                  there could be 2 N_SO following it with the new filename
1137                  and directory.  */
1138               if (saw_fun == 0)
1139                 {
1140                   info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1141                   info->indextable[i].stab = last_stab;
1142                   info->indextable[i].str = str;
1143                   info->indextable[i].directory_name = directory_name;
1144                   info->indextable[i].file_name = file_name;
1145                   info->indextable[i].function_name = NULL;
1146                   ++i;
1147                 }
1148               saw_fun = 0;
1149
1150               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1151               if (*file_name == '\0')
1152                 {
1153                   directory_name = NULL;
1154                   file_name = NULL;
1155                   saw_fun = 1;
1156                 }
1157               else
1158                 {
1159                   last_stab = stab;
1160                   if (stab + STABSIZE >= info->stabs + stabsize
1161                       || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
1162                     {
1163                       directory_name = NULL;
1164                     }
1165                   else
1166                     {
1167                       /* Two consecutive N_SOs are a directory and a
1168                          file name.  */
1169                       stab += STABSIZE;
1170                       directory_name = file_name;
1171                       file_name = ((char *) str
1172                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1173                     }
1174                 }
1175               break;
1176
1177             case N_SOL:
1178               /* The name of an include file.  */
1179               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1180               break;
1181
1182             case N_FUN:
1183               /* A function name.  */
1184               saw_fun = 1;
1185               name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1186
1187               if (*name == '\0')
1188                 name = NULL;
1189
1190               function_name = name;
1191
1192               if (name == NULL)
1193                 continue;
1194
1195               info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1196               info->indextable[i].stab = stab;
1197               info->indextable[i].str = str;
1198               info->indextable[i].directory_name = directory_name;
1199               info->indextable[i].file_name = file_name;
1200               info->indextable[i].function_name = function_name;
1201               ++i;
1202               break;
1203             }
1204         }
1205
1206       if (saw_fun == 0)
1207         {
1208           info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1209           info->indextable[i].stab = last_stab;
1210           info->indextable[i].str = str;
1211           info->indextable[i].directory_name = directory_name;
1212           info->indextable[i].file_name = file_name;
1213           info->indextable[i].function_name = NULL;
1214           ++i;
1215         }
1216
1217       info->indextable[i].val = (bfd_vma) -1;
1218       info->indextable[i].stab = info->stabs + stabsize;
1219       info->indextable[i].str = str;
1220       info->indextable[i].directory_name = NULL;
1221       info->indextable[i].file_name = NULL;
1222       info->indextable[i].function_name = NULL;
1223       ++i;
1224
1225       info->indextablesize = i;
1226       qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1227              cmpindexentry);
1228
1229       *pinfo = (PTR) info;
1230     }
1231
1232   /* We are passed a section relative offset.  The offsets in the
1233      stabs information are absolute.  */
1234   offset += bfd_get_section_vma (abfd, section);
1235
1236 #ifdef ENABLE_CACHING
1237   if (info->cached_indexentry != NULL
1238       && offset >= info->cached_offset
1239       && offset < (info->cached_indexentry + 1)->val)
1240     {
1241       stab = info->cached_stab;
1242       indexentry = info->cached_indexentry;
1243       file_name = info->cached_file_name;
1244     }
1245   else
1246 #endif
1247     {
1248       long low, high;
1249       long mid = -1;
1250
1251       /* Cache non-existant or invalid.  Do binary search on
1252          indextable.  */
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       bfd_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.  If the function was specified, then the value
1308              is relative to the start of the function.  Otherwise, the
1309              value is an absolute address.  */
1310           val = ((indexentry->function_name ? indexentry->val : 0)
1311                  + bfd_get_32 (abfd, stab + VALOFF));
1312           /* If this line starts before our desired offset, or if it's
1313              the first line we've been able to find, use it.  The
1314              !saw_line check works around a bug in GCC 2.95.3, which emits
1315              the first N_SLINE late.  */
1316           if (!saw_line || val <= offset)
1317             {
1318               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1319
1320 #ifdef ENABLE_CACHING
1321               info->cached_stab = stab;
1322               info->cached_offset = val;
1323               info->cached_file_name = file_name;
1324               info->cached_indexentry = indexentry;
1325 #endif
1326             }
1327           if (val > offset)
1328             done = TRUE;
1329           saw_line = TRUE;
1330           break;
1331
1332         case N_FUN:
1333         case N_SO:
1334           if (saw_func || saw_line)
1335             done = TRUE;
1336           saw_func = TRUE;
1337           break;
1338         }
1339
1340       if (done)
1341         break;
1342     }
1343
1344   *pfound = TRUE;
1345
1346   if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1347       || directory_name == NULL)
1348     *pfilename = file_name;
1349   else
1350     {
1351       size_t dirlen;
1352
1353       dirlen = strlen (directory_name);
1354       if (info->filename == NULL
1355           || strncmp (info->filename, directory_name, dirlen) != 0
1356           || strcmp (info->filename + dirlen, file_name) != 0)
1357         {
1358           size_t len;
1359
1360           if (info->filename != NULL)
1361             free (info->filename);
1362           len = strlen (file_name) + 1;
1363           info->filename = (char *) bfd_malloc ((bfd_size_type) dirlen + len);
1364           if (info->filename == NULL)
1365             return FALSE;
1366           memcpy (info->filename, directory_name, dirlen);
1367           memcpy (info->filename + dirlen, file_name, len);
1368         }
1369
1370       *pfilename = info->filename;
1371     }
1372
1373   if (indexentry->function_name != NULL)
1374     {
1375       char *s;
1376
1377       /* This will typically be something like main:F(0,1), so we want
1378          to clobber the colon.  It's OK to change the name, since the
1379          string is in our own local storage anyhow.  */
1380       s = strchr (indexentry->function_name, ':');
1381       if (s != NULL)
1382         *s = '\0';
1383
1384       *pfnname = indexentry->function_name;
1385     }
1386
1387   return TRUE;
1388 }