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