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