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
   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 .
 196 .  struct _bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field. *}
 197 .
 198 .       {* The text of the symbol. The name is left alone, and not copied; the
 199 .          application may not alter it. *}
 200 .  const char *name;
 201 .
 202 .       {* The value of the symbol.  This really should be a union of a
 203 .          numeric value with a pointer, since some flags indicate that
 204 .          a pointer to another symbol is stored here.  *}
 205 .  symvalue value;
 206 .
 207 .       {* Attributes of a symbol: *}
 208 .
 209 .#define BSF_NO_FLAGS    0x00
 210 .
 211 .       {* The symbol has local scope; <<static>> in <<C>>. The value
 212 .          is the offset into the section of the data. *}
 213 .#define BSF_LOCAL      0x01
 214 .
 215 .       {* The symbol has global scope; initialized data in <<C>>. The
 216 .          value is the offset into the section of the data. *}
 217 .#define BSF_GLOBAL     0x02
 218 .
 219 .       {* The symbol has global scope and is exported. The value is
 220 .          the offset into the section of the data. *}
 221 .#define BSF_EXPORT     BSF_GLOBAL {* no real difference *}
 222 .
 223 .       {* A normal C symbol would be one of:
 224 .          <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or
 225 .          <<BSF_GLOBAL>> *}
 226 .
 227 .       {* The symbol is a debugging record. The value has an arbitary
 228 .          meaning, unless BSF_DEBUGGING_RELOC is also set.  *}
 229 .#define BSF_DEBUGGING  0x08
 230 .
 231 .       {* The symbol denotes a function entry point.  Used in ELF,
 232 .          perhaps others someday.  *}
 233 .#define BSF_FUNCTION    0x10
 234 .
 235 .       {* Used by the linker. *}
 236 .#define BSF_KEEP        0x20
 237 .#define BSF_KEEP_G      0x40
 238 .
 239 .       {* A weak global symbol, overridable without warnings by
 240 .          a regular global symbol of the same name.  *}
 241 .#define BSF_WEAK        0x80
 242 .
 243 .       {* This symbol was created to point to a section, e.g. ELF's
 244 .          STT_SECTION symbols.  *}
 245 .#define BSF_SECTION_SYM 0x100
 246 .
 247 .       {* The symbol used to be a common symbol, but now it is
 248 .          allocated. *}
 249 .#define BSF_OLD_COMMON  0x200
 250 .
 251 .       {* The default value for common data. *}
 252 .#define BFD_FORT_COMM_DEFAULT_VALUE 0
 253 .
 254 .       {* In some files the type of a symbol sometimes alters its
 255 .          location in an output file - ie in coff a <<ISFCN>> symbol
 256 .          which is also <<C_EXT>> symbol appears where it was
 257 .          declared and not at the end of a section.  This bit is set
 258 .          by the target BFD part to convey this information. *}
 259 .
 260 .#define BSF_NOT_AT_END    0x400
 261 .
 262 .       {* Signal that the symbol is the label of constructor section. *}
 263 .#define BSF_CONSTRUCTOR   0x800
 264 .
 265 .       {* Signal that the symbol is a warning symbol.  The name is a
 266 .          warning.  The name of the next symbol is the one to warn about;
 267 .          if a reference is made to a symbol with the same name as the next
 268 .          symbol, a warning is issued by the linker. *}
 269 .#define BSF_WARNING       0x1000
 270 .
 271 .       {* Signal that the symbol is indirect.  This symbol is an indirect
 272 .          pointer to the symbol with the same name as the next symbol. *}
 273 .#define BSF_INDIRECT      0x2000
 274 .
 275 .       {* BSF_FILE marks symbols that contain a file name.  This is used
 276 .          for ELF STT_FILE symbols.  *}
 277 .#define BSF_FILE          0x4000
 278 .
 279 .       {* Symbol is from dynamic linking information.  *}
 280 .#define BSF_DYNAMIC       0x8000
 281 .
 282 .       {* The symbol denotes a data object.  Used in ELF, and perhaps
 283 .          others someday.  *}
 284 .#define BSF_OBJECT        0x10000
 285 .
 286 .       {* This symbol is a debugging symbol.  The value is the offset
 287 .          into the section of the data.  BSF_DEBUGGING should be set
 288 .          as well.  *}
 289 .#define BSF_DEBUGGING_RELOC 0x20000
 290 .
 291 .  flagword flags;
 292 .
 293 .       {* A pointer to the section to which this symbol is
 294 .          relative.  This will always be non NULL, there are special
 295 .          sections for undefined and absolute symbols.  *}
 296 .  struct sec *section;
 297 .
 298 .       {* Back end special data.  *}
 299 .  union
 300 .    {
 301 .      PTR p;
 302 .      bfd_vma i;
 303 .    } udata;
 304 .
 305 .} asymbol;
 306 */
 307
 308 #include "bfd.h"
 309 #include "sysdep.h"
 310 #include "libbfd.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 FUNCTION
 386         bfd_canonicalize_symtab
 387
 388 DESCRIPTION
 389         Read the symbols from the BFD @var{abfd}, and fills in
 390         the vector @var{location} with pointers to the symbols and
 391         a trailing NULL.
 392         Return the actual number of symbol pointers, not
 393         including the NULL.
 394
 395 .#define bfd_canonicalize_symtab(abfd, location) \
 396 .     BFD_SEND (abfd, _bfd_canonicalize_symtab,\
 397 .                  (abfd, location))
 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(bfd *abfd, 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 (abfd, arg, symbol)
 444      bfd *abfd;
 445      PTR arg;
 446      asymbol *symbol;
 447 {
 448   FILE *file = (FILE *) arg;
 449   flagword type = symbol->flags;
 450   if (symbol->section != (asection *) NULL)
 451     {
 452       bfd_fprintf_vma (abfd, file,
 453                        symbol->value + symbol->section->vma);
 454     }
 455   else
 456     {
 457       bfd_fprintf_vma (abfd, file, symbol->value);
 458     }
 459
 460   /* This presumes that a symbol can not be both BSF_DEBUGGING and
 461      BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
 462      BSF_OBJECT.  */
 463   fprintf (file, " %c%c%c%c%c%c%c",
 464            ((type & BSF_LOCAL)
 465             ? (type & BSF_GLOBAL) ? '!' : 'l'
 466             : (type & BSF_GLOBAL) ? 'g' : ' '),
 467            (type & BSF_WEAK) ? 'w' : ' ',
 468            (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
 469            (type & BSF_WARNING) ? 'W' : ' ',
 470            (type & BSF_INDIRECT) ? 'I' : ' ',
 471            (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
 472            ((type & BSF_FUNCTION)
 473             ? 'F'
 474             : ((type & BSF_FILE)
 475                ? 'f'
 476                : ((type & BSF_OBJECT) ? 'O' : ' '))));
 477 }
 478
 479 /*
 480 FUNCTION
 481         bfd_make_empty_symbol
 482
 483 DESCRIPTION
 484         Create a new <<asymbol>> structure for the BFD @var{abfd}
 485         and return a pointer to it.
 486
 487         This routine is necessary because each back end has private
 488         information surrounding the <<asymbol>>. Building your own
 489         <<asymbol>> and pointing to it will not create the private
 490         information, and will cause problems later on.
 491
 492 .#define bfd_make_empty_symbol(abfd) \
 493 .     BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
 494 */
 495
 496 /*
 497 FUNCTION
 498         bfd_make_debug_symbol
 499
 500 DESCRIPTION
 501         Create a new <<asymbol>> structure for the BFD @var{abfd},
 502         to be used as a debugging symbol.  Further details of its use have
 503         yet to be worked out.
 504
 505 .#define bfd_make_debug_symbol(abfd,ptr,size) \
 506 .        BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
 507 */
 508
 509 struct section_to_type
 510 {
 511   const char *section;
 512   char type;
 513 };
 514
 515 /* Map section names to POSIX/BSD single-character symbol types.
 516    This table is probably incomplete.  It is sorted for convenience of
 517    adding entries.  Since it is so short, a linear search is used.  */
 518 static const struct section_to_type stt[] =
 519 {
 520   {"*DEBUG*", 'N'},
 521   {".bss", 'b'},
 522   {"zerovars", 'b'},            /* MRI .bss */
 523   {".data", 'd'},
 524   {"vars", 'd'},                /* MRI .data */
 525   {".rdata", 'r'},              /* Read only data.  */
 526   {".rodata", 'r'},             /* Read only data.  */
 527   {".sbss", 's'},               /* Small BSS (uninitialized data).  */
 528   {".scommon", 'c'},            /* Small common.  */
 529   {".sdata", 'g'},              /* Small initialized data.  */
 530   {".text", 't'},
 531   {"code", 't'},                /* MRI .text */
 532   {".drectve", 'i'},            /* MSVC's .drective section */
 533   {".idata", 'i'},              /* MSVC's .idata (import) section */
 534   {".edata", 'e'},              /* MSVC's .edata (export) section */
 535   {".pdata", 'p'},              /* MSVC's .pdata (stack unwind) section */
 536   {".debug", 'N'},              /* MSVC's .debug (non-standard debug syms) */
 537   {0, 0}
 538 };
 539
 540 /* Return the single-character symbol type corresponding to
 541    section S, or '?' for an unknown COFF section.
 542
 543    Check for any leading string which matches, so .text5 returns
 544    't' as well as .text */
 545
 546 static char
 547 coff_section_type (s)
 548      const char *s;
 549 {
 550   const struct section_to_type *t;
 551
 552   for (t = &stt[0]; t->section; t++)
 553     if (!strncmp (s, t->section, strlen (t->section)))
 554       return t->type;
 555
 556   return '?';
 557 }
 558
 559 #ifndef islower
 560 #define islower(c) ((c) >= 'a' && (c) <= 'z')
 561 #endif
 562 #ifndef toupper
 563 #define toupper(c) (islower(c) ? ((c) & ~0x20) : (c))
 564 #endif
 565
 566 /*
 567 FUNCTION
 568         bfd_decode_symclass
 569
 570 DESCRIPTION
 571         Return a character corresponding to the symbol
 572         class of @var{symbol}, or '?' for an unknown class.
 573
 574 SYNOPSIS
 575         int bfd_decode_symclass(asymbol *symbol);
 576 */
 577 int
 578 bfd_decode_symclass (symbol)
 579      asymbol *symbol;
 580 {
 581   char c;
 582
 583   if (bfd_is_com_section (symbol->section))
 584     return 'C';
 585   if (bfd_is_und_section (symbol->section))
 586     {
 587       if (symbol->flags & BSF_WEAK)
 588         {
 589           /* If weak, determine if it's specifically an object
 590              or non-object weak.  */
 591           if (symbol->flags & BSF_OBJECT)
 592             return 'v';
 593           else
 594             return 'w';
 595         }
 596       else
 597         return 'U';
 598     }
 599   if (bfd_is_ind_section (symbol->section))
 600     return 'I';
 601   if (symbol->flags & BSF_WEAK)
 602     {
 603       /* If weak, determine if it's specifically an object
 604          or non-object weak.  */
 605       if (symbol->flags & BSF_OBJECT)
 606         return 'V';
 607       else
 608         return 'W';
 609     }
 610   if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
 611     return '?';
 612
 613   if (bfd_is_abs_section (symbol->section))
 614     c = 'a';
 615   else if (symbol->section)
 616     c = coff_section_type (symbol->section->name);
 617   else
 618     return '?';
 619   if (symbol->flags & BSF_GLOBAL)
 620     c = toupper (c);
 621   return c;
 622
 623   /* We don't have to handle these cases just yet, but we will soon:
 624      N_SETV: 'v';
 625      N_SETA: 'l';
 626      N_SETT: 'x';
 627      N_SETD: 'z';
 628      N_SETB: 's';
 629      N_INDR: 'i';
 630      */
 631 }
 632
 633 /*
 634 FUNCTION
 635         bfd_is_undefined_symclass
 636
 637 DESCRIPTION
 638         Returns non-zero if the class symbol returned by
 639         bfd_decode_symclass represents an undefined symbol.
 640         Returns zero otherwise.
 641
 642 SYNOPSIS
 643         boolean bfd_is_undefined_symclass (int symclass);
 644 */
 645
 646 boolean
 647 bfd_is_undefined_symclass (symclass)
 648      int symclass;
 649 {
 650   return symclass == 'U' || symclass == 'w' || symclass == 'v';
 651 }
 652
 653 /*
 654 FUNCTION
 655         bfd_symbol_info
 656
 657 DESCRIPTION
 658         Fill in the basic info about symbol that nm needs.
 659         Additional info may be added by the back-ends after
 660         calling this function.
 661
 662 SYNOPSIS
 663         void bfd_symbol_info(asymbol *symbol, symbol_info *ret);
 664 */
 665
 666 void
 667 bfd_symbol_info (symbol, ret)
 668      asymbol *symbol;
 669      symbol_info *ret;
 670 {
 671   ret->type = bfd_decode_symclass (symbol);
 672
 673   if (bfd_is_undefined_symclass (ret->type))
 674     ret->value = 0;
 675   else
 676     ret->value = symbol->value + symbol->section->vma;
 677
 678   ret->name = symbol->name;
 679 }
 680
 681 /*
 682 FUNCTION
 683         bfd_copy_private_symbol_data
 684
 685 SYNOPSIS
 686         boolean bfd_copy_private_symbol_data(bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
 687
 688 DESCRIPTION
 689         Copy private symbol information from @var{isym} in the BFD
 690         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
 691         Return <<true>> on success, <<false>> on error.  Possible error
 692         returns are:
 693
 694         o <<bfd_error_no_memory>> -
 695         Not enough memory exists to create private data for @var{osec}.
 696
 697 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
 698 .     BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
 699 .               (ibfd, isymbol, obfd, osymbol))
 700
 701 */
 702
 703 /* The generic version of the function which returns mini symbols.
 704    This is used when the backend does not provide a more efficient
 705    version.  It just uses BFD asymbol structures as mini symbols.  */
 706
 707 long
 708 _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep)
 709      bfd *abfd;
 710      boolean dynamic;
 711      PTR *minisymsp;
 712      unsigned int *sizep;
 713 {
 714   long storage;
 715   asymbol **syms = NULL;
 716   long symcount;
 717
 718   if (dynamic)
 719     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 720   else
 721     storage = bfd_get_symtab_upper_bound (abfd);
 722   if (storage < 0)
 723     goto error_return;
 724
 725   syms = (asymbol **) bfd_malloc ((bfd_size_type) storage);
 726   if (syms == NULL)
 727     goto error_return;
 728
 729   if (dynamic)
 730     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
 731   else
 732     symcount = bfd_canonicalize_symtab (abfd, syms);
 733   if (symcount < 0)
 734     goto error_return;
 735
 736   *minisymsp = (PTR) syms;
 737   *sizep = sizeof (asymbol *);
 738   return symcount;
 739
 740  error_return:
 741   if (syms != NULL)
 742     free (syms);
 743   return -1;
 744 }
 745
 746 /* The generic version of the function which converts a minisymbol to
 747    an asymbol.  We don't worry about the sym argument we are passed;
 748    we just return the asymbol the minisymbol points to.  */
 749
 750 /*ARGSUSED*/
 751 asymbol *
 752 _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
 753      bfd *abfd ATTRIBUTE_UNUSED;
 754      boolean dynamic ATTRIBUTE_UNUSED;
 755      const PTR minisym;
 756      asymbol *sym ATTRIBUTE_UNUSED;
 757 {
 758   return *(asymbol **) minisym;
 759 }
 760
 761 /* Look through stabs debugging information in .stab and .stabstr
 762    sections to find the source file and line closest to a desired
 763    location.  This is used by COFF and ELF targets.  It sets *pfound
 764    to true if it finds some information.  The *pinfo field is used to
 765    pass cached information in and out of this routine; this first time
 766    the routine is called for a BFD, *pinfo should be NULL.  The value
 767    placed in *pinfo should be saved with the BFD, and passed back each
 768    time this function is called.  */
 769
 770 /* We use a cache by default.  */
 771
 772 #define ENABLE_CACHING
 773
 774 /* We keep an array of indexentry structures to record where in the
 775    stabs section we should look to find line number information for a
 776    particular address.  */
 777
 778 struct indexentry
 779 {
 780   bfd_vma val;
 781   bfd_byte *stab;
 782   bfd_byte *str;
 783   char *directory_name;
 784   char *file_name;
 785   char *function_name;
 786 };
 787
 788 /* Compare two indexentry structures.  This is called via qsort.  */
 789
 790 static int
 791 cmpindexentry (a, b)
 792      const PTR a;
 793      const PTR b;
 794 {
 795   const struct indexentry *contestantA = (const struct indexentry *) a;
 796   const struct indexentry *contestantB = (const struct indexentry *) b;
 797
 798   if (contestantA->val < contestantB->val)
 799     return -1;
 800   else if (contestantA->val > contestantB->val)
 801     return 1;
 802   else
 803     return 0;
 804 }
 805
 806 /* A pointer to this structure is stored in *pinfo.  */
 807
 808 struct stab_find_info
 809 {
 810   /* The .stab section.  */
 811   asection *stabsec;
 812   /* The .stabstr section.  */
 813   asection *strsec;
 814   /* The contents of the .stab section.  */
 815   bfd_byte *stabs;
 816   /* The contents of the .stabstr section.  */
 817   bfd_byte *strs;
 818
 819   /* A table that indexes stabs by memory address.  */
 820   struct indexentry *indextable;
 821   /* The number of entries in indextable.  */
 822   int indextablesize;
 823
 824 #ifdef ENABLE_CACHING
 825   /* Cached values to restart quickly.  */
 826   struct indexentry *cached_indexentry;
 827   bfd_vma cached_offset;
 828   bfd_byte *cached_stab;
 829   char *cached_file_name;
 830 #endif
 831
 832   /* Saved ptr to malloc'ed filename.  */
 833   char *filename;
 834 };
 835
 836 boolean
 837 _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
 838                                      pfilename, pfnname, pline, pinfo)
 839      bfd *abfd;
 840      asymbol **symbols;
 841      asection *section;
 842      bfd_vma offset;
 843      boolean *pfound;
 844      const char **pfilename;
 845      const char **pfnname;
 846      unsigned int *pline;
 847      PTR *pinfo;
 848 {
 849   struct stab_find_info *info;
 850   bfd_size_type stabsize, strsize;
 851   bfd_byte *stab, *str;
 852   bfd_byte *last_stab = NULL;
 853   bfd_size_type stroff;
 854   struct indexentry *indexentry;
 855   char *file_name;
 856   char *directory_name;
 857   int saw_fun;
 858
 859   *pfound = false;
 860   *pfilename = bfd_get_filename (abfd);
 861   *pfnname = NULL;
 862   *pline = 0;
 863
 864   /* Stabs entries use a 12 byte format:
 865        4 byte string table index
 866        1 byte stab type
 867        1 byte stab other field
 868        2 byte stab desc field
 869        4 byte stab value
 870      FIXME: This will have to change for a 64 bit object format.
 871
 872      The stabs symbols are divided into compilation units.  For the
 873      first entry in each unit, the type of 0, the value is the length
 874      of the string table for this unit, and the desc field is the
 875      number of stabs symbols for this unit.  */
 876
 877 #define STRDXOFF (0)
 878 #define TYPEOFF (4)
 879 #define OTHEROFF (5)
 880 #define DESCOFF (6)
 881 #define VALOFF (8)
 882 #define STABSIZE (12)
 883
 884   info = (struct stab_find_info *) *pinfo;
 885   if (info != NULL)
 886     {
 887       if (info->stabsec == NULL || info->strsec == NULL)
 888         {
 889           /* No stabs debugging information.  */
 890           return true;
 891         }
 892
 893       stabsize = info->stabsec->_raw_size;
 894       strsize = info->strsec->_raw_size;
 895     }
 896   else
 897     {
 898       long reloc_size, reloc_count;
 899       arelent **reloc_vector;
 900       int i;
 901       char *name;
 902       char *function_name;
 903       bfd_size_type amt = sizeof *info;
 904
 905       info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
 906       if (info == NULL)
 907         return false;
 908
 909       /* FIXME: When using the linker --split-by-file or
 910          --split-by-reloc options, it is possible for the .stab and
 911          .stabstr sections to be split.  We should handle that.  */
 912
 913       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
 914       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
 915
 916       if (info->stabsec == NULL || info->strsec == NULL)
 917         {
 918           /* No stabs debugging information.  Set *pinfo so that we
 919              can return quickly in the info != NULL case above.  */
 920           *pinfo = (PTR) info;
 921           return true;
 922         }
 923
 924       stabsize = info->stabsec->_raw_size;
 925       strsize = info->strsec->_raw_size;
 926
 927       info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
 928       info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
 929       if (info->stabs == NULL || info->strs == NULL)
 930         return false;
 931
 932       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
 933                                       (bfd_vma) 0, stabsize)
 934           || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
 935                                          (bfd_vma) 0, strsize))
 936         return false;
 937
 938       /* If this is a relocateable object file, we have to relocate
 939          the entries in .stab.  This should always be simple 32 bit
 940          relocations against symbols defined in this object file, so
 941          this should be no big deal.  */
 942       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
 943       if (reloc_size < 0)
 944         return false;
 945       reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
 946       if (reloc_vector == NULL && reloc_size != 0)
 947         return false;
 948       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
 949                                             symbols);
 950       if (reloc_count < 0)
 951         {
 952           if (reloc_vector != NULL)
 953             free (reloc_vector);
 954           return false;
 955         }
 956       if (reloc_count > 0)
 957         {
 958           arelent **pr;
 959
 960           for (pr = reloc_vector; *pr != NULL; pr++)
 961             {
 962               arelent *r;
 963               unsigned long val;
 964               asymbol *sym;
 965
 966               r = *pr;
 967               if (r->howto->rightshift != 0
 968                   || r->howto->size != 2
 969                   || r->howto->bitsize != 32
 970                   || r->howto->pc_relative
 971                   || r->howto->bitpos != 0
 972                   || r->howto->dst_mask != 0xffffffff)
 973                 {
 974                   (*_bfd_error_handler)
 975                     (_("Unsupported .stab relocation"));
 976                   bfd_set_error (bfd_error_invalid_operation);
 977                   if (reloc_vector != NULL)
 978                     free (reloc_vector);
 979                   return false;
 980                 }
 981
 982               val = bfd_get_32 (abfd, info->stabs + r->address);
 983               val &= r->howto->src_mask;
 984               sym = *r->sym_ptr_ptr;
 985               val += sym->value + sym->section->vma + r->addend;
 986               bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
 987             }
 988         }
 989
 990       if (reloc_vector != NULL)
 991         free (reloc_vector);
 992
 993       /* First time through this function, build a table matching
 994          function VM addresses to stabs, then sort based on starting
 995          VM address.  Do this in two passes: once to count how many
 996          table entries we'll need, and a second to actually build the
 997          table.  */
 998
 999       info->indextablesize = 0;
