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