bfd/syms.c

   1 /* Generic symbol-table support for the BFD library.
   2    Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
   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. *}
 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 .  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 .    } udata;
 301 .
 302 .} asymbol;
 303 */
 304
 305 #include "bfd.h"
 306 #include "sysdep.h"
 307 #include "libbfd.h"
 308 #include "bfdlink.h"
 309 #include "aout/stab_gnu.h"
 310
 311 static char coff_section_type PARAMS ((const char *));
 312
 313 /*
 314 DOCDD
 315 INODE
 316 symbol handling functions,  , typedef asymbol, Symbols
 317 SUBSECTION
 318         Symbol handling functions
 319 */
 320
 321 /*
 322 FUNCTION
 323         bfd_get_symtab_upper_bound
 324
 325 DESCRIPTION
 326         Return the number of bytes required to store a vector of pointers
 327         to <<asymbols>> for all the symbols in the BFD @var{abfd},
 328         including a terminal NULL pointer. If there are no symbols in
 329         the BFD, then return 0.  If an error occurs, return -1.
 330
 331 .#define bfd_get_symtab_upper_bound(abfd) \
 332 .     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
 333
 334 */
 335
 336 /*
 337 FUNCTION
 338         bfd_is_local_label
 339
 340 SYNOPSIS
 341         boolean bfd_is_local_label(bfd *abfd, asymbol *sym);
 342
 343 DESCRIPTION
 344         Return true if the given symbol @var{sym} in the BFD @var{abfd} is
 345         a compiler generated local label, else return false.
 346 */
 347
 348 boolean
 349 bfd_is_local_label (abfd, sym)
 350      bfd *abfd;
 351      asymbol *sym;
 352 {
 353   if ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
 354     return false;
 355   if (sym->name == NULL)
 356     return false;
 357   return bfd_is_local_label_name (abfd, sym->name);
 358 }
 359
 360 /*
 361 FUNCTION
 362         bfd_is_local_label_name
 363
 364 SYNOPSIS
 365         boolean bfd_is_local_label_name(bfd *abfd, const char *name);
 366
 367 DESCRIPTION
 368         Return true if a symbol with the name @var{name} in the BFD
 369         @var{abfd} is a compiler generated local label, else return
 370         false.  This just checks whether the name has the form of a
 371         local label.
 372
 373 .#define bfd_is_local_label_name(abfd, name) \
 374 .     BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
 375 */
 376
 377 /*
 378 FUNCTION
 379         bfd_canonicalize_symtab
 380
 381 DESCRIPTION
 382         Read the symbols from the BFD @var{abfd}, and fills in
 383         the vector @var{location} with pointers to the symbols and
 384         a trailing NULL.
 385         Return the actual number of symbol pointers, not
 386         including the NULL.
 387
 388
 389 .#define bfd_canonicalize_symtab(abfd, location) \
 390 .     BFD_SEND (abfd, _bfd_canonicalize_symtab,\
 391 .                  (abfd, location))
 392
 393 */
 394
 395
 396 /*
 397 FUNCTION
 398         bfd_set_symtab
 399
 400 SYNOPSIS
 401         boolean bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int count);
 402
 403 DESCRIPTION
 404         Arrange that when the output BFD @var{abfd} is closed,
 405         the table @var{location} of @var{count} pointers to symbols
 406         will be written.
 407 */
 408
 409 boolean
 410 bfd_set_symtab (abfd, location, symcount)
 411      bfd *abfd;
 412      asymbol **location;
 413      unsigned int symcount;
 414 {
 415   if ((abfd->format != bfd_object) || (bfd_read_p (abfd)))
 416     {
 417       bfd_set_error (bfd_error_invalid_operation);
 418       return false;
 419     }
 420
 421   bfd_get_outsymbols (abfd) = location;
 422   bfd_get_symcount (abfd) = symcount;
 423   return true;
 424 }
 425
 426 /*
 427 FUNCTION
 428         bfd_print_symbol_vandf
 429
 430 SYNOPSIS
 431         void bfd_print_symbol_vandf(PTR file, asymbol *symbol);
 432
 433 DESCRIPTION
 434         Print the value and flags of the @var{symbol} supplied to the
 435         stream @var{file}.
 436 */
 437 void
 438 bfd_print_symbol_vandf (arg, symbol)
 439      PTR arg;
 440      asymbol *symbol;
 441 {
 442   FILE *file = (FILE *) arg;
 443   flagword type = symbol->flags;
 444   if (symbol->section != (asection *) NULL)
 445     {
 446       fprintf_vma (file, symbol->value + symbol->section->vma);
 447     }
 448   else
 449     {
 450       fprintf_vma (file, symbol->value);
 451     }
 452
 453   /* This presumes that a symbol can not be both BSF_DEBUGGING and
 454      BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
 455      BSF_OBJECT.  */
 456   fprintf (file, " %c%c%c%c%c%c%c",
 457            ((type & BSF_LOCAL)
 458             ? (type & BSF_GLOBAL) ? '!' : 'l'
 459             : (type & BSF_GLOBAL) ? 'g' : ' '),
 460            (type & BSF_WEAK) ? 'w' : ' ',
 461            (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
 462            (type & BSF_WARNING) ? 'W' : ' ',
 463            (type & BSF_INDIRECT) ? 'I' : ' ',
 464            (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
 465            ((type & BSF_FUNCTION)
 466             ? 'F'
 467             : ((type & BSF_FILE)
 468                ? 'f'
 469                : ((type & BSF_OBJECT) ? 'O' : ' '))));
 470 }
 471
 472
 473 /*
 474 FUNCTION
 475         bfd_make_empty_symbol
 476
 477 DESCRIPTION
 478         Create a new <<asymbol>> structure for the BFD @var{abfd}
 479         and return a pointer to it.
 480
 481         This routine is necessary because each back end has private
 482         information surrounding the <<asymbol>>. Building your own
 483         <<asymbol>> and pointing to it will not create the private
 484         information, and will cause problems later on.
 485
 486 .#define bfd_make_empty_symbol(abfd) \
 487 .     BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
 488 */
 489
 490 /*
 491 FUNCTION
 492         bfd_make_debug_symbol
 493
 494 DESCRIPTION
 495         Create a new <<asymbol>> structure for the BFD @var{abfd},
 496         to be used as a debugging symbol.  Further details of its use have
 497         yet to be worked out.
 498
 499 .#define bfd_make_debug_symbol(abfd,ptr,size) \
 500 .        BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
 501 */
 502
 503 struct section_to_type
 504 {
 505   CONST char *section;
 506   char type;
 507 };
 508
 509 /* Map section names to POSIX/BSD single-character symbol types.
 510    This table is probably incomplete.  It is sorted for convenience of
 511    adding entries.  Since it is so short, a linear search is used.  */
 512 static CONST struct section_to_type stt[] =
 513 {
 514   {"*DEBUG*", 'N'},
 515   {".bss", 'b'},
 516   {"zerovars", 'b'},            /* MRI .bss */
 517   {".data", 'd'},
 518   {"vars", 'd'},                /* MRI .data */
 519   {".rdata", 'r'},              /* Read only data.  */
 520   {".rodata", 'r'},             /* Read only data.  */
 521   {".sbss", 's'},               /* Small BSS (uninitialized data).  */
 522   {".scommon", 'c'},            /* Small common.  */
 523   {".sdata", 'g'},              /* Small initialized data.  */
 524   {".text", 't'},
 525   {"code", 't'},                /* MRI .text */
 526   {".drectve", 'i'},            /* MSVC's .drective section */
 527   {".idata", 'i'},              /* MSVC's .idata (import) section */
 528   {".edata", 'e'},              /* MSVC's .edata (export) section */
 529   {".pdata", 'p'},              /* MSVC's .pdata (stack unwind) section */
 530   {".debug", 'N'},              /* MSVC's .debug (non-standard debug syms) */
 531   {0, 0}
 532 };
 533
 534 /* Return the single-character symbol type corresponding to
 535    section S, or '?' for an unknown COFF section.
 536
 537    Check for any leading string which matches, so .text5 returns
 538    't' as well as .text */
 539
 540 static char
 541 coff_section_type (s)
 542      const char *s;
 543 {
 544   CONST struct section_to_type *t;
 545
 546   for (t = &stt[0]; t->section; t++)
 547     if (!strncmp (s, t->section, strlen (t->section)))
 548       return t->type;
 549
 550   return '?';
 551 }
 552
 553 #ifndef islower
 554 #define islower(c) ((c) >= 'a' && (c) <= 'z')
 555 #endif
 556 #ifndef toupper
 557 #define toupper(c) (islower(c) ? ((c) & ~0x20) : (c))
 558 #endif
 559
 560 /*
 561 FUNCTION
 562         bfd_decode_symclass
 563
 564 DESCRIPTION
 565         Return a character corresponding to the symbol
 566         class of @var{symbol}, or '?' for an unknown class.
 567
 568 SYNOPSIS
 569         int bfd_decode_symclass(asymbol *symbol);
 570 */
 571 int
 572 bfd_decode_symclass (symbol)
 573      asymbol *symbol;
 574 {
 575   char c;
 576
 577   if (bfd_is_com_section (symbol->section))
 578     return 'C';
 579   if (bfd_is_und_section (symbol->section))
 580     {
 581       if (symbol->flags & BSF_WEAK)
 582         return 'w';
 583       else
 584         return 'U';
 585     }
 586   if (bfd_is_ind_section (symbol->section))
 587     return 'I';
 588   if (symbol->flags & BSF_WEAK)
 589     return 'W';
 590   if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
 591     return '?';
 592
 593   if (bfd_is_abs_section (symbol->section))
 594     c = 'a';
 595   else if (symbol->section)
 596     c = coff_section_type (symbol->section->name);
 597   else
 598     return '?';
 599   if (symbol->flags & BSF_GLOBAL)
 600     c = toupper (c);
 601   return c;
 602
 603   /* We don't have to handle these cases just yet, but we will soon:
 604      N_SETV: 'v';
 605      N_SETA: 'l';
 606      N_SETT: 'x';
 607      N_SETD: 'z';
 608      N_SETB: 's';
 609      N_INDR: 'i';
 610      */
 611 }
 612
 613 /*
 614 FUNCTION
 615         bfd_symbol_info
 616
 617 DESCRIPTION
 618         Fill in the basic info about symbol that nm needs.
 619         Additional info may be added by the back-ends after
 620         calling this function.
 621
 622 SYNOPSIS
 623         void bfd_symbol_info(asymbol *symbol, symbol_info *ret);
 624 */
 625
 626 void
 627 bfd_symbol_info (symbol, ret)
 628      asymbol *symbol;
 629      symbol_info *ret;
 630 {
 631   ret->type = bfd_decode_symclass (symbol);
 632   if (ret->type != 'U' && ret->type != 'w')
 633     ret->value = symbol->value + symbol->section->vma;
 634   else
 635     ret->value = 0;
 636   ret->name = symbol->name;
 637 }
 638
 639 /*
 640 FUNCTION
 641         bfd_copy_private_symbol_data
 642
 643 SYNOPSIS
 644         boolean bfd_copy_private_symbol_data(bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
 645
 646 DESCRIPTION
 647         Copy private symbol information from @var{isym} in the BFD
 648         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
 649         Return <<true>> on success, <<false>> on error.  Possible error
 650         returns are:
 651
 652         o <<bfd_error_no_memory>> -
 653         Not enough memory exists to create private data for @var{osec}.
 654
 655 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
 656 .     BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
 657 .               (ibfd, isymbol, obfd, osymbol))
 658
 659 */
 660
 661 /* The generic version of the function which returns mini symbols.
 662    This is used when the backend does not provide a more efficient
 663    version.  It just uses BFD asymbol structures as mini symbols.  */
 664
 665 long
 666 _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep)
 667      bfd *abfd;
 668      boolean dynamic;
 669      PTR *minisymsp;
 670      unsigned int *sizep;
 671 {
 672   long storage;
 673   asymbol **syms = NULL;
 674   long symcount;
 675
 676   if (dynamic)
 677     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 678   else
 679     storage = bfd_get_symtab_upper_bound (abfd);
 680   if (storage < 0)
 681     goto error_return;
 682
 683   syms = (asymbol **) bfd_malloc ((size_t) storage);
 684   if (syms == NULL)
 685     goto error_return;
 686
 687   if (dynamic)
 688     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
 689   else
 690     symcount = bfd_canonicalize_symtab (abfd, syms);
 691   if (symcount < 0)
 692     goto error_return;
 693
 694   *minisymsp = (PTR) syms;
 695   *sizep = sizeof (asymbol *);
 696   return symcount;
 697
 698  error_return:
 699   if (syms != NULL)
 700     free (syms);
 701   return -1;
 702 }
 703
 704 /* The generic version of the function which converts a minisymbol to
 705    an asymbol.  We don't worry about the sym argument we are passed;
 706    we just return the asymbol the minisymbol points to.  */
 707
 708 /*ARGSUSED*/
 709 asymbol *
 710 _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
 711      bfd *abfd ATTRIBUTE_UNUSED;
 712      boolean dynamic ATTRIBUTE_UNUSED;
 713      const PTR minisym;
 714      asymbol *sym ATTRIBUTE_UNUSED;
 715 {
 716   return *(asymbol **) minisym;
 717 }
 718
 719 /* Look through stabs debugging information in .stab and .stabstr
 720    sections to find the source file and line closest to a desired
 721    location.  This is used by COFF and ELF targets.  It sets *pfound
 722    to true if it finds some information.  The *pinfo field is used to
 723    pass cached information in and out of this routine; this first time
 724    the routine is called for a BFD, *pinfo should be NULL.  The value
 725    placed in *pinfo should be saved with the BFD, and passed back each
 726    time this function is called.  */
 727
 728 /* We use a cache by default.  */
 729
 730 #define ENABLE_CACHING
 731
 732 /* We keep an array of indexentry structures to record where in the
 733    stabs section we should look to find line number information for a
 734    particular address.  */
 735
 736 struct indexentry
 737 {
 738   bfd_vma val;
 739   bfd_byte *stab;
 740   bfd_byte *str;
 741   char *directory_name;
 742   char *file_name;
 743   char *function_name;
 744 };
 745
 746 /* Compare two indexentry structures.  This is called via qsort.  */
 747
 748 static int
 749 cmpindexentry (a, b)
 750      const PTR *a;
 751      const PTR *b;
 752 {
 753   const struct indexentry *contestantA = (const struct indexentry *) a;
 754   const struct indexentry *contestantB = (const struct indexentry *) b;
 755
 756   if (contestantA->val < contestantB->val)
 757     return -1;
 758   else if (contestantA->val > contestantB->val)
 759     return 1;
 760   else
 761     return 0;
 762 }
 763
 764 /* A pointer to this structure is stored in *pinfo.  */
 765
 766 struct stab_find_info
 767 {
 768   /* The .stab section.  */
 769   asection *stabsec;
 770   /* The .stabstr section.  */
 771   asection *strsec;
 772   /* The contents of the .stab section.  */
 773   bfd_byte *stabs;
 774   /* The contents of the .stabstr section.  */
 775   bfd_byte *strs;
 776
 777   /* A table that indexes stabs by memory address.  */
 778   struct indexentry *indextable;
 779   /* The number of entries in indextable.  */
 780   int indextablesize;
 781
 782 #ifdef ENABLE_CACHING
 783   /* Cached values to restart quickly.  */
 784   struct indexentry *cached_indexentry;
 785   bfd_vma cached_offset;
 786   bfd_byte *cached_stab;
 787   char *cached_file_name;
 788 #endif
 789
 790   /* Saved ptr to malloc'ed filename.  */
 791   char *filename;
 792 };
 793
 794 boolean
 795 _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
 796                                      pfilename, pfnname, pline, pinfo)
 797      bfd *abfd;
 798      asymbol **symbols;
 799      asection *section;
 800      bfd_vma offset;
 801      boolean *pfound;
 802      const char **pfilename;
 803      const char **pfnname;
 804      unsigned int *pline;
 805      PTR *pinfo;
 806 {
 807   struct stab_find_info *info;
 808   bfd_size_type stabsize, strsize;
 809   bfd_byte *stab, *str;
 810   bfd_byte *last_stab = NULL;
 811   bfd_size_type stroff;
 812   struct indexentry *indexentry;
 813   char *directory_name, *file_name;
 814   int saw_fun;
 815
 816   *pfound = false;
 817   *pfilename = bfd_get_filename (abfd);
 818   *pfnname = NULL;
 819   *pline = 0;
 820
 821   /* Stabs entries use a 12 byte format:
 822        4 byte string table index
 823        1 byte stab type
 824        1 byte stab other field
 825        2 byte stab desc field
 826        4 byte stab value
 827      FIXME: This will have to change for a 64 bit object format.
 828
 829      The stabs symbols are divided into compilation units.  For the
 830      first entry in each unit, the type of 0, the value is the length
 831      of the string table for this unit, and the desc field is the
 832      number of stabs symbols for this unit.  */
 833
 834 #define STRDXOFF (0)
 835 #define TYPEOFF (4)
 836 #define OTHEROFF (5)
 837 #define DESCOFF (6)
 838 #define VALOFF (8)
 839 #define STABSIZE (12)
 840
 841   info = (struct stab_find_info *) *pinfo;
 842   if (info != NULL)
 843     {
 844       if (info->stabsec == NULL || info->strsec == NULL)
 845         {
 846           /* No stabs debugging information.  */
 847           return true;
 848         }
 849
 850       stabsize = info->stabsec->_raw_size;
 851       strsize = info->strsec->_raw_size;
 852     }
 853   else
 854     {
 855       long reloc_size, reloc_count;
 856       arelent **reloc_vector;
 857       int i;
 858       char *name;
 859       char *file_name;
 860       char *directory_name;
 861       char *function_name;
 862
 863       info = (struct stab_find_info *) bfd_zalloc (abfd, sizeof *info);
 864       if (info == NULL)
 865         return false;
 866
 867       /* FIXME: When using the linker --split-by-file or
 868          --split-by-reloc options, it is possible for the .stab and
 869          .stabstr sections to be split.  We should handle that.  */
 870
 871       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
 872       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
 873
 874       if (info->stabsec == NULL || info->strsec == NULL)
 875         {
 876           /* No stabs debugging information.  Set *pinfo so that we
 877              can return quickly in the info != NULL case above.  */
 878           *pinfo = (PTR) info;
 879           return true;
 880         }
 881
 882       stabsize = info->stabsec->_raw_size;
 883       strsize = info->strsec->_raw_size;
 884
 885       info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
 886       info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
 887       if (info->stabs == NULL || info->strs == NULL)
 888         return false;
 889
 890       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs, 0,
 891                                       stabsize)
 892           || ! bfd_get_section_contents (abfd, info->strsec, info->strs, 0,
 893                                          strsize))
 894         return false;
 895
 896       /* If this is a relocateable object file, we have to relocate
 897          the entries in .stab.  This should always be simple 32 bit
 898          relocations against symbols defined in this object file, so
 899          this should be no big deal.  */
 900       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
 901       if (reloc_size < 0)
 902         return false;
 903       reloc_vector = (arelent **) bfd_malloc (reloc_size);
 904       if (reloc_vector == NULL && reloc_size != 0)
 905         return false;
 906       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
 907                                             symbols);
 908       if (reloc_count < 0)
 909         {
 910           if (reloc_vector != NULL)
 911             free (reloc_vector);
 912           return false;
 913         }
 914       if (reloc_count > 0)
 915         {
 916           arelent **pr;
 917
 918           for (pr = reloc_vector; *pr != NULL; pr++)
 919             {
 920               arelent *r;
 921               unsigned long val;
 922               asymbol *sym;
 923
 924               r = *pr;
 925               if (r->howto->rightshift != 0
 926                   || r->howto->size != 2
 927                   || r->howto->bitsize != 32
 928                   || r->howto->pc_relative
 929                   || r->howto->bitpos != 0
 930                   || r->howto->dst_mask != 0xffffffff)
 931                 {
 932                   (*_bfd_error_handler)
 933                     (_("Unsupported .stab relocation"));
 934                   bfd_set_error (bfd_error_invalid_operation);
 935                   if (reloc_vector != NULL)
 936                     free (reloc_vector);
 937                   return false;
 938                 }
 939
 940               val = bfd_get_32 (abfd, info->stabs + r->address);
 941               val &= r->howto->src_mask;
 942               sym = *r->sym_ptr_ptr;
 943               val += sym->value + sym->section->vma + r->addend;
 944               bfd_put_32 (abfd, val, info->stabs + r->address);
 945             }
 946         }
 947
 948       if (reloc_vector != NULL)
 949         free (reloc_vector);
 950
 951       /* First time through this function, build a table matching
 952          function VM addresses to stabs, then sort based on starting
 953          VM address.  Do this in two passes: once to count how many
 954          table entries we'll need, and a second to actually build the
 955          table.  */
 956
 957       info->indextablesize = 0;
 958       saw_fun = 1;
 959       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
 960         {
 961           if (stab[TYPEOFF] == N_SO)
 962             {
 963               /* N_SO with null name indicates EOF */
 964               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
 965                 continue;
 966
 967               /* if we did not see a function def, leave space for one. */
 968               if (saw_fun == 0)
 969                 ++info->indextablesize;
 970
 971               saw_fun = 0;
 972
 973               /* two N_SO's in a row is a filename and directory. Skip */
 974               if (stab + STABSIZE < info->stabs + stabsize
 975                   && *(stab + STABSIZE + TYPEOFF) == N_SO)
 976                 {
 977                   stab += STABSIZE;
 978                 }
 979             }
 980           else if (stab[TYPEOFF] == N_FUN)
 981             {
 982               saw_fun = 1;
 983               ++info->indextablesize;
 984             }
 985         }
 986
 987       if (saw_fun == 0)
 988         ++info->indextablesize;
 989
 990       if (info->indextablesize == 0)
 991         return true;
 992       ++info->indextablesize;
 993
 994       info->indextable = ((struct indexentry *)
 995                           bfd_alloc (abfd,
 996                                      (sizeof (struct indexentry)
 997                                       * info->indextablesize)));
 998       if (info->indextable == NULL)
 999         return false;
