bfd/syms.c

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