1000       saw_fun = 1;
1001       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1002         {
1003           if (stab[TYPEOFF] == N_SO)
1004             {
1005               /* N_SO with null name indicates EOF */
1006               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1007                 continue;
1008
1009               /* if we did not see a function def, leave space for one.  */
1010               if (saw_fun == 0)
1011                 ++info->indextablesize;
1012
1013               saw_fun = 0;
1014
1015               /* two N_SO's in a row is a filename and directory. Skip */
1016               if (stab + STABSIZE < info->stabs + stabsize
1017                   && *(stab + STABSIZE + TYPEOFF) == N_SO)
1018                 {
1019                   stab += STABSIZE;
1020                 }
1021             }
1022           else if (stab[TYPEOFF] == N_FUN)
1023             {
1024               saw_fun = 1;
1025               ++info->indextablesize;
1026             }
1027         }
1028
1029       if (saw_fun == 0)
1030         ++info->indextablesize;
1031
1032       if (info->indextablesize == 0)
1033         return true;
1034       ++info->indextablesize;
1035
1036       amt = info->indextablesize;
1037       amt *= sizeof (struct indexentry);
1038       info->indextable = (struct indexentry *) bfd_alloc (abfd, amt);
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, (size_t) i, sizeof (struct indexentry),
1157              cmpindexentry);
1158
1159       *pinfo = (PTR) info;
1160     }
1161
1162   /* We are passed a section relative offset.  The offsets in the
1163      stabs information are absolute.  */
1164   offset += bfd_get_section_vma (abfd, section);
1165
1166 #ifdef ENABLE_CACHING
1167   if (info->cached_indexentry != NULL
1168       && offset >= info->cached_offset
1169       && offset < (info->cached_indexentry + 1)->val)
1170     {
1171       stab = info->cached_stab;
1172       indexentry = info->cached_indexentry;
1173       file_name = info->cached_file_name;
1174     }
1175   else
1176 #endif
1177     {
1178       /* Cache non-existant or invalid.  Do binary search on
1179          indextable.  */
1180
1181       long low, high;
1182       long mid = -1;
1183
1184       indexentry = NULL;
1185
1186       low = 0;
1187       high = info->indextablesize - 1;
1188       while (low != high)
1189         {
1190           mid = (high + low) / 2;
1191           if (offset >= info->indextable[mid].val
1192               && offset < info->indextable[mid + 1].val)
1193             {
1194               indexentry = &info->indextable[mid];
1195               break;
1196             }
1197
1198           if (info->indextable[mid].val > offset)
1199             high = mid;
1200           else
1201             low = mid + 1;
1202         }
1203
1204       if (indexentry == NULL)
1205         return true;
1206
1207       stab = indexentry->stab + STABSIZE;
1208       file_name = indexentry->file_name;
1209     }
1210
1211   directory_name = indexentry->directory_name;
1212   str = indexentry->str;
1213
1214   for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1215     {
1216       boolean done;
1217       bfd_vma val;
1218
1219       done = false;
1220
1221       switch (stab[TYPEOFF])
1222         {
1223         case N_SOL:
1224           /* The name of an include file.  */
1225           val = bfd_get_32 (abfd, stab + VALOFF);
1226           if (val <= offset)
1227             {
1228               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1229               *pline = 0;
1230             }
1231           break;
1232
1233         case N_SLINE:
1234         case N_DSLINE:
1235         case N_BSLINE:
1236           /* A line number.  The value is relative to the start of the
1237              current function.  */
1238           val = indexentry->val + bfd_get_32 (abfd, stab + VALOFF);
1239           if (val <= offset)
1240             {
1241               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1242
1243 #ifdef ENABLE_CACHING
1244               info->cached_stab = stab;
1245               info->cached_offset = val;
1246               info->cached_file_name = file_name;
1247               info->cached_indexentry = indexentry;
1248 #endif
1249             }
1250           if (val > offset)
1251             done = true;
1252           break;
1253
1254         case N_FUN:
1255         case N_SO:
1256           done = true;
1257           break;
1258         }
1259
1260       if (done)
1261         break;
1262     }
1263
1264   *pfound = true;
1265
1266   if (IS_ABSOLUTE_PATH(file_name) || directory_name == NULL)
1267     *pfilename = file_name;
1268   else
1269     {
1270       size_t dirlen;
1271
1272       dirlen = strlen (directory_name);
1273       if (info->filename == NULL
1274           || strncmp (info->filename, directory_name, dirlen) != 0
1275           || strcmp (info->filename + dirlen, file_name) != 0)
1276         {
1277           if (info->filename != NULL)
1278             free (info->filename);
1279           info->filename = (char *) bfd_malloc ((bfd_size_type) dirlen
1280                                                 + strlen (file_name) + 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 }