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