elfread.c revision 19370
1/* Read ELF (Executable and Linking Format) object files for GDB. 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc. 3 Written by Fred Fish at Cygnus Support. 4 5This file is part of GDB. 6 7This program is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2 of the License, or 10(at your option) any later version. 11 12This program is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with this program; if not, write to the Free Software 19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21#include "defs.h" 22#include "bfd.h" 23#include "gdb_string.h" 24#include "elf-bfd.h" 25#include "elf/mips.h" 26#include "symtab.h" 27#include "symfile.h" 28#include "objfiles.h" 29#include "buildsym.h" 30#include "stabsread.h" 31#include "gdb-stabs.h" 32#include "complaints.h" 33#include "demangle.h" 34 35/* The struct elfinfo is available only during ELF symbol table and 36 psymtab reading. It is destroyed at the complation of psymtab-reading. 37 It's local to elf_symfile_read. */ 38 39struct elfinfo { 40 file_ptr dboffset; /* Offset to dwarf debug section */ 41 unsigned int dbsize; /* Size of dwarf debug section */ 42 file_ptr lnoffset; /* Offset to dwarf line number section */ 43 unsigned int lnsize; /* Size of dwarf line number section */ 44 asection *stabsect; /* Section pointer for .stab section */ 45 asection *stabindexsect; /* Section pointer for .stab.index section */ 46 asection *mdebugsect; /* Section pointer for .mdebug section */ 47}; 48 49/* Various things we might complain about... */ 50 51struct complaint section_info_complaint = 52 {"elf/stab section information %s without a preceding file symbol", 0, 0}; 53 54struct complaint section_info_dup_complaint = 55 {"duplicated elf/stab section information for %s", 0, 0}; 56 57struct complaint stab_info_mismatch_complaint = 58 {"elf/stab section information missing for %s", 0, 0}; 59 60struct complaint stab_info_questionable_complaint = 61 {"elf/stab section information questionable for %s", 0, 0}; 62 63static void 64elf_symfile_init PARAMS ((struct objfile *)); 65 66static void 67elf_new_init PARAMS ((struct objfile *)); 68 69static void 70elf_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int)); 71 72static void 73elf_symfile_finish PARAMS ((struct objfile *)); 74 75static void 76elf_symtab_read PARAMS ((bfd *, CORE_ADDR, struct objfile *, int)); 77 78static void 79free_elfinfo PARAMS ((void *)); 80 81static struct section_offsets * 82elf_symfile_offsets PARAMS ((struct objfile *, CORE_ADDR)); 83 84static struct minimal_symbol * 85record_minimal_symbol_and_info PARAMS ((char *, CORE_ADDR, 86 enum minimal_symbol_type, char *, 87 struct objfile *)); 88 89static void 90elf_locate_sections PARAMS ((bfd *, asection *, void *)); 91 92/* We are called once per section from elf_symfile_read. We 93 need to examine each section we are passed, check to see 94 if it is something we are interested in processing, and 95 if so, stash away some access information for the section. 96 97 For now we recognize the dwarf debug information sections and 98 line number sections from matching their section names. The 99 ELF definition is no real help here since it has no direct 100 knowledge of DWARF (by design, so any debugging format can be 101 used). 102 103 We also recognize the ".stab" sections used by the Sun compilers 104 released with Solaris 2. 105 106 FIXME: The section names should not be hardwired strings (what 107 should they be? I don't think most object file formats have enough 108 section flags to specify what kind of debug section it is 109 -kingdon). */ 110 111static void 112elf_locate_sections (ignore_abfd, sectp, eip) 113 bfd *ignore_abfd; 114 asection *sectp; 115 PTR eip; 116{ 117 register struct elfinfo *ei; 118 119 ei = (struct elfinfo *) eip; 120 if (STREQ (sectp -> name, ".debug")) 121 { 122 ei -> dboffset = sectp -> filepos; 123 ei -> dbsize = bfd_get_section_size_before_reloc (sectp); 124 } 125 else if (STREQ (sectp -> name, ".line")) 126 { 127 ei -> lnoffset = sectp -> filepos; 128 ei -> lnsize = bfd_get_section_size_before_reloc (sectp); 129 } 130 else if (STREQ (sectp -> name, ".stab")) 131 { 132 ei -> stabsect = sectp; 133 } 134 else if (STREQ (sectp -> name, ".stab.index")) 135 { 136 ei -> stabindexsect = sectp; 137 } 138 else if (STREQ (sectp -> name, ".mdebug")) 139 { 140 ei -> mdebugsect = sectp; 141 } 142} 143 144#if 0 /* Currently unused */ 145 146char * 147elf_interpreter (abfd) 148 bfd *abfd; 149{ 150 sec_ptr interp_sec; 151 unsigned size; 152 char *interp = NULL; 153 154 interp_sec = bfd_get_section_by_name (abfd, ".interp"); 155 if (interp_sec) 156 { 157 size = bfd_section_size (abfd, interp_sec); 158 interp = alloca (size); 159 if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr)0, 160 size)) 161 { 162 interp = savestring (interp, size - 1); 163 } 164 else 165 { 166 interp = NULL; 167 } 168 } 169 return (interp); 170} 171 172#endif 173 174static struct minimal_symbol * 175record_minimal_symbol_and_info (name, address, ms_type, info, objfile) 176 char *name; 177 CORE_ADDR address; 178 enum minimal_symbol_type ms_type; 179 char *info; /* FIXME, is this really char *? */ 180 struct objfile *objfile; 181{ 182 int section; 183 184 /* Guess the section from the type. This is likely to be wrong in 185 some cases. */ 186 switch (ms_type) 187 { 188 case mst_text: 189 case mst_file_text: 190 section = SECT_OFF_TEXT; 191#ifdef SMASH_TEXT_ADDRESS 192 SMASH_TEXT_ADDRESS (address); 193#endif 194 break; 195 case mst_data: 196 case mst_file_data: 197 section = SECT_OFF_DATA; 198 break; 199 case mst_bss: 200 case mst_file_bss: 201 section = SECT_OFF_BSS; 202 break; 203 default: 204 section = -1; 205 break; 206 } 207 208 name = obsavestring (name, strlen (name), &objfile -> symbol_obstack); 209 return prim_record_minimal_symbol_and_info 210 (name, address, ms_type, info, section, objfile); 211} 212 213/* 214 215LOCAL FUNCTION 216 217 elf_symtab_read -- read the symbol table of an ELF file 218 219SYNOPSIS 220 221 void elf_symtab_read (bfd *abfd, CORE_ADDR addr, 222 struct objfile *objfile, int dynamic) 223 224DESCRIPTION 225 226 Given an open bfd, a base address to relocate symbols to, and a 227 flag that specifies whether or not this bfd is for an executable 228 or not (may be shared library for example), add all the global 229 function and data symbols to the minimal symbol table. 230 231 In stabs-in-ELF, as implemented by Sun, there are some local symbols 232 defined in the ELF symbol table, which can be used to locate 233 the beginnings of sections from each ".o" file that was linked to 234 form the executable objfile. We gather any such info and record it 235 in data structures hung off the objfile's private data. 236 237*/ 238 239static void 240elf_symtab_read (abfd, addr, objfile, dynamic) 241 bfd *abfd; 242 CORE_ADDR addr; 243 struct objfile *objfile; 244 int dynamic; 245{ 246 long storage_needed; 247 asymbol *sym; 248 asymbol **symbol_table; 249 long number_of_symbols; 250 long i; 251 int index; 252 struct cleanup *back_to; 253 CORE_ADDR symaddr; 254 enum minimal_symbol_type ms_type; 255 /* If sectinfo is nonNULL, it contains section info that should end up 256 filed in the objfile. */ 257 struct stab_section_info *sectinfo = NULL; 258 /* If filesym is nonzero, it points to a file symbol, but we haven't 259 seen any section info for it yet. */ 260 asymbol *filesym = 0; 261#ifdef SOFUN_ADDRESS_MAYBE_MISSING 262 /* Name of filesym, as saved on the symbol_obstack. */ 263 char *filesymname = obsavestring ("", 0, &objfile->symbol_obstack); 264#endif 265 struct dbx_symfile_info *dbx = (struct dbx_symfile_info *) 266 objfile->sym_stab_info; 267 unsigned long size; 268 int stripped = (bfd_get_symcount (abfd) == 0); 269 270 if (dynamic) 271 { 272 storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); 273 274 /* Nothing to be done if there is no dynamic symtab. */ 275 if (storage_needed < 0) 276 return; 277 } 278 else 279 { 280 storage_needed = bfd_get_symtab_upper_bound (abfd); 281 if (storage_needed < 0) 282 error ("Can't read symbols from %s: %s", bfd_get_filename (abfd), 283 bfd_errmsg (bfd_get_error ())); 284 } 285 if (storage_needed > 0) 286 { 287 symbol_table = (asymbol **) xmalloc (storage_needed); 288 back_to = make_cleanup (free, symbol_table); 289 if (dynamic) 290 number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, 291 symbol_table); 292 else 293 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 294 if (number_of_symbols < 0) 295 error ("Can't read symbols from %s: %s", bfd_get_filename (abfd), 296 bfd_errmsg (bfd_get_error ())); 297 for (i = 0; i < number_of_symbols; i++) 298 { 299 sym = symbol_table[i]; 300 if (sym -> name == NULL || *sym -> name == '\0') 301 { 302 /* Skip names that don't exist (shouldn't happen), or names 303 that are null strings (may happen). */ 304 continue; 305 } 306 307 if (dynamic 308 && sym -> section == &bfd_und_section 309 && (sym -> flags & BSF_FUNCTION)) 310 { 311 struct minimal_symbol *msym; 312 313 /* Symbol is a reference to a function defined in 314 a shared library. 315 If its value is non zero then it is usually the address 316 of the corresponding entry in the procedure linkage table, 317 relative to the base address. 318 If its value is zero then the dynamic linker has to resolve 319 the symbol. We are unable to find any meaningful address 320 for this symbol in the executable file, so we skip it. */ 321 symaddr = sym -> value; 322 if (symaddr == 0) 323 continue; 324 symaddr += addr; 325 msym = record_minimal_symbol_and_info 326 ((char *) sym -> name, symaddr, 327 mst_solib_trampoline, NULL, objfile); 328#ifdef SOFUN_ADDRESS_MAYBE_MISSING 329 if (msym != NULL) 330 msym->filename = filesymname; 331#endif 332 continue; 333 } 334 335 /* If it is a nonstripped executable, do not enter dynamic 336 symbols, as the dynamic symbol table is usually a subset 337 of the main symbol table. */ 338 if (dynamic && !stripped) 339 continue; 340 if (sym -> flags & BSF_FILE) 341 { 342 /* STT_FILE debugging symbol that helps stabs-in-elf debugging. 343 Chain any old one onto the objfile; remember new sym. */ 344 if (sectinfo != NULL) 345 { 346 sectinfo -> next = dbx -> stab_section_info; 347 dbx -> stab_section_info = sectinfo; 348 sectinfo = NULL; 349 } 350 filesym = sym; 351#ifdef SOFUN_ADDRESS_MAYBE_MISSING 352 filesymname = 353 obsavestring ((char *)filesym->name, strlen (filesym->name), 354 &objfile->symbol_obstack); 355#endif 356 } 357 else if (sym -> flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK)) 358 { 359 struct minimal_symbol *msym; 360 361 /* Select global/local/weak symbols. Note that bfd puts abs 362 symbols in their own section, so all symbols we are 363 interested in will have a section. */ 364 /* Bfd symbols are section relative. */ 365 symaddr = sym -> value + sym -> section -> vma; 366 /* Relocate all non-absolute symbols by base address. */ 367 if (sym -> section != &bfd_abs_section) 368 { 369 symaddr += addr; 370 } 371 /* For non-absolute symbols, use the type of the section 372 they are relative to, to intuit text/data. Bfd provides 373 no way of figuring this out for absolute symbols. */ 374 if (sym -> section == &bfd_abs_section) 375 { 376 /* This is a hack to get the minimal symbol type 377 right for Irix 5, which has absolute adresses 378 with special section indices for dynamic symbols. */ 379 unsigned short shndx = 380 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx; 381 382 switch (shndx) 383 { 384 case SHN_MIPS_TEXT: 385 ms_type = mst_text; 386 break; 387 case SHN_MIPS_DATA: 388 ms_type = mst_data; 389 break; 390 case SHN_MIPS_ACOMMON: 391 ms_type = mst_bss; 392 break; 393 default: 394 ms_type = mst_abs; 395 } 396 } 397 else if (sym -> section -> flags & SEC_CODE) 398 { 399 if (sym -> flags & BSF_GLOBAL) 400 { 401 ms_type = mst_text; 402 } 403 else if ((sym->name[0] == '.' && sym->name[1] == 'L') 404 || ((sym -> flags & BSF_LOCAL) 405 && sym->name[0] == '$' 406 && sym->name[1] == 'L')) 407 /* Looks like a compiler-generated label. Skip it. 408 The assembler should be skipping these (to keep 409 executables small), but apparently with gcc on the 410 delta m88k SVR4, it loses. So to have us check too 411 should be harmless (but I encourage people to fix this 412 in the assembler instead of adding checks here). */ 413 continue; 414 else 415 { 416 ms_type = mst_file_text; 417 } 418 } 419 else if (sym -> section -> flags & SEC_ALLOC) 420 { 421 if (sym -> flags & BSF_GLOBAL) 422 { 423 if (sym -> section -> flags & SEC_LOAD) 424 { 425 ms_type = mst_data; 426 } 427 else 428 { 429 ms_type = mst_bss; 430 } 431 } 432 else if (sym -> flags & BSF_LOCAL) 433 { 434 /* Named Local variable in a Data section. Check its 435 name for stabs-in-elf. The STREQ macro checks the 436 first character inline, so we only actually do a 437 strcmp function call on names that start with 'B' 438 or 'D' */ 439 index = SECT_OFF_MAX; 440 if (STREQ ("Bbss.bss", sym -> name)) 441 { 442 index = SECT_OFF_BSS; 443 } 444 else if (STREQ ("Ddata.data", sym -> name)) 445 { 446 index = SECT_OFF_DATA; 447 } 448 else if (STREQ ("Drodata.rodata", sym -> name)) 449 { 450 index = SECT_OFF_RODATA; 451 } 452 if (index != SECT_OFF_MAX) 453 { 454 /* Found a special local symbol. Allocate a 455 sectinfo, if needed, and fill it in. */ 456 if (sectinfo == NULL) 457 { 458 sectinfo = (struct stab_section_info *) 459 xmmalloc (objfile -> md, sizeof (*sectinfo)); 460 memset ((PTR) sectinfo, 0, sizeof (*sectinfo)); 461 if (filesym == NULL) 462 { 463 complain (§ion_info_complaint, 464 sym -> name); 465 } 466 else 467 { 468 sectinfo -> filename = 469 (char *) filesym -> name; 470 } 471 } 472 if (sectinfo -> sections[index] != 0) 473 { 474 complain (§ion_info_dup_complaint, 475 sectinfo -> filename); 476 } 477 /* Bfd symbols are section relative. */ 478 symaddr = sym -> value + sym -> section -> vma; 479 /* Relocate non-absolute symbols by base address. */ 480 if (sym -> section != &bfd_abs_section) 481 { 482 symaddr += addr; 483 } 484 sectinfo -> sections[index] = symaddr; 485 /* The special local symbols don't go in the 486 minimal symbol table, so ignore this one. */ 487 continue; 488 } 489 /* Not a special stabs-in-elf symbol, do regular 490 symbol processing. */ 491 if (sym -> section -> flags & SEC_LOAD) 492 { 493 ms_type = mst_file_data; 494 } 495 else 496 { 497 ms_type = mst_file_bss; 498 } 499 } 500 else 501 { 502 ms_type = mst_unknown; 503 } 504 } 505 else 506 { 507 /* FIXME: Solaris2 shared libraries include lots of 508 odd "absolute" and "undefined" symbols, that play 509 hob with actions like finding what function the PC 510 is in. Ignore them if they aren't text, data, or bss. */ 511 /* ms_type = mst_unknown; */ 512 continue; /* Skip this symbol. */ 513 } 514 /* Pass symbol size field in via BFD. FIXME!!! */ 515 size = ((elf_symbol_type *) sym) -> internal_elf_sym.st_size; 516 msym = record_minimal_symbol_and_info 517 ((char *) sym -> name, symaddr, 518 ms_type, (PTR) size, objfile); 519#ifdef SOFUN_ADDRESS_MAYBE_MISSING 520 if (msym != NULL) 521 msym->filename = filesymname; 522#endif 523 } 524 } 525 do_cleanups (back_to); 526 } 527} 528 529/* Scan and build partial symbols for a symbol file. 530 We have been initialized by a call to elf_symfile_init, which 531 currently does nothing. 532 533 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols 534 in each section. We simplify it down to a single offset for all 535 symbols. FIXME. 536 537 MAINLINE is true if we are reading the main symbol 538 table (as opposed to a shared lib or dynamically loaded file). 539 540 This function only does the minimum work necessary for letting the 541 user "name" things symbolically; it does not read the entire symtab. 542 Instead, it reads the external and static symbols and puts them in partial 543 symbol tables. When more extensive information is requested of a 544 file, the corresponding partial symbol table is mutated into a full 545 fledged symbol table by going back and reading the symbols 546 for real. 547 548 We look for sections with specific names, to tell us what debug 549 format to look for: FIXME!!! 550 551 dwarf_build_psymtabs() builds psymtabs for DWARF symbols; 552 elfstab_build_psymtabs() handles STABS symbols; 553 mdebug_build_psymtabs() handles ECOFF debugging information. 554 555 Note that ELF files have a "minimal" symbol table, which looks a lot 556 like a COFF symbol table, but has only the minimal information necessary 557 for linking. We process this also, and use the information to 558 build gdb's minimal symbol table. This gives us some minimal debugging 559 capability even for files compiled without -g. */ 560 561static void 562elf_symfile_read (objfile, section_offsets, mainline) 563 struct objfile *objfile; 564 struct section_offsets *section_offsets; 565 int mainline; 566{ 567 bfd *abfd = objfile->obfd; 568 struct elfinfo ei; 569 struct cleanup *back_to; 570 CORE_ADDR offset; 571 572 init_minimal_symbol_collection (); 573 back_to = make_cleanup (discard_minimal_symbols, 0); 574 575 memset ((char *) &ei, 0, sizeof (ei)); 576 577 /* Allocate struct to keep track of the symfile */ 578 objfile->sym_stab_info = (PTR) 579 xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info)); 580 memset ((char *) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info)); 581 make_cleanup (free_elfinfo, (PTR) objfile); 582 583 /* Process the normal ELF symbol table first. This may write some 584 chain of info into the dbx_symfile_info in objfile->sym_stab_info, 585 which can later be used by elfstab_offset_sections. */ 586 587 /* FIXME, should take a section_offsets param, not just an offset. */ 588 offset = ANOFFSET (section_offsets, 0); 589 elf_symtab_read (abfd, offset, objfile, 0); 590 591 /* Add the dynamic symbols. */ 592 593 elf_symtab_read (abfd, offset, objfile, 1); 594 595 /* Now process debugging information, which is contained in 596 special ELF sections. We first have to find them... */ 597 598 bfd_map_over_sections (abfd, elf_locate_sections, (PTR) &ei); 599 if (ei.dboffset && ei.lnoffset) 600 { 601 /* DWARF sections */ 602 dwarf_build_psymtabs (objfile, 603 section_offsets, mainline, 604 ei.dboffset, ei.dbsize, 605 ei.lnoffset, ei.lnsize); 606 } 607 if (ei.stabsect) 608 { 609 asection *str_sect; 610 611 /* Stab sections have an associated string table that looks like 612 a separate section. */ 613 str_sect = bfd_get_section_by_name (abfd, ".stabstr"); 614 615 /* FIXME should probably warn about a stab section without a stabstr. */ 616 if (str_sect) 617 elfstab_build_psymtabs (objfile, 618 section_offsets, 619 mainline, 620 ei.stabsect->filepos, 621 bfd_section_size (abfd, ei.stabsect), 622 str_sect->filepos, 623 bfd_section_size (abfd, str_sect)); 624 } 625 if (ei.mdebugsect) 626 { 627 const struct ecoff_debug_swap *swap; 628 629 /* .mdebug section, presumably holding ECOFF debugging 630 information. */ 631 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; 632 if (swap) 633 elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect, 634 section_offsets); 635 } 636 637 /* Install any minimal symbols that have been collected as the current 638 minimal symbols for this objfile. */ 639 640 install_minimal_symbols (objfile); 641 642 do_cleanups (back_to); 643} 644 645/* This cleans up the objfile's sym_stab_info pointer, and the chain of 646 stab_section_info's, that might be dangling from it. */ 647 648static void 649free_elfinfo (objp) 650 PTR objp; 651{ 652 struct objfile *objfile = (struct objfile *)objp; 653 struct dbx_symfile_info *dbxinfo = (struct dbx_symfile_info *) 654 objfile->sym_stab_info; 655 struct stab_section_info *ssi, *nssi; 656 657 ssi = dbxinfo->stab_section_info; 658 while (ssi) 659 { 660 nssi = ssi->next; 661 mfree (objfile->md, ssi); 662 ssi = nssi; 663 } 664 665 dbxinfo->stab_section_info = 0; /* Just say No mo info about this. */ 666} 667 668 669/* Initialize anything that needs initializing when a completely new symbol 670 file is specified (not just adding some symbols from another file, e.g. a 671 shared library). 672 673 We reinitialize buildsym, since we may be reading stabs from an ELF file. */ 674 675static void 676elf_new_init (ignore) 677 struct objfile *ignore; 678{ 679 stabsread_new_init (); 680 buildsym_new_init (); 681} 682 683/* Perform any local cleanups required when we are done with a particular 684 objfile. I.E, we are in the process of discarding all symbol information 685 for an objfile, freeing up all memory held for it, and unlinking the 686 objfile struct from the global list of known objfiles. */ 687 688static void 689elf_symfile_finish (objfile) 690 struct objfile *objfile; 691{ 692 if (objfile -> sym_stab_info != NULL) 693 { 694 mfree (objfile -> md, objfile -> sym_stab_info); 695 } 696} 697 698/* ELF specific initialization routine for reading symbols. 699 700 It is passed a pointer to a struct sym_fns which contains, among other 701 things, the BFD for the file whose symbols are being read, and a slot for 702 a pointer to "private data" which we can fill with goodies. 703 704 For now at least, we have nothing in particular to do, so this function is 705 just a stub. */ 706 707static void 708elf_symfile_init (objfile) 709 struct objfile *objfile; 710{ 711 /* ELF objects may be reordered, so set OBJF_REORDERED. If we 712 find this causes a significant slowdown in gdb then we could 713 set it in the debug symbol readers only when necessary. */ 714 objfile->flags |= OBJF_REORDERED; 715} 716 717/* ELF specific parsing routine for section offsets. 718 719 Plain and simple for now. */ 720 721static 722struct section_offsets * 723elf_symfile_offsets (objfile, addr) 724 struct objfile *objfile; 725 CORE_ADDR addr; 726{ 727 struct section_offsets *section_offsets; 728 int i; 729 730 objfile->num_sections = SECT_OFF_MAX; 731 section_offsets = (struct section_offsets *) 732 obstack_alloc (&objfile -> psymbol_obstack, 733 sizeof (struct section_offsets) 734 + sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1)); 735 736 for (i = 0; i < SECT_OFF_MAX; i++) 737 ANOFFSET (section_offsets, i) = addr; 738 739 return section_offsets; 740} 741 742/* When handling an ELF file that contains Sun STABS debug info, 743 some of the debug info is relative to the particular chunk of the 744 section that was generated in its individual .o file. E.g. 745 offsets to static variables are relative to the start of the data 746 segment *for that module before linking*. This information is 747 painfully squirreled away in the ELF symbol table as local symbols 748 with wierd names. Go get 'em when needed. */ 749 750void 751elfstab_offset_sections (objfile, pst) 752 struct objfile *objfile; 753 struct partial_symtab *pst; 754{ 755 char *filename = pst->filename; 756 struct dbx_symfile_info *dbx = (struct dbx_symfile_info *) 757 objfile->sym_stab_info; 758 struct stab_section_info *maybe = dbx->stab_section_info; 759 struct stab_section_info *questionable = 0; 760 int i; 761 char *p; 762 763 /* The ELF symbol info doesn't include path names, so strip the path 764 (if any) from the psymtab filename. */ 765 while (0 != (p = strchr (filename, '/'))) 766 filename = p+1; 767 768 /* FIXME: This linear search could speed up significantly 769 if it was chained in the right order to match how we search it, 770 and if we unchained when we found a match. */ 771 for (; maybe; maybe = maybe->next) 772 { 773 if (filename[0] == maybe->filename[0] 774 && STREQ (filename, maybe->filename)) 775 { 776 /* We found a match. But there might be several source files 777 (from different directories) with the same name. */ 778 if (0 == maybe->found) 779 break; 780 questionable = maybe; /* Might use it later. */ 781 } 782 } 783 784 if (maybe == 0 && questionable != 0) 785 { 786 complain (&stab_info_questionable_complaint, filename); 787 maybe = questionable; 788 } 789 790 if (maybe) 791 { 792 /* Found it! Allocate a new psymtab struct, and fill it in. */ 793 maybe->found++; 794 pst->section_offsets = (struct section_offsets *) 795 obstack_alloc (&objfile -> psymbol_obstack, 796 sizeof (struct section_offsets) + 797 sizeof (pst->section_offsets->offsets) * (SECT_OFF_MAX-1)); 798 799 for (i = 0; i < SECT_OFF_MAX; i++) 800 ANOFFSET (pst->section_offsets, i) = maybe->sections[i]; 801 return; 802 } 803 804 /* We were unable to find any offsets for this file. Complain. */ 805 if (dbx->stab_section_info) /* If there *is* any info, */ 806 complain (&stab_info_mismatch_complaint, filename); 807} 808 809/* Register that we are able to handle ELF object file formats. */ 810 811static struct sym_fns elf_sym_fns = 812{ 813 bfd_target_elf_flavour, 814 elf_new_init, /* sym_new_init: init anything gbl to entire symtab */ 815 elf_symfile_init, /* sym_init: read initial info, setup for sym_read() */ 816 elf_symfile_read, /* sym_read: read a symbol file into symtab */ 817 elf_symfile_finish, /* sym_finish: finished with file, cleanup */ 818 elf_symfile_offsets, /* sym_offsets: Translate ext. to int. relocation */ 819 NULL /* next: pointer to next struct sym_fns */ 820}; 821 822void 823_initialize_elfread () 824{ 825 add_symtab_fns (&elf_sym_fns); 826} 827