syms.c revision 1.1.1.9
1 /* Generic symbol-table support for the BFD library. 2 Copyright (C) 1990-2020 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 0 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_UNDEFINED>> or <<BSF_GLOBAL>>. *} 223 . 224 . {* The symbol is a debugging record. The value has an arbitrary 225 . meaning, unless BSF_DEBUGGING_RELOC is also set. *} 226 .#define BSF_DEBUGGING (1 << 2) 227 . 228 . {* The symbol denotes a function entry point. Used in ELF, 229 . perhaps others someday. *} 230 .#define BSF_FUNCTION (1 << 3) 231 . 232 . {* Used by the linker. *} 233 .#define BSF_KEEP (1 << 5) 234 . 235 . {* An ELF common symbol. *} 236 .#define BSF_ELF_COMMON (1 << 6) 237 . 238 . {* A weak global symbol, overridable without warnings by 239 . a regular global symbol of the same name. *} 240 .#define BSF_WEAK (1 << 7) 241 . 242 . {* This symbol was created to point to a section, e.g. ELF's 243 . STT_SECTION symbols. *} 244 .#define BSF_SECTION_SYM (1 << 8) 245 . 246 . {* The symbol used to be a common symbol, but now it is 247 . allocated. *} 248 .#define BSF_OLD_COMMON (1 << 9) 249 . 250 . {* In some files the type of a symbol sometimes alters its 251 . location in an output file - ie in coff a <<ISFCN>> symbol 252 . which is also <<C_EXT>> symbol appears where it was 253 . declared and not at the end of a section. This bit is set 254 . by the target BFD part to convey this information. *} 255 .#define BSF_NOT_AT_END (1 << 10) 256 . 257 . {* Signal that the symbol is the label of constructor section. *} 258 .#define BSF_CONSTRUCTOR (1 << 11) 259 . 260 . {* Signal that the symbol is a warning symbol. The name is a 261 . warning. The name of the next symbol is the one to warn about; 262 . if a reference is made to a symbol with the same name as the next 263 . symbol, a warning is issued by the linker. *} 264 .#define BSF_WARNING (1 << 12) 265 . 266 . {* Signal that the symbol is indirect. This symbol is an indirect 267 . pointer to the symbol with the same name as the next symbol. *} 268 .#define BSF_INDIRECT (1 << 13) 269 . 270 . {* BSF_FILE marks symbols that contain a file name. This is used 271 . for ELF STT_FILE symbols. *} 272 .#define BSF_FILE (1 << 14) 273 . 274 . {* Symbol is from dynamic linking information. *} 275 .#define BSF_DYNAMIC (1 << 15) 276 . 277 . {* The symbol denotes a data object. Used in ELF, and perhaps 278 . others someday. *} 279 .#define BSF_OBJECT (1 << 16) 280 . 281 . {* This symbol is a debugging symbol. The value is the offset 282 . into the section of the data. BSF_DEBUGGING should be set 283 . as well. *} 284 .#define BSF_DEBUGGING_RELOC (1 << 17) 285 . 286 . {* This symbol is thread local. Used in ELF. *} 287 .#define BSF_THREAD_LOCAL (1 << 18) 288 . 289 . {* This symbol represents a complex relocation expression, 290 . with the expression tree serialized in the symbol name. *} 291 .#define BSF_RELC (1 << 19) 292 . 293 . {* This symbol represents a signed complex relocation expression, 294 . with the expression tree serialized in the symbol name. *} 295 .#define BSF_SRELC (1 << 20) 296 . 297 . {* This symbol was created by bfd_get_synthetic_symtab. *} 298 .#define BSF_SYNTHETIC (1 << 21) 299 . 300 . {* This symbol is an indirect code object. Unrelated to BSF_INDIRECT. 301 . The dynamic linker will compute the value of this symbol by 302 . calling the function that it points to. BSF_FUNCTION must 303 . also be also set. *} 304 .#define BSF_GNU_INDIRECT_FUNCTION (1 << 22) 305 . {* This symbol is a globally unique data object. The dynamic linker 306 . will make sure that in the entire process there is just one symbol 307 . with this name and type in use. BSF_OBJECT must also be set. *} 308 .#define BSF_GNU_UNIQUE (1 << 23) 309 . 310 . flagword flags; 311 . 312 . {* A pointer to the section to which this symbol is 313 . relative. This will always be non NULL, there are special 314 . sections for undefined and absolute symbols. *} 315 . struct bfd_section *section; 316 . 317 . {* Back end special data. *} 318 . union 319 . { 320 . void *p; 321 . bfd_vma i; 322 . } 323 . udata; 324 .} 325 .asymbol; 326 . 327 */ 328 329 #include "sysdep.h" 330 #include "bfd.h" 331 #include "libbfd.h" 332 #include "safe-ctype.h" 333 #include "bfdlink.h" 334 #include "aout/stab_gnu.h" 335 336 /* 337 DOCDD 338 INODE 339 symbol handling functions, , typedef asymbol, Symbols 340 SUBSECTION 341 Symbol handling functions 342 */ 343 344 /* 345 FUNCTION 346 bfd_get_symtab_upper_bound 347 348 DESCRIPTION 349 Return the number of bytes required to store a vector of pointers 350 to <<asymbols>> for all the symbols in the BFD @var{abfd}, 351 including a terminal NULL pointer. If there are no symbols in 352 the BFD, then return 0. If an error occurs, return -1. 353 354 .#define bfd_get_symtab_upper_bound(abfd) \ 355 . BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) 356 . 357 */ 358 359 /* 360 FUNCTION 361 bfd_is_local_label 362 363 SYNOPSIS 364 bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym); 365 366 DESCRIPTION 367 Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is 368 a compiler generated local label, else return FALSE. 369 */ 370 371 bfd_boolean 372 bfd_is_local_label (bfd *abfd, asymbol *sym) 373 { 374 /* The BSF_SECTION_SYM check is needed for IA-64, where every label that 375 starts with '.' is local. This would accidentally catch section names 376 if we didn't reject them here. */ 377 if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0) 378 return FALSE; 379 if (sym->name == NULL) 380 return FALSE; 381 return bfd_is_local_label_name (abfd, sym->name); 382 } 383 384 /* 385 FUNCTION 386 bfd_is_local_label_name 387 388 SYNOPSIS 389 bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name); 390 391 DESCRIPTION 392 Return TRUE if a symbol with the name @var{name} in the BFD 393 @var{abfd} is a compiler generated local label, else return 394 FALSE. This just checks whether the name has the form of a 395 local label. 396 397 .#define bfd_is_local_label_name(abfd, name) \ 398 . BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) 399 . 400 */ 401 402 /* 403 FUNCTION 404 bfd_is_target_special_symbol 405 406 SYNOPSIS 407 bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym); 408 409 DESCRIPTION 410 Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something 411 special to the particular target represented by the BFD. Such symbols 412 should normally not be mentioned to the user. 413 414 .#define bfd_is_target_special_symbol(abfd, sym) \ 415 . BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym)) 416 . 417 */ 418 419 /* 420 FUNCTION 421 bfd_canonicalize_symtab 422 423 DESCRIPTION 424 Read the symbols from the BFD @var{abfd}, and fills in 425 the vector @var{location} with pointers to the symbols and 426 a trailing NULL. 427 Return the actual number of symbol pointers, not 428 including the NULL. 429 430 .#define bfd_canonicalize_symtab(abfd, location) \ 431 . BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location)) 432 . 433 */ 434 435 /* 436 FUNCTION 437 bfd_set_symtab 438 439 SYNOPSIS 440 bfd_boolean bfd_set_symtab 441 (bfd *abfd, asymbol **location, unsigned int count); 442 443 DESCRIPTION 444 Arrange that when the output BFD @var{abfd} is closed, 445 the table @var{location} of @var{count} pointers to symbols 446 will be written. 447 */ 448 449 bfd_boolean 450 bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount) 451 { 452 if (abfd->format != bfd_object || bfd_read_p (abfd)) 453 { 454 bfd_set_error (bfd_error_invalid_operation); 455 return FALSE; 456 } 457 458 abfd->outsymbols = location; 459 abfd->symcount = symcount; 460 return TRUE; 461 } 462 463 /* 464 FUNCTION 465 bfd_print_symbol_vandf 466 467 SYNOPSIS 468 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol); 469 470 DESCRIPTION 471 Print the value and flags of the @var{symbol} supplied to the 472 stream @var{file}. 473 */ 474 void 475 bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol) 476 { 477 FILE *file = (FILE *) arg; 478 479 flagword type = symbol->flags; 480 481 if (symbol->section != NULL) 482 bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma); 483 else 484 bfd_fprintf_vma (abfd, file, symbol->value); 485 486 /* This presumes that a symbol can not be both BSF_DEBUGGING and 487 BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and 488 BSF_OBJECT. */ 489 fprintf (file, " %c%c%c%c%c%c%c", 490 ((type & BSF_LOCAL) 491 ? (type & BSF_GLOBAL) ? '!' : 'l' 492 : (type & BSF_GLOBAL) ? 'g' 493 : (type & BSF_GNU_UNIQUE) ? 'u' : ' '), 494 (type & BSF_WEAK) ? 'w' : ' ', 495 (type & BSF_CONSTRUCTOR) ? 'C' : ' ', 496 (type & BSF_WARNING) ? 'W' : ' ', 497 (type & BSF_INDIRECT) ? 'I' : (type & BSF_GNU_INDIRECT_FUNCTION) ? 'i' : ' ', 498 (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ', 499 ((type & BSF_FUNCTION) 500 ? 'F' 501 : ((type & BSF_FILE) 502 ? 'f' 503 : ((type & BSF_OBJECT) ? 'O' : ' ')))); 504 } 505 506 /* 507 FUNCTION 508 bfd_make_empty_symbol 509 510 DESCRIPTION 511 Create a new <<asymbol>> structure for the BFD @var{abfd} 512 and return a pointer to it. 513 514 This routine is necessary because each back end has private 515 information surrounding the <<asymbol>>. Building your own 516 <<asymbol>> and pointing to it will not create the private 517 information, and will cause problems later on. 518 519 .#define bfd_make_empty_symbol(abfd) \ 520 . BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) 521 . 522 */ 523 524 /* 525 FUNCTION 526 _bfd_generic_make_empty_symbol 527 528 SYNOPSIS 529 asymbol *_bfd_generic_make_empty_symbol (bfd *); 530 531 DESCRIPTION 532 Create a new <<asymbol>> structure for the BFD @var{abfd} 533 and return a pointer to it. Used by core file routines, 534 binary back-end and anywhere else where no private info 535 is needed. 536 */ 537 538 asymbol * 539 _bfd_generic_make_empty_symbol (bfd *abfd) 540 { 541 size_t amt = sizeof (asymbol); 542 asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt); 543 if (new_symbol) 544 new_symbol->the_bfd = abfd; 545 return new_symbol; 546 } 547 548 /* 549 FUNCTION 550 bfd_make_debug_symbol 551 552 DESCRIPTION 553 Create a new <<asymbol>> structure for the BFD @var{abfd}, 554 to be used as a debugging symbol. Further details of its use have 555 yet to be worked out. 556 557 .#define bfd_make_debug_symbol(abfd,ptr,size) \ 558 . BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) 559 . 560 */ 561 562 struct section_to_type 563 { 564 const char *section; 565 char type; 566 }; 567 568 /* Map special section names to POSIX/BSD single-character symbol types. 569 This table is probably incomplete. It is sorted for convenience of 570 adding entries. Since it is so short, a linear search is used. */ 571 static const struct section_to_type stt[] = 572 { 573 {".drectve", 'i'}, /* MSVC's .drective section */ 574 {".edata", 'e'}, /* MSVC's .edata (export) section */ 575 {".idata", 'i'}, /* MSVC's .idata (import) section */ 576 {".pdata", 'p'}, /* MSVC's .pdata (stack unwind) section */ 577 {0, 0} 578 }; 579 580 /* Return the single-character symbol type corresponding to 581 section S, or '?' for an unknown COFF section. 582 583 Check for leading strings which match, followed by a number, '.', 584 or '$' so .idata5 matches the .idata entry. */ 585 586 static char 587 coff_section_type (const char *s) 588 { 589 const struct section_to_type *t; 590 591 for (t = &stt[0]; t->section; t++) 592 { 593 size_t len = strlen (t->section); 594 if (strncmp (s, t->section, len) == 0 595 && memchr (".$0123456789", s[len], 13) != 0) 596 return t->type; 597 } 598 599 return '?'; 600 } 601 602 /* Return the single-character symbol type corresponding to section 603 SECTION, or '?' for an unknown section. This uses section flags to 604 identify sections. 605 606 FIXME These types are unhandled: e, i, p. If we handled these also, 607 we could perhaps obsolete coff_section_type. */ 608 609 static char 610 decode_section_type (const struct bfd_section *section) 611 { 612 if (section->flags & SEC_CODE) 613 return 't'; 614 if (section->flags & SEC_DATA) 615 { 616 if (section->flags & SEC_READONLY) 617 return 'r'; 618 else if (section->flags & SEC_SMALL_DATA) 619 return 'g'; 620 else 621 return 'd'; 622 } 623 if ((section->flags & SEC_HAS_CONTENTS) == 0) 624 { 625 if (section->flags & SEC_SMALL_DATA) 626 return 's'; 627 else 628 return 'b'; 629 } 630 if (section->flags & SEC_DEBUGGING) 631 return 'N'; 632 if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY)) 633 return 'n'; 634 635 return '?'; 636 } 637 638 /* 639 FUNCTION 640 bfd_decode_symclass 641 642 DESCRIPTION 643 Return a character corresponding to the symbol 644 class of @var{symbol}, or '?' for an unknown class. 645 646 SYNOPSIS 647 int bfd_decode_symclass (asymbol *symbol); 648 */ 649 int 650 bfd_decode_symclass (asymbol *symbol) 651 { 652 char c; 653 654 if (symbol->section && bfd_is_com_section (symbol->section)) 655 { 656 if (symbol->section->flags & SEC_SMALL_DATA) 657 return 'c'; 658 else 659 return 'C'; 660 } 661 if (bfd_is_und_section (symbol->section)) 662 { 663 if (symbol->flags & BSF_WEAK) 664 { 665 /* If weak, determine if it's specifically an object 666 or non-object weak. */ 667 if (symbol->flags & BSF_OBJECT) 668 return 'v'; 669 else 670 return 'w'; 671 } 672 else 673 return 'U'; 674 } 675 if (bfd_is_ind_section (symbol->section)) 676 return 'I'; 677 if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION) 678 return 'i'; 679 if (symbol->flags & BSF_WEAK) 680 { 681 /* If weak, determine if it's specifically an object 682 or non-object weak. */ 683 if (symbol->flags & BSF_OBJECT) 684 return 'V'; 685 else 686 return 'W'; 687 } 688 if (symbol->flags & BSF_GNU_UNIQUE) 689 return 'u'; 690 if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL))) 691 return '?'; 692 693 if (bfd_is_abs_section (symbol->section)) 694 c = 'a'; 695 else if (symbol->section) 696 { 697 c = coff_section_type (symbol->section->name); 698 if (c == '?') 699 c = decode_section_type (symbol->section); 700 } 701 else 702 return '?'; 703 if (symbol->flags & BSF_GLOBAL) 704 c = TOUPPER (c); 705 return c; 706 707 /* We don't have to handle these cases just yet, but we will soon: 708 N_SETV: 'v'; 709 N_SETA: 'l'; 710 N_SETT: 'x'; 711 N_SETD: 'z'; 712 N_SETB: 's'; 713 N_INDR: 'i'; 714 */ 715 } 716 717 /* 718 FUNCTION 719 bfd_is_undefined_symclass 720 721 DESCRIPTION 722 Returns non-zero if the class symbol returned by 723 bfd_decode_symclass represents an undefined symbol. 724 Returns zero otherwise. 725 726 SYNOPSIS 727 bfd_boolean bfd_is_undefined_symclass (int symclass); 728 */ 729 730 bfd_boolean 731 bfd_is_undefined_symclass (int symclass) 732 { 733 return symclass == 'U' || symclass == 'w' || symclass == 'v'; 734 } 735 736 /* 737 FUNCTION 738 bfd_symbol_info 739 740 DESCRIPTION 741 Fill in the basic info about symbol that nm needs. 742 Additional info may be added by the back-ends after 743 calling this function. 744 745 SYNOPSIS 746 void bfd_symbol_info (asymbol *symbol, symbol_info *ret); 747 */ 748 749 void 750 bfd_symbol_info (asymbol *symbol, symbol_info *ret) 751 { 752 ret->type = bfd_decode_symclass (symbol); 753 754 if (bfd_is_undefined_symclass (ret->type)) 755 ret->value = 0; 756 else 757 ret->value = symbol->value + symbol->section->vma; 758 759 ret->name = symbol->name; 760 } 761 762 /* 763 FUNCTION 764 bfd_copy_private_symbol_data 765 766 SYNOPSIS 767 bfd_boolean bfd_copy_private_symbol_data 768 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); 769 770 DESCRIPTION 771 Copy private symbol information from @var{isym} in the BFD 772 @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}. 773 Return <<TRUE>> on success, <<FALSE>> on error. Possible error 774 returns are: 775 776 o <<bfd_error_no_memory>> - 777 Not enough memory exists to create private data for @var{osec}. 778 779 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ 780 . BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ 781 . (ibfd, isymbol, obfd, osymbol)) 782 . 783 */ 784 785 /* The generic version of the function which returns mini symbols. 786 This is used when the backend does not provide a more efficient 787 version. It just uses BFD asymbol structures as mini symbols. */ 788 789 long 790 _bfd_generic_read_minisymbols (bfd *abfd, 791 bfd_boolean dynamic, 792 void **minisymsp, 793 unsigned int *sizep) 794 { 795 long storage; 796 asymbol **syms = NULL; 797 long symcount; 798 799 if (dynamic) 800 storage = bfd_get_dynamic_symtab_upper_bound (abfd); 801 else 802 storage = bfd_get_symtab_upper_bound (abfd); 803 if (storage < 0) 804 goto error_return; 805 if (storage == 0) 806 return 0; 807 808 syms = (asymbol **) bfd_malloc (storage); 809 if (syms == NULL) 810 goto error_return; 811 812 if (dynamic) 813 symcount = bfd_canonicalize_dynamic_symtab (abfd, syms); 814 else 815 symcount = bfd_canonicalize_symtab (abfd, syms); 816 if (symcount < 0) 817 goto error_return; 818 819 if (symcount == 0) 820 /* We return 0 above when storage is 0. Exit in the same state 821 here, so as to not complicate callers with having to deal with 822 freeing memory for zero symcount. */ 823 free (syms); 824 else 825 { 826 *minisymsp = syms; 827 *sizep = sizeof (asymbol *); 828 } 829 return symcount; 830 831 error_return: 832 bfd_set_error (bfd_error_no_symbols); 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 int idx; 876 }; 877 878 /* Compare two indexentry structures. This is called via qsort. */ 879 880 static int 881 cmpindexentry (const void *a, const void *b) 882 { 883 const struct indexentry *contestantA = (const struct indexentry *) a; 884 const struct indexentry *contestantB = (const struct indexentry *) b; 885 886 if (contestantA->val < contestantB->val) 887 return -1; 888 if (contestantA->val > contestantB->val) 889 return 1; 890 return contestantA->idx - contestantB->idx; 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 *nul_fun, *nul_str; 938 bfd_size_type stroff; 939 struct indexentry *indexentry; 940 char *file_name; 941 char *directory_name; 942 bfd_boolean saw_line, saw_func; 943 944 *pfound = FALSE; 945 *pfilename = bfd_get_filename (abfd); 946 *pfnname = NULL; 947 *pline = 0; 948 949 /* Stabs entries use a 12 byte format: 950 4 byte string table index 951 1 byte stab type 952 1 byte stab other field 953 2 byte stab desc field 954 4 byte stab value 955 FIXME: This will have to change for a 64 bit object format. 956 957 The stabs symbols are divided into compilation units. For the 958 first entry in each unit, the type of 0, the value is the length 959 of the string table for this unit, and the desc field is the 960 number of stabs symbols for this unit. */ 961 962 #define STRDXOFF (0) 963 #define TYPEOFF (4) 964 #define OTHEROFF (5) 965 #define DESCOFF (6) 966 #define VALOFF (8) 967 #define STABSIZE (12) 968 969 info = (struct stab_find_info *) *pinfo; 970 if (info != NULL) 971 { 972 if (info->stabsec == NULL || info->strsec == NULL) 973 { 974 /* No stabs debugging information. */ 975 return TRUE; 976 } 977 978 stabsize = (info->stabsec->rawsize 979 ? info->stabsec->rawsize 980 : info->stabsec->size); 981 strsize = (info->strsec->rawsize 982 ? info->strsec->rawsize 983 : info->strsec->size); 984 } 985 else 986 { 987 long reloc_size, reloc_count; 988 arelent **reloc_vector; 989 int i; 990 char *function_name; 991 bfd_size_type amt = sizeof *info; 992 993 info = (struct stab_find_info *) bfd_zalloc (abfd, amt); 994 if (info == NULL) 995 return FALSE; 996 997 /* FIXME: When using the linker --split-by-file or 998 --split-by-reloc options, it is possible for the .stab and 999 .stabstr sections to be split. We should handle that. */ 1000 1001 info->stabsec = bfd_get_section_by_name (abfd, ".stab"); 1002 info->strsec = bfd_get_section_by_name (abfd, ".stabstr"); 1003 1004 if (info->stabsec == NULL || info->strsec == NULL) 1005 { 1006 /* Try SOM section names. */ 1007 info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$"); 1008 info->strsec = bfd_get_section_by_name (abfd, "$GDB_STRINGS$"); 1009 1010 if (info->stabsec == NULL || info->strsec == NULL) 1011 { 1012 /* No stabs debugging information. Set *pinfo so that we 1013 can return quickly in the info != NULL case above. */ 1014 *pinfo = info; 1015 return TRUE; 1016 } 1017 } 1018 1019 stabsize = (info->stabsec->rawsize 1020 ? info->stabsec->rawsize 1021 : info->stabsec->size); 1022 stabsize = (stabsize / STABSIZE) * STABSIZE; 1023 strsize = (info->strsec->rawsize 1024 ? info->strsec->rawsize 1025 : info->strsec->size); 1026 1027 info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize); 1028 info->strs = (bfd_byte *) bfd_alloc (abfd, strsize); 1029 if (info->stabs == NULL || info->strs == NULL) 1030 return FALSE; 1031 1032 if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs, 1033 0, stabsize) 1034 || ! bfd_get_section_contents (abfd, info->strsec, info->strs, 1035 0, strsize)) 1036 return FALSE; 1037 1038 /* Stab strings ought to be nul terminated. Ensure the last one 1039 is, to prevent running off the end of the buffer. */ 1040 info->strs[strsize - 1] = 0; 1041 1042 /* If this is a relocatable object file, we have to relocate 1043 the entries in .stab. This should always be simple 32 bit 1044 relocations against symbols defined in this object file, so 1045 this should be no big deal. */ 1046 reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec); 1047 if (reloc_size < 0) 1048 return FALSE; 1049 reloc_vector = (arelent **) bfd_malloc (reloc_size); 1050 if (reloc_vector == NULL && reloc_size != 0) 1051 return FALSE; 1052 reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector, 1053 symbols); 1054 if (reloc_count < 0) 1055 { 1056 free (reloc_vector); 1057 return FALSE; 1058 } 1059 if (reloc_count > 0) 1060 { 1061 arelent **pr; 1062 1063 for (pr = reloc_vector; *pr != NULL; pr++) 1064 { 1065 arelent *r; 1066 unsigned long val; 1067 asymbol *sym; 1068 bfd_size_type octets; 1069 1070 r = *pr; 1071 /* Ignore R_*_NONE relocs. */ 1072 if (r->howto->dst_mask == 0) 1073 continue; 1074 1075 octets = r->address * bfd_octets_per_byte (abfd, NULL); 1076 if (r->howto->rightshift != 0 1077 || r->howto->size != 2 1078 || r->howto->bitsize != 32 1079 || r->howto->pc_relative 1080 || r->howto->bitpos != 0 1081 || r->howto->dst_mask != 0xffffffff 1082 || octets + 4 > stabsize) 1083 { 1084 _bfd_error_handler 1085 (_("unsupported .stab relocation")); 1086 bfd_set_error (bfd_error_invalid_operation); 1087 free (reloc_vector); 1088 return FALSE; 1089 } 1090 1091 val = bfd_get_32 (abfd, info->stabs + octets); 1092 val &= r->howto->src_mask; 1093 sym = *r->sym_ptr_ptr; 1094 val += sym->value + sym->section->vma + r->addend; 1095 bfd_put_32 (abfd, (bfd_vma) val, info->stabs + octets); 1096 } 1097 } 1098 1099 free (reloc_vector); 1100 1101 /* First time through this function, build a table matching 1102 function VM addresses to stabs, then sort based on starting 1103 VM address. Do this in two passes: once to count how many 1104 table entries we'll need, and a second to actually build the 1105 table. */ 1106 1107 info->indextablesize = 0; 1108 nul_fun = NULL; 1109 for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE) 1110 { 1111 if (stab[TYPEOFF] == (bfd_byte) N_SO) 1112 { 1113 /* if we did not see a function def, leave space for one. */ 1114 if (nul_fun != NULL) 1115 ++info->indextablesize; 1116 1117 /* N_SO with null name indicates EOF */ 1118 if (bfd_get_32 (abfd, stab + STRDXOFF) == 0) 1119 nul_fun = NULL; 1120 else 1121 { 1122 nul_fun = stab; 1123 1124 /* two N_SO's in a row is a filename and directory. Skip */ 1125 if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize 1126 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO) 1127 stab += STABSIZE; 1128 } 1129 } 1130 else if (stab[TYPEOFF] == (bfd_byte) N_FUN 1131 && bfd_get_32 (abfd, stab + STRDXOFF) != 0) 1132 { 1133 nul_fun = NULL; 1134 ++info->indextablesize; 1135 } 1136 } 1137 1138 if (nul_fun != NULL) 1139 ++info->indextablesize; 1140 1141 if (info->indextablesize == 0) 1142 return TRUE; 1143 ++info->indextablesize; 1144 1145 amt = info->indextablesize; 1146 amt *= sizeof (struct indexentry); 1147 info->indextable = (struct indexentry *) bfd_alloc (abfd, amt); 1148 if (info->indextable == NULL) 1149 return FALSE; 1150 1151 file_name = NULL; 1152 directory_name = NULL; 1153 nul_fun = NULL; 1154 stroff = 0; 1155 1156 for (i = 0, stab = info->stabs, nul_str = str = info->strs; 1157 i < info->indextablesize && stab < info->stabs + stabsize; 1158 stab += STABSIZE) 1159 { 1160 switch (stab[TYPEOFF]) 1161 { 1162 case 0: 1163 /* This is the first entry in a compilation unit. */ 1164 if ((bfd_size_type) ((info->strs + strsize) - str) < stroff) 1165 break; 1166 str += stroff; 1167 stroff = bfd_get_32 (abfd, stab + VALOFF); 1168 break; 1169 1170 case N_SO: 1171 /* The main file name. */ 1172 1173 /* The following code creates a new indextable entry with 1174 a NULL function name if there were no N_FUNs in a file. 1175 Note that a N_SO without a file name is an EOF and 1176 there could be 2 N_SO following it with the new filename 1177 and directory. */ 1178 if (nul_fun != NULL) 1179 { 1180 info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF); 1181 info->indextable[i].stab = nul_fun; 1182 info->indextable[i].str = nul_str; 1183 info->indextable[i].directory_name = directory_name; 1184 info->indextable[i].file_name = file_name; 1185 info->indextable[i].function_name = NULL; 1186 info->indextable[i].idx = i; 1187 ++i; 1188 } 1189 1190 directory_name = NULL; 1191 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1192 if (file_name == (char *) str) 1193 { 1194 file_name = NULL; 1195 nul_fun = NULL; 1196 } 1197 else 1198 { 1199 nul_fun = stab; 1200 nul_str = str; 1201 if (file_name >= (char *) info->strs + strsize 1202 || file_name < (char *) str) 1203 file_name = NULL; 1204 if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize 1205 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO) 1206 { 1207 /* Two consecutive N_SOs are a directory and a 1208 file name. */ 1209 stab += STABSIZE; 1210 directory_name = file_name; 1211 file_name = ((char *) str 1212 + bfd_get_32 (abfd, stab + STRDXOFF)); 1213 if (file_name >= (char *) info->strs + strsize 1214 || file_name < (char *) str) 1215 file_name = NULL; 1216 } 1217 } 1218 break; 1219 1220 case N_SOL: 1221 /* The name of an include file. */ 1222 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1223 /* PR 17512: file: 0c680a1f. */ 1224 /* PR 17512: file: 5da8aec4. */ 1225 if (file_name >= (char *) info->strs + strsize 1226 || file_name < (char *) str) 1227 file_name = NULL; 1228 break; 1229 1230 case N_FUN: 1231 /* A function name. */ 1232 function_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1233 if (function_name == (char *) str) 1234 continue; 1235 if (function_name >= (char *) info->strs + strsize 1236 || function_name < (char *) str) 1237 function_name = NULL; 1238 1239 nul_fun = NULL; 1240 info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF); 1241 info->indextable[i].stab = stab; 1242 info->indextable[i].str = str; 1243 info->indextable[i].directory_name = directory_name; 1244 info->indextable[i].file_name = file_name; 1245 info->indextable[i].function_name = function_name; 1246 info->indextable[i].idx = i; 1247 ++i; 1248 break; 1249 } 1250 } 1251 1252 if (nul_fun != NULL) 1253 { 1254 info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF); 1255 info->indextable[i].stab = nul_fun; 1256 info->indextable[i].str = nul_str; 1257 info->indextable[i].directory_name = directory_name; 1258 info->indextable[i].file_name = file_name; 1259 info->indextable[i].function_name = NULL; 1260 info->indextable[i].idx = i; 1261 ++i; 1262 } 1263 1264 info->indextable[i].val = (bfd_vma) -1; 1265 info->indextable[i].stab = info->stabs + stabsize; 1266 info->indextable[i].str = str; 1267 info->indextable[i].directory_name = NULL; 1268 info->indextable[i].file_name = NULL; 1269 info->indextable[i].function_name = NULL; 1270 info->indextable[i].idx = i; 1271 ++i; 1272 1273 info->indextablesize = i; 1274 qsort (info->indextable, (size_t) i, sizeof (struct indexentry), 1275 cmpindexentry); 1276 1277 *pinfo = info; 1278 } 1279 1280 /* We are passed a section relative offset. The offsets in the 1281 stabs information are absolute. */ 1282 offset += bfd_section_vma (section); 1283 1284 #ifdef ENABLE_CACHING 1285 if (info->cached_indexentry != NULL 1286 && offset >= info->cached_offset 1287 && offset < (info->cached_indexentry + 1)->val) 1288 { 1289 stab = info->cached_stab; 1290 indexentry = info->cached_indexentry; 1291 file_name = info->cached_file_name; 1292 } 1293 else 1294 #endif 1295 { 1296 long low, high; 1297 long mid = -1; 1298 1299 /* Cache non-existent or invalid. Do binary search on 1300 indextable. */ 1301 indexentry = NULL; 1302 1303 low = 0; 1304 high = info->indextablesize - 1; 1305 while (low != high) 1306 { 1307 mid = (high + low) / 2; 1308 if (offset >= info->indextable[mid].val 1309 && offset < info->indextable[mid + 1].val) 1310 { 1311 indexentry = &info->indextable[mid]; 1312 break; 1313 } 1314 1315 if (info->indextable[mid].val > offset) 1316 high = mid; 1317 else 1318 low = mid + 1; 1319 } 1320 1321 if (indexentry == NULL) 1322 return TRUE; 1323 1324 stab = indexentry->stab + STABSIZE; 1325 file_name = indexentry->file_name; 1326 } 1327 1328 directory_name = indexentry->directory_name; 1329 str = indexentry->str; 1330 1331 saw_line = FALSE; 1332 saw_func = FALSE; 1333 for (; stab < (indexentry+1)->stab; stab += STABSIZE) 1334 { 1335 bfd_boolean done; 1336 bfd_vma val; 1337 1338 done = FALSE; 1339 1340 switch (stab[TYPEOFF]) 1341 { 1342 case N_SOL: 1343 /* The name of an include file. */ 1344 val = bfd_get_32 (abfd, stab + VALOFF); 1345 if (val <= offset) 1346 { 1347 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1348 if (file_name >= (char *) info->strs + strsize 1349 || file_name < (char *) str) 1350 file_name = NULL; 1351 *pline = 0; 1352 } 1353 break; 1354 1355 case N_SLINE: 1356 case N_DSLINE: 1357 case N_BSLINE: 1358 /* A line number. If the function was specified, then the value 1359 is relative to the start of the function. Otherwise, the 1360 value is an absolute address. */ 1361 val = ((indexentry->function_name ? indexentry->val : 0) 1362 + bfd_get_32 (abfd, stab + VALOFF)); 1363 /* If this line starts before our desired offset, or if it's 1364 the first line we've been able to find, use it. The 1365 !saw_line check works around a bug in GCC 2.95.3, which emits 1366 the first N_SLINE late. */ 1367 if (!saw_line || val <= offset) 1368 { 1369 *pline = bfd_get_16 (abfd, stab + DESCOFF); 1370 1371 #ifdef ENABLE_CACHING 1372 info->cached_stab = stab; 1373 info->cached_offset = val; 1374 info->cached_file_name = file_name; 1375 info->cached_indexentry = indexentry; 1376 #endif 1377 } 1378 if (val > offset) 1379 done = TRUE; 1380 saw_line = TRUE; 1381 break; 1382 1383 case N_FUN: 1384 case N_SO: 1385 if (saw_func || saw_line) 1386 done = TRUE; 1387 saw_func = TRUE; 1388 break; 1389 } 1390 1391 if (done) 1392 break; 1393 } 1394 1395 *pfound = TRUE; 1396 1397 if (file_name == NULL || IS_ABSOLUTE_PATH (file_name) 1398 || directory_name == NULL) 1399 *pfilename = file_name; 1400 else 1401 { 1402 size_t dirlen; 1403 1404 dirlen = strlen (directory_name); 1405 if (info->filename == NULL 1406 || filename_ncmp (info->filename, directory_name, dirlen) != 0 1407 || filename_cmp (info->filename + dirlen, file_name) != 0) 1408 { 1409 size_t len; 1410 1411 /* Don't free info->filename here. objdump and other 1412 apps keep a copy of a previously returned file name 1413 pointer. */ 1414 len = strlen (file_name) + 1; 1415 info->filename = (char *) bfd_alloc (abfd, dirlen + len); 1416 if (info->filename == NULL) 1417 return FALSE; 1418 memcpy (info->filename, directory_name, dirlen); 1419 memcpy (info->filename + dirlen, file_name, len); 1420 } 1421 1422 *pfilename = info->filename; 1423 } 1424 1425 if (indexentry->function_name != NULL) 1426 { 1427 char *s; 1428 1429 /* This will typically be something like main:F(0,1), so we want 1430 to clobber the colon. It's OK to change the name, since the 1431 string is in our own local storage anyhow. */ 1432 s = strchr (indexentry->function_name, ':'); 1433 if (s != NULL) 1434 *s = '\0'; 1435 1436 *pfnname = indexentry->function_name; 1437 } 1438 1439 return TRUE; 1440 } 1441 1442 long 1443 _bfd_nosymbols_canonicalize_symtab (bfd *abfd ATTRIBUTE_UNUSED, 1444 asymbol **location ATTRIBUTE_UNUSED) 1445 { 1446 return 0; 1447 } 1448 1449 void 1450 _bfd_nosymbols_print_symbol (bfd *abfd ATTRIBUTE_UNUSED, 1451 void *afile ATTRIBUTE_UNUSED, 1452 asymbol *symbol ATTRIBUTE_UNUSED, 1453 bfd_print_symbol_type how ATTRIBUTE_UNUSED) 1454 { 1455 } 1456 1457 void 1458 _bfd_nosymbols_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 1459 asymbol *sym ATTRIBUTE_UNUSED, 1460 symbol_info *ret ATTRIBUTE_UNUSED) 1461 { 1462 } 1463 1464 const char * 1465 _bfd_nosymbols_get_symbol_version_string (bfd *abfd, 1466 asymbol *symbol ATTRIBUTE_UNUSED, 1467 bfd_boolean base_p ATTRIBUTE_UNUSED, 1468 bfd_boolean *hidden ATTRIBUTE_UNUSED) 1469 { 1470 return (const char *) _bfd_ptr_bfd_null_error (abfd); 1471 } 1472 1473 bfd_boolean 1474 _bfd_nosymbols_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, 1475 const char *name ATTRIBUTE_UNUSED) 1476 { 1477 return FALSE; 1478 } 1479 1480 alent * 1481 _bfd_nosymbols_get_lineno (bfd *abfd, asymbol *sym ATTRIBUTE_UNUSED) 1482 { 1483 return (alent *) _bfd_ptr_bfd_null_error (abfd); 1484 } 1485 1486 bfd_boolean 1487 _bfd_nosymbols_find_nearest_line 1488 (bfd *abfd, 1489 asymbol **symbols ATTRIBUTE_UNUSED, 1490 asection *section ATTRIBUTE_UNUSED, 1491 bfd_vma offset ATTRIBUTE_UNUSED, 1492 const char **filename_ptr ATTRIBUTE_UNUSED, 1493 const char **functionname_ptr ATTRIBUTE_UNUSED, 1494 unsigned int *line_ptr ATTRIBUTE_UNUSED, 1495 unsigned int *discriminator_ptr ATTRIBUTE_UNUSED) 1496 { 1497 return _bfd_bool_bfd_false_error (abfd); 1498 } 1499 1500 bfd_boolean 1501 _bfd_nosymbols_find_line (bfd *abfd, 1502 asymbol **symbols ATTRIBUTE_UNUSED, 1503 asymbol *symbol ATTRIBUTE_UNUSED, 1504 const char **filename_ptr ATTRIBUTE_UNUSED, 1505 unsigned int *line_ptr ATTRIBUTE_UNUSED) 1506 { 1507 return _bfd_bool_bfd_false_error (abfd); 1508 } 1509 1510 bfd_boolean 1511 _bfd_nosymbols_find_inliner_info 1512 (bfd *abfd, 1513 const char **filename_ptr ATTRIBUTE_UNUSED, 1514 const char **functionname_ptr ATTRIBUTE_UNUSED, 1515 unsigned int *line_ptr ATTRIBUTE_UNUSED) 1516 { 1517 return _bfd_bool_bfd_false_error (abfd); 1518 } 1519 1520 asymbol * 1521 _bfd_nosymbols_bfd_make_debug_symbol (bfd *abfd, 1522 void *ptr ATTRIBUTE_UNUSED, 1523 unsigned long sz ATTRIBUTE_UNUSED) 1524 { 1525 return (asymbol *) _bfd_ptr_bfd_null_error (abfd); 1526 } 1527 1528 long 1529 _bfd_nosymbols_read_minisymbols (bfd *abfd, 1530 bfd_boolean dynamic ATTRIBUTE_UNUSED, 1531 void **minisymsp ATTRIBUTE_UNUSED, 1532 unsigned int *sizep ATTRIBUTE_UNUSED) 1533 { 1534 return _bfd_long_bfd_n1_error (abfd); 1535 } 1536 1537 asymbol * 1538 _bfd_nosymbols_minisymbol_to_symbol (bfd *abfd, 1539 bfd_boolean dynamic ATTRIBUTE_UNUSED, 1540 const void *minisym ATTRIBUTE_UNUSED, 1541 asymbol *sym ATTRIBUTE_UNUSED) 1542 { 1543 return (asymbol *) _bfd_ptr_bfd_null_error (abfd); 1544 } 1545 1546 long 1547 _bfd_nodynamic_get_synthetic_symtab (bfd *abfd, 1548 long symcount ATTRIBUTE_UNUSED, 1549 asymbol **syms ATTRIBUTE_UNUSED, 1550 long dynsymcount ATTRIBUTE_UNUSED, 1551 asymbol **dynsyms ATTRIBUTE_UNUSED, 1552 asymbol **ret ATTRIBUTE_UNUSED) 1553 { 1554 return _bfd_long_bfd_n1_error (abfd); 1555 } 1556
Indexes created Tue Mar 17 00:23:13 UTC 2026