bfd/syms.c

   1 /* Generic symbol-table support for the BFD library.
   2    Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /*
  22 SECTION
  23         Symbols
  24
  25         BFD tries to maintain as much symbol information as it can when
  26         it moves information from file to file. BFD passes information
  27         to applications though the <<asymbol>> structure. When the
  28         application requests the symbol table, BFD reads the table in
  29         the native form and translates parts of it into the internal
  30         format. To maintain more than the information passed to
  31         applications, some targets keep some information ``behind the
  32         scenes'' in a structure only the particular back end knows
  33         about. For example, the coff back end keeps the original
  34         symbol table structure as well as the canonical structure when
  35         a BFD is read in. On output, the coff back end can reconstruct
  36         the output symbol table so that no information is lost, even
  37         information unique to coff which BFD doesn't know or
  38         understand. If a coff symbol table were read, but were written
  39         through an a.out back end, all the coff specific information
  40         would be lost. The symbol table of a BFD
  41         is not necessarily read in until a canonicalize request is
  42         made. Then the BFD back end fills in a table provided by the
  43         application with pointers to the canonical information.  To
  44         output symbols, the application provides BFD with a table of
  45         pointers to pointers to <<asymbol>>s. This allows applications
  46         like the linker to output a symbol as it was read, since the ``behind
  47         the scenes'' information will be still available.
  48 @menu
  49 @* Reading Symbols::
  50 @* Writing Symbols::
  51 @* Mini Symbols::
  52 @* typedef asymbol::
  53 @* symbol handling functions::
  54 @end menu
  55
  56 INODE
  57 Reading Symbols, Writing Symbols, Symbols, Symbols
  58 SUBSECTION
  59         Reading symbols
  60
  61         There are two stages to reading a symbol table from a BFD:
  62         allocating storage, and the actual reading process. This is an
  63         excerpt from an application which reads the symbol table:
  64
  65 |         long storage_needed;
  66 |         asymbol **symbol_table;
  67 |         long number_of_symbols;
  68 |         long i;
  69 |
  70 |         storage_needed = bfd_get_symtab_upper_bound (abfd);
  71 |
  72 |         if (storage_needed < 0)
  73 |           FAIL
  74 |
  75 |         if (storage_needed == 0) {
  76 |            return ;
  77 |         }
  78 |         symbol_table = (asymbol **) xmalloc (storage_needed);
  79 |           ...
  80 |         number_of_symbols =
  81 |            bfd_canonicalize_symtab (abfd, symbol_table);
  82 |
  83 |         if (number_of_symbols < 0)
  84 |           FAIL
  85 |
  86 |         for (i = 0; i < number_of_symbols; i++) {
  87 |            process_symbol (symbol_table[i]);
  88 |         }
  89
  90         All storage for the symbols themselves is in an obstack
  91         connected to the BFD; it is freed when the BFD is closed.
  92
  93
  94 INODE
  95 Writing Symbols, Mini Symbols, Reading Symbols, Symbols
  96 SUBSECTION
  97         Writing symbols
  98
  99         Writing of a symbol table is automatic when a BFD open for
 100         writing is closed. The application attaches a vector of
 101         pointers to pointers to symbols to the BFD being written, and
 102         fills in the symbol count. The close and cleanup code reads
 103         through the table provided and performs all the necessary
 104         operations. The BFD output code must always be provided with an
 105         ``owned'' symbol: one which has come from another BFD, or one
 106         which has been created using <<bfd_make_empty_symbol>>.  Here is an
 107         example showing the creation of a symbol table with only one element:
 108
 109 |       #include "bfd.h"
 110 |       main()
 111 |       {
 112 |         bfd *abfd;
 113 |         asymbol *ptrs[2];
 114 |         asymbol *new;
 115 |
 116 |         abfd = bfd_openw("foo","a.out-sunos-big");
 117 |         bfd_set_format(abfd, bfd_object);
 118 |         new = bfd_make_empty_symbol(abfd);
 119 |         new->name = "dummy_symbol";
 120 |         new->section = bfd_make_section_old_way(abfd, ".text");
 121 |         new->flags = BSF_GLOBAL;
 122 |         new->value = 0x12345;
 123 |
 124 |         ptrs[0] = new;
 125 |         ptrs[1] = (asymbol *)0;
 126 |
 127 |         bfd_set_symtab(abfd, ptrs, 1);
 128 |         bfd_close(abfd);
 129 |       }
 130 |
 131 |       ./makesym
 132 |       nm foo
 133 |       00012345 A dummy_symbol
 134
 135         Many formats cannot represent arbitary symbol information; for
 136         instance, the <<a.out>> object format does not allow an
 137         arbitary number of sections. A symbol pointing to a section
 138         which is not one  of <<.text>>, <<.data>> or <<.bss>> cannot
 139         be described.
 140
 141 INODE
 142 Mini Symbols, typedef asymbol, Writing Symbols, Symbols
 143 SUBSECTION
 144         Mini Symbols
 145
 146         Mini symbols provide read-only access to the symbol table.
 147         They use less memory space, but require more time to access.
 148         They can be useful for tools like nm or objdump, which may
 149         have to handle symbol tables of extremely large executables.
 150
 151         The <<bfd_read_minisymbols>> function will read the symbols
 152         into memory in an internal form.  It will return a <<void *>>
 153         pointer to a block of memory, a symbol count, and the size of
 154         each symbol.  The pointer is allocated using <<malloc>>, and
 155         should be freed by the caller when it is no longer needed.
 156
 157         The function <<bfd_minisymbol_to_symbol>> will take a pointer
 158         to a minisymbol, and a pointer to a structure returned by
 159         <<bfd_make_empty_symbol>>, and return a <<asymbol>> structure.
 160         The return value may or may not be the same as the value from
 161         <<bfd_make_empty_symbol>> which was passed in.
 162
 163 */
 164
 165
 166
 167 /*
 168 DOCDD
 169 INODE
 170 typedef asymbol, symbol handling functions, Mini Symbols, Symbols
 171
 172 */
 173 /*
 174 SUBSECTION
 175         typedef asymbol
 176
 177         An <<asymbol>> has the form:
 178
 179 */
 180
 181 /*
 182 CODE_FRAGMENT
 183
 184 .
 185 .typedef struct symbol_cache_entry
 186 .{
 187 .       {* A pointer to the BFD which owns the symbol. This information
 188 .          is necessary so that a back end can work out what additional
 189 .          information (invisible to the application writer) is carried
 190 .          with the symbol.
 191 .
 192 .          This field is *almost* redundant, since you can use section->owner
 193 .          instead, except that some symbols point to the global sections
 194 .          bfd_{abs,com,und}_section.  This could be fixed by making
 195 .          these globals be per-bfd (or per-target-flavor).  FIXME. *}
 196 .
 197 .  struct _bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field. *}
 198 .
 199 .       {* The text of the symbol. The name is left alone, and not copied; the
 200 .          application may not alter it. *}
 201 .  CONST char *name;
 202 .
 203 .       {* The value of the symbol.  This really should be a union of a
 204 .          numeric value with a pointer, since some flags indicate that
 205 .          a pointer to another symbol is stored here.  *}
 206 .  symvalue value;
 207 .
 208 .       {* Attributes of a symbol: *}
 209 .
 210 .#define BSF_NO_FLAGS    0x00
 211 .
 212 .       {* The symbol has local scope; <<static>> in <<C>>. The value
 213 .          is the offset into the section of the data. *}
 214 .#define BSF_LOCAL      0x01
 215 .
 216 .       {* The symbol has global scope; initialized data in <<C>>. The
 217 .          value is the offset into the section of the data. *}
 218 .#define BSF_GLOBAL     0x02
 219 .
 220 .       {* The symbol has global scope and is exported. The value is
 221 .          the offset into the section of the data. *}
 222 .#define BSF_EXPORT     BSF_GLOBAL {* no real difference *}
 223 .
 224 .       {* A normal C symbol would be one of:
 225 .          <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or
 226 .          <<BSF_GLOBAL>> *}
 227 .
 228 .       {* The symbol is a debugging record. The value has an arbitary
 229 .          meaning. *}
 230 .#define BSF_DEBUGGING  0x08
 231 .
 232 .       {* The symbol denotes a function entry point.  Used in ELF,
 233 .          perhaps others someday.  *}
 234 .#define BSF_FUNCTION    0x10
 235 .
 236 .       {* Used by the linker. *}
 237 .#define BSF_KEEP        0x20
 238 .#define BSF_KEEP_G      0x40
 239 .
 240 .       {* A weak global symbol, overridable without warnings by
 241 .          a regular global symbol of the same name.  *}
 242 .#define BSF_WEAK        0x80
 243 .
 244 .       {* This symbol was created to point to a section, e.g. ELF's
 245 .          STT_SECTION symbols.  *}
 246 .#define BSF_SECTION_SYM 0x100
 247 .
 248 .       {* The symbol used to be a common symbol, but now it is
 249 .          allocated. *}
 250 .#define BSF_OLD_COMMON  0x200
 251 .
 252 .       {* The default value for common data. *}
 253 .#define BFD_FORT_COMM_DEFAULT_VALUE 0
 254 .
 255 .       {* In some files the type of a symbol sometimes alters its
 256 .          location in an output file - ie in coff a <<ISFCN>> symbol
 257 .          which is also <<C_EXT>> symbol appears where it was
 258 .          declared and not at the end of a section.  This bit is set
 259 .          by the target BFD part to convey this information. *}
 260 .
 261 .#define BSF_NOT_AT_END    0x400
 262 .
 263 .       {* Signal that the symbol is the label of constructor section. *}
 264 .#define BSF_CONSTRUCTOR   0x800
 265 .
 266 .       {* Signal that the symbol is a warning symbol.  The name is a
 267 .          warning.  The name of the next symbol is the one to warn about;
 268 .          if a reference is made to a symbol with the same name as the next
 269 .          symbol, a warning is issued by the linker. *}
 270 .#define BSF_WARNING       0x1000
 271 .
 272 .       {* Signal that the symbol is indirect.  This symbol is an indirect
 273 .          pointer to the symbol with the same name as the next symbol. *}
 274 .#define BSF_INDIRECT      0x2000
 275 .
 276 .       {* BSF_FILE marks symbols that contain a file name.  This is used
 277 .          for ELF STT_FILE symbols.  *}
 278 .#define BSF_FILE          0x4000
 279 .
 280 .       {* Symbol is from dynamic linking information.  *}
 281 .#define BSF_DYNAMIC       0x8000
 282 .
 283 .       {* The symbol denotes a data object.  Used in ELF, and perhaps
 284 .          others someday.  *}
 285 .#define BSF_OBJECT        0x10000
 286 .
 287 .  flagword flags;
 288 .
 289 .       {* A pointer to the section to which this symbol is
 290 .          relative.  This will always be non NULL, there are special
 291 .          sections for undefined and absolute symbols.  *}
 292 .  struct sec *section;
 293 .
 294 .       {* Back end special data.  *}
 295 .  union
 296 .    {
 297 .      PTR p;
 298 .      bfd_vma i;
 299 .    } udata;
 300 .
 301 .} asymbol;
 302 */
 303
 304 #include "bfd.h"
 305 #include "sysdep.h"
 306 #include "libbfd.h"
 307 #include "bfdlink.h"
 308 #include "aout/stab_gnu.h"
 309
 310 /*
 311 DOCDD
 312 INODE
 313 symbol handling functions,  , typedef asymbol, Symbols
 314 SUBSECTION
 315         Symbol handling functions
 316 */
 317
 318 /*
 319 FUNCTION
 320         bfd_get_symtab_upper_bound
 321
 322 DESCRIPTION
 323         Return the number of bytes required to store a vector of pointers
 324         to <<asymbols>> for all the symbols in the BFD @var{abfd},
 325         including a terminal NULL pointer. If there are no symbols in
 326         the BFD, then return 0.  If an error occurs, return -1.
 327
 328 .#define bfd_get_symtab_upper_bound(abfd) \
 329 .     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
 330
 331 */
 332
 333 /*
 334 FUNCTION
 335         bfd_is_local_label
 336
 337 SYNOPSIS
 338         boolean bfd_is_local_label(bfd *abfd, asymbol *sym);
 339
 340 DESCRIPTION
 341         Return true if the given symbol @var{sym} in the BFD @var{abfd} is
 342         a compiler generated local label, else return false.
 343 .#define bfd_is_local_label(abfd, sym) \
 344 .     BFD_SEND (abfd, _bfd_is_local_label,(abfd, sym))
 345 */
 346
 347 /*
 348 FUNCTION
 349         bfd_canonicalize_symtab
 350
 351 DESCRIPTION
 352         Read the symbols from the BFD @var{abfd}, and fills in
 353         the vector @var{location} with pointers to the symbols and
 354         a trailing NULL.
 355         Return the actual number of symbol pointers, not
 356         including the NULL.
 357
 358
 359 .#define bfd_canonicalize_symtab(abfd, location) \
 360 .     BFD_SEND (abfd, _bfd_canonicalize_symtab,\
 361 .                  (abfd, location))
 362
 363 */
 364
 365
 366 /*
 367 FUNCTION
 368         bfd_set_symtab
 369
 370 SYNOPSIS
 371         boolean bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int count);
 372
 373 DESCRIPTION
 374         Arrange that when the output BFD @var{abfd} is closed,
 375         the table @var{location} of @var{count} pointers to symbols
 376         will be written.
 377 */
 378
 379 boolean
 380 bfd_set_symtab (abfd, location, symcount)
 381      bfd *abfd;
 382      asymbol **location;
 383      unsigned int symcount;
 384 {
 385   if ((abfd->format != bfd_object) || (bfd_read_p (abfd)))
 386     {
 387       bfd_set_error (bfd_error_invalid_operation);
 388       return false;
 389     }
 390
 391   bfd_get_outsymbols (abfd) = location;
 392   bfd_get_symcount (abfd) = symcount;
 393   return true;
 394 }
 395
 396 /*
 397 FUNCTION
 398         bfd_print_symbol_vandf
 399
 400 SYNOPSIS
 401         void bfd_print_symbol_vandf(PTR file, asymbol *symbol);
 402
 403 DESCRIPTION
 404         Print the value and flags of the @var{symbol} supplied to the
 405         stream @var{file}.
 406 */
 407 void
 408 bfd_print_symbol_vandf (arg, symbol)
 409      PTR arg;
 410      asymbol *symbol;
 411 {
 412   FILE *file = (FILE *) arg;
 413   flagword type = symbol->flags;
 414   if (symbol->section != (asection *) NULL)
 415     {
 416       fprintf_vma (file, symbol->value + symbol->section->vma);
 417     }
 418   else
 419     {
 420       fprintf_vma (file, symbol->value);
 421     }
 422
 423   /* This presumes that a symbol can not be both BSF_DEBUGGING and
 424      BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
 425      BSF_OBJECT.  */
 426   fprintf (file, " %c%c%c%c%c%c%c",
 427            ((type & BSF_LOCAL)
 428             ? (type & BSF_GLOBAL) ? '!' : 'l'
 429             : (type & BSF_GLOBAL) ? 'g' : ' '),
 430            (type & BSF_WEAK) ? 'w' : ' ',
 431            (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
 432            (type & BSF_WARNING) ? 'W' : ' ',
 433            (type & BSF_INDIRECT) ? 'I' : ' ',
 434            (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
 435            ((type & BSF_FUNCTION)
 436             ? 'F'
 437             : ((type & BSF_FILE)
 438                ? 'f'
 439                : ((type & BSF_OBJECT) ? 'O' : ' '))));
 440 }
 441
 442
 443 /*
 444 FUNCTION
 445         bfd_make_empty_symbol
 446
 447 DESCRIPTION
 448         Create a new <<asymbol>> structure for the BFD @var{abfd}
 449         and return a pointer to it.
 450
 451         This routine is necessary because each back end has private
 452         information surrounding the <<asymbol>>. Building your own
 453         <<asymbol>> and pointing to it will not create the private
 454         information, and will cause problems later on.
 455
 456 .#define bfd_make_empty_symbol(abfd) \
 457 .     BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
 458 */
 459
 460 /*
 461 FUNCTION
 462         bfd_make_debug_symbol
 463
 464 DESCRIPTION
 465         Create a new <<asymbol>> structure for the BFD @var{abfd},
 466         to be used as a debugging symbol.  Further details of its use have
 467         yet to be worked out.
 468
 469 .#define bfd_make_debug_symbol(abfd,ptr,size) \
 470 .        BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
 471 */
 472
 473 struct section_to_type
 474 {
 475   CONST char *section;
 476   char type;
 477 };
 478
 479 /* Map section names to POSIX/BSD single-character symbol types.
 480    This table is probably incomplete.  It is sorted for convenience of
 481    adding entries.  Since it is so short, a linear search is used.  */
 482 static CONST struct section_to_type stt[] =
 483 {
 484   {"*DEBUG*", 'N'},
 485   {".bss", 'b'},
 486   {".data", 'd'},
 487   {".rdata", 'r'},              /* Read only data.  */
 488   {".rodata", 'r'},             /* Read only data.  */
 489   {".sbss", 's'},               /* Small BSS (uninitialized data).  */
 490   {".scommon", 'c'},            /* Small common.  */
 491   {".sdata", 'g'},              /* Small initialized data.  */
 492   {".text", 't'},
 493   {0, 0}
 494 };
 495
 496 /* Return the single-character symbol type corresponding to
 497    section S, or '?' for an unknown COFF section.
 498
 499    Check for any leading string which matches, so .text5 returns
 500    't' as well as .text */
 501
 502 static char
 503 coff_section_type (s)
 504      char *s;
 505 {
 506   CONST struct section_to_type *t;
 507
 508   for (t = &stt[0]; t->section; t++)
 509     if (!strncmp (s, t->section, strlen (t->section)))
 510       return t->type;
 511
 512   return '?';
 513 }
 514
 515 #ifndef islower
 516 #define islower(c) ((c) >= 'a' && (c) <= 'z')
 517 #endif
 518 #ifndef toupper
 519 #define toupper(c) (islower(c) ? ((c) & ~0x20) : (c))
 520 #endif
 521
 522 /*
 523 FUNCTION
 524         bfd_decode_symclass
 525
 526 DESCRIPTION
 527         Return a character corresponding to the symbol
 528         class of @var{symbol}, or '?' for an unknown class.
 529
 530 SYNOPSIS
 531         int bfd_decode_symclass(asymbol *symbol);
 532 */
 533 int
 534 bfd_decode_symclass (symbol)
 535      asymbol *symbol;
 536 {
 537   char c;
 538
 539   if (bfd_is_com_section (symbol->section))
 540     return 'C';
 541   if (bfd_is_und_section (symbol->section))
 542     return 'U';
 543   if (bfd_is_ind_section (symbol->section))
 544     return 'I';
 545   if (symbol->flags & BSF_WEAK)
 546     return 'W';
 547   if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
 548     return '?';
 549
 550   if (bfd_is_abs_section (symbol->section))
 551     c = 'a';
 552   else if (symbol->section)
 553     c = coff_section_type (symbol->section->name);
 554   else
 555     return '?';
 556   if (symbol->flags & BSF_GLOBAL)
 557     c = toupper (c);
 558   return c;
 559
 560   /* We don't have to handle these cases just yet, but we will soon:
 561      N_SETV: 'v';
 562      N_SETA: 'l';
 563      N_SETT: 'x';
 564      N_SETD: 'z';
 565      N_SETB: 's';
 566      N_INDR: 'i';
 567      */
 568 }
 569
 570 /*
 571 FUNCTION
 572         bfd_symbol_info
 573
 574 DESCRIPTION
 575         Fill in the basic info about symbol that nm needs.
 576         Additional info may be added by the back-ends after
 577         calling this function.
 578
 579 SYNOPSIS
 580         void bfd_symbol_info(asymbol *symbol, symbol_info *ret);
 581 */
 582
 583 void
 584 bfd_symbol_info (symbol, ret)
 585      asymbol *symbol;
 586      symbol_info *ret;
 587 {
 588   ret->type = bfd_decode_symclass (symbol);
 589   if (ret->type != 'U')
 590     ret->value = symbol->value + symbol->section->vma;
 591   else
 592     ret->value = 0;
 593   ret->name = symbol->name;
 594 }
 595
 596 void
 597 bfd_symbol_is_absolute ()
 598 {
 599   abort ();
 600 }
 601
 602 /*
 603 FUNCTION
 604         bfd_copy_private_symbol_data
 605
 606 SYNOPSIS
 607         boolean bfd_copy_private_symbol_data(bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
 608
 609 DESCRIPTION
 610         Copy private symbol information from @var{isym} in the BFD
 611         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
 612         Return <<true>> on success, <<false>> on error.  Possible error
 613         returns are:
 614
 615         o <<bfd_error_no_memory>> -
 616         Not enough memory exists to create private data for @var{osec}.
 617
 618 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
 619 .     BFD_SEND (ibfd, _bfd_copy_private_symbol_data, \
 620 .               (ibfd, isymbol, obfd, osymbol))
 621
 622 */
 623
 624 /* The generic version of the function which returns mini symbols.
 625    This is used when the backend does not provide a more efficient
 626    version.  It just uses BFD asymbol structures as mini symbols.  */
 627
 628 long
 629 _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep)
 630      bfd *abfd;
 631      boolean dynamic;
 632      PTR *minisymsp;
 633      unsigned int *sizep;
 634 {
 635   long storage;
 636   asymbol **syms = NULL;
 637   long symcount;
 638
 639   if (dynamic)
 640     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 641   else
 642     storage = bfd_get_symtab_upper_bound (abfd);
 643   if (storage < 0)
 644     goto error_return;
 645
 646   syms = (asymbol **) bfd_malloc ((size_t) storage);
 647   if (syms == NULL)
 648     goto error_return;
 649
 650   if (dynamic)
 651     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
 652   else
 653     symcount = bfd_canonicalize_symtab (abfd, syms);
 654   if (symcount < 0)
 655     goto error_return;
 656
 657   *minisymsp = (PTR) syms;
 658   *sizep = sizeof (asymbol *);
 659   return symcount;
 660
 661  error_return:
 662   if (syms != NULL)
 663     free (syms);
 664   return -1;
 665 }
 666
 667 /* The generic version of the function which converts a minisymbol to
 668    an asymbol.  We don't worry about the sym argument we are passed;
 669    we just return the asymbol the minisymbol points to.  */
 670
 671 /*ARGSUSED*/
 672 asymbol *
 673 _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
 674      bfd *abfd;
 675      boolean dynamic;
 676      const PTR minisym;
 677      asymbol *sym;
 678 {
 679   return *(asymbol **) minisym;
 680 }
 681
 682 /* Look through stabs debugging information in .stab and .stabstr
 683    sections to find the source file and line closest to a desired
 684    location.  This is used by COFF and ELF targets.  It sets *pfound
 685    to true if it finds some information.  The *pinfo field is used to
 686    pass cached information in and out of this routine; this first time
 687    the routine is called for a BFD, *pinfo should be NULL.  The value
 688    placed in *pinfo should be saved with the BFD, and passed back each
 689    time this function is called.  */
 690
 691 /* A pointer to this structure is stored in *pinfo.  */
 692
 693 struct stab_find_info
 694 {
 695   /* The .stab section.  */
 696   asection *stabsec;
 697   /* The .stabstr section.  */
 698   asection *strsec;
 699   /* The contents of the .stab section.  */
 700   bfd_byte *stabs;
 701   /* The contents of the .stabstr section.  */
 702   bfd_byte *strs;
 703   /* An malloc buffer to hold the file name.  */
 704   char *filename;
 705   /* Cached values to restart quickly.  */
 706   bfd_vma cached_offset;
 707   bfd_byte *cached_stab;
 708   bfd_byte *cached_str;
 709   bfd_size_type cached_stroff;
 710 };
 711
 712 boolean
 713 _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
 714                                      pfilename, pfnname, pline, pinfo)
 715      bfd *abfd;
 716      asymbol **symbols;
 717      asection *section;
 718      bfd_vma offset;
 719      boolean *pfound;
 720      const char **pfilename;
 721      const char **pfnname;
 722      unsigned int *pline;
 723      PTR *pinfo;
 724 {
 725   struct stab_find_info *info;
 726   bfd_size_type stabsize, strsize;
 727   bfd_byte *stab, *stabend, *str;
 728   bfd_size_type stroff;
 729   bfd_vma fnaddr;
 730   char *directory_name, *main_file_name, *current_file_name, *line_file_name;
 731   char *fnname;
 732   bfd_vma low_func_vma, low_line_vma;
 733
 734   *pfound = false;
 735   *pfilename = bfd_get_filename (abfd);
 736   *pfnname = NULL;
 737   *pline = 0;
 738
 739   info = (struct stab_find_info *) *pinfo;
 740   if (info != NULL)
 741     {
 742       if (info->stabsec == NULL || info->strsec == NULL)
 743         {
 744           /* No stabs debugging information.  */
 745           return true;
 746         }
 747
 748       stabsize = info->stabsec->_raw_size;
 749       strsize = info->strsec->_raw_size;
 750     }
 751   else
 752     {
 753       long reloc_size, reloc_count;
 754       arelent **reloc_vector;
 755
 756       info = (struct stab_find_info *) bfd_zalloc (abfd, sizeof *info);
 757       if (info == NULL)
 758         return false;
 759
 760       /* FIXME: When using the linker --split-by-file or
 761          --split-by-reloc options, it is possible for the .stab and
 762          .stabstr sections to be split.  We should handle that.  */
 763
 764       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
 765       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
 766
 767       if (info->stabsec == NULL || info->strsec == NULL)
 768         {
 769           /* No stabs debugging information.  Set *pinfo so that we
 770              can return quickly in the info != NULL case above.  */
 771           *pinfo = info;
 772           return true;
 773         }
 774
 775       stabsize = info->stabsec->_raw_size;
 776       strsize = info->strsec->_raw_size;
 777
 778       info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
 779       info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
 780       if (info->stabs == NULL || info->strs == NULL)
 781         return false;
 782
 783       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs, 0,
 784                                       stabsize)
 785           || ! bfd_get_section_contents (abfd, info->strsec, info->strs, 0,
 786                                          strsize))
 787         return false;
 788
 789       /* If this is a relocateable object file, we have to relocate
 790          the entries in .stab.  This should always be simple 32 bit
 791          relocations against symbols defined in this object file, so
 792          this should be no big deal.  */
 793       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
 794       if (reloc_size < 0)
 795         return false;
 796       reloc_vector = (arelent **) bfd_malloc (reloc_size);
 797       if (reloc_vector == NULL && reloc_size != 0)
 798         return false;
 799       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
 800                                             symbols);
 801       if (reloc_count < 0)
 802         {
 803           if (reloc_vector != NULL)
 804             free (reloc_vector);
 805           return false;
 806         }
 807       if (reloc_count > 0)
 808         {
 809           arelent **pr;
 810
 811           for (pr = reloc_vector; *pr != NULL; pr++)
 812             {
 813               arelent *r;
 814               unsigned long val;
 815               asymbol *sym;
 816
 817               r = *pr;
 818               if (r->howto->rightshift != 0
 819                   || r->howto->size != 2
 820                   || r->howto->bitsize != 32
 821                   || r->howto->pc_relative
 822                   || r->howto->bitpos != 0
 823                   || r->howto->dst_mask != 0xffffffff)
 824                 {
 825                   (*_bfd_error_handler)
 826                     ("Unsupported .stab relocation");
 827                   bfd_set_error (bfd_error_invalid_operation);
 828                   if (reloc_vector != NULL)
 829                     free (reloc_vector);
 830                   return false;
 831                 }
 832
 833               val = bfd_get_32 (abfd, info->stabs + r->address);
 834               val &= r->howto->src_mask;
 835               sym = *r->sym_ptr_ptr;
 836               val += sym->value + sym->section->vma + r->addend;
 837               bfd_put_32 (abfd, val, info->stabs + r->address);
 838             }
 839         }
 840
 841       if (reloc_vector != NULL)
 842         free (reloc_vector);
 843
 844       *pinfo = info;
 845     }
 846
 847   /* We are passed a section relative offset.  The offsets in the
 848      stabs information are absolute.  */
 849   offset += bfd_get_section_vma (abfd, section);
 850
 851   /* Stabs entries use a 12 byte format:
 852        4 byte string table index
 853        1 byte stab type
 854        1 byte stab other field
 855        2 byte stab desc field
 856        4 byte stab value
 857      FIXME: This will have to change for a 64 bit object format.
 858
 859      The stabs symbols are divided into compilation units.  For the
 860      first entry in each unit, the type of 0, the value is the length
 861      of the string table for this unit, and the desc field is the
 862      number of stabs symbols for this unit.  */
 863
 864 #define STRDXOFF (0)
 865 #define TYPEOFF (4)
 866 #define OTHEROFF (5)
 867 #define DESCOFF (6)
 868 #define VALOFF (8)
 869 #define STABSIZE (12)
 870
 871   /* It would be nice if we could skip ahead to the stabs symbols for
 872      the next compilation unit to quickly scan through the compilation
 873      units.  Unfortunately, since each line number gets a separate
 874      stabs entry, it is entirely plausible that a large source file
 875      will overflow the 16 bit count of stabs entries.  */
 876   fnaddr = 0;
 877   directory_name = NULL;
 878   main_file_name = NULL;
 879   current_file_name = NULL;
 880   line_file_name = NULL;
 881   fnname = NULL;
 882   low_func_vma = 0;
 883   low_line_vma = 0;
 884
 885   stabend = info->stabs + stabsize;
 886
 887   if (info->cached_stab == NULL || offset < info->cached_offset)
 888     {
 889       stab = info->stabs;
 890       str = info->strs;
 891       stroff = 0;
 892     }
 893   else
 894     {
 895       stab = info->cached_stab;
 896       str = info->cached_str;
 897       stroff = info->cached_stroff;
 898     }
 899
 900   info->cached_offset = offset;
 901
 902   for (; stab < stabend; stab += STABSIZE)
 903     {
 904       boolean done;
 905       bfd_vma val;
 906       char *name;
 907
 908       done = false;
 909
 910       switch (stab[TYPEOFF])
 911         {
 912         case 0:
 913           /* This is the first entry in a compilation unit.  */
 914           if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
 915             {
 916               done = true;
 917               break;
 918             }
 919           str += stroff;
 920           stroff = bfd_get_32 (abfd, stab + VALOFF);
 921           break;
 922
 923         case N_SO:
 924           /* The main file name.  */
 925
 926           val = bfd_get_32 (abfd, stab + VALOFF);
 927           if (val > offset)
 928             {
 929               done = true;
 930               break;
 931             }
 932
 933           name = str + bfd_get_32 (abfd, stab + STRDXOFF);
 934
 935           /* An empty string indicates the end of the compilation
 936              unit.  */
 937           if (*name == '\0')
 938             {
 939               /* If there are functions in different sections, they
 940                  may have addresses larger than val, but we don't want
 941                  to forget the file name.  When there are functions in
 942                  different cases, there is supposed to be an N_FUN at
 943                  the end of the function indicating where it ends.  */
 944               if (low_func_vma < val || fnname == NULL)
 945                 main_file_name = NULL;
 946               break;
 947             }
 948
 949           /* We know that we have to get to at least this point in the
 950              stabs entries for this offset.  */
 951           info->cached_stab = stab;
 952           info->cached_str = str;
 953           info->cached_stroff = stroff;
 954
 955           current_file_name = name;
 956
 957           /* Look ahead to the next symbol.  Two consecutive N_SO
 958              symbols are a directory and a file name.  */
 959           if (stab + STABSIZE >= stabend
 960               || *(stab + STABSIZE + TYPEOFF) != N_SO)
 961             directory_name = NULL;
 962           else
 963             {
 964               stab += STABSIZE;
 965               directory_name = current_file_name;
 966               current_file_name = str + bfd_get_32 (abfd, stab + STRDXOFF);
 967             }
 968
 969           main_file_name = current_file_name;
 970
 971           break;
 972
 973         case N_SOL:
 974           /* The name of an include file.  */
 975           current_file_name = str + bfd_get_32 (abfd, stab + STRDXOFF);
 976           break;
 977
 978         case N_SLINE:
 979         case N_DSLINE:
 980         case N_BSLINE:
 981           /* A line number.  The value is relative to the start of the
 982              current function.  */
 983           val = fnaddr + bfd_get_32 (abfd, stab + VALOFF);
 984           if (val >= low_line_vma && val <= offset)
 985             {
 986               *pline = bfd_get_16 (abfd, stab + DESCOFF);
 987               low_line_vma = val;
 988               line_file_name = current_file_name;
 989             }
 990           break;
 991
 992         case N_FUN:
 993           /* A function name.  */
 994           val = bfd_get_32 (abfd, stab + VALOFF);
 995           name = str + bfd_get_32 (abfd, stab + STRDXOFF);
 996
 997           /* An empty string here indicates the end of a function, and
 998              the value is relative to fnaddr.  */
 999
1000           if (*name == '\0')
1001             {
1002               val += fnaddr;
1003               if (val >= low_func_vma && val < offset)
1004                 fnname = NULL;
1005             }
1006           else
1007             {
1008               if (val >= low_func_vma && val <= offset)
1009                 {
1010                   fnname = name;
1011                   low_func_vma = val;
1012                 }
1013
1014                fnaddr = val;
1015              }
1016
1017           break;
1018         }
1019
1020       if (done)
1021         break;
1022     }
1023
1024   if (main_file_name == NULL)
1025     {
1026       /* No information found.  */
1027       return true;
1028     }
1029
1030   *pfound = true;
1031
1032   if (*pline != 0)
1033     main_file_name = line_file_name;
1034
1035   if (main_file_name != NULL)
1036     {
1037       if (main_file_name[0] == '/' || directory_name == NULL)
1038         *pfilename = main_file_name;
1039       else
1040         {
1041           size_t dirlen;
1042
1043           dirlen = strlen (directory_name);
1044           if (info->filename == NULL
1045               || strncmp (info->filename, directory_name, dirlen) != 0
1046               || strcmp (info->filename + dirlen, main_file_name) != 0)
1047             {
1048               if (info->filename != NULL)
1049                 free (info->filename);
1050               info->filename = (char *) bfd_malloc (dirlen +
1051                                                     strlen (main_file_name)
1052                                                     + 1);
1053               if (info->filename == NULL)
1054                 return false;
1055               strcpy (info->filename, directory_name);
1056               strcpy (info->filename + dirlen, main_file_name);
1057             }
1058
1059           *pfilename = info->filename;
1060         }
1061     }
1062
1063   if (fnname != NULL)
1064     {
1065       char *s;
1066
1067       /* This will typically be something like main:F(0,1), so we want
1068          to clobber the colon.  It's OK to change the name, since the
1069          string is in our own local storage anyhow.  */
1070
1071       s = strchr (fnname, ':');
1072       if (s != NULL)
1073         *s = '\0';
1074
1075       *pfnname = fnname;
1076     }
1077
1078   return true;
1079 }