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