bfd/syms.c

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