contrib/gdb/bfd/syms.c

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