syms.c revision 1.1.1.8
1 /* Generic symbol-table support for the BFD library. 2 Copyright (C) 1990-2019 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 bfd_get_outsymbols (abfd) = location; 459 bfd_get_symcount (abfd) = 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 bfd_size_type 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 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 {".bss", 'b'}, 574 {"code", 't'}, /* MRI .text */ 575 {".data", 'd'}, 576 {"*DEBUG*", 'N'}, 577 {".debug", 'N'}, /* MSVC's .debug (non-standard debug syms) */ 578 {".drectve", 'i'}, /* MSVC's .drective section */ 579 {".edata", 'e'}, /* MSVC's .edata (export) section */ 580 {".fini", 't'}, /* ELF fini section */ 581 {".idata", 'i'}, /* MSVC's .idata (import) section */ 582 {".init", 't'}, /* ELF init section */ 583 {".pdata", 'p'}, /* MSVC's .pdata (stack unwind) section */ 584 {".rdata", 'r'}, /* Read only data. */ 585 {".rodata", 'r'}, /* Read only data. */ 586 {".sbss", 's'}, /* Small BSS (uninitialized data). */ 587 {".scommon", 'c'}, /* Small common. */ 588 {".sdata", 'g'}, /* Small initialized data. */ 589 {".text", 't'}, 590 {"vars", 'd'}, /* MRI .data */ 591 {"zerovars", 'b'}, /* MRI .bss */ 592 {0, 0} 593 }; 594 595 /* Return the single-character symbol type corresponding to 596 section S, or '?' for an unknown COFF section. 597 598 Check for any leading string which matches, so .text5 returns 599 't' as well as .text */ 600 601 static char 602 coff_section_type (const char *s) 603 { 604 const struct section_to_type *t; 605 606 for (t = &stt[0]; t->section; t++) 607 if (!strncmp (s, t->section, strlen (t->section))) 608 return t->type; 609 610 return '?'; 611 } 612 613 /* Return the single-character symbol type corresponding to section 614 SECTION, or '?' for an unknown section. This uses section flags to 615 identify sections. 616 617 FIXME These types are unhandled: c, i, e, p. If we handled these also, 618 we could perhaps obsolete coff_section_type. */ 619 620 static char 621 decode_section_type (const struct bfd_section *section) 622 { 623 if (section->flags & SEC_CODE) 624 return 't'; 625 if (section->flags & SEC_DATA) 626 { 627 if (section->flags & SEC_READONLY) 628 return 'r'; 629 else if (section->flags & SEC_SMALL_DATA) 630 return 'g'; 631 else 632 return 'd'; 633 } 634 if ((section->flags & SEC_HAS_CONTENTS) == 0) 635 { 636 if (section->flags & SEC_SMALL_DATA) 637 return 's'; 638 else 639 return 'b'; 640 } 641 if (section->flags & SEC_DEBUGGING) 642 return 'N'; 643 if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY)) 644 return 'n'; 645 646 return '?'; 647 } 648 649 /* 650 FUNCTION 651 bfd_decode_symclass 652 653 DESCRIPTION 654 Return a character corresponding to the symbol 655 class of @var{symbol}, or '?' for an unknown class. 656 657 SYNOPSIS 658 int bfd_decode_symclass (asymbol *symbol); 659 */ 660 int 661 bfd_decode_symclass (asymbol *symbol) 662 { 663 char c; 664 665 if (symbol->section && bfd_is_com_section (symbol->section)) 666 return 'C'; 667 if (bfd_is_und_section (symbol->section)) 668 { 669 if (symbol->flags & BSF_WEAK) 670 { 671 /* If weak, determine if it's specifically an object 672 or non-object weak. */ 673 if (symbol->flags & BSF_OBJECT) 674 return 'v'; 675 else 676 return 'w'; 677 } 678 else 679 return 'U'; 680 } 681 if (bfd_is_ind_section (symbol->section)) 682 return 'I'; 683 if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION) 684 return 'i'; 685 if (symbol->flags & BSF_WEAK) 686 { 687 /* If weak, determine if it's specifically an object 688 or non-object weak. */ 689 if (symbol->flags & BSF_OBJECT) 690 return 'V'; 691 else 692 return 'W'; 693 } 694 if (symbol->flags & BSF_GNU_UNIQUE) 695 return 'u'; 696 if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL))) 697 return '?'; 698 699 if (bfd_is_abs_section (symbol->section)) 700 c = 'a'; 701 else if (symbol->section) 702 { 703 c = coff_section_type (symbol->section->name); 704 if (c == '?') 705 c = decode_section_type (symbol->section); 706 } 707 else 708 return '?'; 709 if (symbol->flags & BSF_GLOBAL) 710 c = TOUPPER (c); 711 return c; 712 713 /* We don't have to handle these cases just yet, but we will soon: 714 N_SETV: 'v'; 715 N_SETA: 'l'; 716 N_SETT: 'x'; 717 N_SETD: 'z'; 718 N_SETB: 's'; 719 N_INDR: 'i'; 720 */ 721 } 722 723 /* 724 FUNCTION 725 bfd_is_undefined_symclass 726 727 DESCRIPTION 728 Returns non-zero if the class symbol returned by 729 bfd_decode_symclass represents an undefined symbol. 730 Returns zero otherwise. 731 732 SYNOPSIS 733 bfd_boolean bfd_is_undefined_symclass (int symclass); 734 */ 735 736 bfd_boolean 737 bfd_is_undefined_symclass (int symclass) 738 { 739 return symclass == 'U' || symclass == 'w' || symclass == 'v'; 740 } 741 742 /* 743 FUNCTION 744 bfd_symbol_info 745 746 DESCRIPTION 747 Fill in the basic info about symbol that nm needs. 748 Additional info may be added by the back-ends after 749 calling this function. 750 751 SYNOPSIS 752 void bfd_symbol_info (asymbol *symbol, symbol_info *ret); 753 */ 754 755 void 756 bfd_symbol_info (asymbol *symbol, symbol_info *ret) 757 { 758 ret->type = bfd_decode_symclass (symbol); 759 760 if (bfd_is_undefined_symclass (ret->type)) 761 ret->value = 0; 762 else 763 ret->value = symbol->value + symbol->section->vma; 764 765 ret->name = symbol->name; 766 } 767 768 /* 769 FUNCTION 770 bfd_copy_private_symbol_data 771 772 SYNOPSIS 773 bfd_boolean bfd_copy_private_symbol_data 774 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); 775 776 DESCRIPTION 777 Copy private symbol information from @var{isym} in the BFD 778 @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}. 779 Return <<TRUE>> on success, <<FALSE>> on error. Possible error 780 returns are: 781 782 o <<bfd_error_no_memory>> - 783 Not enough memory exists to create private data for @var{osec}. 784 785 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ 786 . BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ 787 . (ibfd, isymbol, obfd, osymbol)) 788 . 789 */ 790 791 /* The generic version of the function which returns mini symbols. 792 This is used when the backend does not provide a more efficient 793 version. It just uses BFD asymbol structures as mini symbols. */ 794 795 long 796 _bfd_generic_read_minisymbols (bfd *abfd, 797 bfd_boolean dynamic, 798 void **minisymsp, 799 unsigned int *sizep) 800 { 801 long storage; 802 asymbol **syms = NULL; 803 long symcount; 804 805 if (dynamic) 806 storage = bfd_get_dynamic_symtab_upper_bound (abfd); 807 else 808 storage = bfd_get_symtab_upper_bound (abfd); 809 if (storage < 0) 810 goto error_return; 811 if (storage == 0) 812 return 0; 813 814 syms = (asymbol **) bfd_malloc (storage); 815 if (syms == NULL) 816 goto error_return; 817 818 if (dynamic) 819 symcount = bfd_canonicalize_dynamic_symtab (abfd, syms); 820 else 821 symcount = bfd_canonicalize_symtab (abfd, syms); 822 if (symcount < 0) 823 goto error_return; 824 825 if (symcount == 0) 826 /* We return 0 above when storage is 0. Exit in the same state 827 here, so as to not complicate callers with having to deal with 828 freeing memory for zero symcount. */ 829 free (syms); 830 else 831 { 832 *minisymsp = syms; 833 *sizep = sizeof (asymbol *); 834 } 835 return symcount; 836 837 error_return: 838 bfd_set_error (bfd_error_no_symbols); 839 if (syms != NULL) 840 free (syms); 841 return -1; 842 } 843 844 /* The generic version of the function which converts a minisymbol to 845 an asymbol. We don't worry about the sym argument we are passed; 846 we just return the asymbol the minisymbol points to. */ 847 848 asymbol * 849 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED, 850 bfd_boolean dynamic ATTRIBUTE_UNUSED, 851 const void *minisym, 852 asymbol *sym ATTRIBUTE_UNUSED) 853 { 854 return *(asymbol **) minisym; 855 } 856 857 /* Look through stabs debugging information in .stab and .stabstr 858 sections to find the source file and line closest to a desired 859 location. This is used by COFF and ELF targets. It sets *pfound 860 to TRUE if it finds some information. The *pinfo field is used to 861 pass cached information in and out of this routine; this first time 862 the routine is called for a BFD, *pinfo should be NULL. The value 863 placed in *pinfo should be saved with the BFD, and passed back each 864 time this function is called. */ 865 866 /* We use a cache by default. */ 867 868 #define ENABLE_CACHING 869 870 /* We keep an array of indexentry structures to record where in the 871 stabs section we should look to find line number information for a 872 particular address. */ 873 874 struct indexentry 875 { 876 bfd_vma val; 877 bfd_byte *stab; 878 bfd_byte *str; 879 char *directory_name; 880 char *file_name; 881 char *function_name; 882 }; 883 884 /* Compare two indexentry structures. This is called via qsort. */ 885 886 static int 887 cmpindexentry (const void *a, const void *b) 888 { 889 const struct indexentry *contestantA = (const struct indexentry *) a; 890 const struct indexentry *contestantB = (const struct indexentry *) b; 891 892 if (contestantA->val < contestantB->val) 893 return -1; 894 else if (contestantA->val > contestantB->val) 895 return 1; 896 else 897 return 0; 898 } 899 900 /* A pointer to this structure is stored in *pinfo. */ 901 902 struct stab_find_info 903 { 904 /* The .stab section. */ 905 asection *stabsec; 906 /* The .stabstr section. */ 907 asection *strsec; 908 /* The contents of the .stab section. */ 909 bfd_byte *stabs; 910 /* The contents of the .stabstr section. */ 911 bfd_byte *strs; 912 913 /* A table that indexes stabs by memory address. */ 914 struct indexentry *indextable; 915 /* The number of entries in indextable. */ 916 int indextablesize; 917 918 #ifdef ENABLE_CACHING 919 /* Cached values to restart quickly. */ 920 struct indexentry *cached_indexentry; 921 bfd_vma cached_offset; 922 bfd_byte *cached_stab; 923 char *cached_file_name; 924 #endif 925 926 /* Saved ptr to malloc'ed filename. */ 927 char *filename; 928 }; 929 930 bfd_boolean 931 _bfd_stab_section_find_nearest_line (bfd *abfd, 932 asymbol **symbols, 933 asection *section, 934 bfd_vma offset, 935 bfd_boolean *pfound, 936 const char **pfilename, 937 const char **pfnname, 938 unsigned int *pline, 939 void **pinfo) 940 { 941 struct stab_find_info *info; 942 bfd_size_type stabsize, strsize; 943 bfd_byte *stab, *str; 944 bfd_byte *nul_fun, *nul_str; 945 bfd_size_type stroff; 946 struct indexentry *indexentry; 947 char *file_name; 948 char *directory_name; 949 bfd_boolean saw_line, saw_func; 950 951 *pfound = FALSE; 952 *pfilename = bfd_get_filename (abfd); 953 *pfnname = NULL; 954 *pline = 0; 955 956 /* Stabs entries use a 12 byte format: 957 4 byte string table index 958 1 byte stab type 959 1 byte stab other field 960 2 byte stab desc field 961 4 byte stab value 962 FIXME: This will have to change for a 64 bit object format. 963 964 The stabs symbols are divided into compilation units. For the 965 first entry in each unit, the type of 0, the value is the length 966 of the string table for this unit, and the desc field is the 967 number of stabs symbols for this unit. */ 968 969 #define STRDXOFF (0) 970 #define TYPEOFF (4) 971 #define OTHEROFF (5) 972 #define DESCOFF (6) 973 #define VALOFF (8) 974 #define STABSIZE (12) 975 976 info = (struct stab_find_info *) *pinfo; 977 if (info != NULL) 978 { 979 if (info->stabsec == NULL || info->strsec == NULL) 980 { 981 /* No stabs debugging information. */ 982 return TRUE; 983 } 984 985 stabsize = (info->stabsec->rawsize 986 ? info->stabsec->rawsize 987 : info->stabsec->size); 988 strsize = (info->strsec->rawsize 989 ? info->strsec->rawsize 990 : info->strsec->size); 991 } 992 else 993 { 994 long reloc_size, reloc_count; 995 arelent **reloc_vector; 996 int i; 997 char *function_name; 998 bfd_size_type amt = sizeof *info; 999 1000 info = (struct stab_find_info *) bfd_zalloc (abfd, amt); 1001 if (info == NULL) 1002 return FALSE; 1003 1004 /* FIXME: When using the linker --split-by-file or 1005 --split-by-reloc options, it is possible for the .stab and 1006 .stabstr sections to be split. We should handle that. */ 1007 1008 info->stabsec = bfd_get_section_by_name (abfd, ".stab"); 1009 info->strsec = bfd_get_section_by_name (abfd, ".stabstr"); 1010 1011 if (info->stabsec == NULL || info->strsec == NULL) 1012 { 1013 /* Try SOM section names. */ 1014 info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$"); 1015 info->strsec = bfd_get_section_by_name (abfd, "$GDB_STRINGS$"); 1016 1017 if (info->stabsec == NULL || info->strsec == NULL) 1018 { 1019 /* No stabs debugging information. Set *pinfo so that we 1020 can return quickly in the info != NULL case above. */ 1021 *pinfo = info; 1022 return TRUE; 1023 } 1024 } 1025 1026 stabsize = (info->stabsec->rawsize 1027 ? info->stabsec->rawsize 1028 : info->stabsec->size); 1029 stabsize = (stabsize / STABSIZE) * STABSIZE; 1030 strsize = (info->strsec->rawsize 1031 ? info->strsec->rawsize 1032 : info->strsec->size); 1033 1034 info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize); 1035 info->strs = (bfd_byte *) bfd_alloc (abfd, strsize); 1036 if (info->stabs == NULL || info->strs == NULL) 1037 return FALSE; 1038 1039 if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs, 1040 0, stabsize) 1041 || ! bfd_get_section_contents (abfd, info->strsec, info->strs, 1042 0, strsize)) 1043 return FALSE; 1044 1045 /* Stab strings ought to be nul terminated. Ensure the last one 1046 is, to prevent running off the end of the buffer. */ 1047 info->strs[strsize - 1] = 0; 1048 1049 /* If this is a relocatable object file, we have to relocate 1050 the entries in .stab. This should always be simple 32 bit 1051 relocations against symbols defined in this object file, so 1052 this should be no big deal. */ 1053 reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec); 1054 if (reloc_size < 0) 1055 return FALSE; 1056 reloc_vector = (arelent **) bfd_malloc (reloc_size); 1057 if (reloc_vector == NULL && reloc_size != 0) 1058 return FALSE; 1059 reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector, 1060 symbols); 1061 if (reloc_count < 0) 1062 { 1063 if (reloc_vector != NULL) 1064 free (reloc_vector); 1065 return FALSE; 1066 } 1067 if (reloc_count > 0) 1068 { 1069 arelent **pr; 1070 1071 for (pr = reloc_vector; *pr != NULL; pr++) 1072 { 1073 arelent *r; 1074 unsigned long val; 1075 asymbol *sym; 1076 1077 r = *pr; 1078 /* Ignore R_*_NONE relocs. */ 1079 if (r->howto->dst_mask == 0) 1080 continue; 1081 1082 if (r->howto->rightshift != 0 1083 || r->howto->size != 2 1084 || r->howto->bitsize != 32 1085 || r->howto->pc_relative 1086 || r->howto->bitpos != 0 1087 || r->howto->dst_mask != 0xffffffff 1088 || r->address * bfd_octets_per_byte (abfd) + 4 > stabsize) 1089 { 1090 _bfd_error_handler 1091 (_("unsupported .stab relocation")); 1092 bfd_set_error (bfd_error_invalid_operation); 1093 if (reloc_vector != NULL) 1094 free (reloc_vector); 1095 return FALSE; 1096 } 1097 1098 val = bfd_get_32 (abfd, info->stabs 1099 + r->address * bfd_octets_per_byte (abfd)); 1100 val &= r->howto->src_mask; 1101 sym = *r->sym_ptr_ptr; 1102 val += sym->value + sym->section->vma + r->addend; 1103 bfd_put_32 (abfd, (bfd_vma) val, info->stabs 1104 + r->address * bfd_octets_per_byte (abfd)); 1105 } 1106 } 1107 1108 if (reloc_vector != NULL) 1109 free (reloc_vector); 1110 1111 /* First time through this function, build a table matching 1112 function VM addresses to stabs, then sort based on starting 1113 VM address. Do this in two passes: once to count how many 1114 table entries we'll need, and a second to actually build the 1115 table. */ 1116 1117 info->indextablesize = 0; 1118 nul_fun = NULL; 1119 for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE) 1120 { 1121 if (stab[TYPEOFF] == (bfd_byte) N_SO) 1122 { 1123 /* if we did not see a function def, leave space for one. */ 1124 if (nul_fun != NULL) 1125 ++info->indextablesize; 1126 1127 /* N_SO with null name indicates EOF */ 1128 if (bfd_get_32 (abfd, stab + STRDXOFF) == 0) 1129 nul_fun = NULL; 1130 else 1131 { 1132 nul_fun = stab; 1133 1134 /* two N_SO's in a row is a filename and directory. Skip */ 1135 if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize 1136 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO) 1137 stab += STABSIZE; 1138 } 1139 } 1140 else if (stab[TYPEOFF] == (bfd_byte) N_FUN 1141 && bfd_get_32 (abfd, stab + STRDXOFF) != 0) 1142 { 1143 nul_fun = NULL; 1144 ++info->indextablesize; 1145 } 1146 } 1147 1148 if (nul_fun != NULL) 1149 ++info->indextablesize; 1150 1151 if (info->indextablesize == 0) 1152 return TRUE; 1153 ++info->indextablesize; 1154 1155 amt = info->indextablesize; 1156 amt *= sizeof (struct indexentry); 1157 info->indextable = (struct indexentry *) bfd_alloc (abfd, amt); 1158 if (info->indextable == NULL) 1159 return FALSE; 1160 1161 file_name = NULL; 1162 directory_name = NULL; 1163 nul_fun = NULL; 1164 stroff = 0; 1165 1166 for (i = 0, stab = info->stabs, nul_str = str = info->strs; 1167 i < info->indextablesize && stab < info->stabs + stabsize; 1168 stab += STABSIZE) 1169 { 1170 switch (stab[TYPEOFF]) 1171 { 1172 case 0: 1173 /* This is the first entry in a compilation unit. */ 1174 if ((bfd_size_type) ((info->strs + strsize) - str) < stroff) 1175 break; 1176 str += stroff; 1177 stroff = bfd_get_32 (abfd, stab + VALOFF); 1178 break; 1179 1180 case N_SO: 1181 /* The main file name. */ 1182 1183 /* The following code creates a new indextable entry with 1184 a NULL function name if there were no N_FUNs in a file. 1185 Note that a N_SO without a file name is an EOF and 1186 there could be 2 N_SO following it with the new filename 1187 and directory. */ 1188 if (nul_fun != NULL) 1189 { 1190 info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF); 1191 info->indextable[i].stab = nul_fun; 1192 info->indextable[i].str = nul_str; 1193 info->indextable[i].directory_name = directory_name; 1194 info->indextable[i].file_name = file_name; 1195 info->indextable[i].function_name = NULL; 1196 ++i; 1197 } 1198 1199 directory_name = NULL; 1200 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1201 if (file_name == (char *) str) 1202 { 1203 file_name = NULL; 1204 nul_fun = NULL; 1205 } 1206 else 1207 { 1208 nul_fun = stab; 1209 nul_str = str; 1210 if (file_name >= (char *) info->strs + strsize 1211 || file_name < (char *) str) 1212 file_name = NULL; 1213 if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize 1214 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO) 1215 { 1216 /* Two consecutive N_SOs are a directory and a 1217 file name. */ 1218 stab += STABSIZE; 1219 directory_name = file_name; 1220 file_name = ((char *) str 1221 + bfd_get_32 (abfd, stab + STRDXOFF)); 1222 if (file_name >= (char *) info->strs + strsize 1223 || file_name < (char *) str) 1224 file_name = NULL; 1225 } 1226 } 1227 break; 1228 1229 case N_SOL: 1230 /* The name of an include file. */ 1231 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1232 /* PR 17512: file: 0c680a1f. */ 1233 /* PR 17512: file: 5da8aec4. */ 1234 if (file_name >= (char *) info->strs + strsize 1235 || file_name < (char *) str) 1236 file_name = NULL; 1237 break; 1238 1239 case N_FUN: 1240 /* A function name. */ 1241 function_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1242 if (function_name == (char *) str) 1243 continue; 1244 if (function_name >= (char *) info->strs + strsize 1245 || function_name < (char *) str) 1246 function_name = NULL; 1247 1248 nul_fun = NULL; 1249 info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF); 1250 info->indextable[i].stab = stab; 1251 info->indextable[i].str = str; 1252 info->indextable[i].directory_name = directory_name; 1253 info->indextable[i].file_name = file_name; 1254 info->indextable[i].function_name = function_name; 1255 ++i; 1256 break; 1257 } 1258 } 1259 1260 if (nul_fun != NULL) 1261 { 1262 info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF); 1263 info->indextable[i].stab = nul_fun; 1264 info->indextable[i].str = nul_str; 1265 info->indextable[i].directory_name = directory_name; 1266 info->indextable[i].file_name = file_name; 1267 info->indextable[i].function_name = NULL; 1268 ++i; 1269 } 1270 1271 info->indextable[i].val = (bfd_vma) -1; 1272 info->indextable[i].stab = info->stabs + stabsize; 1273 info->indextable[i].str = str; 1274 info->indextable[i].directory_name = NULL; 1275 info->indextable[i].file_name = NULL; 1276 info->indextable[i].function_name = NULL; 1277 ++i; 1278 1279 info->indextablesize = i; 1280 qsort (info->indextable, (size_t) i, sizeof (struct indexentry), 1281 cmpindexentry); 1282 1283 *pinfo = info; 1284 } 1285 1286 /* We are passed a section relative offset. The offsets in the 1287 stabs information are absolute. */ 1288 offset += bfd_get_section_vma (abfd, section); 1289 1290 #ifdef ENABLE_CACHING 1291 if (info->cached_indexentry != NULL 1292 && offset >= info->cached_offset 1293 && offset < (info->cached_indexentry + 1)->val) 1294 { 1295 stab = info->cached_stab; 1296 indexentry = info->cached_indexentry; 1297 file_name = info->cached_file_name; 1298 } 1299 else 1300 #endif 1301 { 1302 long low, high; 1303 long mid = -1; 1304 1305 /* Cache non-existent or invalid. Do binary search on 1306 indextable. */ 1307 indexentry = NULL; 1308 1309 low = 0; 1310 high = info->indextablesize - 1; 1311 while (low != high) 1312 { 1313 mid = (high + low) / 2; 1314 if (offset >= info->indextable[mid].val 1315 && offset < info->indextable[mid + 1].val) 1316 { 1317 indexentry = &info->indextable[mid]; 1318 break; 1319 } 1320 1321 if (info->indextable[mid].val > offset) 1322 high = mid; 1323 else 1324 low = mid + 1; 1325 } 1326 1327 if (indexentry == NULL) 1328 return TRUE; 1329 1330 stab = indexentry->stab + STABSIZE; 1331 file_name = indexentry->file_name; 1332 } 1333 1334 directory_name = indexentry->directory_name; 1335 str = indexentry->str; 1336 1337 saw_line = FALSE; 1338 saw_func = FALSE; 1339 for (; stab < (indexentry+1)->stab; stab += STABSIZE) 1340 { 1341 bfd_boolean done; 1342 bfd_vma val; 1343 1344 done = FALSE; 1345 1346 switch (stab[TYPEOFF]) 1347 { 1348 case N_SOL: 1349 /* The name of an include file. */ 1350 val = bfd_get_32 (abfd, stab + VALOFF); 1351 if (val <= offset) 1352 { 1353 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1354 if (file_name >= (char *) info->strs + strsize 1355 || file_name < (char *) str) 1356 file_name = NULL; 1357 *pline = 0; 1358 } 1359 break; 1360 1361 case N_SLINE: 1362 case N_DSLINE: 1363 case N_BSLINE: 1364 /* A line number. If the function was specified, then the value 1365 is relative to the start of the function. Otherwise, the 1366 value is an absolute address. */ 1367 val = ((indexentry->function_name ? indexentry->val : 0) 1368 + bfd_get_32 (abfd, stab + VALOFF)); 1369 /* If this line starts before our desired offset, or if it's 1370 the first line we've been able to find, use it. The 1371 !saw_line check works around a bug in GCC 2.95.3, which emits 1372 the first N_SLINE late. */ 1373 if (!saw_line || val <= offset) 1374 { 1375 *pline = bfd_get_16 (abfd, stab + DESCOFF); 1376 1377 #ifdef ENABLE_CACHING 1378 info->cached_stab = stab; 1379 info->cached_offset = val; 1380 info->cached_file_name = file_name; 1381 info->cached_indexentry = indexentry; 1382 #endif 1383 } 1384 if (val > offset) 1385 done = TRUE; 1386 saw_line = TRUE; 1387 break; 1388 1389 case N_FUN: 1390 case N_SO: 1391 if (saw_func || saw_line) 1392 done = TRUE; 1393 saw_func = TRUE; 1394 break; 1395 } 1396 1397 if (done) 1398 break; 1399 } 1400 1401 *pfound = TRUE; 1402 1403 if (file_name == NULL || IS_ABSOLUTE_PATH (file_name) 1404 || directory_name == NULL) 1405 *pfilename = file_name; 1406 else 1407 { 1408 size_t dirlen; 1409 1410 dirlen = strlen (directory_name); 1411 if (info->filename == NULL 1412 || filename_ncmp (info->filename, directory_name, dirlen) != 0 1413 || filename_cmp (info->filename + dirlen, file_name) != 0) 1414 { 1415 size_t len; 1416 1417 /* Don't free info->filename here. objdump and other 1418 apps keep a copy of a previously returned file name 1419 pointer. */ 1420 len = strlen (file_name) + 1; 1421 info->filename = (char *) bfd_alloc (abfd, dirlen + len); 1422 if (info->filename == NULL) 1423 return FALSE; 1424 memcpy (info->filename, directory_name, dirlen); 1425 memcpy (info->filename + dirlen, file_name, len); 1426 } 1427 1428 *pfilename = info->filename; 1429 } 1430 1431 if (indexentry->function_name != NULL) 1432 { 1433 char *s; 1434 1435 /* This will typically be something like main:F(0,1), so we want 1436 to clobber the colon. It's OK to change the name, since the 1437 string is in our own local storage anyhow. */ 1438 s = strchr (indexentry->function_name, ':'); 1439 if (s != NULL) 1440 *s = '\0'; 1441 1442 *pfnname = indexentry->function_name; 1443 } 1444 1445 return TRUE; 1446 } 1447 1448 long 1449 _bfd_nosymbols_canonicalize_symtab (bfd *abfd ATTRIBUTE_UNUSED, 1450 asymbol **location ATTRIBUTE_UNUSED) 1451 { 1452 return 0; 1453 } 1454 1455 void 1456 _bfd_nosymbols_print_symbol (bfd *abfd ATTRIBUTE_UNUSED, 1457 void *afile ATTRIBUTE_UNUSED, 1458 asymbol *symbol ATTRIBUTE_UNUSED, 1459 bfd_print_symbol_type how ATTRIBUTE_UNUSED) 1460 { 1461 } 1462 1463 void 1464 _bfd_nosymbols_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 1465 asymbol *sym ATTRIBUTE_UNUSED, 1466 symbol_info *ret ATTRIBUTE_UNUSED) 1467 { 1468 } 1469 1470 const char * 1471 _bfd_nosymbols_get_symbol_version_string (bfd *abfd, 1472 asymbol *symbol ATTRIBUTE_UNUSED, 1473 bfd_boolean *hidden ATTRIBUTE_UNUSED) 1474 { 1475 return (const char *) _bfd_ptr_bfd_null_error (abfd); 1476 } 1477 1478 bfd_boolean 1479 _bfd_nosymbols_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, 1480 const char *name ATTRIBUTE_UNUSED) 1481 { 1482 return FALSE; 1483 } 1484 1485 alent * 1486 _bfd_nosymbols_get_lineno (bfd *abfd, asymbol *sym ATTRIBUTE_UNUSED) 1487 { 1488 return (alent *) _bfd_ptr_bfd_null_error (abfd); 1489 } 1490 1491 bfd_boolean 1492 _bfd_nosymbols_find_nearest_line 1493 (bfd *abfd, 1494 asymbol **symbols ATTRIBUTE_UNUSED, 1495 asection *section ATTRIBUTE_UNUSED, 1496 bfd_vma offset ATTRIBUTE_UNUSED, 1497 const char **filename_ptr ATTRIBUTE_UNUSED, 1498 const char **functionname_ptr ATTRIBUTE_UNUSED, 1499 unsigned int *line_ptr ATTRIBUTE_UNUSED, 1500 unsigned int *discriminator_ptr ATTRIBUTE_UNUSED) 1501 { 1502 return _bfd_bool_bfd_false_error (abfd); 1503 } 1504 1505 bfd_boolean 1506 _bfd_nosymbols_find_line (bfd *abfd, 1507 asymbol **symbols ATTRIBUTE_UNUSED, 1508 asymbol *symbol ATTRIBUTE_UNUSED, 1509 const char **filename_ptr ATTRIBUTE_UNUSED, 1510 unsigned int *line_ptr ATTRIBUTE_UNUSED) 1511 { 1512 return _bfd_bool_bfd_false_error (abfd); 1513 } 1514 1515 bfd_boolean 1516 _bfd_nosymbols_find_inliner_info 1517 (bfd *abfd, 1518 const char **filename_ptr ATTRIBUTE_UNUSED, 1519 const char **functionname_ptr ATTRIBUTE_UNUSED, 1520 unsigned int *line_ptr ATTRIBUTE_UNUSED) 1521 { 1522 return _bfd_bool_bfd_false_error (abfd); 1523 } 1524 1525 asymbol * 1526 _bfd_nosymbols_bfd_make_debug_symbol (bfd *abfd, 1527 void *ptr ATTRIBUTE_UNUSED, 1528 unsigned long sz ATTRIBUTE_UNUSED) 1529 { 1530 return (asymbol *) _bfd_ptr_bfd_null_error (abfd); 1531 } 1532 1533 long 1534 _bfd_nosymbols_read_minisymbols (bfd *abfd, 1535 bfd_boolean dynamic ATTRIBUTE_UNUSED, 1536 void **minisymsp ATTRIBUTE_UNUSED, 1537 unsigned int *sizep ATTRIBUTE_UNUSED) 1538 { 1539 return _bfd_long_bfd_n1_error (abfd); 1540 } 1541 1542 asymbol * 1543 _bfd_nosymbols_minisymbol_to_symbol (bfd *abfd, 1544 bfd_boolean dynamic ATTRIBUTE_UNUSED, 1545 const void *minisym ATTRIBUTE_UNUSED, 1546 asymbol *sym ATTRIBUTE_UNUSED) 1547 { 1548 return (asymbol *) _bfd_ptr_bfd_null_error (abfd); 1549 } 1550 1551 long 1552 _bfd_nodynamic_get_synthetic_symtab (bfd *abfd, 1553 long symcount ATTRIBUTE_UNUSED, 1554 asymbol **syms ATTRIBUTE_UNUSED, 1555 long dynsymcount ATTRIBUTE_UNUSED, 1556 asymbol **dynsyms ATTRIBUTE_UNUSED, 1557 asymbol **ret ATTRIBUTE_UNUSED) 1558 { 1559 return _bfd_long_bfd_n1_error (abfd); 1560 } 1561
Indexes created Tue Mar 17 00:23:13 UTC 2026