syms.c revision 33965
1/* Generic symbol-table support for the BFD library. 2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 1997 3 Free Software Foundation, Inc. 4 Written by Cygnus Support. 5 6This file is part of BFD, the Binary File Descriptor library. 7 8This program is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2 of the License, or 11(at your option) any later version. 12 13This program is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with this program; if not, write to the Free Software 20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 21 22/* 23SECTION 24 Symbols 25 26 BFD tries to maintain as much symbol information as it can when 27 it moves information from file to file. BFD passes information 28 to applications though the <<asymbol>> structure. When the 29 application requests the symbol table, BFD reads the table in 30 the native form and translates parts of it into the internal 31 format. To maintain more than the information passed to 32 applications, some targets keep some information ``behind the 33 scenes'' in a structure only the particular back end knows 34 about. For example, the coff back end keeps the original 35 symbol table structure as well as the canonical structure when 36 a BFD is read in. On output, the coff back end can reconstruct 37 the output symbol table so that no information is lost, even 38 information unique to coff which BFD doesn't know or 39 understand. If a coff symbol table were read, but were written 40 through an a.out back end, all the coff specific information 41 would be lost. The symbol table of a BFD 42 is not necessarily read in until a canonicalize request is 43 made. Then the BFD back end fills in a table provided by the 44 application with pointers to the canonical information. To 45 output symbols, the application provides BFD with a table of 46 pointers to pointers to <<asymbol>>s. This allows applications 47 like the linker to output a symbol as it was read, since the ``behind 48 the scenes'' information will be still available. 49@menu 50@* Reading Symbols:: 51@* Writing Symbols:: 52@* Mini Symbols:: 53@* typedef asymbol:: 54@* symbol handling functions:: 55@end menu 56 57INODE 58Reading Symbols, Writing Symbols, Symbols, Symbols 59SUBSECTION 60 Reading symbols 61 62 There are two stages to reading a symbol table from a BFD: 63 allocating storage, and the actual reading process. This is an 64 excerpt from an application which reads the symbol table: 65 66| long storage_needed; 67| asymbol **symbol_table; 68| long number_of_symbols; 69| long i; 70| 71| storage_needed = bfd_get_symtab_upper_bound (abfd); 72| 73| if (storage_needed < 0) 74| FAIL 75| 76| if (storage_needed == 0) { 77| return ; 78| } 79| symbol_table = (asymbol **) xmalloc (storage_needed); 80| ... 81| number_of_symbols = 82| bfd_canonicalize_symtab (abfd, symbol_table); 83| 84| if (number_of_symbols < 0) 85| FAIL 86| 87| for (i = 0; i < number_of_symbols; i++) { 88| process_symbol (symbol_table[i]); 89| } 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 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 167 168/* 169DOCDD 170INODE 171typedef asymbol, symbol handling functions, Mini Symbols, Symbols 172 173*/ 174/* 175SUBSECTION 176 typedef asymbol 177 178 An <<asymbol>> has the form: 179 180*/ 181 182/* 183CODE_FRAGMENT 184 185. 186.typedef struct symbol_cache_entry 187.{ 188. {* A pointer to the BFD which owns the symbol. This information 189. is necessary so that a back end can work out what additional 190. information (invisible to the application writer) is carried 191. with the symbol. 192. 193. This field is *almost* redundant, since you can use section->owner 194. instead, except that some symbols point to the global sections 195. bfd_{abs,com,und}_section. This could be fixed by making 196. these globals be per-bfd (or per-target-flavor). FIXME. *} 197. 198. struct _bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field. *} 199. 200. {* The text of the symbol. The name is left alone, and not copied; the 201. application may not alter it. *} 202. CONST char *name; 203. 204. {* The value of the symbol. This really should be a union of a 205. numeric value with a pointer, since some flags indicate that 206. a pointer to another symbol is stored here. *} 207. symvalue value; 208. 209. {* Attributes of a symbol: *} 210. 211.#define BSF_NO_FLAGS 0x00 212. 213. {* The symbol has local scope; <<static>> in <<C>>. The value 214. is the offset into the section of the data. *} 215.#define BSF_LOCAL 0x01 216. 217. {* The symbol has global scope; initialized data in <<C>>. The 218. value is the offset into the section of the data. *} 219.#define BSF_GLOBAL 0x02 220. 221. {* The symbol has global scope and is exported. The value is 222. the offset into the section of the data. *} 223.#define BSF_EXPORT BSF_GLOBAL {* no real difference *} 224. 225. {* A normal C symbol would be one of: 226. <<BSF_LOCAL>>, <<BSF_FORT_COMM>>, <<BSF_UNDEFINED>> or 227. <<BSF_GLOBAL>> *} 228. 229. {* The symbol is a debugging record. The value has an arbitary 230. meaning. *} 231.#define BSF_DEBUGGING 0x08 232. 233. {* The symbol denotes a function entry point. Used in ELF, 234. perhaps others someday. *} 235.#define BSF_FUNCTION 0x10 236. 237. {* Used by the linker. *} 238.#define BSF_KEEP 0x20 239.#define BSF_KEEP_G 0x40 240. 241. {* A weak global symbol, overridable without warnings by 242. a regular global symbol of the same name. *} 243.#define BSF_WEAK 0x80 244. 245. {* This symbol was created to point to a section, e.g. ELF's 246. STT_SECTION symbols. *} 247.#define BSF_SECTION_SYM 0x100 248. 249. {* The symbol used to be a common symbol, but now it is 250. allocated. *} 251.#define BSF_OLD_COMMON 0x200 252. 253. {* The default value for common data. *} 254.#define BFD_FORT_COMM_DEFAULT_VALUE 0 255. 256. {* In some files the type of a symbol sometimes alters its 257. location in an output file - ie in coff a <<ISFCN>> symbol 258. which is also <<C_EXT>> symbol appears where it was 259. declared and not at the end of a section. This bit is set 260. by the target BFD part to convey this information. *} 261. 262.#define BSF_NOT_AT_END 0x400 263. 264. {* Signal that the symbol is the label of constructor section. *} 265.#define BSF_CONSTRUCTOR 0x800 266. 267. {* Signal that the symbol is a warning symbol. The name is a 268. warning. The name of the next symbol is the one to warn about; 269. if a reference is made to a symbol with the same name as the next 270. symbol, a warning is issued by the linker. *} 271.#define BSF_WARNING 0x1000 272. 273. {* Signal that the symbol is indirect. This symbol is an indirect 274. pointer to the symbol with the same name as the next symbol. *} 275.#define BSF_INDIRECT 0x2000 276. 277. {* BSF_FILE marks symbols that contain a file name. This is used 278. for ELF STT_FILE symbols. *} 279.#define BSF_FILE 0x4000 280. 281. {* Symbol is from dynamic linking information. *} 282.#define BSF_DYNAMIC 0x8000 283. 284. {* The symbol denotes a data object. Used in ELF, and perhaps 285. others someday. *} 286.#define BSF_OBJECT 0x10000 287. 288. flagword flags; 289. 290. {* A pointer to the section to which this symbol is 291. relative. This will always be non NULL, there are special 292. sections for undefined and absolute symbols. *} 293. struct sec *section; 294. 295. {* Back end special data. *} 296. union 297. { 298. PTR p; 299. bfd_vma i; 300. } udata; 301. 302.} asymbol; 303*/ 304 305#include "bfd.h" 306#include "sysdep.h" 307#include "libbfd.h" 308#include "bfdlink.h" 309#include "aout/stab_gnu.h" 310 311static char coff_section_type PARAMS ((const char *)); 312 313/* 314DOCDD 315INODE 316symbol handling functions, , typedef asymbol, Symbols 317SUBSECTION 318 Symbol handling functions 319*/ 320 321/* 322FUNCTION 323 bfd_get_symtab_upper_bound 324 325DESCRIPTION 326 Return the number of bytes required to store a vector of pointers 327 to <<asymbols>> for all the symbols in the BFD @var{abfd}, 328 including a terminal NULL pointer. If there are no symbols in 329 the BFD, then return 0. If an error occurs, return -1. 330 331.#define bfd_get_symtab_upper_bound(abfd) \ 332. BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) 333 334*/ 335 336/* 337FUNCTION 338 bfd_is_local_label 339 340SYNOPSIS 341 boolean bfd_is_local_label(bfd *abfd, asymbol *sym); 342 343DESCRIPTION 344 Return true if the given symbol @var{sym} in the BFD @var{abfd} is 345 a compiler generated local label, else return false. 346*/ 347 348boolean 349bfd_is_local_label (abfd, sym) 350 bfd *abfd; 351 asymbol *sym; 352{ 353 if ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0) 354 return false; 355 if (sym->name == NULL) 356 return false; 357 return bfd_is_local_label_name (abfd, sym->name); 358} 359 360/* 361FUNCTION 362 bfd_is_local_label_name 363 364SYNOPSIS 365 boolean bfd_is_local_label_name(bfd *abfd, const char *name); 366 367DESCRIPTION 368 Return true if a symbol with the name @var{name} in the BFD 369 @var{abfd} is a compiler generated local label, else return 370 false. This just checks whether the name has the form of a 371 local label. 372 373.#define bfd_is_local_label_name(abfd, name) \ 374. BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) 375*/ 376 377/* 378FUNCTION 379 bfd_canonicalize_symtab 380 381DESCRIPTION 382 Read the symbols from the BFD @var{abfd}, and fills in 383 the vector @var{location} with pointers to the symbols and 384 a trailing NULL. 385 Return the actual number of symbol pointers, not 386 including the NULL. 387 388 389.#define bfd_canonicalize_symtab(abfd, location) \ 390. BFD_SEND (abfd, _bfd_canonicalize_symtab,\ 391. (abfd, location)) 392 393*/ 394 395 396/* 397FUNCTION 398 bfd_set_symtab 399 400SYNOPSIS 401 boolean bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int count); 402 403DESCRIPTION 404 Arrange that when the output BFD @var{abfd} is closed, 405 the table @var{location} of @var{count} pointers to symbols 406 will be written. 407*/ 408 409boolean 410bfd_set_symtab (abfd, location, symcount) 411 bfd *abfd; 412 asymbol **location; 413 unsigned int symcount; 414{ 415 if ((abfd->format != bfd_object) || (bfd_read_p (abfd))) 416 { 417 bfd_set_error (bfd_error_invalid_operation); 418 return false; 419 } 420 421 bfd_get_outsymbols (abfd) = location; 422 bfd_get_symcount (abfd) = symcount; 423 return true; 424} 425 426/* 427FUNCTION 428 bfd_print_symbol_vandf 429 430SYNOPSIS 431 void bfd_print_symbol_vandf(PTR file, asymbol *symbol); 432 433DESCRIPTION 434 Print the value and flags of the @var{symbol} supplied to the 435 stream @var{file}. 436*/ 437void 438bfd_print_symbol_vandf (arg, symbol) 439 PTR arg; 440 asymbol *symbol; 441{ 442 FILE *file = (FILE *) arg; 443 flagword type = symbol->flags; 444 if (symbol->section != (asection *) NULL) 445 { 446 fprintf_vma (file, symbol->value + symbol->section->vma); 447 } 448 else 449 { 450 fprintf_vma (file, symbol->value); 451 } 452 453 /* This presumes that a symbol can not be both BSF_DEBUGGING and 454 BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and 455 BSF_OBJECT. */ 456 fprintf (file, " %c%c%c%c%c%c%c", 457 ((type & BSF_LOCAL) 458 ? (type & BSF_GLOBAL) ? '!' : 'l' 459 : (type & BSF_GLOBAL) ? 'g' : ' '), 460 (type & BSF_WEAK) ? 'w' : ' ', 461 (type & BSF_CONSTRUCTOR) ? 'C' : ' ', 462 (type & BSF_WARNING) ? 'W' : ' ', 463 (type & BSF_INDIRECT) ? 'I' : ' ', 464 (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ', 465 ((type & BSF_FUNCTION) 466 ? 'F' 467 : ((type & BSF_FILE) 468 ? 'f' 469 : ((type & BSF_OBJECT) ? 'O' : ' ')))); 470} 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 {0, 0} 527}; 528 529/* Return the single-character symbol type corresponding to 530 section S, or '?' for an unknown COFF section. 531 532 Check for any leading string which matches, so .text5 returns 533 't' as well as .text */ 534 535static char 536coff_section_type (s) 537 const char *s; 538{ 539 CONST struct section_to_type *t; 540 541 for (t = &stt[0]; t->section; t++) 542 if (!strncmp (s, t->section, strlen (t->section))) 543 return t->type; 544 545 return '?'; 546} 547 548#ifndef islower 549#define islower(c) ((c) >= 'a' && (c) <= 'z') 550#endif 551#ifndef toupper 552#define toupper(c) (islower(c) ? ((c) & ~0x20) : (c)) 553#endif 554 555/* 556FUNCTION 557 bfd_decode_symclass 558 559DESCRIPTION 560 Return a character corresponding to the symbol 561 class of @var{symbol}, or '?' for an unknown class. 562 563SYNOPSIS 564 int bfd_decode_symclass(asymbol *symbol); 565*/ 566int 567bfd_decode_symclass (symbol) 568 asymbol *symbol; 569{ 570 char c; 571 572 if (bfd_is_com_section (symbol->section)) 573 return 'C'; 574 if (bfd_is_und_section (symbol->section)) 575 return 'U'; 576 if (bfd_is_ind_section (symbol->section)) 577 return 'I'; 578 if (symbol->flags & BSF_WEAK) 579 return 'W'; 580 if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL))) 581 return '?'; 582 583 if (bfd_is_abs_section (symbol->section)) 584 c = 'a'; 585 else if (symbol->section) 586 c = coff_section_type (symbol->section->name); 587 else 588 return '?'; 589 if (symbol->flags & BSF_GLOBAL) 590 c = toupper (c); 591 return c; 592 593 /* We don't have to handle these cases just yet, but we will soon: 594 N_SETV: 'v'; 595 N_SETA: 'l'; 596 N_SETT: 'x'; 597 N_SETD: 'z'; 598 N_SETB: 's'; 599 N_INDR: 'i'; 600 */ 601} 602 603/* 604FUNCTION 605 bfd_symbol_info 606 607DESCRIPTION 608 Fill in the basic info about symbol that nm needs. 609 Additional info may be added by the back-ends after 610 calling this function. 611 612SYNOPSIS 613 void bfd_symbol_info(asymbol *symbol, symbol_info *ret); 614*/ 615 616void 617bfd_symbol_info (symbol, ret) 618 asymbol *symbol; 619 symbol_info *ret; 620{ 621 ret->type = bfd_decode_symclass (symbol); 622 if (ret->type != 'U') 623 ret->value = symbol->value + symbol->section->vma; 624 else 625 ret->value = 0; 626 ret->name = symbol->name; 627} 628 629/* 630FUNCTION 631 bfd_copy_private_symbol_data 632 633SYNOPSIS 634 boolean bfd_copy_private_symbol_data(bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); 635 636DESCRIPTION 637 Copy private symbol information from @var{isym} in the BFD 638 @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}. 639 Return <<true>> on success, <<false>> on error. Possible error 640 returns are: 641 642 o <<bfd_error_no_memory>> - 643 Not enough memory exists to create private data for @var{osec}. 644 645.#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ 646. BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ 647. (ibfd, isymbol, obfd, osymbol)) 648 649*/ 650 651/* The generic version of the function which returns mini symbols. 652 This is used when the backend does not provide a more efficient 653 version. It just uses BFD asymbol structures as mini symbols. */ 654 655long 656_bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep) 657 bfd *abfd; 658 boolean dynamic; 659 PTR *minisymsp; 660 unsigned int *sizep; 661{ 662 long storage; 663 asymbol **syms = NULL; 664 long symcount; 665 666 if (dynamic) 667 storage = bfd_get_dynamic_symtab_upper_bound (abfd); 668 else 669 storage = bfd_get_symtab_upper_bound (abfd); 670 if (storage < 0) 671 goto error_return; 672 673 syms = (asymbol **) bfd_malloc ((size_t) storage); 674 if (syms == NULL) 675 goto error_return; 676 677 if (dynamic) 678 symcount = bfd_canonicalize_dynamic_symtab (abfd, syms); 679 else 680 symcount = bfd_canonicalize_symtab (abfd, syms); 681 if (symcount < 0) 682 goto error_return; 683 684 *minisymsp = (PTR) syms; 685 *sizep = sizeof (asymbol *); 686 return symcount; 687 688 error_return: 689 if (syms != NULL) 690 free (syms); 691 return -1; 692} 693 694/* The generic version of the function which converts a minisymbol to 695 an asymbol. We don't worry about the sym argument we are passed; 696 we just return the asymbol the minisymbol points to. */ 697 698/*ARGSUSED*/ 699asymbol * 700_bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym) 701 bfd *abfd; 702 boolean dynamic; 703 const PTR minisym; 704 asymbol *sym; 705{ 706 return *(asymbol **) minisym; 707} 708 709/* Look through stabs debugging information in .stab and .stabstr 710 sections to find the source file and line closest to a desired 711 location. This is used by COFF and ELF targets. It sets *pfound 712 to true if it finds some information. The *pinfo field is used to 713 pass cached information in and out of this routine; this first time 714 the routine is called for a BFD, *pinfo should be NULL. The value 715 placed in *pinfo should be saved with the BFD, and passed back each 716 time this function is called. */ 717 718/* A pointer to this structure is stored in *pinfo. */ 719 720struct stab_find_info 721{ 722 /* The .stab section. */ 723 asection *stabsec; 724 /* The .stabstr section. */ 725 asection *strsec; 726 /* The contents of the .stab section. */ 727 bfd_byte *stabs; 728 /* The contents of the .stabstr section. */ 729 bfd_byte *strs; 730 /* An malloc buffer to hold the file name. */ 731 char *filename; 732 /* Cached values to restart quickly. */ 733 bfd_vma cached_offset; 734 bfd_byte *cached_stab; 735 bfd_byte *cached_str; 736 bfd_size_type cached_stroff; 737}; 738 739boolean 740_bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound, 741 pfilename, pfnname, pline, pinfo) 742 bfd *abfd; 743 asymbol **symbols; 744 asection *section; 745 bfd_vma offset; 746 boolean *pfound; 747 const char **pfilename; 748 const char **pfnname; 749 unsigned int *pline; 750 PTR *pinfo; 751{ 752 struct stab_find_info *info; 753 bfd_size_type stabsize, strsize; 754 bfd_byte *stab, *stabend, *str; 755 bfd_size_type stroff; 756 bfd_vma fnaddr; 757 char *directory_name, *main_file_name, *current_file_name, *line_file_name; 758 char *fnname; 759 bfd_vma low_func_vma, low_line_vma; 760 761 *pfound = false; 762 *pfilename = bfd_get_filename (abfd); 763 *pfnname = NULL; 764 *pline = 0; 765 766 info = (struct stab_find_info *) *pinfo; 767 if (info != NULL) 768 { 769 if (info->stabsec == NULL || info->strsec == NULL) 770 { 771 /* No stabs debugging information. */ 772 return true; 773 } 774 775 stabsize = info->stabsec->_raw_size; 776 strsize = info->strsec->_raw_size; 777 } 778 else 779 { 780 long reloc_size, reloc_count; 781 arelent **reloc_vector; 782 783 info = (struct stab_find_info *) bfd_zalloc (abfd, sizeof *info); 784 if (info == NULL) 785 return false; 786 787 /* FIXME: When using the linker --split-by-file or 788 --split-by-reloc options, it is possible for the .stab and 789 .stabstr sections to be split. We should handle that. */ 790 791 info->stabsec = bfd_get_section_by_name (abfd, ".stab"); 792 info->strsec = bfd_get_section_by_name (abfd, ".stabstr"); 793 794 if (info->stabsec == NULL || info->strsec == NULL) 795 { 796 /* No stabs debugging information. Set *pinfo so that we 797 can return quickly in the info != NULL case above. */ 798 *pinfo = (PTR) info; 799 return true; 800 } 801 802 stabsize = info->stabsec->_raw_size; 803 strsize = info->strsec->_raw_size; 804 805 info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize); 806 info->strs = (bfd_byte *) bfd_alloc (abfd, strsize); 807 if (info->stabs == NULL || info->strs == NULL) 808 return false; 809 810 if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs, 0, 811 stabsize) 812 || ! bfd_get_section_contents (abfd, info->strsec, info->strs, 0, 813 strsize)) 814 return false; 815 816 /* If this is a relocateable object file, we have to relocate 817 the entries in .stab. This should always be simple 32 bit 818 relocations against symbols defined in this object file, so 819 this should be no big deal. */ 820 reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec); 821 if (reloc_size < 0) 822 return false; 823 reloc_vector = (arelent **) bfd_malloc (reloc_size); 824 if (reloc_vector == NULL && reloc_size != 0) 825 return false; 826 reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector, 827 symbols); 828 if (reloc_count < 0) 829 { 830 if (reloc_vector != NULL) 831 free (reloc_vector); 832 return false; 833 } 834 if (reloc_count > 0) 835 { 836 arelent **pr; 837 838 for (pr = reloc_vector; *pr != NULL; pr++) 839 { 840 arelent *r; 841 unsigned long val; 842 asymbol *sym; 843 844 r = *pr; 845 if (r->howto->rightshift != 0 846 || r->howto->size != 2 847 || r->howto->bitsize != 32 848 || r->howto->pc_relative 849 || r->howto->bitpos != 0 850 || r->howto->dst_mask != 0xffffffff) 851 { 852 (*_bfd_error_handler) 853 ("Unsupported .stab relocation"); 854 bfd_set_error (bfd_error_invalid_operation); 855 if (reloc_vector != NULL) 856 free (reloc_vector); 857 return false; 858 } 859 860 val = bfd_get_32 (abfd, info->stabs + r->address); 861 val &= r->howto->src_mask; 862 sym = *r->sym_ptr_ptr; 863 val += sym->value + sym->section->vma + r->addend; 864 bfd_put_32 (abfd, val, info->stabs + r->address); 865 } 866 } 867 868 if (reloc_vector != NULL) 869 free (reloc_vector); 870 871 *pinfo = (PTR) info; 872 } 873 874 /* We are passed a section relative offset. The offsets in the 875 stabs information are absolute. */ 876 offset += bfd_get_section_vma (abfd, section); 877 878 /* Stabs entries use a 12 byte format: 879 4 byte string table index 880 1 byte stab type 881 1 byte stab other field 882 2 byte stab desc field 883 4 byte stab value 884 FIXME: This will have to change for a 64 bit object format. 885 886 The stabs symbols are divided into compilation units. For the 887 first entry in each unit, the type of 0, the value is the length 888 of the string table for this unit, and the desc field is the 889 number of stabs symbols for this unit. */ 890 891#define STRDXOFF (0) 892#define TYPEOFF (4) 893#define OTHEROFF (5) 894#define DESCOFF (6) 895#define VALOFF (8) 896#define STABSIZE (12) 897 898 /* It would be nice if we could skip ahead to the stabs symbols for 899 the next compilation unit to quickly scan through the compilation 900 units. Unfortunately, since each line number gets a separate 901 stabs entry, it is entirely plausible that a large source file 902 will overflow the 16 bit count of stabs entries. */ 903 fnaddr = 0; 904 directory_name = NULL; 905 main_file_name = NULL; 906 current_file_name = NULL; 907 line_file_name = NULL; 908 fnname = NULL; 909 low_func_vma = 0; 910 low_line_vma = 0; 911 912 stabend = info->stabs + stabsize; 913 914 if (info->cached_stab == NULL || offset < info->cached_offset) 915 { 916 stab = info->stabs; 917 str = info->strs; 918 stroff = 0; 919 } 920 else 921 { 922 stab = info->cached_stab; 923 str = info->cached_str; 924 stroff = info->cached_stroff; 925 } 926 927 info->cached_offset = offset; 928 929 for (; stab < stabend; stab += STABSIZE) 930 { 931 boolean done; 932 bfd_vma val; 933 char *name; 934 935 done = false; 936 937 switch (stab[TYPEOFF]) 938 { 939 case 0: 940 /* This is the first entry in a compilation unit. */ 941 if ((bfd_size_type) ((info->strs + strsize) - str) < stroff) 942 { 943 done = true; 944 break; 945 } 946 str += stroff; 947 stroff = bfd_get_32 (abfd, stab + VALOFF); 948 break; 949 950 case N_SO: 951 /* The main file name. */ 952 953 val = bfd_get_32 (abfd, stab + VALOFF); 954 if (val > offset) 955 { 956 done = true; 957 break; 958 } 959 960 name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 961 962 /* An empty string indicates the end of the compilation 963 unit. */ 964 if (*name == '\0') 965 { 966 /* If there are functions in different sections, they 967 may have addresses larger than val, but we don't want 968 to forget the file name. When there are functions in 969 different cases, there is supposed to be an N_FUN at 970 the end of the function indicating where it ends. */ 971 if (low_func_vma < val || fnname == NULL) 972 main_file_name = NULL; 973 break; 974 } 975 976 /* We know that we have to get to at least this point in the 977 stabs entries for this offset. */ 978 info->cached_stab = stab; 979 info->cached_str = str; 980 info->cached_stroff = stroff; 981 982 current_file_name = name; 983 984 /* Look ahead to the next symbol. Two consecutive N_SO 985 symbols are a directory and a file name. */ 986 if (stab + STABSIZE >= stabend 987 || *(stab + STABSIZE + TYPEOFF) != N_SO) 988 directory_name = NULL; 989 else 990 { 991 stab += STABSIZE; 992 directory_name = current_file_name; 993 current_file_name = ((char *) str 994 + bfd_get_32 (abfd, stab + STRDXOFF)); 995 } 996 997 main_file_name = current_file_name; 998 999 break; 1000 1001 case N_SOL: 1002 /* The name of an include file. */ 1003 current_file_name = ((char *) str 1004 + bfd_get_32 (abfd, stab + STRDXOFF)); 1005 break; 1006 1007 case N_SLINE: 1008 case N_DSLINE: 1009 case N_BSLINE: 1010 /* A line number. The value is relative to the start of the 1011 current function. */ 1012 val = fnaddr + bfd_get_32 (abfd, stab + VALOFF); 1013 if (val >= low_line_vma && val <= offset) 1014 { 1015 *pline = bfd_get_16 (abfd, stab + DESCOFF); 1016 low_line_vma = val; 1017 line_file_name = current_file_name; 1018 } 1019 break; 1020 1021 case N_FUN: 1022 /* A function name. */ 1023 val = bfd_get_32 (abfd, stab + VALOFF); 1024 name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); 1025 1026 /* An empty string here indicates the end of a function, and 1027 the value is relative to fnaddr. */ 1028 1029 if (*name == '\0') 1030 { 1031 val += fnaddr; 1032 if (val >= low_func_vma && val < offset) 1033 fnname = NULL; 1034 } 1035 else 1036 { 1037 if (val >= low_func_vma && val <= offset) 1038 { 1039 fnname = name; 1040 low_func_vma = val; 1041 } 1042 1043 fnaddr = val; 1044 } 1045 1046 break; 1047 } 1048 1049 if (done) 1050 break; 1051 } 1052 1053 if (main_file_name == NULL) 1054 { 1055 /* No information found. */ 1056 return true; 1057 } 1058 1059 *pfound = true; 1060 1061 if (*pline != 0) 1062 main_file_name = line_file_name; 1063 1064 if (main_file_name != NULL) 1065 { 1066 if (main_file_name[0] == '/' || directory_name == NULL) 1067 *pfilename = main_file_name; 1068 else 1069 { 1070 size_t dirlen; 1071 1072 dirlen = strlen (directory_name); 1073 if (info->filename == NULL 1074 || strncmp (info->filename, directory_name, dirlen) != 0 1075 || strcmp (info->filename + dirlen, main_file_name) != 0) 1076 { 1077 if (info->filename != NULL) 1078 free (info->filename); 1079 info->filename = (char *) bfd_malloc (dirlen + 1080 strlen (main_file_name) 1081 + 1); 1082 if (info->filename == NULL) 1083 return false; 1084 strcpy (info->filename, directory_name); 1085 strcpy (info->filename + dirlen, main_file_name); 1086 } 1087 1088 *pfilename = info->filename; 1089 } 1090 } 1091 1092 if (fnname != NULL) 1093 { 1094 char *s; 1095 1096 /* This will typically be something like main:F(0,1), so we want 1097 to clobber the colon. It's OK to change the name, since the 1098 string is in our own local storage anyhow. */ 1099 1100 s = strchr (fnname, ':'); 1101 if (s != NULL) 1102 *s = '\0'; 1103 1104 *pfnname = fnname; 1105 } 1106 1107 return true; 1108} 1109