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