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