1/* GDB routines for manipulating objfiles. 2 3 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 4 2001, 2002, 2003, 2004 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 2 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 59 Temple Place - Suite 330, 23 Boston, MA 02111-1307, USA. */ 24 25/* This file contains support routines for creating, manipulating, and 26 destroying objfile structures. */ 27 28#include "defs.h" 29#include "bfd.h" /* Binary File Description */ 30#include "symtab.h" 31#include "symfile.h" 32#include "objfiles.h" 33#include "gdb-stabs.h" 34#include "target.h" 35#include "bcache.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 49/* Prototypes for local functions */ 50 51static void objfile_alloc_data (struct objfile *objfile); 52static void objfile_free_data (struct objfile *objfile); 53 54/* Externally visible variables that are owned by this module. 55 See declarations in objfile.h for more info. */ 56 57struct objfile *object_files; /* Linked list of all objfiles */ 58struct objfile *current_objfile; /* For symbol file being read in */ 59struct objfile *symfile_objfile; /* Main symbol table loaded from */ 60struct objfile *rt_common_objfile; /* For runtime common symbols */ 61 62/* Locate all mappable sections of a BFD file. 63 objfile_p_char is a char * to get it through 64 bfd_map_over_sections; we cast it back to its proper type. */ 65 66#ifndef TARGET_KEEP_SECTION 67#define TARGET_KEEP_SECTION(ASECT) 0 68#endif 69 70/* Called via bfd_map_over_sections to build up the section table that 71 the objfile references. The objfile contains pointers to the start 72 of the table (objfile->sections) and to the first location after 73 the end of the table (objfile->sections_end). */ 74 75static void 76add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect, 77 void *objfile_p_char) 78{ 79 struct objfile *objfile = (struct objfile *) objfile_p_char; 80 struct obj_section section; 81 flagword aflag; 82 83 aflag = bfd_get_section_flags (abfd, asect); 84 85 if (!(aflag & SEC_ALLOC) && !(TARGET_KEEP_SECTION (asect))) 86 return; 87 88 if (0 == bfd_section_size (abfd, asect)) 89 return; 90 section.offset = 0; 91 section.objfile = objfile; 92 section.the_bfd_section = asect; 93 section.ovly_mapped = 0; 94 section.addr = bfd_section_vma (abfd, asect); 95 section.endaddr = section.addr + bfd_section_size (abfd, asect); 96 obstack_grow (&objfile->objfile_obstack, (char *) §ion, sizeof (section)); 97 objfile->sections_end = (struct obj_section *) (((unsigned long) objfile->sections_end) + 1); 98} 99 100/* Builds a section table for OBJFILE. 101 Returns 0 if OK, 1 on error (in which case bfd_error contains the 102 error). 103 104 Note that while we are building the table, which goes into the 105 psymbol obstack, we hijack the sections_end pointer to instead hold 106 a count of the number of sections. When bfd_map_over_sections 107 returns, this count is used to compute the pointer to the end of 108 the sections table, which then overwrites the count. 109 110 Also note that the OFFSET and OVLY_MAPPED in each table entry 111 are initialized to zero. 112 113 Also note that if anything else writes to the psymbol obstack while 114 we are building the table, we're pretty much hosed. */ 115 116int 117build_objfile_section_table (struct objfile *objfile) 118{ 119 /* objfile->sections can be already set when reading a mapped symbol 120 file. I believe that we do need to rebuild the section table in 121 this case (we rebuild other things derived from the bfd), but we 122 can't free the old one (it's in the objfile_obstack). So we just 123 waste some memory. */ 124 125 objfile->sections_end = 0; 126 bfd_map_over_sections (objfile->obfd, add_to_objfile_sections, (char *) objfile); 127 objfile->sections = (struct obj_section *) 128 obstack_finish (&objfile->objfile_obstack); 129 objfile->sections_end = objfile->sections + (unsigned long) objfile->sections_end; 130 return (0); 131} 132 133/* Given a pointer to an initialized bfd (ABFD) and some flag bits 134 allocate a new objfile struct, fill it in as best we can, link it 135 into the list of all known objfiles, and return a pointer to the 136 new objfile struct. 137 138 The FLAGS word contains various bits (OBJF_*) that can be taken as 139 requests for specific operations. Other bits like OBJF_SHARED are 140 simply copied through to the new objfile flags member. */ 141 142/* NOTE: carlton/2003-02-04: This function is called with args NULL, 0 143 by jv-lang.c, to create an artificial objfile used to hold 144 information about dynamically-loaded Java classes. Unfortunately, 145 that branch of this function doesn't get tested very frequently, so 146 it's prone to breakage. (E.g. at one time the name was set to NULL 147 in that situation, which broke a loop over all names in the dynamic 148 library loader.) If you change this function, please try to leave 149 things in a consistent state even if abfd is NULL. */ 150 151struct objfile * 152allocate_objfile (bfd *abfd, int flags) 153{ 154 struct objfile *objfile = NULL; 155 struct objfile *last_one = NULL; 156 157 /* If we don't support mapped symbol files, didn't ask for the file to be 158 mapped, or failed to open the mapped file for some reason, then revert 159 back to an unmapped objfile. */ 160 161 if (objfile == NULL) 162 { 163 objfile = (struct objfile *) xmalloc (sizeof (struct objfile)); 164 memset (objfile, 0, sizeof (struct objfile)); 165 objfile->md = NULL; 166 objfile->psymbol_cache = bcache_xmalloc (); 167 objfile->macro_cache = bcache_xmalloc (); 168 /* We could use obstack_specify_allocation here instead, but 169 gdb_obstack.h specifies the alloc/dealloc functions. */ 170 obstack_init (&objfile->objfile_obstack); 171 terminate_minimal_symbol_table (objfile); 172 } 173 174 objfile_alloc_data (objfile); 175 176 /* Update the per-objfile information that comes from the bfd, ensuring 177 that any data that is reference is saved in the per-objfile data 178 region. */ 179 180 objfile->obfd = abfd; 181 if (objfile->name != NULL) 182 { 183 xmfree (objfile->md, objfile->name); 184 } 185 if (abfd != NULL) 186 { 187 objfile->name = mstrsave (objfile->md, bfd_get_filename (abfd)); 188 objfile->mtime = bfd_get_mtime (abfd); 189 190 /* Build section table. */ 191 192 if (build_objfile_section_table (objfile)) 193 { 194 error ("Can't find the file sections in `%s': %s", 195 objfile->name, bfd_errmsg (bfd_get_error ())); 196 } 197 } 198 else 199 { 200 objfile->name = mstrsave (objfile->md, "<<anonymous objfile>>"); 201 } 202 203 /* Initialize the section indexes for this objfile, so that we can 204 later detect if they are used w/o being properly assigned to. */ 205 206 objfile->sect_index_text = -1; 207 objfile->sect_index_data = -1; 208 objfile->sect_index_bss = -1; 209 objfile->sect_index_rodata = -1; 210 211 /* We don't yet have a C++-specific namespace symtab. */ 212 213 objfile->cp_namespace_symtab = NULL; 214 215 /* Add this file onto the tail of the linked list of other such files. */ 216 217 objfile->next = NULL; 218 if (object_files == NULL) 219 object_files = objfile; 220 else 221 { 222 for (last_one = object_files; 223 last_one->next; 224 last_one = last_one->next); 225 last_one->next = objfile; 226 } 227 228 /* Save passed in flag bits. */ 229 objfile->flags |= flags; 230 231 return (objfile); 232} 233 234/* Initialize entry point information for this objfile. */ 235 236void 237init_entry_point_info (struct objfile *objfile) 238{ 239 /* Save startup file's range of PC addresses to help blockframe.c 240 decide where the bottom of the stack is. */ 241 242 if (bfd_get_file_flags (objfile->obfd) & EXEC_P) 243 { 244 /* Executable file -- record its entry point so we'll recognize 245 the startup file because it contains the entry point. */ 246 objfile->ei.entry_point = bfd_get_start_address (objfile->obfd); 247 } 248 else 249 { 250 /* Examination of non-executable.o files. Short-circuit this stuff. */ 251 objfile->ei.entry_point = INVALID_ENTRY_POINT; 252 } 253 objfile->ei.deprecated_entry_file_lowpc = INVALID_ENTRY_LOWPC; 254 objfile->ei.deprecated_entry_file_highpc = INVALID_ENTRY_HIGHPC; 255 objfile->ei.entry_func_lowpc = INVALID_ENTRY_LOWPC; 256 objfile->ei.entry_func_highpc = INVALID_ENTRY_HIGHPC; 257 objfile->ei.main_func_lowpc = INVALID_ENTRY_LOWPC; 258 objfile->ei.main_func_highpc = INVALID_ENTRY_HIGHPC; 259} 260 261/* Get current entry point address. */ 262 263CORE_ADDR 264entry_point_address (void) 265{ 266 return symfile_objfile ? symfile_objfile->ei.entry_point : 0; 267} 268 269/* Create the terminating entry of OBJFILE's minimal symbol table. 270 If OBJFILE->msymbols is zero, allocate a single entry from 271 OBJFILE->objfile_obstack; otherwise, just initialize 272 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */ 273void 274terminate_minimal_symbol_table (struct objfile *objfile) 275{ 276 if (! objfile->msymbols) 277 objfile->msymbols = ((struct minimal_symbol *) 278 obstack_alloc (&objfile->objfile_obstack, 279 sizeof (objfile->msymbols[0]))); 280 281 { 282 struct minimal_symbol *m 283 = &objfile->msymbols[objfile->minimal_symbol_count]; 284 285 memset (m, 0, sizeof (*m)); 286 /* Don't rely on these enumeration values being 0's. */ 287 MSYMBOL_TYPE (m) = mst_unknown; 288 SYMBOL_INIT_LANGUAGE_SPECIFIC (m, language_unknown); 289 } 290} 291 292 293/* Put one object file before a specified on in the global list. 294 This can be used to make sure an object file is destroyed before 295 another when using ALL_OBJFILES_SAFE to free all objfiles. */ 296void 297put_objfile_before (struct objfile *objfile, struct objfile *before_this) 298{ 299 struct objfile **objp; 300 301 unlink_objfile (objfile); 302 303 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next)) 304 { 305 if (*objp == before_this) 306 { 307 objfile->next = *objp; 308 *objp = objfile; 309 return; 310 } 311 } 312 313 internal_error (__FILE__, __LINE__, 314 "put_objfile_before: before objfile not in list"); 315} 316 317/* Put OBJFILE at the front of the list. */ 318 319void 320objfile_to_front (struct objfile *objfile) 321{ 322 struct objfile **objp; 323 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next)) 324 { 325 if (*objp == objfile) 326 { 327 /* Unhook it from where it is. */ 328 *objp = objfile->next; 329 /* Put it in the front. */ 330 objfile->next = object_files; 331 object_files = objfile; 332 break; 333 } 334 } 335} 336 337/* Unlink OBJFILE from the list of known objfiles, if it is found in the 338 list. 339 340 It is not a bug, or error, to call this function if OBJFILE is not known 341 to be in the current list. This is done in the case of mapped objfiles, 342 for example, just to ensure that the mapped objfile doesn't appear twice 343 in the list. Since the list is threaded, linking in a mapped objfile 344 twice would create a circular list. 345 346 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after 347 unlinking it, just to ensure that we have completely severed any linkages 348 between the OBJFILE and the list. */ 349 350void 351unlink_objfile (struct objfile *objfile) 352{ 353 struct objfile **objpp; 354 355 for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next)) 356 { 357 if (*objpp == objfile) 358 { 359 *objpp = (*objpp)->next; 360 objfile->next = NULL; 361 return; 362 } 363 } 364 365 internal_error (__FILE__, __LINE__, 366 "unlink_objfile: objfile already unlinked"); 367} 368 369 370/* Destroy an objfile and all the symtabs and psymtabs under it. Note 371 that as much as possible is allocated on the objfile_obstack 372 so that the memory can be efficiently freed. 373 374 Things which we do NOT free because they are not in malloc'd memory 375 or not in memory specific to the objfile include: 376 377 objfile -> sf 378 379 FIXME: If the objfile is using reusable symbol information (via mmalloc), 380 then we need to take into account the fact that more than one process 381 may be using the symbol information at the same time (when mmalloc is 382 extended to support cooperative locking). When more than one process 383 is using the mapped symbol info, we need to be more careful about when 384 we free objects in the reusable area. */ 385 386void 387free_objfile (struct objfile *objfile) 388{ 389 if (objfile->separate_debug_objfile) 390 { 391 free_objfile (objfile->separate_debug_objfile); 392 } 393 394 if (objfile->separate_debug_objfile_backlink) 395 { 396 /* We freed the separate debug file, make sure the base objfile 397 doesn't reference it. */ 398 objfile->separate_debug_objfile_backlink->separate_debug_objfile = NULL; 399 } 400 401 /* First do any symbol file specific actions required when we are 402 finished with a particular symbol file. Note that if the objfile 403 is using reusable symbol information (via mmalloc) then each of 404 these routines is responsible for doing the correct thing, either 405 freeing things which are valid only during this particular gdb 406 execution, or leaving them to be reused during the next one. */ 407 408 if (objfile->sf != NULL) 409 { 410 (*objfile->sf->sym_finish) (objfile); 411 } 412 413 /* We always close the bfd. */ 414 415 if (objfile->obfd != NULL) 416 { 417 char *name = bfd_get_filename (objfile->obfd); 418 if (!bfd_close (objfile->obfd)) 419 warning ("cannot close \"%s\": %s", 420 name, bfd_errmsg (bfd_get_error ())); 421 xfree (name); 422 } 423 424 /* Remove it from the chain of all objfiles. */ 425 426 unlink_objfile (objfile); 427 428 /* If we are going to free the runtime common objfile, mark it 429 as unallocated. */ 430 431 if (objfile == rt_common_objfile) 432 rt_common_objfile = NULL; 433 434 /* Before the symbol table code was redone to make it easier to 435 selectively load and remove information particular to a specific 436 linkage unit, gdb used to do these things whenever the monolithic 437 symbol table was blown away. How much still needs to be done 438 is unknown, but we play it safe for now and keep each action until 439 it is shown to be no longer needed. */ 440 441 /* I *think* all our callers call clear_symtab_users. If so, no need 442 to call this here. */ 443 clear_pc_function_cache (); 444 445 /* The last thing we do is free the objfile struct itself. */ 446 447 objfile_free_data (objfile); 448 if (objfile->name != NULL) 449 { 450 xmfree (objfile->md, objfile->name); 451 } 452 if (objfile->global_psymbols.list) 453 xmfree (objfile->md, objfile->global_psymbols.list); 454 if (objfile->static_psymbols.list) 455 xmfree (objfile->md, objfile->static_psymbols.list); 456 /* Free the obstacks for non-reusable objfiles */ 457 bcache_xfree (objfile->psymbol_cache); 458 bcache_xfree (objfile->macro_cache); 459 if (objfile->demangled_names_hash) 460 htab_delete (objfile->demangled_names_hash); 461 obstack_free (&objfile->objfile_obstack, 0); 462 xmfree (objfile->md, objfile); 463 objfile = NULL; 464} 465 466static void 467do_free_objfile_cleanup (void *obj) 468{ 469 free_objfile (obj); 470} 471 472struct cleanup * 473make_cleanup_free_objfile (struct objfile *obj) 474{ 475 return make_cleanup (do_free_objfile_cleanup, obj); 476} 477 478/* Free all the object files at once and clean up their users. */ 479 480void 481free_all_objfiles (void) 482{ 483 struct objfile *objfile, *temp; 484 485 ALL_OBJFILES_SAFE (objfile, temp) 486 { 487 free_objfile (objfile); 488 } 489 clear_symtab_users (); 490} 491 492/* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS 493 entries in new_offsets. */ 494void 495objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets) 496{ 497 struct section_offsets *delta = 498 ((struct section_offsets *) 499 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections))); 500 501 { 502 int i; 503 int something_changed = 0; 504 for (i = 0; i < objfile->num_sections; ++i) 505 { 506 delta->offsets[i] = 507 ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i); 508 if (ANOFFSET (delta, i) != 0) 509 something_changed = 1; 510 } 511 if (!something_changed) 512 return; 513 } 514 515 /* OK, get all the symtabs. */ 516 { 517 struct symtab *s; 518 519 ALL_OBJFILE_SYMTABS (objfile, s) 520 { 521 struct linetable *l; 522 struct blockvector *bv; 523 int i; 524 525 /* First the line table. */ 526 l = LINETABLE (s); 527 if (l) 528 { 529 for (i = 0; i < l->nitems; ++i) 530 l->item[i].pc += ANOFFSET (delta, s->block_line_section); 531 } 532 533 /* Don't relocate a shared blockvector more than once. */ 534 if (!s->primary) 535 continue; 536 537 bv = BLOCKVECTOR (s); 538 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i) 539 { 540 struct block *b; 541 struct symbol *sym; 542 struct dict_iterator iter; 543 544 b = BLOCKVECTOR_BLOCK (bv, i); 545 BLOCK_START (b) += ANOFFSET (delta, s->block_line_section); 546 BLOCK_END (b) += ANOFFSET (delta, s->block_line_section); 547 548 ALL_BLOCK_SYMBOLS (b, iter, sym) 549 { 550 fixup_symbol_section (sym, objfile); 551 552 /* The RS6000 code from which this was taken skipped 553 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN. 554 But I'm leaving out that test, on the theory that 555 they can't possibly pass the tests below. */ 556 if ((SYMBOL_CLASS (sym) == LOC_LABEL 557 || SYMBOL_CLASS (sym) == LOC_STATIC 558 || SYMBOL_CLASS (sym) == LOC_INDIRECT) 559 && SYMBOL_SECTION (sym) >= 0) 560 { 561 SYMBOL_VALUE_ADDRESS (sym) += 562 ANOFFSET (delta, SYMBOL_SECTION (sym)); 563 } 564#ifdef MIPS_EFI_SYMBOL_NAME 565 /* Relocate Extra Function Info for ecoff. */ 566 567 else if (SYMBOL_CLASS (sym) == LOC_CONST 568 && SYMBOL_DOMAIN (sym) == LABEL_DOMAIN 569 && strcmp (DEPRECATED_SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0) 570 ecoff_relocate_efi (sym, ANOFFSET (delta, 571 s->block_line_section)); 572#endif 573 } 574 } 575 } 576 } 577 578 { 579 struct partial_symtab *p; 580 581 ALL_OBJFILE_PSYMTABS (objfile, p) 582 { 583 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 584 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 585 } 586 } 587 588 { 589 struct partial_symbol **psym; 590 591 for (psym = objfile->global_psymbols.list; 592 psym < objfile->global_psymbols.next; 593 psym++) 594 { 595 fixup_psymbol_section (*psym, objfile); 596 if (SYMBOL_SECTION (*psym) >= 0) 597 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta, 598 SYMBOL_SECTION (*psym)); 599 } 600 for (psym = objfile->static_psymbols.list; 601 psym < objfile->static_psymbols.next; 602 psym++) 603 { 604 fixup_psymbol_section (*psym, objfile); 605 if (SYMBOL_SECTION (*psym) >= 0) 606 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta, 607 SYMBOL_SECTION (*psym)); 608 } 609 } 610 611 { 612 struct minimal_symbol *msym; 613 ALL_OBJFILE_MSYMBOLS (objfile, msym) 614 if (SYMBOL_SECTION (msym) >= 0) 615 SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym)); 616 } 617 /* Relocating different sections by different amounts may cause the symbols 618 to be out of order. */ 619 msymbols_sort (objfile); 620 621 { 622 int i; 623 for (i = 0; i < objfile->num_sections; ++i) 624 (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i); 625 } 626 627 if (objfile->ei.entry_point != ~(CORE_ADDR) 0) 628 { 629 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT 630 only as a fallback. */ 631 struct obj_section *s; 632 s = find_pc_section (objfile->ei.entry_point); 633 if (s) 634 objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index); 635 else 636 objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 637 } 638 639 { 640 struct obj_section *s; 641 bfd *abfd; 642 643 abfd = objfile->obfd; 644 645 ALL_OBJFILE_OSECTIONS (objfile, s) 646 { 647 int idx = s->the_bfd_section->index; 648 649 s->addr += ANOFFSET (delta, idx); 650 s->endaddr += ANOFFSET (delta, idx); 651 } 652 } 653 654 if (objfile->ei.entry_func_lowpc != INVALID_ENTRY_LOWPC) 655 { 656 objfile->ei.entry_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 657 objfile->ei.entry_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 658 } 659 660 if (objfile->ei.deprecated_entry_file_lowpc != INVALID_ENTRY_LOWPC) 661 { 662 objfile->ei.deprecated_entry_file_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 663 objfile->ei.deprecated_entry_file_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 664 } 665 666 if (objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC) 667 { 668 objfile->ei.main_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 669 objfile->ei.main_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 670 } 671 672 /* Relocate breakpoints as necessary, after things are relocated. */ 673 breakpoint_re_set (); 674} 675 676/* Many places in gdb want to test just to see if we have any partial 677 symbols available. This function returns zero if none are currently 678 available, nonzero otherwise. */ 679 680int 681have_partial_symbols (void) 682{ 683 struct objfile *ofp; 684 685 ALL_OBJFILES (ofp) 686 { 687 if (ofp->psymtabs != NULL) 688 { 689 return 1; 690 } 691 } 692 return 0; 693} 694 695/* Many places in gdb want to test just to see if we have any full 696 symbols available. This function returns zero if none are currently 697 available, nonzero otherwise. */ 698 699int 700have_full_symbols (void) 701{ 702 struct objfile *ofp; 703 704 ALL_OBJFILES (ofp) 705 { 706 if (ofp->symtabs != NULL) 707 { 708 return 1; 709 } 710 } 711 return 0; 712} 713 714 715/* This operations deletes all objfile entries that represent solibs that 716 weren't explicitly loaded by the user, via e.g., the add-symbol-file 717 command. 718 */ 719void 720objfile_purge_solibs (void) 721{ 722 struct objfile *objf; 723 struct objfile *temp; 724 725 ALL_OBJFILES_SAFE (objf, temp) 726 { 727 /* We assume that the solib package has been purged already, or will 728 be soon. 729 */ 730 if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED)) 731 free_objfile (objf); 732 } 733} 734 735 736/* Many places in gdb want to test just to see if we have any minimal 737 symbols available. This function returns zero if none are currently 738 available, nonzero otherwise. */ 739 740int 741have_minimal_symbols (void) 742{ 743 struct objfile *ofp; 744 745 ALL_OBJFILES (ofp) 746 { 747 if (ofp->minimal_symbol_count > 0) 748 { 749 return 1; 750 } 751 } 752 return 0; 753} 754 755/* Returns a section whose range includes PC and SECTION, or NULL if 756 none found. Note the distinction between the return type, struct 757 obj_section (which is defined in gdb), and the input type "struct 758 bfd_section" (which is a bfd-defined data type). The obj_section 759 contains a pointer to the "struct bfd_section". */ 760 761struct obj_section * 762find_pc_sect_section (CORE_ADDR pc, struct bfd_section *section) 763{ 764 struct obj_section *s; 765 struct objfile *objfile; 766 767 ALL_OBJSECTIONS (objfile, s) 768 if ((section == 0 || section == s->the_bfd_section) && 769 s->addr <= pc && pc < s->endaddr) 770 return (s); 771 772 return (NULL); 773} 774 775/* Returns a section whose range includes PC or NULL if none found. 776 Backward compatibility, no section. */ 777 778struct obj_section * 779find_pc_section (CORE_ADDR pc) 780{ 781 return find_pc_sect_section (pc, find_pc_mapped_section (pc)); 782} 783 784 785/* In SVR4, we recognize a trampoline by it's section name. 786 That is, if the pc is in a section named ".plt" then we are in 787 a trampoline. */ 788 789int 790in_plt_section (CORE_ADDR pc, char *name) 791{ 792 struct obj_section *s; 793 int retval = 0; 794 795 s = find_pc_section (pc); 796 797 retval = (s != NULL 798 && s->the_bfd_section->name != NULL 799 && strcmp (s->the_bfd_section->name, ".plt") == 0); 800 return (retval); 801} 802 803/* Return nonzero if NAME is in the import list of OBJFILE. Else 804 return zero. */ 805 806int 807is_in_import_list (char *name, struct objfile *objfile) 808{ 809 int i; 810 811 if (!objfile || !name || !*name) 812 return 0; 813 814 for (i = 0; i < objfile->import_list_size; i++) 815 if (objfile->import_list[i] && DEPRECATED_STREQ (name, objfile->import_list[i])) 816 return 1; 817 return 0; 818} 819 820 821/* Keep a registry of per-objfile data-pointers required by other GDB 822 modules. */ 823 824struct objfile_data 825{ 826 unsigned index; 827}; 828 829struct objfile_data_registration 830{ 831 struct objfile_data *data; 832 struct objfile_data_registration *next; 833}; 834 835struct objfile_data_registry 836{ 837 struct objfile_data_registration *registrations; 838 unsigned num_registrations; 839}; 840 841static struct objfile_data_registry objfile_data_registry = { NULL, 0 }; 842 843const struct objfile_data * 844register_objfile_data (void) 845{ 846 struct objfile_data_registration **curr; 847 848 /* Append new registration. */ 849 for (curr = &objfile_data_registry.registrations; 850 *curr != NULL; curr = &(*curr)->next); 851 852 *curr = XMALLOC (struct objfile_data_registration); 853 (*curr)->next = NULL; 854 (*curr)->data = XMALLOC (struct objfile_data); 855 (*curr)->data->index = objfile_data_registry.num_registrations++; 856 857 return (*curr)->data; 858} 859 860static void 861objfile_alloc_data (struct objfile *objfile) 862{ 863 gdb_assert (objfile->data == NULL); 864 objfile->num_data = objfile_data_registry.num_registrations; 865 objfile->data = XCALLOC (objfile->num_data, void *); 866} 867 868static void 869objfile_free_data (struct objfile *objfile) 870{ 871 gdb_assert (objfile->data != NULL); 872 xfree (objfile->data); 873 objfile->data = NULL; 874} 875 876void 877clear_objfile_data (struct objfile *objfile) 878{ 879 gdb_assert (objfile->data != NULL); 880 memset (objfile->data, 0, objfile->num_data * sizeof (void *)); 881} 882 883void 884set_objfile_data (struct objfile *objfile, const struct objfile_data *data, 885 void *value) 886{ 887 gdb_assert (data->index < objfile->num_data); 888 objfile->data[data->index] = value; 889} 890 891void * 892objfile_data (struct objfile *objfile, const struct objfile_data *data) 893{ 894 gdb_assert (data->index < objfile->num_data); 895 return objfile->data[data->index]; 896} 897