1000
1001       file_name = NULL;
1002       directory_name = NULL;
1003       saw_fun = 1;
1004
1005       for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1006            i < info->indextablesize && stab < info->stabs + stabsize;
1007            stab += STABSIZE)
1008         {
1009           switch (stab[TYPEOFF])
1010             {
1011             case 0:
1012               /* This is the first entry in a compilation unit.  */
1013               if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1014                 break;
1015               str += stroff;
1016               stroff = bfd_get_32 (abfd, stab + VALOFF);
1017               break;
1018
1019             case N_SO:
1020               /* The main file name.  */
1021
1022               /* The following code creates a new indextable entry with
1023                  a NULL function name if there were no N_FUNs in a file.
1024                  Note that a N_SO without a file name is an EOF and
1025                  there could be 2 N_SO following it with the new filename
1026                  and directory. */
1027               if (saw_fun == 0)
1028                 {
1029                   info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1030                   info->indextable[i].stab = last_stab;
1031                   info->indextable[i].str = str;
1032                   info->indextable[i].directory_name = directory_name;
1033                   info->indextable[i].file_name = file_name;
1034                   info->indextable[i].function_name = NULL;
1035                   ++i;
1036                 }
1037               saw_fun = 0;
1038
1039               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1040               if (*file_name == '\0')
1041                 {
1042                   directory_name = NULL;
1043                   file_name = NULL;
1044                   saw_fun = 1;
1045                 }
1046               else
1047                 {
1048                   last_stab = stab;
1049                   if (stab + STABSIZE >= info->stabs + stabsize
1050                       || *(stab + STABSIZE + TYPEOFF) != N_SO)
1051                     {
1052                       directory_name = NULL;
1053                     }
1054                   else
1055                     {
1056                       /* Two consecutive N_SOs are a directory and a
1057                          file name.  */
1058                       stab += STABSIZE;
1059                       directory_name = file_name;
1060                       file_name = ((char *) str
1061                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1062                     }
1063                 }
1064               break;
1065
1066             case N_SOL:
1067               /* The name of an include file.  */
1068               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1069               break;
1070
1071             case N_FUN:
1072               /* A function name.  */
1073               saw_fun = 1;
1074               name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1075
1076               if (*name == '\0')
1077                 name = NULL;
1078
1079               function_name = name;
1080
1081               if (name == NULL)
1082                 continue;
1083
1084               info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1085               info->indextable[i].stab = stab;
1086               info->indextable[i].str = str;
1087               info->indextable[i].directory_name = directory_name;
1088               info->indextable[i].file_name = file_name;
1089               info->indextable[i].function_name = function_name;
1090               ++i;
1091               break;
1092             }
1093         }
1094
1095       if (saw_fun == 0)
1096         {
1097           info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1098           info->indextable[i].stab = last_stab;
1099           info->indextable[i].str = str;
1100           info->indextable[i].directory_name = directory_name;
1101           info->indextable[i].file_name = file_name;
1102           info->indextable[i].function_name = NULL;
1103           ++i;
1104         }
1105
1106       info->indextable[i].val = (bfd_vma) -1;
1107       info->indextable[i].stab = info->stabs + stabsize;
1108       info->indextable[i].str = str;
1109       info->indextable[i].directory_name = NULL;
1110       info->indextable[i].file_name = NULL;
1111       info->indextable[i].function_name = NULL;
1112       ++i;
1113
1114       info->indextablesize = i;
1115       qsort (info->indextable, i, sizeof (struct indexentry), cmpindexentry);
1116
1117       *pinfo = (PTR) info;
1118     }
1119
1120   /* We are passed a section relative offset.  The offsets in the
1121      stabs information are absolute.  */
1122   offset += bfd_get_section_vma (abfd, section);
1123
1124 #ifdef ENABLE_CACHING
1125   if (info->cached_indexentry != NULL
1126       && offset >= info->cached_offset
1127       && offset < (info->cached_indexentry + 1)->val)
1128     {
1129       stab = info->cached_stab;
1130       indexentry = info->cached_indexentry;
1131       file_name = info->cached_file_name;
1132     }
1133   else
1134 #endif
1135     {
1136       /* Cache non-existant or invalid.  Do binary search on
1137          indextable.  */
1138
1139       long low, high;
1140       long mid = -1;
1141
1142       indexentry = NULL;
1143
1144       low = 0;
1145       high = info->indextablesize - 1;
1146       while (low != high)
1147         {
1148           mid = (high + low) / 2;
1149           if (offset >= info->indextable[mid].val
1150               && offset < info->indextable[mid + 1].val)
1151             {
1152               indexentry = &info->indextable[mid];
1153               break;
1154             }
1155
1156           if (info->indextable[mid].val > offset)
1157             high = mid;
1158           else
1159             low = mid + 1;
1160         }
1161
1162       if (indexentry == NULL)
1163         return true;
1164
1165       stab = indexentry->stab + STABSIZE;
1166       file_name = indexentry->file_name;
1167     }
1168
1169   directory_name = indexentry->directory_name;
1170   str = indexentry->str;
1171
1172   for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1173     {
1174       boolean done;
1175       bfd_vma val;
1176
1177       done = false;
1178
1179       switch (stab[TYPEOFF])
1180         {
1181         case N_SOL:
1182           /* The name of an include file.  */
1183           val = bfd_get_32 (abfd, stab + VALOFF);
1184           if (val <= offset)
1185             {
1186               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1187               *pline = 0;
1188             }
1189           break;
1190
1191         case N_SLINE:
1192         case N_DSLINE:
1193         case N_BSLINE:
1194           /* A line number.  The value is relative to the start of the
1195              current function.  */
1196           val = indexentry->val + bfd_get_32 (abfd, stab + VALOFF);
1197           if (val <= offset)
1198             {
1199               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1200
1201 #ifdef ENABLE_CACHING
1202               info->cached_stab = stab;
1203               info->cached_offset = val;
1204               info->cached_file_name = file_name;
1205               info->cached_indexentry = indexentry;
1206 #endif
1207             }
1208           if (val > offset)
1209             done = true;
1210           break;
1211
1212         case N_FUN:
1213         case N_SO:
1214           done = true;
1215           break;
1216         }
1217
1218       if (done)
1219         break;
1220     }
1221
1222   *pfound = true;
1223
1224   if (file_name[0] == '/' || directory_name == NULL)
1225     *pfilename = file_name;
1226   else
1227     {
1228       size_t dirlen;
1229
1230       dirlen = strlen (directory_name);
1231       if (info->filename == NULL
1232           || strncmp (info->filename, directory_name, dirlen) != 0
1233           || strcmp (info->filename + dirlen, file_name) != 0)
1234         {
1235           if (info->filename != NULL)
1236             free (info->filename);
1237           info->filename = (char *) bfd_malloc (dirlen +
1238                                                 strlen (file_name)
1239                                                 + 1);
1240           if (info->filename == NULL)
1241             return false;
1242           strcpy (info->filename, directory_name);
1243           strcpy (info->filename + dirlen, file_name);
1244         }
1245
1246       *pfilename = info->filename;
1247     }
1248
1249   if (indexentry->function_name != NULL)
1250     {
1251       char *s;
1252
1253       /* This will typically be something like main:F(0,1), so we want
1254          to clobber the colon.  It's OK to change the name, since the
1255          string is in our own local storage anyhow.  */
1256
1257       s = strchr (indexentry->function_name, ':');
1258       if (s != NULL)
1259         *s = '\0';
1260
1261       *pfnname = indexentry->function_name;
1262     }
1263
1264   return true;
1265 }