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