1 /* GDB routines for manipulating objfiles. 2 3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 4 2002, 2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc. 5 6 Contributed by Cygnus Support, using pieces from other GDB modules. 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 3 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, see <http://www.gnu.org/licenses/>. */ 22 23 /* This file contains support routines for creating, manipulating, and 24 destroying objfile structures. */ 25 26 #include "defs.h" 27 #include "bfd.h" /* Binary File Description */ 28 #include "symtab.h" 29 #include "symfile.h" 30 #include "objfiles.h" 31 #include "gdb-stabs.h" 32 #include "target.h" 33 #include "bcache.h" 34 #include "mdebugread.h" 35 #include "expression.h" 36 #include "parser-defs.h" 37 38 #include "gdb_assert.h" 39 #include <sys/types.h> 40 #include "gdb_stat.h" 41 #include <fcntl.h> 42 #include "gdb_obstack.h" 43 #include "gdb_string.h" 44 #include "hashtab.h" 45 46 #include "breakpoint.h" 47 #include "block.h" 48 #include "dictionary.h" 49 #include "source.h" 50 #include "addrmap.h" 51 #include "arch-utils.h" 52 #include "exec.h" 53 #include "observer.h" 54 #include "complaints.h" 55 56 /* Prototypes for local functions */ 57 58 static void objfile_alloc_data (struct objfile *objfile); 59 static void objfile_free_data (struct objfile *objfile); 60 61 /* Externally visible variables that are owned by this module. 62 See declarations in objfile.h for more info. */ 63 64 struct objfile *object_files; /* Linked list of all objfiles */ 65 struct objfile *current_objfile; /* For symbol file being read in */ 66 struct objfile *symfile_objfile; /* Main symbol table loaded from */ 67 struct objfile *rt_common_objfile; /* For runtime common symbols */ 68 69 /* Records whether any objfiles appeared or disappeared since we last updated 70 address to obj section map. */ 71 72 static int objfiles_changed_p; 73 74 /* Locate all mappable sections of a BFD file. 75 objfile_p_char is a char * to get it through 76 bfd_map_over_sections; we cast it back to its proper type. */ 77 78 /* Called via bfd_map_over_sections to build up the section table that 79 the objfile references. The objfile contains pointers to the start 80 of the table (objfile->sections) and to the first location after 81 the end of the table (objfile->sections_end). */ 82 83 static void 84 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect, 85 void *objfile_p_char) 86 { 87 struct objfile *objfile = (struct objfile *) objfile_p_char; 88 struct obj_section section; 89 flagword aflag; 90 91 aflag = bfd_get_section_flags (abfd, asect); 92 93 if (!(aflag & SEC_ALLOC)) 94 return; 95 96 if (0 == bfd_section_size (abfd, asect)) 97 return; 98 section.objfile = objfile; 99 section.the_bfd_section = asect; 100 section.ovly_mapped = 0; 101 obstack_grow (&objfile->objfile_obstack, (char *) §ion, sizeof (section)); 102 objfile->sections_end 103 = (struct obj_section *) (((size_t) objfile->sections_end) + 1); 104 } 105 106 /* Builds a section table for OBJFILE. 107 Returns 0 if OK, 1 on error (in which case bfd_error contains the 108 error). 109 110 Note that while we are building the table, which goes into the 111 psymbol obstack, we hijack the sections_end pointer to instead hold 112 a count of the number of sections. When bfd_map_over_sections 113 returns, this count is used to compute the pointer to the end of 114 the sections table, which then overwrites the count. 115 116 Also note that the OFFSET and OVLY_MAPPED in each table entry 117 are initialized to zero. 118 119 Also note that if anything else writes to the psymbol obstack while 120 we are building the table, we're pretty much hosed. */ 121 122 int 123 build_objfile_section_table (struct objfile *objfile) 124 { 125 /* objfile->sections can be already set when reading a mapped symbol 126 file. I believe that we do need to rebuild the section table in 127 this case (we rebuild other things derived from the bfd), but we 128 can't free the old one (it's in the objfile_obstack). So we just 129 waste some memory. */ 130 131 objfile->sections_end = 0; 132 bfd_map_over_sections (objfile->obfd, 133 add_to_objfile_sections, (void *) objfile); 134 objfile->sections = obstack_finish (&objfile->objfile_obstack); 135 objfile->sections_end = objfile->sections + (size_t) objfile->sections_end; 136 return (0); 137 } 138 139 /* Given a pointer to an initialized bfd (ABFD) and some flag bits 140 allocate a new objfile struct, fill it in as best we can, link it 141 into the list of all known objfiles, and return a pointer to the 142 new objfile struct. 143 144 The FLAGS word contains various bits (OBJF_*) that can be taken as 145 requests for specific operations. Other bits like OBJF_SHARED are 146 simply copied through to the new objfile flags member. */ 147 148 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0 149 by jv-lang.c, to create an artificial objfile used to hold 150 information about dynamically-loaded Java classes. Unfortunately, 151 that branch of this function doesn't get tested very frequently, so 152 it's prone to breakage. (E.g. at one time the name was set to NULL 153 in that situation, which broke a loop over all names in the dynamic 154 library loader.) If you change this function, please try to leave 155 things in a consistent state even if abfd is NULL. */ 156 157 struct objfile * 158 allocate_objfile (bfd *abfd, int flags) 159 { 160 struct objfile *objfile = NULL; 161 struct objfile *last_one = NULL; 162 163 /* If we don't support mapped symbol files, didn't ask for the file to be 164 mapped, or failed to open the mapped file for some reason, then revert 165 back to an unmapped objfile. */ 166 167 if (objfile == NULL) 168 { 169 objfile = (struct objfile *) xmalloc (sizeof (struct objfile)); 170 memset (objfile, 0, sizeof (struct objfile)); 171 objfile->psymbol_cache = bcache_xmalloc (); 172 objfile->macro_cache = bcache_xmalloc (); 173 /* We could use obstack_specify_allocation here instead, but 174 gdb_obstack.h specifies the alloc/dealloc functions. */ 175 obstack_init (&objfile->objfile_obstack); 176 terminate_minimal_symbol_table (objfile); 177 } 178 179 objfile_alloc_data (objfile); 180 181 /* Update the per-objfile information that comes from the bfd, ensuring 182 that any data that is reference is saved in the per-objfile data 183 region. */ 184 185 objfile->obfd = gdb_bfd_ref (abfd); 186 if (objfile->name != NULL) 187 { 188 xfree (objfile->name); 189 } 190 if (abfd != NULL) 191 { 192 /* Look up the gdbarch associated with the BFD. */ 193 objfile->gdbarch = gdbarch_from_bfd (abfd); 194 195 objfile->name = xstrdup (bfd_get_filename (abfd)); 196 objfile->mtime = bfd_get_mtime (abfd); 197 198 /* Build section table. */ 199 200 if (build_objfile_section_table (objfile)) 201 { 202 error (_("Can't find the file sections in `%s': %s"), 203 objfile->name, bfd_errmsg (bfd_get_error ())); 204 } 205 } 206 else 207 { 208 objfile->name = xstrdup ("<<anonymous objfile>>"); 209 } 210 211 /* Initialize the section indexes for this objfile, so that we can 212 later detect if they are used w/o being properly assigned to. */ 213 214 objfile->sect_index_text = -1; 215 objfile->sect_index_data = -1; 216 objfile->sect_index_bss = -1; 217 objfile->sect_index_rodata = -1; 218 219 /* We don't yet have a C++-specific namespace symtab. */ 220 221 objfile->cp_namespace_symtab = NULL; 222 223 /* Add this file onto the tail of the linked list of other such files. */ 224 225 objfile->next = NULL; 226 if (object_files == NULL) 227 object_files = objfile; 228 else 229 { 230 for (last_one = object_files; 231 last_one->next; 232 last_one = last_one->next); 233 last_one->next = objfile; 234 } 235 236 /* Save passed in flag bits. */ 237 objfile->flags |= flags; 238 239 objfiles_changed_p = 1; /* Rebuild section map next time we need it. */ 240 241 return (objfile); 242 } 243 244 /* Retrieve the gdbarch associated with OBJFILE. */ 245 struct gdbarch * 246 get_objfile_arch (struct objfile *objfile) 247 { 248 return objfile->gdbarch; 249 } 250 251 /* Initialize entry point information for this objfile. */ 252 253 void 254 init_entry_point_info (struct objfile *objfile) 255 { 256 /* Save startup file's range of PC addresses to help blockframe.c 257 decide where the bottom of the stack is. */ 258 259 if (bfd_get_file_flags (objfile->obfd) & EXEC_P) 260 { 261 /* Executable file -- record its entry point so we'll recognize 262 the startup file because it contains the entry point. */ 263 objfile->ei.entry_point = bfd_get_start_address (objfile->obfd); 264 } 265 else if (bfd_get_file_flags (objfile->obfd) & DYNAMIC 266 && bfd_get_start_address (objfile->obfd) != 0) 267 /* Some shared libraries may have entry points set and be 268 runnable. There's no clear way to indicate this, so just check 269 for values other than zero. */ 270 objfile->ei.entry_point = bfd_get_start_address (objfile->obfd); 271 else 272 { 273 /* Examination of non-executable.o files. Short-circuit this stuff. */ 274 objfile->ei.entry_point = INVALID_ENTRY_POINT; 275 } 276 } 277 278 /* Get current entry point address. */ 279 280 CORE_ADDR 281 entry_point_address (void) 282 { 283 struct gdbarch *gdbarch; 284 CORE_ADDR entry_point; 285 286 if (symfile_objfile == NULL) 287 return 0; 288 289 gdbarch = get_objfile_arch (symfile_objfile); 290 291 entry_point = symfile_objfile->ei.entry_point; 292 293 /* Make certain that the address points at real code, and not a 294 function descriptor. */ 295 entry_point = gdbarch_convert_from_func_ptr_addr (gdbarch, entry_point, 296 ¤t_target); 297 298 /* Remove any ISA markers, so that this matches entries in the 299 symbol table. */ 300 entry_point = gdbarch_addr_bits_remove (gdbarch, entry_point); 301 302 return entry_point; 303 } 304 305 /* Create the terminating entry of OBJFILE's minimal symbol table. 306 If OBJFILE->msymbols is zero, allocate a single entry from 307 OBJFILE->objfile_obstack; otherwise, just initialize 308 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */ 309 void 310 terminate_minimal_symbol_table (struct objfile *objfile) 311 { 312 if (! objfile->msymbols) 313 objfile->msymbols = ((struct minimal_symbol *) 314 obstack_alloc (&objfile->objfile_obstack, 315 sizeof (objfile->msymbols[0]))); 316 317 { 318 struct minimal_symbol *m 319 = &objfile->msymbols[objfile->minimal_symbol_count]; 320 321 memset (m, 0, sizeof (*m)); 322 /* Don't rely on these enumeration values being 0's. */ 323 MSYMBOL_TYPE (m) = mst_unknown; 324 SYMBOL_INIT_LANGUAGE_SPECIFIC (m, language_unknown); 325 } 326 } 327 328 329 /* Put one object file before a specified on in the global list. 330 This can be used to make sure an object file is destroyed before 331 another when using ALL_OBJFILES_SAFE to free all objfiles. */ 332 void 333 put_objfile_before (struct objfile *objfile, struct objfile *before_this) 334 { 335 struct objfile **objp; 336 337 unlink_objfile (objfile); 338 339 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next)) 340 { 341 if (*objp == before_this) 342 { 343 objfile->next = *objp; 344 *objp = objfile; 345 return; 346 } 347 } 348 349 internal_error (__FILE__, __LINE__, 350 _("put_objfile_before: before objfile not in list")); 351 } 352 353 /* Put OBJFILE at the front of the list. */ 354 355 void 356 objfile_to_front (struct objfile *objfile) 357 { 358 struct objfile **objp; 359 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next)) 360 { 361 if (*objp == objfile) 362 { 363 /* Unhook it from where it is. */ 364 *objp = objfile->next; 365 /* Put it in the front. */ 366 objfile->next = object_files; 367 object_files = objfile; 368 break; 369 } 370 } 371 } 372 373 /* Unlink OBJFILE from the list of known objfiles, if it is found in the 374 list. 375 376 It is not a bug, or error, to call this function if OBJFILE is not known 377 to be in the current list. This is done in the case of mapped objfiles, 378 for example, just to ensure that the mapped objfile doesn't appear twice 379 in the list. Since the list is threaded, linking in a mapped objfile 380 twice would create a circular list. 381 382 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after 383 unlinking it, just to ensure that we have completely severed any linkages 384 between the OBJFILE and the list. */ 385 386 void 387 unlink_objfile (struct objfile *objfile) 388 { 389 struct objfile **objpp; 390 391 for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next)) 392 { 393 if (*objpp == objfile) 394 { 395 *objpp = (*objpp)->next; 396 objfile->next = NULL; 397 return; 398 } 399 } 400 401 internal_error (__FILE__, __LINE__, 402 _("unlink_objfile: objfile already unlinked")); 403 } 404 405 406 /* Destroy an objfile and all the symtabs and psymtabs under it. Note 407 that as much as possible is allocated on the objfile_obstack 408 so that the memory can be efficiently freed. 409 410 Things which we do NOT free because they are not in malloc'd memory 411 or not in memory specific to the objfile include: 412 413 objfile -> sf 414 415 FIXME: If the objfile is using reusable symbol information (via mmalloc), 416 then we need to take into account the fact that more than one process 417 may be using the symbol information at the same time (when mmalloc is 418 extended to support cooperative locking). When more than one process 419 is using the mapped symbol info, we need to be more careful about when 420 we free objects in the reusable area. */ 421 422 void 423 free_objfile (struct objfile *objfile) 424 { 425 if (objfile->separate_debug_objfile) 426 { 427 free_objfile (objfile->separate_debug_objfile); 428 } 429 430 if (objfile->separate_debug_objfile_backlink) 431 { 432 /* We freed the separate debug file, make sure the base objfile 433 doesn't reference it. */ 434 objfile->separate_debug_objfile_backlink->separate_debug_objfile = NULL; 435 } 436 437 /* Remove any references to this objfile in the global value 438 lists. */ 439 preserve_values (objfile); 440 441 /* First do any symbol file specific actions required when we are 442 finished with a particular symbol file. Note that if the objfile 443 is using reusable symbol information (via mmalloc) then each of 444 these routines is responsible for doing the correct thing, either 445 freeing things which are valid only during this particular gdb 446 execution, or leaving them to be reused during the next one. */ 447 448 if (objfile->sf != NULL) 449 { 450 (*objfile->sf->sym_finish) (objfile); 451 } 452 453 /* Discard any data modules have associated with the objfile. */ 454 objfile_free_data (objfile); 455 456 gdb_bfd_unref (objfile->obfd); 457 458 /* Remove it from the chain of all objfiles. */ 459 460 unlink_objfile (objfile); 461 462 if (objfile == symfile_objfile) 463 symfile_objfile = NULL; 464 465 if (objfile == rt_common_objfile) 466 rt_common_objfile = NULL; 467 468 /* Before the symbol table code was redone to make it easier to 469 selectively load and remove information particular to a specific 470 linkage unit, gdb used to do these things whenever the monolithic 471 symbol table was blown away. How much still needs to be done 472 is unknown, but we play it safe for now and keep each action until 473 it is shown to be no longer needed. */ 474 475 /* Not all our callers call clear_symtab_users (objfile_purge_solibs, 476 for example), so we need to call this here. */ 477 clear_pc_function_cache (); 478 479 /* Clear globals which might have pointed into a removed objfile. 480 FIXME: It's not clear which of these are supposed to persist 481 between expressions and which ought to be reset each time. */ 482 expression_context_block = NULL; 483 innermost_block = NULL; 484 485 /* Check to see if the current_source_symtab belongs to this objfile, 486 and if so, call clear_current_source_symtab_and_line. */ 487 488 { 489 struct symtab_and_line cursal = get_current_source_symtab_and_line (); 490 struct symtab *s; 491 492 ALL_OBJFILE_SYMTABS (objfile, s) 493 { 494 if (s == cursal.symtab) 495 clear_current_source_symtab_and_line (); 496 } 497 } 498 499 /* The last thing we do is free the objfile struct itself. */ 500 501 if (objfile->name != NULL) 502 { 503 xfree (objfile->name); 504 } 505 if (objfile->global_psymbols.list) 506 xfree (objfile->global_psymbols.list); 507 if (objfile->static_psymbols.list) 508 xfree (objfile->static_psymbols.list); 509 /* Free the obstacks for non-reusable objfiles */ 510 bcache_xfree (objfile->psymbol_cache); 511 bcache_xfree (objfile->macro_cache); 512 if (objfile->demangled_names_hash) 513 htab_delete (objfile->demangled_names_hash); 514 obstack_free (&objfile->objfile_obstack, 0); 515 xfree (objfile); 516 objfile = NULL; 517 objfiles_changed_p = 1; /* Rebuild section map next time we need it. */ 518 } 519 520 static void 521 do_free_objfile_cleanup (void *obj) 522 { 523 free_objfile (obj); 524 } 525 526 struct cleanup * 527 make_cleanup_free_objfile (struct objfile *obj) 528 { 529 return make_cleanup (do_free_objfile_cleanup, obj); 530 } 531 532 /* Free all the object files at once and clean up their users. */ 533 534 void 535 free_all_objfiles (void) 536 { 537 struct objfile *objfile, *temp; 538 539 ALL_OBJFILES_SAFE (objfile, temp) 540 { 541 free_objfile (objfile); 542 } 543 clear_symtab_users (); 544 } 545 546 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS 547 entries in new_offsets. */ 548 void 549 objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets) 550 { 551 struct obj_section *s; 552 struct section_offsets *delta = 553 ((struct section_offsets *) 554 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections))); 555 556 { 557 int i; 558 int something_changed = 0; 559 for (i = 0; i < objfile->num_sections; ++i) 560 { 561 delta->offsets[i] = 562 ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i); 563 if (ANOFFSET (delta, i) != 0) 564 something_changed = 1; 565 } 566 if (!something_changed) 567 return; 568 } 569 570 /* OK, get all the symtabs. */ 571 { 572 struct symtab *s; 573 574 ALL_OBJFILE_SYMTABS (objfile, s) 575 { 576 struct linetable *l; 577 struct blockvector *bv; 578 int i; 579 580 /* First the line table. */ 581 l = LINETABLE (s); 582 if (l) 583 { 584 for (i = 0; i < l->nitems; ++i) 585 l->item[i].pc += ANOFFSET (delta, s->block_line_section); 586 } 587 588 /* Don't relocate a shared blockvector more than once. */ 589 if (!s->primary) 590 continue; 591 592 bv = BLOCKVECTOR (s); 593 if (BLOCKVECTOR_MAP (bv)) 594 addrmap_relocate (BLOCKVECTOR_MAP (bv), 595 ANOFFSET (delta, s->block_line_section)); 596 597 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i) 598 { 599 struct block *b; 600 struct symbol *sym; 601 struct dict_iterator iter; 602 603 b = BLOCKVECTOR_BLOCK (bv, i); 604 BLOCK_START (b) += ANOFFSET (delta, s->block_line_section); 605 BLOCK_END (b) += ANOFFSET (delta, s->block_line_section); 606 607 ALL_BLOCK_SYMBOLS (b, iter, sym) 608 { 609 fixup_symbol_section (sym, objfile); 610 611 /* The RS6000 code from which this was taken skipped 612 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN. 613 But I'm leaving out that test, on the theory that 614 they can't possibly pass the tests below. */ 615 if ((SYMBOL_CLASS (sym) == LOC_LABEL 616 || SYMBOL_CLASS (sym) == LOC_STATIC) 617 && SYMBOL_SECTION (sym) >= 0) 618 { 619 SYMBOL_VALUE_ADDRESS (sym) += 620 ANOFFSET (delta, SYMBOL_SECTION (sym)); 621 } 622 } 623 } 624 } 625 } 626 627 { 628 struct partial_symtab *p; 629 630 ALL_OBJFILE_PSYMTABS (objfile, p) 631 { 632 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 633 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 634 } 635 } 636 637 { 638 struct partial_symbol **psym; 639 640 for (psym = objfile->global_psymbols.list; 641 psym < objfile->global_psymbols.next; 642 psym++) 643 { 644 fixup_psymbol_section (*psym, objfile); 645 if (SYMBOL_SECTION (*psym) >= 0) 646 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta, 647 SYMBOL_SECTION (*psym)); 648 } 649 for (psym = objfile->static_psymbols.list; 650 psym < objfile->static_psymbols.next; 651 psym++) 652 { 653 fixup_psymbol_section (*psym, objfile); 654 if (SYMBOL_SECTION (*psym) >= 0) 655 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta, 656 SYMBOL_SECTION (*psym)); 657 } 658 } 659 660 { 661 struct minimal_symbol *msym; 662 ALL_OBJFILE_MSYMBOLS (objfile, msym) 663 if (SYMBOL_SECTION (msym) >= 0) 664 SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym)); 665 } 666 /* Relocating different sections by different amounts may cause the symbols 667 to be out of order. */ 668 msymbols_sort (objfile); 669 670 if (objfile->ei.entry_point != ~(CORE_ADDR) 0) 671 { 672 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT 673 only as a fallback. */ 674 struct obj_section *s; 675 s = find_pc_section (objfile->ei.entry_point); 676 if (s) 677 objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index); 678 else 679 objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 680 } 681 682 { 683 int i; 684 for (i = 0; i < objfile->num_sections; ++i) 685 (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i); 686 } 687 688 /* Rebuild section map next time we need it. */ 689 objfiles_changed_p = 1; 690 691 /* Update the table in exec_ops, used to read memory. */ 692 ALL_OBJFILE_OSECTIONS (objfile, s) 693 { 694 int idx = s->the_bfd_section->index; 695 696 exec_set_section_address (bfd_get_filename (objfile->obfd), idx, 697 obj_section_addr (s)); 698 } 699 700 /* Relocate breakpoints as necessary, after things are relocated. */ 701 breakpoint_re_set (); 702 } 703 704 /* Return non-zero if OBJFILE has partial symbols. */ 705 706 int 707 objfile_has_partial_symbols (struct objfile *objfile) 708 { 709 return objfile->psymtabs != NULL; 710 } 711 712 /* Return non-zero if OBJFILE has full symbols. */ 713 714 int 715 objfile_has_full_symbols (struct objfile *objfile) 716 { 717 return objfile->symtabs != NULL; 718 } 719 720 /* Many places in gdb want to test just to see if we have any partial 721 symbols available. This function returns zero if none are currently 722 available, nonzero otherwise. */ 723 724 int 725 have_partial_symbols (void) 726 { 727 struct objfile *ofp; 728 729 ALL_OBJFILES (ofp) 730 { 731 if (objfile_has_partial_symbols (ofp)) 732 return 1; 733 } 734 return 0; 735 } 736 737 /* Many places in gdb want to test just to see if we have any full 738 symbols available. This function returns zero if none are currently 739 available, nonzero otherwise. */ 740 741 int 742 have_full_symbols (void) 743 { 744 struct objfile *ofp; 745 746 ALL_OBJFILES (ofp) 747 { 748 if (objfile_has_full_symbols (ofp)) 749 return 1; 750 } 751 return 0; 752 } 753 754 755 /* This operations deletes all objfile entries that represent solibs that 756 weren't explicitly loaded by the user, via e.g., the add-symbol-file 757 command. 758 */ 759 void 760 objfile_purge_solibs (void) 761 { 762 struct objfile *objf; 763 struct objfile *temp; 764 765 ALL_OBJFILES_SAFE (objf, temp) 766 { 767 /* We assume that the solib package has been purged already, or will 768 be soon. 769 */ 770 if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED)) 771 free_objfile (objf); 772 } 773 } 774 775 776 /* Many places in gdb want to test just to see if we have any minimal 777 symbols available. This function returns zero if none are currently 778 available, nonzero otherwise. */ 779 780 int 781 have_minimal_symbols (void) 782 { 783 struct objfile *ofp; 784 785 ALL_OBJFILES (ofp) 786 { 787 if (ofp->minimal_symbol_count > 0) 788 { 789 return 1; 790 } 791 } 792 return 0; 793 } 794 795 /* Qsort comparison function. */ 796 797 static int 798 qsort_cmp (const void *a, const void *b) 799 { 800 const struct obj_section *sect1 = *(const struct obj_section **) a; 801 const struct obj_section *sect2 = *(const struct obj_section **) b; 802 const CORE_ADDR sect1_addr = obj_section_addr (sect1); 803 const CORE_ADDR sect2_addr = obj_section_addr (sect2); 804 805 if (sect1_addr < sect2_addr) 806 return -1; 807 else if (sect1_addr > sect2_addr) 808 return 1; 809 else 810 { 811 /* Sections are at the same address. This could happen if 812 A) we have an objfile and a separate debuginfo. 813 B) we are confused, and have added sections without proper relocation, 814 or something like that. */ 815 816 const struct objfile *const objfile1 = sect1->objfile; 817 const struct objfile *const objfile2 = sect2->objfile; 818 819 if (objfile1->separate_debug_objfile == objfile2 820 || objfile2->separate_debug_objfile == objfile1) 821 { 822 /* Case A. The ordering doesn't matter: separate debuginfo files 823 will be filtered out later. */ 824 825 return 0; 826 } 827 828 /* Case B. Maintain stable sort order, so bugs in GDB are easier to 829 triage. This section could be slow (since we iterate over all 830 objfiles in each call to qsort_cmp), but this shouldn't happen 831 very often (GDB is already in a confused state; one hopes this 832 doesn't happen at all). If you discover that significant time is 833 spent in the loops below, do 'set complaints 100' and examine the 834 resulting complaints. */ 835 836 if (objfile1 == objfile2) 837 { 838 /* Both sections came from the same objfile. We are really confused. 839 Sort on sequence order of sections within the objfile. */ 840 841 const struct obj_section *osect; 842 843 ALL_OBJFILE_OSECTIONS (objfile1, osect) 844 if (osect == sect1) 845 return -1; 846 else if (osect == sect2) 847 return 1; 848 849 /* We should have found one of the sections before getting here. */ 850 gdb_assert (0); 851 } 852 else 853 { 854 /* Sort on sequence number of the objfile in the chain. */ 855 856 const struct objfile *objfile; 857 858 ALL_OBJFILES (objfile) 859 if (objfile == objfile1) 860 return -1; 861 else if (objfile == objfile2) 862 return 1; 863 864 /* We should have found one of the objfiles before getting here. */ 865 gdb_assert (0); 866 } 867 868 } 869 870 /* Unreachable. */ 871 gdb_assert (0); 872 return 0; 873 } 874 875 /* Select "better" obj_section to keep. We prefer the one that came from 876 the real object, rather than the one from separate debuginfo. 877 Most of the time the two sections are exactly identical, but with 878 prelinking the .rel.dyn section in the real object may have different 879 size. */ 880 881 static struct obj_section * 882 preferred_obj_section (struct obj_section *a, struct obj_section *b) 883 { 884 gdb_assert (obj_section_addr (a) == obj_section_addr (b)); 885 gdb_assert ((a->objfile->separate_debug_objfile == b->objfile) 886 || (b->objfile->separate_debug_objfile == a->objfile)); 887 gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile) 888 || (b->objfile->separate_debug_objfile_backlink == a->objfile)); 889 890 if (a->objfile->separate_debug_objfile != NULL) 891 return a; 892 return b; 893 } 894 895 /* Return 1 if SECTION should be inserted into the section map. 896 We want to insert only non-overlay and non-TLS section. */ 897 898 static int 899 insert_section_p (const struct bfd *abfd, 900 const struct bfd_section *section) 901 { 902 const bfd_vma lma = bfd_section_lma (abfd, section); 903 904 if (lma != 0 && lma != bfd_section_vma (abfd, section) 905 && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0) 906 /* This is an overlay section. IN_MEMORY check is needed to avoid 907 discarding sections from the "system supplied DSO" (aka vdso) 908 on some Linux systems (e.g. Fedora 11). */ 909 return 0; 910 if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0) 911 /* This is a TLS section. */ 912 return 0; 913 914 return 1; 915 } 916 917 /* Filter out overlapping sections where one section came from the real 918 objfile, and the other from a separate debuginfo file. 919 Return the size of table after redundant sections have been eliminated. */ 920 921 static int 922 filter_debuginfo_sections (struct obj_section **map, int map_size) 923 { 924 int i, j; 925 926 for (i = 0, j = 0; i < map_size - 1; i++) 927 { 928 struct obj_section *const sect1 = map[i]; 929 struct obj_section *const sect2 = map[i + 1]; 930 const struct objfile *const objfile1 = sect1->objfile; 931 const struct objfile *const objfile2 = sect2->objfile; 932 const CORE_ADDR sect1_addr = obj_section_addr (sect1); 933 const CORE_ADDR sect2_addr = obj_section_addr (sect2); 934 935 if (sect1_addr == sect2_addr 936 && (objfile1->separate_debug_objfile == objfile2 937 || objfile2->separate_debug_objfile == objfile1)) 938 { 939 map[j++] = preferred_obj_section (sect1, sect2); 940 ++i; 941 } 942 else 943 map[j++] = sect1; 944 } 945 946 if (i < map_size) 947 { 948 gdb_assert (i == map_size - 1); 949 map[j++] = map[i]; 950 } 951 952 /* The map should not have shrunk to less than half the original size. */ 953 gdb_assert (map_size / 2 <= j); 954 955 return j; 956 } 957 958 /* Filter out overlapping sections, issuing a warning if any are found. 959 Overlapping sections could really be overlay sections which we didn't 960 classify as such in insert_section_p, or we could be dealing with a 961 corrupt binary. */ 962 963 static int 964 filter_overlapping_sections (struct obj_section **map, int map_size) 965 { 966 int i, j; 967 968 for (i = 0, j = 0; i < map_size - 1; ) 969 { 970 int k; 971 972 map[j++] = map[i]; 973 for (k = i + 1; k < map_size; k++) 974 { 975 struct obj_section *const sect1 = map[i]; 976 struct obj_section *const sect2 = map[k]; 977 const CORE_ADDR sect1_addr = obj_section_addr (sect1); 978 const CORE_ADDR sect2_addr = obj_section_addr (sect2); 979 const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1); 980 981 gdb_assert (sect1_addr <= sect2_addr); 982 983 if (sect1_endaddr <= sect2_addr) 984 break; 985 else 986 { 987 /* We have an overlap. Report it. */ 988 989 struct objfile *const objf1 = sect1->objfile; 990 struct objfile *const objf2 = sect2->objfile; 991 992 const struct bfd *const abfd1 = objf1->obfd; 993 const struct bfd *const abfd2 = objf2->obfd; 994 995 const struct bfd_section *const bfds1 = sect1->the_bfd_section; 996 const struct bfd_section *const bfds2 = sect2->the_bfd_section; 997 998 const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2); 999 1000 struct gdbarch *const gdbarch = get_objfile_arch (objf1); 1001 1002 complaint (&symfile_complaints, 1003 _("unexpected overlap between:\n" 1004 " (A) section `%s' from `%s' [%s, %s)\n" 1005 " (B) section `%s' from `%s' [%s, %s).\n" 1006 "Will ignore section B"), 1007 bfd_section_name (abfd1, bfds1), objf1->name, 1008 paddress (gdbarch, sect1_addr), 1009 paddress (gdbarch, sect1_endaddr), 1010 bfd_section_name (abfd2, bfds2), objf2->name, 1011 paddress (gdbarch, sect2_addr), 1012 paddress (gdbarch, sect2_endaddr)); 1013 } 1014 } 1015 i = k; 1016 } 1017 1018 if (i < map_size) 1019 { 1020 gdb_assert (i == map_size - 1); 1021 map[j++] = map[i]; 1022 } 1023 1024 return j; 1025 } 1026 1027 1028 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any 1029 TLS, overlay and overlapping sections. */ 1030 1031 static void 1032 update_section_map (struct obj_section ***pmap, int *pmap_size) 1033 { 1034 int alloc_size, map_size, i; 1035 struct obj_section *s, **map; 1036 struct objfile *objfile; 1037 1038 gdb_assert (objfiles_changed_p != 0); 1039 1040 map = *pmap; 1041 xfree (map); 1042 1043 alloc_size = 0; 1044 ALL_OBJSECTIONS (objfile, s) 1045 if (insert_section_p (objfile->obfd, s->the_bfd_section)) 1046 alloc_size += 1; 1047 1048 map = xmalloc (alloc_size * sizeof (*map)); 1049 1050 i = 0; 1051 ALL_OBJSECTIONS (objfile, s) 1052 if (insert_section_p (objfile->obfd, s->the_bfd_section)) 1053 map[i++] = s; 1054 1055 qsort (map, alloc_size, sizeof (*map), qsort_cmp); 1056 map_size = filter_debuginfo_sections(map, alloc_size); 1057 map_size = filter_overlapping_sections(map, map_size); 1058 1059 if (map_size < alloc_size) 1060 /* Some sections were eliminated. Trim excess space. */ 1061 map = xrealloc (map, map_size * sizeof (*map)); 1062 else 1063 gdb_assert (alloc_size == map_size); 1064 1065 *pmap = map; 1066 *pmap_size = map_size; 1067 } 1068 1069 /* Bsearch comparison function. */ 1070 1071 static int 1072 bsearch_cmp (const void *key, const void *elt) 1073 { 1074 const CORE_ADDR pc = *(CORE_ADDR *) key; 1075 const struct obj_section *section = *(const struct obj_section **) elt; 1076 1077 if (pc < obj_section_addr (section)) 1078 return -1; 1079 if (pc < obj_section_endaddr (section)) 1080 return 0; 1081 return 1; 1082 } 1083 1084 /* Returns a section whose range includes PC or NULL if none found. */ 1085 1086 struct obj_section * 1087 find_pc_section (CORE_ADDR pc) 1088 { 1089 static struct obj_section **sections; 1090 static int num_sections; 1091 1092 struct obj_section *s, **sp; 1093 1094 /* Check for mapped overlay section first. */ 1095 s = find_pc_mapped_section (pc); 1096 if (s) 1097 return s; 1098 1099 if (objfiles_changed_p != 0) 1100 { 1101 update_section_map (§ions, &num_sections); 1102 1103 /* Don't need updates to section map until objfiles are added 1104 or removed. */ 1105 objfiles_changed_p = 0; 1106 } 1107 1108 sp = (struct obj_section **) bsearch (&pc, sections, num_sections, 1109 sizeof (*sections), bsearch_cmp); 1110 if (sp != NULL) 1111 return *sp; 1112 return NULL; 1113 } 1114 1115 1116 /* In SVR4, we recognize a trampoline by it's section name. 1117 That is, if the pc is in a section named ".plt" then we are in 1118 a trampoline. */ 1119 1120 int 1121 in_plt_section (CORE_ADDR pc, char *name) 1122 { 1123 struct obj_section *s; 1124 int retval = 0; 1125 1126 s = find_pc_section (pc); 1127 1128 retval = (s != NULL 1129 && s->the_bfd_section->name != NULL 1130 && strcmp (s->the_bfd_section->name, ".plt") == 0); 1131 return (retval); 1132 } 1133 1134 1135 /* Keep a registry of per-objfile data-pointers required by other GDB 1136 modules. */ 1137 1138 struct objfile_data 1139 { 1140 unsigned index; 1141 void (*save) (struct objfile *, void *); 1142 void (*free) (struct objfile *, void *); 1143 }; 1144 1145 struct objfile_data_registration 1146 { 1147 struct objfile_data *data; 1148 struct objfile_data_registration *next; 1149 }; 1150 1151 struct objfile_data_registry 1152 { 1153 struct objfile_data_registration *registrations; 1154 unsigned num_registrations; 1155 }; 1156 1157 static struct objfile_data_registry objfile_data_registry = { NULL, 0 }; 1158 1159 const struct objfile_data * 1160 register_objfile_data_with_cleanup (void (*save) (struct objfile *, void *), 1161 void (*free) (struct objfile *, void *)) 1162 { 1163 struct objfile_data_registration **curr; 1164 1165 /* Append new registration. */ 1166 for (curr = &objfile_data_registry.registrations; 1167 *curr != NULL; curr = &(*curr)->next); 1168 1169 *curr = XMALLOC (struct objfile_data_registration); 1170 (*curr)->next = NULL; 1171 (*curr)->data = XMALLOC (struct objfile_data); 1172 (*curr)->data->index = objfile_data_registry.num_registrations++; 1173 (*curr)->data->save = save; 1174 (*curr)->data->free = free; 1175 1176 return (*curr)->data; 1177 } 1178 1179 const struct objfile_data * 1180 register_objfile_data (void) 1181 { 1182 return register_objfile_data_with_cleanup (NULL, NULL); 1183 } 1184 1185 static void 1186 objfile_alloc_data (struct objfile *objfile) 1187 { 1188 gdb_assert (objfile->data == NULL); 1189 objfile->num_data = objfile_data_registry.num_registrations; 1190 objfile->data = XCALLOC (objfile->num_data, void *); 1191 } 1192 1193 static void 1194 objfile_free_data (struct objfile *objfile) 1195 { 1196 gdb_assert (objfile->data != NULL); 1197 clear_objfile_data (objfile); 1198 xfree (objfile->data); 1199 objfile->data = NULL; 1200 } 1201 1202 void 1203 clear_objfile_data (struct objfile *objfile) 1204 { 1205 struct objfile_data_registration *registration; 1206 int i; 1207 1208 gdb_assert (objfile->data != NULL); 1209 1210 /* Process all the save handlers. */ 1211 1212 for (registration = objfile_data_registry.registrations, i = 0; 1213 i < objfile->num_data; 1214 registration = registration->next, i++) 1215 if (objfile->data[i] != NULL && registration->data->save != NULL) 1216 registration->data->save (objfile, objfile->data[i]); 1217 1218 /* Now process all the free handlers. */ 1219 1220 for (registration = objfile_data_registry.registrations, i = 0; 1221 i < objfile->num_data; 1222 registration = registration->next, i++) 1223 if (objfile->data[i] != NULL && registration->data->free != NULL) 1224 registration->data->free (objfile, objfile->data[i]); 1225 1226 memset (objfile->data, 0, objfile->num_data * sizeof (void *)); 1227 } 1228 1229 void 1230 set_objfile_data (struct objfile *objfile, const struct objfile_data *data, 1231 void *value) 1232 { 1233 gdb_assert (data->index < objfile->num_data); 1234 objfile->data[data->index] = value; 1235 } 1236 1237 void * 1238 objfile_data (struct objfile *objfile, const struct objfile_data *data) 1239 { 1240 gdb_assert (data->index < objfile->num_data); 1241 return objfile->data[data->index]; 1242 } 1243 1244 /* Set objfiles_changed_p so section map will be rebuilt next time it 1245 is used. Called by reread_symbols. */ 1246 1247 void 1248 objfiles_changed (void) 1249 { 1250 objfiles_changed_p = 1; /* Rebuild section map next time we need it. */ 1251 } 1252 1253 /* Add reference to ABFD. Returns ABFD. */ 1254 struct bfd * 1255 gdb_bfd_ref (struct bfd *abfd) 1256 { 1257 int *p_refcount = bfd_usrdata (abfd); 1258 1259 if (p_refcount != NULL) 1260 { 1261 *p_refcount += 1; 1262 return abfd; 1263 } 1264 1265 p_refcount = xmalloc (sizeof (*p_refcount)); 1266 *p_refcount = 1; 1267 bfd_usrdata (abfd) = p_refcount; 1268 1269 return abfd; 1270 } 1271 1272 /* Unreference and possibly close ABFD. */ 1273 void 1274 gdb_bfd_unref (struct bfd *abfd) 1275 { 1276 int *p_refcount; 1277 char *name; 1278 1279 if (abfd == NULL) 1280 return; 1281 1282 p_refcount = bfd_usrdata (abfd); 1283 1284 /* Valid range for p_refcount: a pointer to int counter, which has a 1285 value of 1 (single owner) or 2 (shared). */ 1286 gdb_assert (*p_refcount == 1 || *p_refcount == 2); 1287 1288 *p_refcount -= 1; 1289 if (*p_refcount > 0) 1290 return; 1291 1292 xfree (p_refcount); 1293 bfd_usrdata (abfd) = NULL; /* Paranoia. */ 1294 1295 name = bfd_get_filename (abfd); 1296 if (!bfd_close (abfd)) 1297 warning (_("cannot close \"%s\": %s"), 1298 name, bfd_errmsg (bfd_get_error ())); 1299 xfree (name); 1300 } 1301