bfd/syms.c

   1 /* Generic symbol-table support for the BFD library.
   2    Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 1997
   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   {0, 0}
 527 };
 528
 529 /* Return the single-character symbol type corresponding to
 530    section S, or '?' for an unknown COFF section.
 531
 532    Check for any leading string which matches, so .text5 returns
 533    't' as well as .text */
 534
 535 static char
 536 coff_section_type (s)
 537      const char *s;
 538 {
 539   CONST struct section_to_type *t;
 540
 541   for (t = &stt[0]; t->section; t++)
 542     if (!strncmp (s, t->section, strlen (t->section)))
 543       return t->type;
 544
 545   return '?';
 546 }
 547
 548 #ifndef islower
 549 #define islower(c) ((c) >= 'a' && (c) <= 'z')
 550 #endif
 551 #ifndef toupper
 552 #define toupper(c) (islower(c) ? ((c) & ~0x20) : (c))
 553 #endif
 554
 555 /*
 556 FUNCTION
 557         bfd_decode_symclass
 558
 559 DESCRIPTION
 560         Return a character corresponding to the symbol
 561         class of @var{symbol}, or '?' for an unknown class.
 562
 563 SYNOPSIS
 564         int bfd_decode_symclass(asymbol *symbol);
 565 */
 566 int
 567 bfd_decode_symclass (symbol)
 568      asymbol *symbol;
 569 {
 570   char c;
 571
 572   if (bfd_is_com_section (symbol->section))
 573     return 'C';
 574   if (bfd_is_und_section (symbol->section))
 575     return 'U';
 576   if (bfd_is_ind_section (symbol->section))
 577     return 'I';
 578   if (symbol->flags & BSF_WEAK)
 579     return 'W';
 580   if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
 581     return '?';
 582
 583   if (bfd_is_abs_section (symbol->section))
 584     c = 'a';
 585   else if (symbol->section)
 586     c = coff_section_type (symbol->section->name);
 587   else
 588     return '?';
 589   if (symbol->flags & BSF_GLOBAL)
 590     c = toupper (c);
 591   return c;
 592
 593   /* We don't have to handle these cases just yet, but we will soon:
 594      N_SETV: 'v';
 595      N_SETA: 'l';
 596      N_SETT: 'x';
 597      N_SETD: 'z';
 598      N_SETB: 's';
 599      N_INDR: 'i';
 600      */
 601 }
 602
 603 /*
 604 FUNCTION
 605         bfd_symbol_info
 606
 607 DESCRIPTION
 608         Fill in the basic info about symbol that nm needs.
 609         Additional info may be added by the back-ends after
 610         calling this function.
 611
 612 SYNOPSIS
 613         void bfd_symbol_info(asymbol *symbol, symbol_info *ret);
 614 */
 615
 616 void
 617 bfd_symbol_info (symbol, ret)
 618      asymbol *symbol;
 619      symbol_info *ret;
 620 {
 621   ret->type = bfd_decode_symclass (symbol);
 622   if (ret->type != 'U')
 623     ret->value = symbol->value + symbol->section->vma;
 624   else
 625     ret->value = 0;
 626   ret->name = symbol->name;
 627 }
 628
 629 void
 630 bfd_symbol_is_absolute ()
 631 {
 632   abort ();
 633 }
 634
 635 /*
 636 FUNCTION
 637         bfd_copy_private_symbol_data
 638
 639 SYNOPSIS
 640         boolean bfd_copy_private_symbol_data(bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
 641
 642 DESCRIPTION
 643         Copy private symbol information from @var{isym} in the BFD
 644         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
 645         Return <<true>> on success, <<false>> on error.  Possible error
 646         returns are:
 647
 648         o <<bfd_error_no_memory>> -
 649         Not enough memory exists to create private data for @var{osec}.
 650
 651 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
 652 .     BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
 653 .               (ibfd, isymbol, obfd, osymbol))
 654
 655 */
 656
 657 /* The generic version of the function which returns mini symbols.
 658    This is used when the backend does not provide a more efficient
 659    version.  It just uses BFD asymbol structures as mini symbols.  */
 660
 661 long
 662 _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep)
 663      bfd *abfd;
 664      boolean dynamic;
 665      PTR *minisymsp;
 666      unsigned int *sizep;
 667 {
 668   long storage;
 669   asymbol **syms = NULL;
 670   long symcount;
 671
 672   if (dynamic)
 673     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 674   else
 675     storage = bfd_get_symtab_upper_bound (abfd);
 676   if (storage < 0)
 677     goto error_return;
 678
 679   syms = (asymbol **) bfd_malloc ((size_t) storage);
 680   if (syms == NULL)
 681     goto error_return;
 682
 683   if (dynamic)
 684     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
 685   else
 686     symcount = bfd_canonicalize_symtab (abfd, syms);
 687   if (symcount < 0)
 688     goto error_return;
 689
 690   *minisymsp = (PTR) syms;
 691   *sizep = sizeof (asymbol *);
 692   return symcount;
 693
 694  error_return:
 695   if (syms != NULL)
 696     free (syms);
 697   return -1;
 698 }
 699
 700 /* The generic version of the function which converts a minisymbol to
 701    an asymbol.  We don't worry about the sym argument we are passed;
 702    we just return the asymbol the minisymbol points to.  */
 703
 704 /*ARGSUSED*/
 705 asymbol *
 706 _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
 707      bfd *abfd;
 708      boolean dynamic;
 709      const PTR minisym;
 710      asymbol *sym;
 711 {
 712   return *(asymbol **) minisym;
 713 }
 714
 715 /* Look through stabs debugging information in .stab and .stabstr
 716    sections to find the source file and line closest to a desired
 717    location.  This is used by COFF and ELF targets.  It sets *pfound
 718    to true if it finds some information.  The *pinfo field is used to
 719    pass cached information in and out of this routine; this first time
 720    the routine is called for a BFD, *pinfo should be NULL.  The value
 721    placed in *pinfo should be saved with the BFD, and passed back each
 722    time this function is called.  */
 723
 724 /* A pointer to this structure is stored in *pinfo.  */
 725
 726 struct stab_find_info
 727 {
 728   /* The .stab section.  */
 729   asection *stabsec;
 730   /* The .stabstr section.  */
 731   asection *strsec;
 732   /* The contents of the .stab section.  */
 733   bfd_byte *stabs;
 734   /* The contents of the .stabstr section.  */
 735   bfd_byte *strs;
 736   /* An malloc buffer to hold the file name.  */
 737   char *filename;
 738   /* Cached values to restart quickly.  */
 739   bfd_vma cached_offset;
 740   bfd_byte *cached_stab;
 741   bfd_byte *cached_str;
 742   bfd_size_type cached_stroff;
 743 };
 744
 745 boolean
 746 _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
 747                                      pfilename, pfnname, pline, pinfo)
 748      bfd *abfd;
 749      asymbol **symbols;
 750      asection *section;
 751      bfd_vma offset;
 752      boolean *pfound;
 753      const char **pfilename;
 754      const char **pfnname;
 755      unsigned int *pline;
 756      PTR *pinfo;
 757 {
 758   struct stab_find_info *info;
 759   bfd_size_type stabsize, strsize;
 760   bfd_byte *stab, *stabend, *str;
 761   bfd_size_type stroff;
 762   bfd_vma fnaddr;
 763   char *directory_name, *main_file_name, *current_file_name, *line_file_name;
 764   char *fnname;
 765   bfd_vma low_func_vma, low_line_vma;
 766
 767   *pfound = false;
 768   *pfilename = bfd_get_filename (abfd);
 769   *pfnname = NULL;
 770   *pline = 0;
 771
 772   info = (struct stab_find_info *) *pinfo;
 773   if (info != NULL)
 774     {
 775       if (info->stabsec == NULL || info->strsec == NULL)
 776         {
 777           /* No stabs debugging information.  */
 778           return true;
 779         }
 780
 781       stabsize = info->stabsec->_raw_size;
 782       strsize = info->strsec->_raw_size;
 783     }
 784   else
 785     {
 786       long reloc_size, reloc_count;
 787       arelent **reloc_vector;
 788
 789       info = (struct stab_find_info *) bfd_zalloc (abfd, sizeof *info);
 790       if (info == NULL)
 791         return false;
 792
 793       /* FIXME: When using the linker --split-by-file or
 794          --split-by-reloc options, it is possible for the .stab and
 795          .stabstr sections to be split.  We should handle that.  */
 796
 797       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
 798       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
 799
 800       if (info->stabsec == NULL || info->strsec == NULL)
 801         {
 802           /* No stabs debugging information.  Set *pinfo so that we
 803              can return quickly in the info != NULL case above.  */
 804           *pinfo = (PTR) info;
 805           return true;
 806         }
 807
 808       stabsize = info->stabsec->_raw_size;
 809       strsize = info->strsec->_raw_size;
 810
 811       info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
 812       info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
 813       if (info->stabs == NULL || info->strs == NULL)
 814         return false;
 815
 816       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs, 0,
 817                                       stabsize)
 818           || ! bfd_get_section_contents (abfd, info->strsec, info->strs, 0,
 819                                          strsize))
 820         return false;
 821
 822       /* If this is a relocateable object file, we have to relocate
 823          the entries in .stab.  This should always be simple 32 bit
 824          relocations against symbols defined in this object file, so
 825          this should be no big deal.  */
 826       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
 827       if (reloc_size < 0)
 828         return false;
 829       reloc_vector = (arelent **) bfd_malloc (reloc_size);
 830       if (reloc_vector == NULL && reloc_size != 0)
 831         return false;
 832       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
 833                                             symbols);
 834       if (reloc_count < 0)
 835         {
 836           if (reloc_vector != NULL)
 837             free (reloc_vector);
 838           return false;
 839         }
 840       if (reloc_count > 0)
 841         {
 842           arelent **pr;
 843
 844           for (pr = reloc_vector; *pr != NULL; pr++)
 845             {
 846               arelent *r;
 847               unsigned long val;
 848               asymbol *sym;
 849
 850               r = *pr;
 851               if (r->howto->rightshift != 0
 852                   || r->howto->size != 2
 853                   || r->howto->bitsize != 32
 854                   || r->howto->pc_relative
 855                   || r->howto->bitpos != 0
 856                   || r->howto->dst_mask != 0xffffffff)
 857                 {
 858                   (*_bfd_error_handler)
 859                     ("Unsupported .stab relocation");
 860                   bfd_set_error (bfd_error_invalid_operation);
 861                   if (reloc_vector != NULL)
 862                     free (reloc_vector);
 863                   return false;
 864                 }
 865
 866               val = bfd_get_32 (abfd, info->stabs + r->address);
 867               val &= r->howto->src_mask;
 868               sym = *r->sym_ptr_ptr;
 869               val += sym->value + sym->section->vma + r->addend;
 870               bfd_put_32 (abfd, val, info->stabs + r->address);
 871             }
 872         }
 873
 874       if (reloc_vector != NULL)
 875         free (reloc_vector);
 876
 877       *pinfo = (PTR) info;
 878     }
 879
 880   /* We are passed a section relative offset.  The offsets in the
 881      stabs information are absolute.  */
 882   offset += bfd_get_section_vma (abfd, section);
 883
 884   /* Stabs entries use a 12 byte format:
 885        4 byte string table index
 886        1 byte stab type
 887        1 byte stab other field
 888        2 byte stab desc field
 889        4 byte stab value
 890      FIXME: This will have to change for a 64 bit object format.
 891
 892      The stabs symbols are divided into compilation units.  For the
 893      first entry in each unit, the type of 0, the value is the length
 894      of the string table for this unit, and the desc field is the
 895      number of stabs symbols for this unit.  */
 896
 897 #define STRDXOFF (0)
 898 #define TYPEOFF (4)
 899 #define OTHEROFF (5)
 900 #define DESCOFF (6)
 901 #define VALOFF (8)
 902 #define STABSIZE (12)
 903
 904   /* It would be nice if we could skip ahead to the stabs symbols for
 905      the next compilation unit to quickly scan through the compilation
 906      units.  Unfortunately, since each line number gets a separate
 907      stabs entry, it is entirely plausible that a large source file
 908      will overflow the 16 bit count of stabs entries.  */
 909   fnaddr = 0;
 910   directory_name = NULL;
 911   main_file_name = NULL;
 912   current_file_name = NULL;
 913   line_file_name = NULL;
 914   fnname = NULL;
 915   low_func_vma = 0;
 916   low_line_vma = 0;
 917
 918   stabend = info->stabs + stabsize;
 919
 920   if (info->cached_stab == NULL || offset < info->cached_offset)
 921     {
 922       stab = info->stabs;
 923       str = info->strs;
 924       stroff = 0;
 925     }
 926   else
 927     {
 928       stab = info->cached_stab;
 929       str = info->cached_str;
 930       stroff = info->cached_stroff;
 931     }
 932
 933   info->cached_offset = offset;
 934
 935   for (; stab < stabend; stab += STABSIZE)
 936     {
 937       boolean done;
 938       bfd_vma val;
 939       char *name;
 940
 941       done = false;
 942
 943       switch (stab[TYPEOFF])
 944         {
 945         case 0:
 946           /* This is the first entry in a compilation unit.  */
 947           if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
 948             {
 949               done = true;
 950               break;
 951             }
 952           str += stroff;
 953           stroff = bfd_get_32 (abfd, stab + VALOFF);
 954           break;
 955
 956         case N_SO:
 957           /* The main file name.  */
 958
 959           val = bfd_get_32 (abfd, stab + VALOFF);
 960           if (val > offset)
 961             {
 962               done = true;
 963               break;
 964             }
 965
 966           name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
 967
 968           /* An empty string indicates the end of the compilation
 969              unit.  */
 970           if (*name == '\0')
 971             {
 972               /* If there are functions in different sections, they
 973                  may have addresses larger than val, but we don't want
 974                  to forget the file name.  When there are functions in
 975                  different cases, there is supposed to be an N_FUN at
 976                  the end of the function indicating where it ends.  */
 977               if (low_func_vma < val || fnname == NULL)
 978                 main_file_name = NULL;
 979               break;
 980             }
 981
 982           /* We know that we have to get to at least this point in the
 983              stabs entries for this offset.  */
 984           info->cached_stab = stab;
 985           info->cached_str = str;
 986           info->cached_stroff = stroff;
 987
 988           current_file_name = name;
 989
 990           /* Look ahead to the next symbol.  Two consecutive N_SO
 991              symbols are a directory and a file name.  */
 992           if (stab + STABSIZE >= stabend
 993               || *(stab + STABSIZE + TYPEOFF) != N_SO)
 994             directory_name = NULL;
 995           else
 996             {
 997               stab += STABSIZE;
 998               directory_name = current_file_name;
 999               current_file_name = ((char *) str
1000                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1001             }
1002
1003           main_file_name = current_file_name;
1004
1005           break;
1006
1007         case N_SOL:
1008           /* The name of an include file.  */
1009           current_file_name = ((char *) str
1010                                + bfd_get_32 (abfd, stab + STRDXOFF));
1011           break;
1012
1013         case N_SLINE:
1014         case N_DSLINE:
1015         case N_BSLINE:
1016           /* A line number.  The value is relative to the start of the
1017              current function.  */
1018           val = fnaddr + bfd_get_32 (abfd, stab + VALOFF);
1019           if (val >= low_line_vma && val <= offset)
1020             {
1021               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1022               low_line_vma = val;
1023               line_file_name = current_file_name;
1024             }
1025           break;
1026
1027         case N_FUN:
1028           /* A function name.  */
1029           val = bfd_get_32 (abfd, stab + VALOFF);
1030           name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1031
1032           /* An empty string here indicates the end of a function, and
1033              the value is relative to fnaddr.  */
1034
1035           if (*name == '\0')
1036             {
1037               val += fnaddr;
1038               if (val >= low_func_vma && val < offset)
1039                 fnname = NULL;
1040             }
1041           else
1042             {
1043               if (val >= low_func_vma && val <= offset)
1044                 {
1045                   fnname = name;
1046                   low_func_vma = val;
1047                 }
1048
1049                fnaddr = val;
1050              }
1051
1052           break;
1053         }
1054
1055       if (done)
1056         break;
1057     }
1058
1059   if (main_file_name == NULL)
1060     {
1061       /* No information found.  */
1062       return true;
1063     }
1064
1065   *pfound = true;
1066
1067   if (*pline != 0)
1068     main_file_name = line_file_name;
1069
1070   if (main_file_name != NULL)
1071     {
1072       if (main_file_name[0] == '/' || directory_name == NULL)
1073         *pfilename = main_file_name;
1074       else
1075         {
1076           size_t dirlen;
1077
1078           dirlen = strlen (directory_name);
1079           if (info->filename == NULL
1080               || strncmp (info->filename, directory_name, dirlen) != 0
1081               || strcmp (info->filename + dirlen, main_file_name) != 0)
1082             {
1083               if (info->filename != NULL)
1084                 free (info->filename);
1085               info->filename = (char *) bfd_malloc (dirlen +
1086                                                     strlen (main_file_name)
1087                                                     + 1);
1088               if (info->filename == NULL)
1089                 return false;
1090               strcpy (info->filename, directory_name);
1091               strcpy (info->filename + dirlen, main_file_name);
1092             }
1093
1094           *pfilename = info->filename;
1095         }
1096     }
1097
1098   if (fnname != NULL)
1099     {
1100       char *s;
1101
1102       /* This will typically be something like main:F(0,1), so we want
1103          to clobber the colon.  It's OK to change the name, since the
1104          string is in our own local storage anyhow.  */
1105
1106       s = strchr (fnname, ':');
1107       if (s != NULL)
1108         *s = '\0';
1109
1110       *pfnname = fnname;
1111     }
1112
1113   return true;
1114 }