1 /* Generic symbol-table support for the BFD library. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2012 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 /* 25 SECTION 26 Symbols 27 28 BFD tries to maintain as much symbol information as it can when 29 it moves information from file to file. BFD passes information 30 to applications though the <<asymbol>> structure. When the 31 application requests the symbol table, BFD reads the table in 32 the native form and translates parts of it into the internal 33 format. To maintain more than the information passed to 34 applications, some targets keep some information ``behind the 35 scenes'' in a structure only the particular back end knows 36 about. For example, the coff back end keeps the original 37 symbol table structure as well as the canonical structure when 38 a BFD is read in. On output, the coff back end can reconstruct 39 the output symbol table so that no information is lost, even 40 information unique to coff which BFD doesn't know or 41 understand. If a coff symbol table were read, but were written 42 through an a.out back end, all the coff specific information 43 would be lost. The symbol table of a BFD 44 is not necessarily read in until a canonicalize request is 45 made. Then the BFD back end fills in a table provided by the 46 application with pointers to the canonical information. To 47 output symbols, the application provides BFD with a table of 48 pointers to pointers to <<asymbol>>s. This allows applications 49 like the linker to output a symbol as it was read, since the ``behind 50 the scenes'' information will be still available. 51 @menu 52 @* Reading Symbols:: 53 @* Writing Symbols:: 54 @* Mini Symbols:: 55 @* typedef asymbol:: 56 @* symbol handling functions:: 57 @end menu 58 59 INODE 60 Reading Symbols, Writing Symbols, Symbols, Symbols 61 SUBSECTION 62 Reading symbols 63 64 There are two stages to reading a symbol table from a BFD: 65 allocating storage, and the actual reading process. This is an 66 excerpt from an application which reads the symbol table: 67 68 | long storage_needed; 69 | asymbol **symbol_table; 70 | long number_of_symbols; 71 | long i; 72 | 73 | storage_needed = bfd_get_symtab_upper_bound (abfd); 74 | 75 | if (storage_needed < 0) 76 | FAIL 77 | 78 | if (storage_needed == 0) 79 | return; 80 | 81 | symbol_table = xmalloc (storage_needed); 82 | ... 83 | number_of_symbols = 84 | bfd_canonicalize_symtab (abfd, symbol_table); 85 | 86 | if (number_of_symbols < 0) 87 | FAIL 88 | 89 | for (i = 0; i < number_of_symbols; i++) 90 | process_symbol (symbol_table[i]); 91 92 All storage for the symbols themselves is in an objalloc 93 connected to the BFD; it is freed when the BFD is closed. 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 "sysdep.h" 111 | #include "bfd.h" 112 | int main (void) 113 | { 114 | bfd *abfd; 115 | asymbol *ptrs[2]; 116 | asymbol *new; 117 | 118 | abfd = bfd_openw ("foo","a.out-sunos-big"); 119 | bfd_set_format (abfd, bfd_object); 120 | new = bfd_make_empty_symbol (abfd); 121 | new->name = "dummy_symbol"; 122 | new->section = bfd_make_section_old_way (abfd, ".text"); 123 | new->flags = BSF_GLOBAL; 124 | new->value = 0x12345; 125 | 126 | ptrs[0] = new; 127 | ptrs[1] = 0; 128 | 129 | bfd_set_symtab (abfd, ptrs, 1); 130 | bfd_close (abfd); 131 | return 0; 132 | } 133 | 134 | ./makesym 135 | nm foo 136 | 00012345 A dummy_symbol 137 138 Many formats cannot represent arbitrary symbol information; for 139 instance, the <<a.out>> object format does not allow an 140 arbitrary number of sections. A symbol pointing to a section 141 which is not one of <<.text>>, <<.data>> or <<.bss>> cannot 142 be described. 143 144 INODE 145 Mini Symbols, typedef asymbol, Writing Symbols, Symbols 146 SUBSECTION 147 Mini Symbols 148 149 Mini symbols provide read-only access to the symbol table. 150 They use less memory space, but require more time to access. 151 They can be useful for tools like nm or objdump, which may 152 have to handle symbol tables of extremely large executables. 153 154 The <<bfd_read_minisymbols>> function will read the symbols 155 into memory in an internal form. It will return a <<void *>> 156 pointer to a block of memory, a symbol count, and the size of 157 each symbol. The pointer is allocated using <<malloc>>, and 158 should be freed by the caller when it is no longer needed. 159 160 The function <<bfd_minisymbol_to_symbol>> will take a pointer 161 to a minisymbol, and a pointer to a structure returned by 162 <<bfd_make_empty_symbol>>, and return a <<asymbol>> structure. 163 The return value may or may not be the same as the value from 164 <<bfd_make_empty_symbol>> which was passed in. 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 bfd_symbol 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 . 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 .#define BSF_NO_FLAGS 0x00 210 . 211 . {* The symbol has local scope; <<static>> in <<C>>. The value 212 . is the offset into the section of the data. *} 213 .#define BSF_LOCAL (1 << 0) 214 . 215 . {* The symbol has global scope; initialized data in <<C>>. The 216 . value is the offset into the section of the data. *} 217 .#define BSF_GLOBAL (1 << 1) 218 . 219 . {* The symbol has global scope and is exported. The value is 220 . the offset into the section of the data. *} 221 .#define BSF_EXPORT BSF_GLOBAL {* No real difference. *} 222 . 223 . {* A normal C symbol would be one of: 224 . <<BSF_LOCAL>>, <<BSF_COMMON>>, <<BSF_UNDEFINED>> or 225 . <<BSF_GLOBAL>>. *} 226 . 227 . {* The symbol is a debugging record. The value has an arbitrary 228 . meaning, unless BSF_DEBUGGING_RELOC is also set. *} 229 .#define BSF_DEBUGGING (1 << 2) 230 . 231 . {* The symbol denotes a function entry point. Used in ELF, 232 . perhaps others someday. *} 233 .#define BSF_FUNCTION (1 << 3) 234 . 235 . {* Used by the linker. *} 236 .#define BSF_KEEP (1 << 5) 237 .#define BSF_KEEP_G (1 << 6) 238 . 239 . {* A weak global symbol, overridable without warnings by 240 . a regular global symbol of the same name. *} 241 .#define BSF_WEAK (1 << 7) 242 . 243 . {* This symbol was created to point to a section, e.g. ELF's 244 . STT_SECTION symbols. *} 245 .#define BSF_SECTION_SYM (1 << 8) 246 . 247 . {* The symbol used to be a common symbol, but now it is 248 . allocated. *} 249 .#define BSF_OLD_COMMON (1 << 9) 250 . 251 . {* In some files the type of a symbol sometimes alters its 252 . location in an output file - ie in coff a <<ISFCN>> symbol 253 . which is also <<C_EXT>> symbol appears where it was 254 . declared and not at the end of a section. This bit is set 255 . by the target BFD part to convey this information. *} 256 .#define BSF_NOT_AT_END (1 << 10) 257 . 258 . {* Signal that the symbol is the label of constructor section. *} 259 .#define BSF_CONSTRUCTOR (1 << 11) 260 . 261 . {* Signal that the symbol is a warning symbol. The name is a 262 . warning. The name of the next symbol is the one to warn about; 263 . if a reference is made to a symbol with the same name as the next 264 . symbol, a warning is issued by the linker. *} 265 .#define BSF_WARNING (1 << 12) 266 . 267 . {* Signal that the symbol is indirect. This symbol is an indirect 268 . pointer to the symbol with the same name as the next symbol. *} 269 .#define BSF_INDIRECT (1 << 13) 270 . 271 . {* BSF_FILE marks symbols that contain a file name. This is used 272 . for ELF STT_FILE symbols. *} 273 .#define BSF_FILE (1 << 14) 274 . 275 . {* Symbol is from dynamic linking information. *} 276 .#define BSF_DYNAMIC (1 << 15) 277 . 278 . {* The symbol denotes a data object. Used in ELF, and perhaps 279 . others someday. *} 280 .#define BSF_OBJECT (1 << 16) 281 . 282 . {* This symbol is a debugging symbol. The value is the offset 283 . into the section of the data. BSF_DEBUGGING should be set 284 . as well. *} 285 .#define BSF_DEBUGGING_RELOC (1 << 17) 286 . 287 . {* This symbol is thread local. Used in ELF. *} 288 .#define BSF_THREAD_LOCAL (1 << 18) 289 . 290 . {* This symbol represents a complex relocation expression, 291 . with the expression tree serialized in the symbol name. *} 292 .#define BSF_RELC (1 << 19) 293 . 294 . {* This symbol represents a signed complex relocation expression, 295 . with the expression tree serialized in the symbol name. *} 296 .#define BSF_SRELC (1 << 20) 297 . 298 . {* This symbol was created by bfd_get_synthetic_symtab. *} 299 .#define BSF_SYNTHETIC (1 << 21) 300 . 301 . {* This symbol is an indirect code object. Unrelated to BSF_INDIRECT. 302 . The dynamic linker will compute the value of this symbol by 303 . calling the function that it points to. BSF_FUNCTION must 304 . also be also set. *} 305 .#define BSF_GNU_INDIRECT_FUNCTION (1 << 22) 306 . {* This symbol is a globally unique data object. The dynamic linker 307 . will make sure that in the entire process there is just one symbol 308 . with this name and type in use. BSF_OBJECT must also be set. *} 309 .#define BSF_GNU_UNIQUE (1 << 23) 310 . 311 . flagword flags; 312 . 313 . {* A pointer to the section to which this symbol is 314 . relative. This will always be non NULL, there are special 315 . sections for undefined and absolute symbols. *} 316 . struct bfd_section *section; 317 . 318 . {* Back end special data. *} 319 . union 320 . { 321 . void *p; 322 . bfd_vma i; 323 . } 324 . udata; 325 .} 326 .asymbol; 327 . 328 */ 329 330 #include "sysdep.h" 331 #include "bfd.h" 332 #include "libbfd.h" 333 #include "safe-ctype.h" 334 #include "bfdlink.h" 335 #include "aout/stab_gnu.h" 336 337 /* 338 DOCDD 339 INODE 340 symbol handling functions, , typedef asymbol, Symbols 341 SUBSECTION 342 Symbol handling functions 343 */ 344 345 /* 346 FUNCTION 347 bfd_get_symtab_upper_bound 348 349 DESCRIPTION 350 Return the number of bytes required to store a vector of pointers 351 to <<asymbols>> for all the symbols in the BFD @var{abfd}, 352 including a terminal NULL pointer. If there are no symbols in 353 the BFD, then return 0. If an error occurs, return -1. 354 355 .#define bfd_get_symtab_upper_bound(abfd) \ 356 . BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) 357 . 358 */ 359 360 /* 361 FUNCTION 362 bfd_is_local_label 363 364 SYNOPSIS 365 bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym); 366 367 DESCRIPTION 368 Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is 369 a compiler generated local label, else return FALSE. 370 */ 371 372 bfd_boolean 373 bfd_is_local_label (bfd *abfd, asymbol *sym) 374 { 375 /* The BSF_SECTION_SYM check is needed for IA-64, where every label that 376 starts with '.' is local. This would accidentally catch section names 377 if we didn't reject them here. */ 378 if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0) 379 return FALSE; 380 if (sym->name == NULL) 381 return FALSE; 382 return bfd_is_local_label_name (abfd, sym->name); 383 } 384 385 /* 386 FUNCTION 387 bfd_is_local_label_name 388 389 SYNOPSIS 390 bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name); 391 392 DESCRIPTION 393 Return TRUE if a symbol with the name @var{name} in the BFD 394 @var{abfd} is a compiler generated local label, else return 395 FALSE. This just checks whether the name has the form of a 396 local label. 397 398 .#define bfd_is_local_label_name(abfd, name) \ 399 . BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) 400 . 401 */ 402 403 /* 404 FUNCTION 405 bfd_is_target_special_symbol 406 407 SYNOPSIS 408 bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym); 409 410 DESCRIPTION 411 Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something 412 special to the particular target represented by the BFD. Such symbols 413 should normally not be mentioned to the user. 414 415 .#define bfd_is_target_special_symbol(abfd, sym) \ 416 . BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym)) 417 . 418 */ 419 420 /* 421 FUNCTION 422 bfd_canonicalize_symtab 423 424 DESCRIPTION 425 Read the symbols from the BFD @var{abfd}, and fills in 426 the vector @var{location} with pointers to the symbols and 427 a trailing NULL. 428 Return the actual number of symbol pointers, not 429 including the NULL. 430 431 .#define bfd_canonicalize_symtab(abfd, location) \ 432 . BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location)) 433 . 434 */ 435 436 /* 437 FUNCTION 438 bfd_set_symtab 439 440 SYNOPSIS 441 bfd_boolean bfd_set_symtab 442 (bfd *abfd, asymbol **location, unsigned int count); 443 444 DESCRIPTION 445 Arrange that when the output BFD @var{abfd} is closed, 446 the table @var{location} of @var{count} pointers to symbols 447 will be written. 448 */ 449 450 bfd_boolean 451 bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount) 452 { 453 if (abfd->format != bfd_object || bfd_read_p (abfd)) 454 { 455 bfd_set_error (bfd_error_invalid_operation); 456 return FALSE; 457 } 458 459 bfd_get_outsymbols (abfd) = location; 460 bfd_get_symcount (abfd) = symcount; 461 return TRUE; 462 } 463 464 /* 465 FUNCTION 466 bfd_print_symbol_vandf 467 468 SYNOPSIS 469 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol); 470 471 DESCRIPTION 472 Print the value and flags of the @var{symbol} supplied to the 473 stream @var{file}. 474 */ 475 void 476 bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol) 477 { 478 FILE *file = (FILE *) arg; 479 480 flagword type = symbol->flags; 481 482 if (symbol->section != NULL) 483 bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma); 484 else 485 bfd_fprintf_vma (abfd, file, symbol->value); 486 487 /* This presumes that a symbol can not be both BSF_DEBUGGING and 488 BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and 489 BSF_OBJECT. */ 490 fprintf (file, " %c%c%c%c%c%c%c", 491 ((type & BSF_LOCAL) 492 ? (type & BSF_GLOBAL) ? '!' : 'l' 493 : (type & BSF_GLOBAL) ? 'g' 494 : (type & BSF_GNU_UNIQUE) ? 'u' : ' '), 495 (type & BSF_WEAK) ? 'w' : ' ', 496 (type & BSF_CONSTRUCTOR) ? 'C' : ' ', 497 (type & BSF_WARNING) ? 'W' : ' ', 498 (type & BSF_INDIRECT) ? 'I' : (type & BSF_GNU_INDIRECT_FUNCTION) ? 'i' : ' ', 499 (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ', 500 ((type & BSF_FUNCTION) 501 ? 'F' 502 : ((type & BSF_FILE) 503 ? 'f' 504 : ((type & BSF_OBJECT) ? 'O' : ' ')))); 505 } 506 507 /* 508 FUNCTION 509 bfd_make_empty_symbol 510 511 DESCRIPTION 512 Create a new <<asymbol>> structure for the BFD @var{abfd} 513 and return a pointer to it. 514 515 This routine is necessary because each back end has private 516 information surrounding the <<asymbol>>. Building your own 517 <<asymbol>> and pointing to it will not create the private 518 information, and will cause problems later on. 519 520 .#define bfd_make_empty_symbol(abfd) \ 521 . BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) 522 . 523 */ 524 525 /* 526 FUNCTION 527 _bfd_generic_make_empty_symbol 528 529 SYNOPSIS 530 asymbol *_bfd_generic_make_empty_symbol (bfd *); 531 532 DESCRIPTION 533 Create a new <<asymbol>> structure for the BFD @var{abfd} 534 and return a pointer to it. Used by core file routines, 535 binary back-end and anywhere else where no private info 536 is needed. 537 */ 538 539 asymbol * 540 _bfd_generic_make_empty_symbol (bfd *abfd) 541 { 542 bfd_size_type amt = sizeof (asymbol); 543 asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt); 544 if (new_symbol) 545 new_symbol->the_bfd = abfd; 546 return new_symbol; 547 } 548 549 /* 550 FUNCTION 551 bfd_make_debug_symbol 552 553 DESCRIPTION 554 Create a new <<asymbol>> structure for the BFD @var{abfd}, 555 to be used as a debugging symbol. Further details of its use have 556 yet to be worked out. 557 558 .#define bfd_make_debug_symbol(abfd,ptr,size) \ 559 . BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) 560 . 561 */ 562 563 struct section_to_type 564 { 565 const char *section; 566 char type; 567 }; 568 569 /* Map section names to POSIX/BSD single-character symbol types. 570 This table is probably incomplete. It is sorted for convenience of 571 adding entries. Since it is so short, a linear search is used. */ 572 static const struct section_to_type stt[] = 573 { 574 {".bss", 'b'}, 575 {"code", 't'}, /* MRI .text */ 576 {".data", 'd'}, 577 {"*DEBUG*", 'N'}, 578 {".debug", 'N'}, /* MSVC's .debug (non-standard debug syms) */ 579 {".drectve", 'i'}, /* MSVC's .drective section */ 580 {".edata", 'e'}, /* MSVC's .edata (export) section */ 581 {".fini", 't'}, /* ELF fini section */ 582 {".idata", 'i'}, /* MSVC's .idata (import) section */ 583 {".init", 't'}, /* ELF init section */ 584 {".pdata", 'p'}, /* MSVC's .pdata (stack unwind) section */ 585 {".rdata", 'r'}, /* Read only data. */ 586 {".rodata", 'r'}, /* Read only data. */ 587 {".sbss", 's'}, /* Small BSS (uninitialized data). */ 588 {".scommon", 'c'}, /* Small common. */ 589 {".sdata", 'g'}, /* Small initialized data. */ 590 {".text", 't'}, 591 {"vars", 'd'}, /* MRI .data */ 592 {"zerovars", 'b'}, /* MRI .bss */ 593 {0, 0} 594 }; 595 596 /* Return the single-character symbol type corresponding to 597 section S, or '?' for an unknown COFF section. 598 599 Check for any leading string which matches, so .text5 returns 600 't' as well as .text */ 601 602 static char 603 coff_section_type (const char *s) 604 { 605 const struct section_to_type *t; 606 607 for (t = &stt[0]; t->section; t++) 608 if (!strncmp (s, t->section, strlen (t->section))) 609 return t->type; 610 611 return '?'; 612 } 613 614 /* Return the single-character symbol type corresponding to section 615 SECTION, or '?' for an unknown section. This uses section flags to 616 identify sections. 617 618 FIXME These types are unhandled: c, i, e, p. If we handled these also, 619 we could perhaps obsolete coff_section_type. */ 620 621 static char 622 decode_section_type (const struct bfd_section *section) 623 { 624 if (section->flags & SEC_CODE) 625 return 't'; 626 if (section->flags & SEC_DATA) 627 { 628 if (section->flags & SEC_READONLY) 629 return 'r'; 630 else if (section->flags & SEC_SMALL_DATA) 631 return 'g'; 632 else 633 return 'd'; 634 } 635 if ((section->flags & SEC_HAS_CONTENTS) == 0) 636 { 637 if (section->flags & SEC_SMALL_DATA) 638 return 's'; 639 else 640 return 'b'; 641 } 642 if (section->flags & SEC_DEBUGGING) 643 return 'N'; 644 if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY)) 645 return 'n'; 646 647 return '?'; 648 } 649 650 /* 651 FUNCTION 652 bfd_decode_symclass 653 654 DESCRIPTION 655 Return a character corresponding to the symbol 656 class of @var{symbol}, or '?' for an unknown class. 657 658 SYNOPSIS 659 int bfd_decode_symclass (asymbol *symbol); 660 */ 661 int 662 bfd_decode_symclass (asymbol *symbol) 663 { 664 char c; 665 666 if (symbol->section && bfd_is_com_section (symbol->section)) 667 return 'C'; 668 if (bfd_is_und_section (symbol->section)) 669 { 670 if (symbol->flags & BSF_WEAK) 671 { 672 /* If weak, determine if it's specifically an object 673 or non-object weak. */ 674 if (symbol->flags & BSF_OBJECT) 675 return 'v'; 676 else 677 return 'w'; 678 } 679 else 680 return 'U'; 681 } 682 if (bfd_is_ind_section (symbol->section)) 683 return 'I'; 684 if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION) 685 return 'i'; 686 if (symbol->flags & BSF_WEAK) 687 { 688 /* If weak, determine if it's specifically an object 689 or non-object weak. */ 690 if (symbol->flags & BSF_OBJECT) 691 return 'V'; 692 else 693 return 'W'; 694 } 695 if (symbol->flags & BSF_GNU_UNIQUE) 696 return 'u'; 697 if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL))) 698 return '?'; 699 700 if (bfd_is_abs_section (symbol->section)) 701 c = 'a'; 702 else if (symbol->section) 703 { 704 c = coff_section_type (symbol->section->name); 705 if (c == '?') 706 c = decode_section_type (symbol->section); 707 } 708 else 709 return '?'; 710 if (symbol->flags & BSF_GLOBAL) 711 c = TOUPPER (c); 712 return c; 713 714 /* We don't have to handle these cases just yet, but we will soon: 715 N_SETV: 'v'; 716 N_SETA: 'l'; 717 N_SETT: 'x'; 718 N_SETD: 'z'; 719 N_SETB: 's'; 720 N_INDR: 'i'; 721 */ 722 } 723 724 /* 725 FUNCTION 726 bfd_is_undefined_symclass 727 728 DESCRIPTION 729 Returns non-zero if the class symbol returned by 730 bfd_decode_symclass represents an undefined symbol. 731 Returns zero otherwise. 732 733 SYNOPSIS 734 bfd_boolean bfd_is_undefined_symclass (int symclass); 735 */ 736 737 bfd_boolean 738 bfd_is_undefined_symclass (int symclass) 739 { 740 return symclass == 'U' || symclass == 'w' || symclass == 'v'; 741 } 742 743 /* 744 FUNCTION 745 bfd_symbol_info 746 747 DESCRIPTION 748 Fill in the basic info about symbol that nm needs. 749 Additional info may be added by the back-ends after 750 calling this function. 751 752 SYNOPSIS 753 void bfd_symbol_info (asymbol *symbol, symbol_info *ret); 754 */ 755 756 void 757 bfd_symbol_info (asymbol *symbol, symbol_info *ret) 758 { 759 ret->type = bfd_decode_symclass (symbol); 760 761 if (bfd_is_undefined_symclass (ret->type)) 762 ret->value = 0; 763 else 764 ret->value = symbol->value + symbol->section->vma; 765 766 ret->name = symbol->name; 767 } 768 769 /* 770 FUNCTION 771 bfd_copy_private_symbol_data 772 773 SYNOPSIS 774 bfd_boolean bfd_copy_private_symbol_data 775 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); 776 777 DESCRIPTION 778 Copy private symbol information from @var{isym} in the BFD 779 @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}. 780 Return <<TRUE>> on success, <<FALSE>> on error. Possible error 781 returns are: 782 783 o <<bfd_error_no_memory>> - 784 Not enough memory exists to create private data for @var{osec}. 785 786 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ 787 . BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ 788 . (ibfd, isymbol, obfd, osymbol)) 789 . 790 */ 791 792 /* The generic version of the function which returns mini symbols. 793 This is used when the backend does not provide a more efficient 794 version. It just uses BFD asymbol structures as mini symbols. */ 795 796 long 797 _bfd_generic_read_minisymbols (bfd *abfd, 798 bfd_boolean dynamic, 799 void **minisymsp, 800 unsigned int *sizep) 801 { 802 long storage; 803 asymbol **syms = NULL; 804 long symcount; 805 806 if (dynamic) 807 storage = bfd_get_dynamic_symtab_upper_bound (abfd); 808 else 809 storage = bfd_get_symtab_upper_bound (abfd); 810 if (storage < 0) 811 goto error_return; 812 if (storage == 0) 813 return 0; 814 815 syms = (asymbol **) bfd_malloc (storage); 816 if (syms == NULL) 817 goto error_return; 818 819 if (dynamic) 820 symcount = bfd_canonicalize_dynamic_symtab (abfd, syms); 821 else 822 symcount = bfd_canonicalize_symtab (abfd, syms); 823 if (symcount < 0) 824 goto error_return; 825 826 *minisymsp = syms; 827 *sizep = sizeof (asymbol *); 828 return symcount; 829 830 error_return: 831 bfd_set_error (bfd_error_no_symbols); 832 if (syms != NULL) 833 free (syms); 834 return -1; 835 } 836 837 /* The generic version of the function which converts a minisymbol to 838 an asymbol. We don't worry about the sym argument we are passed; 839 we just return the asymbol the minisymbol points to. */ 840 841 asymbol * 842 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED, 843 bfd_boolean dynamic ATTRIBUTE_UNUSED, 844 const void *minisym, 845 asymbol *sym ATTRIBUTE_UNUSED) 846 { 847 return *(asymbol **) minisym; 848 } 849 850 /* Look through stabs debugging information in .stab and .stabstr 851 sections to find the source file and line closest to a desired 852 location. This is used by COFF and ELF targets. It sets *pfound 853 to TRUE if it finds some information. The *pinfo field is used to 854 pass cached information in and out of this routine; this first time 855 the routine is called for a BFD, *pinfo should be NULL. The value 856 placed in *pinfo should be saved with the BFD, and passed back each 857 time this function is called. */ 858 859 /* We use a cache by default. */ 860 861 #define ENABLE_CACHING 862 863 /* We keep an array of indexentry structures to record where in the 864 stabs section we should look to find line number information for a 865 particular address. */ 866 867 struct indexentry 868 { 869 bfd_vma val; 870 bfd_byte *stab; 871 bfd_byte *str; 872 char *directory_name; 873 char *file_name; 874 char *function_name; 875 }; 876 877 /* Compare two indexentry structures. This is called via qsort. */ 878 879 static int 880 cmpindexentry (const void *a, const void *b) 881 { 882 const struct indexentry *contestantA = (const struct indexentry *) a; 883 const struct indexentry *contestantB = (const struct indexentry *) b; 884 885 if (contestantA->val < contestantB->val) 886 return -1; 887 else if (contestantA->val > contestantB->val) 888 return 1; 889 else 890 return 0; 891 } 892 893 /* A pointer to this structure is stored in *pinfo. */ 894 895 struct stab_find_info 896 { 897 /* The .stab section. */ 898 asection *stabsec; 899 /* The .stabstr section. */ 900 asection *strsec; 901 /* The contents of the .stab section. */ 902 bfd_byte *stabs; 903 /* The contents of the .stabstr section. */ 904 bfd_byte *strs; 905 906 /* A table that indexes stabs by memory address. */ 907 struct indexentry *indextable; 908 /* The number of entries in indextable. */ 909 int indextablesize; 910 911 #ifdef ENABLE_CACHING 912 /* Cached values to restart quickly. */ 913 struct indexentry *cached_indexentry; 914 bfd_vma cached_offset; 915 bfd_byte *cached_stab; 916 char *cached_file_name; 917 #endif 918 919 /* Saved ptr to malloc'ed filename. */ 920 char *filename; 921 }; 922 923 bfd_boolean 924 _bfd_stab_section_find_nearest_line (bfd *abfd, 925 asymbol **symbols, 926 asection *section, 927 bfd_vma offset, 928 bfd_boolean *pfound, 929 const char **pfilename, 930 const char **pfnname, 931 unsigned int *pline, 932 void **pinfo) 933 { 934 struct stab_find_info *info; 935 bfd_size_type stabsize, strsize; 936 bfd_byte *stab, *str; 937 bfd_byte *last_stab = NULL; 938 bfd_size_type stroff; 939 struct indexentry *indexentry; 940 char *file_name; 941 char *directory_name; 942 int saw_fun; 943 bfd_boolean saw_line, saw_func; 944 945 *pfound = FALSE; 946 *pfilename = bfd_get_filename (abfd); 947 *pfnname = NULL; 948 *pline = 0; 949 950 /* Stabs entries use a 12 byte format: 951 4 byte string table index 952 1 byte stab type 953 1 byte stab other field 954 2 byte stab desc field 955 4 byte stab value 956 FIXME: This will have to change for a 64 bit object format. 957 958 The stabs symbols are divided into compilation units. For the 959 first entry in each unit, the type of 0, the value is the length 960 of the string table for this unit, and the desc field is the 961 number of stabs symbols for this unit. */ 962 963 #define STRDXOFF (0) 964 #define TYPEOFF (4) 965 #define OTHEROFF (5) 966 #define DESCOFF (6) 967 #define VALOFF (8) 968 #define STABSIZE (12) 969 970 info = (struct stab_find_info *) *pinfo; 971 if (info != NULL) 972 { 973 if (info->stabsec == NULL || info->strsec == NULL) 974 { 975 /* No stabs debugging information. */ 976 return TRUE; 977 } 978 979 stabsize = (info->stabsec->rawsize 980 ? info->stabsec->rawsize 981 : info->stabsec->size); 982 strsize = (info->strsec->rawsize 983 ? info->strsec->rawsize 984 : info->strsec->size); 985 } 986 else 987 { 988 long reloc_size, reloc_count; 989 arelent **reloc_vector; 990 int i; 991 char *name; 992 char *function_name; 993 bfd_size_type amt = sizeof *info; 994 995 info = (struct stab_find_info *) bfd_zalloc (abfd, amt); 996 if (info == NULL) 997 return FALSE; 998 999 /* FIXME: When using the linker --split-by-file or 1000 --split-by-reloc options, it is possible for the .stab and 1001 .stabstr sections to be split. We should handle that. */ 1002 1003 info->stabsec = bfd_get_section_by_name (abfd, ".stab"); 1004 info->strsec = bfd_get_section_by_name (abfd, ".stabstr"); 1005 1006 if (info->stabsec == NULL || info->strsec == NULL) 1007 { 1008 /* Try SOM section names. */ 1009 info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$"); 1010 info->strsec = bfd_get_section_by_name (abfd, "$GDB_STRINGS$"); 1011 1012 if (info->stabsec == NULL || info->strsec == NULL) 1013 { 1014 /* No stabs debugging information. Set *pinfo so that we 1015 can return quickly in the info != NULL case above. */ 1016 *pinfo = info; 1017 return TRUE; 1018 } 1019 } 1020 1021 stabsize = (info->stabsec->rawsize 1022 ? info->stabsec->rawsize 1023 : info->stabsec->size); 1024 strsize = (info->strsec->rawsize 1025 ? info->strsec->rawsize 1026 : info->strsec->size); 1027 1028 info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize); 1029 info->strs = (bfd_byte *) bfd_alloc (abfd, strsize); 1030 if (info->stabs == NULL || info->strs == NULL) 1031 return FALSE; 1032 1033 if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs, 1034 0, stabsize) 1035 || ! bfd_get_section_contents (abfd, info->strsec, info->strs, 1036 0, strsize)) 1037 return FALSE; 1038 1039 /* If this is a relocatable object file, we have to relocate 1040 the entries in .stab. This should always be simple 32 bit 1041 relocations against symbols defined in this object file, so 1042 this should be no big deal. */ 1043 reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec); 1044 if (reloc_size < 0) 1045 return FALSE; 1046 reloc_vector = (arelent **) bfd_malloc (reloc_size); 1047 if (reloc_vector == NULL && reloc_size != 0) 1048 return FALSE; 1049 reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector, 1050 symbols); 1051 if (reloc_count < 0) 1052 { 1053 if (reloc_vector != NULL) 1054 free (reloc_vector); 1055 return FALSE; 1056 } 1057 if (reloc_count > 0) 1058 { 1059 arelent **pr; 1060 1061 for (pr = reloc_vector; *pr != NULL; pr++) 1062 { 1063 arelent *r; 1064 unsigned long val; 1065 asymbol *sym; 1066 1067 r = *pr; 1068 /* Ignore R_*_NONE relocs. */ 1069 if (r->howto->dst_mask == 0) 1070 continue; 1071 1072 if (r->howto->rightshift != 0 1073 || r->howto->size != 2 1074 || r->howto->bitsize != 32 1075 || r->howto->pc_relative 1076 || r->howto->bitpos != 0 1077 || r->howto->dst_mask != 0xffffffff) 1078 { 1079 (*_bfd_error_handler) 1080 (_("Unsupported .stab relocation")); 1081 bfd_set_error (bfd_error_invalid_operation); 1082 if (reloc_vector != NULL) 1083 free (reloc_vector); 1084 return FALSE; 1085 } 1086 1087 val = bfd_get_32 (abfd, info->stabs + r->address); 1088 val &= r->howto->src_mask; 1089 sym = *r->sym_ptr_ptr; 1090 val += sym->value + sym->section->vma + r->addend; 1091 bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address); 1092 } 1093 } 1094 1095 if (reloc_vector != NULL) 1096 free (reloc_vector); 1097 1098 /* First time through this function, build a table matching 1099 function VM addresses to stabs, then sort based on starting 1100 VM address. Do this in two passes: once to count how many 1101 table entries we'll need, and a second to actually build the 1102 table. */ 1103 1104 info->indextablesize = 0; 1105 saw_fun = 1; 1106 for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE) 1107 { 1108 if (stab[TYPEOFF] == (bfd_byte) N_SO) 1109 { 1110 /* N_SO with null name indicates EOF */ 1111 if (bfd_get_32 (abfd, stab + STRDXOFF) == 0) 1112 continue; 1113 1114 /* if we did not see a function def, leave space for one. */ 1115 if (saw_fun == 0) 1116 ++info->indextablesize; 1117 1118 saw_fun = 0; 1119 1120 /* two N_SO's in a row is a filename and directory. Skip */ 1121 if (stab + STABSIZE < info->stabs + stabsize 1122 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO) 1123 { 1124 stab += STABSIZE; 1125 } 1126 } 1127 else if (stab[TYPEOFF] == (bfd_byte) N_FUN) 1128 { 1129 saw_fun = 1; 1130 ++info->indextablesize; 1131 } 1132 } 1133 1134 if (saw_fun == 0) 1135 ++info->indextablesize; 1136 1137 if (info->indextablesize == 0) 1138 return TRUE; 1139 ++info->indextablesize; 1140 1141 amt = info->indextablesize; 1142 amt *= sizeof (struct indexentry); 1143 info->indextable = (struct indexentry *) bfd_alloc (abfd, amt); 1144 if (info->indextable == NULL) 1145 return FALSE; 1146 1147 file_name = NULL; 1148 directory_name = NULL; 1149 saw_fun = 1; 1150 1151 for (i = 0, stroff = 0, stab = info->stabs, str = info->strs; 1152 i < info->indextablesize && stab < info->stabs + stabsize; 1153 stab += STABSIZE) 1154 { 1155 switch (stab[TYPEOFF]) 1156 { 1157 case 0: 1158 /* This is the first entry in a compilation unit. */ 1159 if ((bfd_size_type) ((info->strs + strsize) - str) < stroff) 1160 break; 1161 str += stroff; 1162 stroff = bfd_get_32 (abfd, stab + VALOFF); 1163 break; 1164 1165 case N_SO: 1166 /* The main file name. */ 1167 1168 /* The following code creates a new indextable entry with 1169 a NULL function name if there were no N_FUNs in a file. 1170 Note that a N_SO without a file name is an EOF and 1171 there could be 2 N_SO following it with the new filename 1172 and directory. */ 1173 if (saw_fun == 0) 1174 { 1175 info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF); 1176 info->indextable[i].stab = last_stab; 1177 info->indextable[i].str = str; 1178 info->indextable[i].directory_name = directory_name; 1179 info->indextable[i].file_name = file_name; 1180 info->indextable[i].function_name = NULL; 1181 ++i; 1182 } 1183 saw_fun = 0; 1184 1185 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1186 if (*file_name == '\0') 1187 { 1188 directory_name = NULL; 1189 file_name = NULL; 1190 saw_fun = 1; 1191 } 1192 else 1193 { 1194 last_stab = stab; 1195 if (stab + STABSIZE >= info->stabs + stabsize 1196 || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO) 1197 { 1198 directory_name = NULL; 1199 } 1200 else 1201 { 1202 /* Two consecutive N_SOs are a directory and a 1203 file name. */ 1204 stab += STABSIZE; 1205 directory_name = file_name; 1206 file_name = ((char *) str 1207 + bfd_get_32 (abfd, stab + STRDXOFF)); 1208 } 1209 } 1210 break; 1211 1212 case N_SOL: 1213 /* The name of an include file. */ 1214 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1215 break; 1216 1217 case N_FUN: 1218 /* A function name. */ 1219 saw_fun = 1; 1220 name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1221 1222 if (*name == '\0') 1223 name = NULL; 1224 1225 function_name = name; 1226 1227 if (name == NULL) 1228 continue; 1229 1230 info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF); 1231 info->indextable[i].stab = stab; 1232 info->indextable[i].str = str; 1233 info->indextable[i].directory_name = directory_name; 1234 info->indextable[i].file_name = file_name; 1235 info->indextable[i].function_name = function_name; 1236 ++i; 1237 break; 1238 } 1239 } 1240 1241 if (saw_fun == 0) 1242 { 1243 info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF); 1244 info->indextable[i].stab = last_stab; 1245 info->indextable[i].str = str; 1246 info->indextable[i].directory_name = directory_name; 1247 info->indextable[i].file_name = file_name; 1248 info->indextable[i].function_name = NULL; 1249 ++i; 1250 } 1251 1252 info->indextable[i].val = (bfd_vma) -1; 1253 info->indextable[i].stab = info->stabs + stabsize; 1254 info->indextable[i].str = str; 1255 info->indextable[i].directory_name = NULL; 1256 info->indextable[i].file_name = NULL; 1257 info->indextable[i].function_name = NULL; 1258 ++i; 1259 1260 info->indextablesize = i; 1261 qsort (info->indextable, (size_t) i, sizeof (struct indexentry), 1262 cmpindexentry); 1263 1264 *pinfo = info; 1265 } 1266 1267 /* We are passed a section relative offset. The offsets in the 1268 stabs information are absolute. */ 1269 offset += bfd_get_section_vma (abfd, section); 1270 1271 #ifdef ENABLE_CACHING 1272 if (info->cached_indexentry != NULL 1273 && offset >= info->cached_offset 1274 && offset < (info->cached_indexentry + 1)->val) 1275 { 1276 stab = info->cached_stab; 1277 indexentry = info->cached_indexentry; 1278 file_name = info->cached_file_name; 1279 } 1280 else 1281 #endif 1282 { 1283 long low, high; 1284 long mid = -1; 1285 1286 /* Cache non-existent or invalid. Do binary search on 1287 indextable. */ 1288 indexentry = NULL; 1289 1290 low = 0; 1291 high = info->indextablesize - 1; 1292 while (low != high) 1293 { 1294 mid = (high + low) / 2; 1295 if (offset >= info->indextable[mid].val 1296 && offset < info->indextable[mid + 1].val) 1297 { 1298 indexentry = &info->indextable[mid]; 1299 break; 1300 } 1301 1302 if (info->indextable[mid].val > offset) 1303 high = mid; 1304 else 1305 low = mid + 1; 1306 } 1307 1308 if (indexentry == NULL) 1309 return TRUE; 1310 1311 stab = indexentry->stab + STABSIZE; 1312 file_name = indexentry->file_name; 1313 } 1314 1315 directory_name = indexentry->directory_name; 1316 str = indexentry->str; 1317 1318 saw_line = FALSE; 1319 saw_func = FALSE; 1320 for (; stab < (indexentry+1)->stab; stab += STABSIZE) 1321 { 1322 bfd_boolean done; 1323 bfd_vma val; 1324 1325 done = FALSE; 1326 1327 switch (stab[TYPEOFF]) 1328 { 1329 case N_SOL: 1330 /* The name of an include file. */ 1331 val = bfd_get_32 (abfd, stab + VALOFF); 1332 if (val <= offset) 1333 { 1334 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1335 *pline = 0; 1336 } 1337 break; 1338 1339 case N_SLINE: 1340 case N_DSLINE: 1341 case N_BSLINE: 1342 /* A line number. If the function was specified, then the value 1343 is relative to the start of the function. Otherwise, the 1344 value is an absolute address. */ 1345 val = ((indexentry->function_name ? indexentry->val : 0) 1346 + bfd_get_32 (abfd, stab + VALOFF)); 1347 /* If this line starts before our desired offset, or if it's 1348 the first line we've been able to find, use it. The 1349 !saw_line check works around a bug in GCC 2.95.3, which emits 1350 the first N_SLINE late. */ 1351 if (!saw_line || val <= offset) 1352 { 1353 *pline = bfd_get_16 (abfd, stab + DESCOFF); 1354 1355 #ifdef ENABLE_CACHING 1356 info->cached_stab = stab; 1357 info->cached_offset = val; 1358 info->cached_file_name = file_name; 1359 info->cached_indexentry = indexentry; 1360 #endif 1361 } 1362 if (val > offset) 1363 done = TRUE; 1364 saw_line = TRUE; 1365 break; 1366 1367 case N_FUN: 1368 case N_SO: 1369 if (saw_func || saw_line) 1370 done = TRUE; 1371 saw_func = TRUE; 1372 break; 1373 } 1374 1375 if (done) 1376 break; 1377 } 1378 1379 *pfound = TRUE; 1380 1381 if (file_name == NULL || IS_ABSOLUTE_PATH (file_name) 1382 || directory_name == NULL) 1383 *pfilename = file_name; 1384 else 1385 { 1386 size_t dirlen; 1387 1388 dirlen = strlen (directory_name); 1389 if (info->filename == NULL 1390 || filename_ncmp (info->filename, directory_name, dirlen) != 0 1391 || filename_cmp (info->filename + dirlen, file_name) != 0) 1392 { 1393 size_t len; 1394 1395 /* Don't free info->filename here. objdump and other 1396 apps keep a copy of a previously returned file name 1397 pointer. */ 1398 len = strlen (file_name) + 1; 1399 info->filename = (char *) bfd_alloc (abfd, dirlen + len); 1400 if (info->filename == NULL) 1401 return FALSE; 1402 memcpy (info->filename, directory_name, dirlen); 1403 memcpy (info->filename + dirlen, file_name, len); 1404 } 1405 1406 *pfilename = info->filename; 1407 } 1408 1409 if (indexentry->function_name != NULL) 1410 { 1411 char *s; 1412 1413 /* This will typically be something like main:F(0,1), so we want 1414 to clobber the colon. It's OK to change the name, since the 1415 string is in our own local storage anyhow. */ 1416 s = strchr (indexentry->function_name, ':'); 1417 if (s != NULL) 1418 *s = '\0'; 1419 1420 *pfnname = indexentry->function_name; 1421 } 1422 1423 return TRUE; 1424 } 1425