bfd/syms.c

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