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 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. {* This symbol represents a complex relocation expression, 292. with the expression tree serialized in the symbol name. *} 293.#define BSF_RELC 0x80000 294. 295. {* This symbol represents a signed complex relocation expression, 296. with the expression tree serialized in the symbol name. *} 297.#define BSF_SRELC 0x100000 298. 299. flagword flags; 300. 301. {* A pointer to the section to which this symbol is 302. relative. This will always be non NULL, there are special 303. sections for undefined and absolute symbols. *} 304. struct bfd_section *section; 305. 306. {* Back end special data. *} 307. union 308. { 309. void *p; 310. bfd_vma i; 311. } 312. udata; 313.} 314.asymbol; 315. 316*/ 317 318#include "sysdep.h" 319#include "bfd.h" 320#include "libbfd.h" 321#include "safe-ctype.h" 322#include "bfdlink.h" 323#include "aout/stab_gnu.h" 324 325/* 326DOCDD 327INODE 328symbol handling functions, , typedef asymbol, Symbols 329SUBSECTION 330 Symbol handling functions 331*/ 332 333/* 334FUNCTION 335 bfd_get_symtab_upper_bound 336 337DESCRIPTION 338 Return the number of bytes required to store a vector of pointers 339 to <<asymbols>> for all the symbols in the BFD @var{abfd}, 340 including a terminal NULL pointer. If there are no symbols in 341 the BFD, then return 0. If an error occurs, return -1. 342 343.#define bfd_get_symtab_upper_bound(abfd) \ 344. BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) 345. 346*/ 347 348/* 349FUNCTION 350 bfd_is_local_label 351 352SYNOPSIS 353 bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym); 354 355DESCRIPTION 356 Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is 357 a compiler generated local label, else return FALSE. 358*/ 359 360bfd_boolean 361bfd_is_local_label (bfd *abfd, asymbol *sym) 362{ 363 /* The BSF_SECTION_SYM check is needed for IA-64, where every label that 364 starts with '.' is local. This would accidentally catch section names 365 if we didn't reject them here. */ 366 if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0) 367 return FALSE; 368 if (sym->name == NULL) 369 return FALSE; 370 return bfd_is_local_label_name (abfd, sym->name); 371} 372 373/* 374FUNCTION 375 bfd_is_local_label_name 376 377SYNOPSIS 378 bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name); 379 380DESCRIPTION 381 Return TRUE if a symbol with the name @var{name} in the BFD 382 @var{abfd} is a compiler generated local label, else return 383 FALSE. This just checks whether the name has the form of a 384 local label. 385 386.#define bfd_is_local_label_name(abfd, name) \ 387. BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) 388. 389*/ 390 391/* 392FUNCTION 393 bfd_is_target_special_symbol 394 395SYNOPSIS 396 bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym); 397 398DESCRIPTION 399 Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something 400 special to the particular target represented by the BFD. Such symbols 401 should normally not be mentioned to the user. 402 403.#define bfd_is_target_special_symbol(abfd, sym) \ 404. BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym)) 405. 406*/ 407 408/* 409FUNCTION 410 bfd_canonicalize_symtab 411 412DESCRIPTION 413 Read the symbols from the BFD @var{abfd}, and fills in 414 the vector @var{location} with pointers to the symbols and 415 a trailing NULL. 416 Return the actual number of symbol pointers, not 417 including the NULL. 418 419.#define bfd_canonicalize_symtab(abfd, location) \ 420. BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location)) 421. 422*/ 423 424/* 425FUNCTION 426 bfd_set_symtab 427 428SYNOPSIS 429 bfd_boolean bfd_set_symtab 430 (bfd *abfd, asymbol **location, unsigned int count); 431 432DESCRIPTION 433 Arrange that when the output BFD @var{abfd} is closed, 434 the table @var{location} of @var{count} pointers to symbols 435 will be written. 436*/ 437 438bfd_boolean 439bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount) 440{ 441 if (abfd->format != bfd_object || bfd_read_p (abfd)) 442 { 443 bfd_set_error (bfd_error_invalid_operation); 444 return FALSE; 445 } 446 447 bfd_get_outsymbols (abfd) = location; 448 bfd_get_symcount (abfd) = symcount; 449 return TRUE; 450} 451 452/* 453FUNCTION 454 bfd_print_symbol_vandf 455 456SYNOPSIS 457 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol); 458 459DESCRIPTION 460 Print the value and flags of the @var{symbol} supplied to the 461 stream @var{file}. 462*/ 463void 464bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol) 465{ 466 FILE *file = arg; 467 468 flagword type = symbol->flags; 469 470 if (symbol->section != NULL) 471 bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma); 472 else 473 bfd_fprintf_vma (abfd, file, symbol->value); 474 475 /* This presumes that a symbol can not be both BSF_DEBUGGING and 476 BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and 477 BSF_OBJECT. */ 478 fprintf (file, " %c%c%c%c%c%c%c", 479 ((type & BSF_LOCAL) 480 ? (type & BSF_GLOBAL) ? '!' : 'l' 481 : (type & BSF_GLOBAL) ? 'g' : ' '), 482 (type & BSF_WEAK) ? 'w' : ' ', 483 (type & BSF_CONSTRUCTOR) ? 'C' : ' ', 484 (type & BSF_WARNING) ? 'W' : ' ', 485 (type & BSF_INDIRECT) ? 'I' : ' ', 486 (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ', 487 ((type & BSF_FUNCTION) 488 ? 'F' 489 : ((type & BSF_FILE) 490 ? 'f' 491 : ((type & BSF_OBJECT) ? 'O' : ' ')))); 492} 493 494/* 495FUNCTION 496 bfd_make_empty_symbol 497 498DESCRIPTION 499 Create a new <<asymbol>> structure for the BFD @var{abfd} 500 and return a pointer to it. 501 502 This routine is necessary because each back end has private 503 information surrounding the <<asymbol>>. Building your own 504 <<asymbol>> and pointing to it will not create the private 505 information, and will cause problems later on. 506 507.#define bfd_make_empty_symbol(abfd) \ 508. BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) 509. 510*/ 511 512/* 513FUNCTION 514 _bfd_generic_make_empty_symbol 515 516SYNOPSIS 517 asymbol *_bfd_generic_make_empty_symbol (bfd *); 518 519DESCRIPTION 520 Create a new <<asymbol>> structure for the BFD @var{abfd} 521 and return a pointer to it. Used by core file routines, 522 binary back-end and anywhere else where no private info 523 is needed. 524*/ 525 526asymbol * 527_bfd_generic_make_empty_symbol (bfd *abfd) 528{ 529 bfd_size_type amt = sizeof (asymbol); 530 asymbol *new = bfd_zalloc (abfd, amt); 531 if (new) 532 new->the_bfd = abfd; 533 return new; 534} 535 536/* 537FUNCTION 538 bfd_make_debug_symbol 539 540DESCRIPTION 541 Create a new <<asymbol>> structure for the BFD @var{abfd}, 542 to be used as a debugging symbol. Further details of its use have 543 yet to be worked out. 544 545.#define bfd_make_debug_symbol(abfd,ptr,size) \ 546. BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) 547. 548*/ 549 550struct section_to_type 551{ 552 const char *section; 553 char type; 554}; 555 556/* Map section names to POSIX/BSD single-character symbol types. 557 This table is probably incomplete. It is sorted for convenience of 558 adding entries. Since it is so short, a linear search is used. */ 559static const struct section_to_type stt[] = 560{ 561 {".bss", 'b'}, 562 {"code", 't'}, /* MRI .text */ 563 {".data", 'd'}, 564 {"*DEBUG*", 'N'}, 565 {".debug", 'N'}, /* MSVC's .debug (non-standard debug syms) */ 566 {".drectve", 'i'}, /* MSVC's .drective section */ 567 {".edata", 'e'}, /* MSVC's .edata (export) section */ 568 {".fini", 't'}, /* ELF fini section */ 569 {".idata", 'i'}, /* MSVC's .idata (import) section */ 570 {".init", 't'}, /* ELF init section */ 571 {".pdata", 'p'}, /* MSVC's .pdata (stack unwind) section */ 572 {".rdata", 'r'}, /* Read only data. */ 573 {".rodata", 'r'}, /* Read only data. */ 574 {".sbss", 's'}, /* Small BSS (uninitialized data). */ 575 {".scommon", 'c'}, /* Small common. */ 576 {".sdata", 'g'}, /* Small initialized data. */ 577 {".text", 't'}, 578 {"vars", 'd'}, /* MRI .data */ 579 {"zerovars", 'b'}, /* MRI .bss */ 580 {0, 0} 581}; 582 583/* Return the single-character symbol type corresponding to 584 section S, or '?' for an unknown COFF section. 585 586 Check for any leading string which matches, so .text5 returns 587 't' as well as .text */ 588 589static char 590coff_section_type (const char *s) 591{ 592 const struct section_to_type *t; 593 594 for (t = &stt[0]; t->section; t++) 595 if (!strncmp (s, t->section, strlen (t->section))) 596 return t->type; 597 598 return '?'; 599} 600 601/* Return the single-character symbol type corresponding to section 602 SECTION, or '?' for an unknown section. This uses section flags to 603 identify sections. 604 605 FIXME These types are unhandled: c, i, e, p. If we handled these also, 606 we could perhaps obsolete coff_section_type. */ 607 608static char 609decode_section_type (const struct bfd_section *section) 610{ 611 if (section->flags & SEC_CODE) 612 return 't'; 613 if (section->flags & SEC_DATA) 614 { 615 if (section->flags & SEC_READONLY) 616 return 'r'; 617 else if (section->flags & SEC_SMALL_DATA) 618 return 'g'; 619 else 620 return 'd'; 621 } 622 if ((section->flags & SEC_HAS_CONTENTS) == 0) 623 { 624 if (section->flags & SEC_SMALL_DATA) 625 return 's'; 626 else 627 return 'b'; 628 } 629 if (section->flags & SEC_DEBUGGING) 630 return 'N'; 631 if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY)) 632 return 'n'; 633 634 return '?'; 635} 636 637/* 638FUNCTION 639 bfd_decode_symclass 640 641DESCRIPTION 642 Return a character corresponding to the symbol 643 class of @var{symbol}, or '?' for an unknown class. 644 645SYNOPSIS 646 int bfd_decode_symclass (asymbol *symbol); 647*/ 648int 649bfd_decode_symclass (asymbol *symbol) 650{ 651 char c; 652 653 if (bfd_is_com_section (symbol->section)) 654 return 'C'; 655 if (bfd_is_und_section (symbol->section)) 656 { 657 if (symbol->flags & BSF_WEAK) 658 { 659 /* If weak, determine if it's specifically an object 660 or non-object weak. */ 661 if (symbol->flags & BSF_OBJECT) 662 return 'v'; 663 else 664 return 'w'; 665 } 666 else 667 return 'U'; 668 } 669 if (bfd_is_ind_section (symbol->section)) 670 return 'I'; 671 if (symbol->flags & BSF_WEAK) 672 { 673 /* If weak, determine if it's specifically an object 674 or non-object weak. */ 675 if (symbol->flags & BSF_OBJECT) 676 return 'V'; 677 else 678 return 'W'; 679 } 680 if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL))) 681 return '?'; 682 683 if (bfd_is_abs_section (symbol->section)) 684 c = 'a'; 685 else if (symbol->section) 686 { 687 c = coff_section_type (symbol->section->name); 688 if (c == '?') 689 c = decode_section_type (symbol->section); 690 } 691 else 692 return '?'; 693 if (symbol->flags & BSF_GLOBAL) 694 c = TOUPPER (c); 695 return c; 696 697 /* We don't have to handle these cases just yet, but we will soon: 698 N_SETV: 'v'; 699 N_SETA: 'l'; 700 N_SETT: 'x'; 701 N_SETD: 'z'; 702 N_SETB: 's'; 703 N_INDR: 'i'; 704 */ 705} 706 707/* 708FUNCTION 709 bfd_is_undefined_symclass 710 711DESCRIPTION 712 Returns non-zero if the class symbol returned by 713 bfd_decode_symclass represents an undefined symbol. 714 Returns zero otherwise. 715 716SYNOPSIS 717 bfd_boolean bfd_is_undefined_symclass (int symclass); 718*/ 719 720bfd_boolean 721bfd_is_undefined_symclass (int symclass) 722{ 723 return symclass == 'U' || symclass == 'w' || symclass == 'v'; 724} 725 726/* 727FUNCTION 728 bfd_symbol_info 729 730DESCRIPTION 731 Fill in the basic info about symbol that nm needs. 732 Additional info may be added by the back-ends after 733 calling this function. 734 735SYNOPSIS 736 void bfd_symbol_info (asymbol *symbol, symbol_info *ret); 737*/ 738 739void 740bfd_symbol_info (asymbol *symbol, symbol_info *ret) 741{ 742 ret->type = bfd_decode_symclass (symbol); 743 744 if (bfd_is_undefined_symclass (ret->type)) 745 ret->value = 0; 746 else 747 ret->value = symbol->value + symbol->section->vma; 748 749 ret->name = symbol->name; 750} 751 752/* 753FUNCTION 754 bfd_copy_private_symbol_data 755 756SYNOPSIS 757 bfd_boolean bfd_copy_private_symbol_data 758 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); 759 760DESCRIPTION 761 Copy private symbol information from @var{isym} in the BFD 762 @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}. 763 Return <<TRUE>> on success, <<FALSE>> on error. Possible error 764 returns are: 765 766 o <<bfd_error_no_memory>> - 767 Not enough memory exists to create private data for @var{osec}. 768 769.#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ 770. BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ 771. (ibfd, isymbol, obfd, osymbol)) 772. 773*/ 774 775/* The generic version of the function which returns mini symbols. 776 This is used when the backend does not provide a more efficient 777 version. It just uses BFD asymbol structures as mini symbols. */ 778 779long 780_bfd_generic_read_minisymbols (bfd *abfd, 781 bfd_boolean dynamic, 782 void **minisymsp, 783 unsigned int *sizep) 784{ 785 long storage; 786 asymbol **syms = NULL; 787 long symcount; 788 789 if (dynamic) 790 storage = bfd_get_dynamic_symtab_upper_bound (abfd); 791 else 792 storage = bfd_get_symtab_upper_bound (abfd); 793 if (storage < 0) 794 goto error_return; 795 if (storage == 0) 796 return 0; 797 798 syms = bfd_malloc (storage); 799 if (syms == NULL) 800 goto error_return; 801 802 if (dynamic) 803 symcount = bfd_canonicalize_dynamic_symtab (abfd, syms); 804 else 805 symcount = bfd_canonicalize_symtab (abfd, syms); 806 if (symcount < 0) 807 goto error_return; 808 809 *minisymsp = syms; 810 *sizep = sizeof (asymbol *); 811 return symcount; 812 813 error_return: 814 bfd_set_error (bfd_error_no_symbols); 815 if (syms != NULL) 816 free (syms); 817 return -1; 818} 819 820/* The generic version of the function which converts a minisymbol to 821 an asymbol. We don't worry about the sym argument we are passed; 822 we just return the asymbol the minisymbol points to. */ 823 824asymbol * 825_bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED, 826 bfd_boolean dynamic ATTRIBUTE_UNUSED, 827 const void *minisym, 828 asymbol *sym ATTRIBUTE_UNUSED) 829{ 830 return *(asymbol **) minisym; 831} 832 833/* Look through stabs debugging information in .stab and .stabstr 834 sections to find the source file and line closest to a desired 835 location. This is used by COFF and ELF targets. It sets *pfound 836 to TRUE if it finds some information. The *pinfo field is used to 837 pass cached information in and out of this routine; this first time 838 the routine is called for a BFD, *pinfo should be NULL. The value 839 placed in *pinfo should be saved with the BFD, and passed back each 840 time this function is called. */ 841 842/* We use a cache by default. */ 843 844#define ENABLE_CACHING 845 846/* We keep an array of indexentry structures to record where in the 847 stabs section we should look to find line number information for a 848 particular address. */ 849 850struct indexentry 851{ 852 bfd_vma val; 853 bfd_byte *stab; 854 bfd_byte *str; 855 char *directory_name; 856 char *file_name; 857 char *function_name; 858}; 859 860/* Compare two indexentry structures. This is called via qsort. */ 861 862static int 863cmpindexentry (const void *a, const void *b) 864{ 865 const struct indexentry *contestantA = a; 866 const struct indexentry *contestantB = b; 867 868 if (contestantA->val < contestantB->val) 869 return -1; 870 else if (contestantA->val > contestantB->val) 871 return 1; 872 else 873 return 0; 874} 875 876/* A pointer to this structure is stored in *pinfo. */ 877 878struct stab_find_info 879{ 880 /* The .stab section. */ 881 asection *stabsec; 882 /* The .stabstr section. */ 883 asection *strsec; 884 /* The contents of the .stab section. */ 885 bfd_byte *stabs; 886 /* The contents of the .stabstr section. */ 887 bfd_byte *strs; 888 889 /* A table that indexes stabs by memory address. */ 890 struct indexentry *indextable; 891 /* The number of entries in indextable. */ 892 int indextablesize; 893 894#ifdef ENABLE_CACHING 895 /* Cached values to restart quickly. */ 896 struct indexentry *cached_indexentry; 897 bfd_vma cached_offset; 898 bfd_byte *cached_stab; 899 char *cached_file_name; 900#endif 901 902 /* Saved ptr to malloc'ed filename. */ 903 char *filename; 904}; 905 906bfd_boolean 907_bfd_stab_section_find_nearest_line (bfd *abfd, 908 asymbol **symbols, 909 asection *section, 910 bfd_vma offset, 911 bfd_boolean *pfound, 912 const char **pfilename, 913 const char **pfnname, 914 unsigned int *pline, 915 void **pinfo) 916{ 917 struct stab_find_info *info; 918 bfd_size_type stabsize, strsize; 919 bfd_byte *stab, *str; 920 bfd_byte *last_stab = NULL; 921 bfd_size_type stroff; 922 struct indexentry *indexentry; 923 char *file_name; 924 char *directory_name; 925 int saw_fun; 926 bfd_boolean saw_line, saw_func; 927 928 *pfound = FALSE; 929 *pfilename = bfd_get_filename (abfd); 930 *pfnname = NULL; 931 *pline = 0; 932 933 /* Stabs entries use a 12 byte format: 934 4 byte string table index 935 1 byte stab type 936 1 byte stab other field 937 2 byte stab desc field 938 4 byte stab value 939 FIXME: This will have to change for a 64 bit object format. 940 941 The stabs symbols are divided into compilation units. For the 942 first entry in each unit, the type of 0, the value is the length 943 of the string table for this unit, and the desc field is the 944 number of stabs symbols for this unit. */ 945 946#define STRDXOFF (0) 947#define TYPEOFF (4) 948#define OTHEROFF (5) 949#define DESCOFF (6) 950#define VALOFF (8) 951#define STABSIZE (12) 952 953 info = *pinfo; 954 if (info != NULL) 955 { 956 if (info->stabsec == NULL || info->strsec == NULL) 957 { 958 /* No stabs debugging information. */ 959 return TRUE; 960 } 961 962 stabsize = (info->stabsec->rawsize 963 ? info->stabsec->rawsize 964 : info->stabsec->size); 965 strsize = (info->strsec->rawsize 966 ? info->strsec->rawsize 967 : info->strsec->size); 968 } 969 else 970 { 971 long reloc_size, reloc_count; 972 arelent **reloc_vector; 973 int i; 974 char *name; 975 char *function_name; 976 bfd_size_type amt = sizeof *info; 977 978 info = bfd_zalloc (abfd, amt); 979 if (info == NULL) 980 return FALSE; 981 982 /* FIXME: When using the linker --split-by-file or 983 --split-by-reloc options, it is possible for the .stab and 984 .stabstr sections to be split. We should handle that. */ 985 986 info->stabsec = bfd_get_section_by_name (abfd, ".stab"); 987 info->strsec = bfd_get_section_by_name (abfd, ".stabstr"); 988 989 if (info->stabsec == NULL || info->strsec == NULL) 990 { 991 /* No stabs debugging information. Set *pinfo so that we 992 can return quickly in the info != NULL case above. */ 993 *pinfo = info; 994 return TRUE; 995 } 996 997 stabsize = (info->stabsec->rawsize 998 ? info->stabsec->rawsize 999 : info->stabsec->size); 1000 strsize = (info->strsec->rawsize 1001 ? info->strsec->rawsize 1002 : info->strsec->size); 1003 1004 info->stabs = bfd_alloc (abfd, stabsize); 1005 info->strs = bfd_alloc (abfd, strsize); 1006 if (info->stabs == NULL || info->strs == NULL) 1007 return FALSE; 1008 1009 if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs, 1010 0, stabsize) 1011 || ! bfd_get_section_contents (abfd, info->strsec, info->strs, 1012 0, strsize)) 1013 return FALSE; 1014 1015 /* If this is a relocatable object file, we have to relocate 1016 the entries in .stab. This should always be simple 32 bit 1017 relocations against symbols defined in this object file, so 1018 this should be no big deal. */ 1019 reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec); 1020 if (reloc_size < 0) 1021 return FALSE; 1022 reloc_vector = bfd_malloc (reloc_size); 1023 if (reloc_vector == NULL && reloc_size != 0) 1024 return FALSE; 1025 reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector, 1026 symbols); 1027 if (reloc_count < 0) 1028 { 1029 if (reloc_vector != NULL) 1030 free (reloc_vector); 1031 return FALSE; 1032 } 1033 if (reloc_count > 0) 1034 { 1035 arelent **pr; 1036 1037 for (pr = reloc_vector; *pr != NULL; pr++) 1038 { 1039 arelent *r; 1040 unsigned long val; 1041 asymbol *sym; 1042 1043 r = *pr; 1044 /* Ignore R_*_NONE relocs. */ 1045 if (r->howto->dst_mask == 0) 1046 continue; 1047 1048 if (r->howto->rightshift != 0 1049 || r->howto->size != 2 1050 || r->howto->bitsize != 32 1051 || r->howto->pc_relative 1052 || r->howto->bitpos != 0 1053 || r->howto->dst_mask != 0xffffffff) 1054 { 1055 (*_bfd_error_handler) 1056 (_("Unsupported .stab relocation")); 1057 bfd_set_error (bfd_error_invalid_operation); 1058 if (reloc_vector != NULL) 1059 free (reloc_vector); 1060 return FALSE; 1061 } 1062 1063 val = bfd_get_32 (abfd, info->stabs + r->address); 1064 val &= r->howto->src_mask; 1065 sym = *r->sym_ptr_ptr; 1066 val += sym->value + sym->section->vma + r->addend; 1067 bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address); 1068 } 1069 } 1070 1071 if (reloc_vector != NULL) 1072 free (reloc_vector); 1073 1074 /* First time through this function, build a table matching 1075 function VM addresses to stabs, then sort based on starting 1076 VM address. Do this in two passes: once to count how many 1077 table entries we'll need, and a second to actually build the 1078 table. */ 1079 1080 info->indextablesize = 0; 1081 saw_fun = 1; 1082 for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE) 1083 { 1084 if (stab[TYPEOFF] == (bfd_byte) N_SO) 1085 { 1086 /* N_SO with null name indicates EOF */ 1087 if (bfd_get_32 (abfd, stab + STRDXOFF) == 0) 1088 continue; 1089 1090 /* if we did not see a function def, leave space for one. */ 1091 if (saw_fun == 0) 1092 ++info->indextablesize; 1093 1094 saw_fun = 0; 1095 1096 /* two N_SO's in a row is a filename and directory. Skip */ 1097 if (stab + STABSIZE < info->stabs + stabsize 1098 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO) 1099 { 1100 stab += STABSIZE; 1101 } 1102 } 1103 else if (stab[TYPEOFF] == (bfd_byte) N_FUN) 1104 { 1105 saw_fun = 1; 1106 ++info->indextablesize; 1107 } 1108 } 1109 1110 if (saw_fun == 0) 1111 ++info->indextablesize; 1112 1113 if (info->indextablesize == 0) 1114 return TRUE; 1115 ++info->indextablesize; 1116 1117 amt = info->indextablesize; 1118 amt *= sizeof (struct indexentry); 1119 info->indextable = bfd_alloc (abfd, amt); 1120 if (info->indextable == NULL) 1121 return FALSE; 1122 1123 file_name = NULL; 1124 directory_name = NULL; 1125 saw_fun = 1; 1126 1127 for (i = 0, stroff = 0, stab = info->stabs, str = info->strs; 1128 i < info->indextablesize && stab < info->stabs + stabsize; 1129 stab += STABSIZE) 1130 { 1131 switch (stab[TYPEOFF]) 1132 { 1133 case 0: 1134 /* This is the first entry in a compilation unit. */ 1135 if ((bfd_size_type) ((info->strs + strsize) - str) < stroff) 1136 break; 1137 str += stroff; 1138 stroff = bfd_get_32 (abfd, stab + VALOFF); 1139 break; 1140 1141 case N_SO: 1142 /* The main file name. */ 1143 1144 /* The following code creates a new indextable entry with 1145 a NULL function name if there were no N_FUNs in a file. 1146 Note that a N_SO without a file name is an EOF and 1147 there could be 2 N_SO following it with the new filename 1148 and directory. */ 1149 if (saw_fun == 0) 1150 { 1151 info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF); 1152 info->indextable[i].stab = last_stab; 1153 info->indextable[i].str = str; 1154 info->indextable[i].directory_name = directory_name; 1155 info->indextable[i].file_name = file_name; 1156 info->indextable[i].function_name = NULL; 1157 ++i; 1158 } 1159 saw_fun = 0; 1160 1161 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1162 if (*file_name == '\0') 1163 { 1164 directory_name = NULL; 1165 file_name = NULL; 1166 saw_fun = 1; 1167 } 1168 else 1169 { 1170 last_stab = stab; 1171 if (stab + STABSIZE >= info->stabs + stabsize 1172 || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO) 1173 { 1174 directory_name = NULL; 1175 } 1176 else 1177 { 1178 /* Two consecutive N_SOs are a directory and a 1179 file name. */ 1180 stab += STABSIZE; 1181 directory_name = file_name; 1182 file_name = ((char *) str 1183 + bfd_get_32 (abfd, stab + STRDXOFF)); 1184 } 1185 } 1186 break; 1187 1188 case N_SOL: 1189 /* The name of an include file. */ 1190 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1191 break; 1192 1193 case N_FUN: 1194 /* A function name. */ 1195 saw_fun = 1; 1196 name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1197 1198 if (*name == '\0') 1199 name = NULL; 1200 1201 function_name = name; 1202 1203 if (name == NULL) 1204 continue; 1205 1206 info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF); 1207 info->indextable[i].stab = stab; 1208 info->indextable[i].str = str; 1209 info->indextable[i].directory_name = directory_name; 1210 info->indextable[i].file_name = file_name; 1211 info->indextable[i].function_name = function_name; 1212 ++i; 1213 break; 1214 } 1215 } 1216 1217 if (saw_fun == 0) 1218 { 1219 info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF); 1220 info->indextable[i].stab = last_stab; 1221 info->indextable[i].str = str; 1222 info->indextable[i].directory_name = directory_name; 1223 info->indextable[i].file_name = file_name; 1224 info->indextable[i].function_name = NULL; 1225 ++i; 1226 } 1227 1228 info->indextable[i].val = (bfd_vma) -1; 1229 info->indextable[i].stab = info->stabs + stabsize; 1230 info->indextable[i].str = str; 1231 info->indextable[i].directory_name = NULL; 1232 info->indextable[i].file_name = NULL; 1233 info->indextable[i].function_name = NULL; 1234 ++i; 1235 1236 info->indextablesize = i; 1237 qsort (info->indextable, (size_t) i, sizeof (struct indexentry), 1238 cmpindexentry); 1239 1240 *pinfo = info; 1241 } 1242 1243 /* We are passed a section relative offset. The offsets in the 1244 stabs information are absolute. */ 1245 offset += bfd_get_section_vma (abfd, section); 1246 1247#ifdef ENABLE_CACHING 1248 if (info->cached_indexentry != NULL 1249 && offset >= info->cached_offset 1250 && offset < (info->cached_indexentry + 1)->val) 1251 { 1252 stab = info->cached_stab; 1253 indexentry = info->cached_indexentry; 1254 file_name = info->cached_file_name; 1255 } 1256 else 1257#endif 1258 { 1259 long low, high; 1260 long mid = -1; 1261 1262 /* Cache non-existent or invalid. Do binary search on 1263 indextable. */ 1264 indexentry = NULL; 1265 1266 low = 0; 1267 high = info->indextablesize - 1; 1268 while (low != high) 1269 { 1270 mid = (high + low) / 2; 1271 if (offset >= info->indextable[mid].val 1272 && offset < info->indextable[mid + 1].val) 1273 { 1274 indexentry = &info->indextable[mid]; 1275 break; 1276 } 1277 1278 if (info->indextable[mid].val > offset) 1279 high = mid; 1280 else 1281 low = mid + 1; 1282 } 1283 1284 if (indexentry == NULL) 1285 return TRUE; 1286 1287 stab = indexentry->stab + STABSIZE; 1288 file_name = indexentry->file_name; 1289 } 1290 1291 directory_name = indexentry->directory_name; 1292 str = indexentry->str; 1293 1294 saw_line = FALSE; 1295 saw_func = FALSE; 1296 for (; stab < (indexentry+1)->stab; stab += STABSIZE) 1297 { 1298 bfd_boolean done; 1299 bfd_vma val; 1300 1301 done = FALSE; 1302 1303 switch (stab[TYPEOFF]) 1304 { 1305 case N_SOL: 1306 /* The name of an include file. */ 1307 val = bfd_get_32 (abfd, stab + VALOFF); 1308 if (val <= offset) 1309 { 1310 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1311 *pline = 0; 1312 } 1313 break; 1314 1315 case N_SLINE: 1316 case N_DSLINE: 1317 case N_BSLINE: 1318 /* A line number. If the function was specified, then the value 1319 is relative to the start of the function. Otherwise, the 1320 value is an absolute address. */ 1321 val = ((indexentry->function_name ? indexentry->val : 0) 1322 + bfd_get_32 (abfd, stab + VALOFF)); 1323 /* If this line starts before our desired offset, or if it's 1324 the first line we've been able to find, use it. The 1325 !saw_line check works around a bug in GCC 2.95.3, which emits 1326 the first N_SLINE late. */ 1327 if (!saw_line || val <= offset) 1328 { 1329 *pline = bfd_get_16 (abfd, stab + DESCOFF); 1330 1331#ifdef ENABLE_CACHING 1332 info->cached_stab = stab; 1333 info->cached_offset = val; 1334 info->cached_file_name = file_name; 1335 info->cached_indexentry = indexentry; 1336#endif 1337 } 1338 if (val > offset) 1339 done = TRUE; 1340 saw_line = TRUE; 1341 break; 1342 1343 case N_FUN: 1344 case N_SO: 1345 if (saw_func || saw_line) 1346 done = TRUE; 1347 saw_func = TRUE; 1348 break; 1349 } 1350 1351 if (done) 1352 break; 1353 } 1354 1355 *pfound = TRUE; 1356 1357 if (file_name == NULL || IS_ABSOLUTE_PATH (file_name) 1358 || directory_name == NULL) 1359 *pfilename = file_name; 1360 else 1361 { 1362 size_t dirlen; 1363 1364 dirlen = strlen (directory_name); 1365 if (info->filename == NULL 1366 || strncmp (info->filename, directory_name, dirlen) != 0 1367 || strcmp (info->filename + dirlen, file_name) != 0) 1368 { 1369 size_t len; 1370 1371 if (info->filename != NULL) 1372 free (info->filename); 1373 len = strlen (file_name) + 1; 1374 info->filename = bfd_malloc (dirlen + len); 1375 if (info->filename == NULL) 1376 return FALSE; 1377 memcpy (info->filename, directory_name, dirlen); 1378 memcpy (info->filename + dirlen, file_name, len); 1379 } 1380 1381 *pfilename = info->filename; 1382 } 1383 1384 if (indexentry->function_name != NULL) 1385 { 1386 char *s; 1387 1388 /* This will typically be something like main:F(0,1), so we want 1389 to clobber the colon. It's OK to change the name, since the 1390 string is in our own local storage anyhow. */ 1391 s = strchr (indexentry->function_name, ':'); 1392 if (s != NULL) 1393 *s = '\0'; 1394 1395 *pfnname = indexentry->function_name; 1396 } 1397 1398 return TRUE; 1399} 1400