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