gdb/objfiles.c

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