gdb/objfiles.c

   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
  51 static void objfile_alloc_data (struct objfile *objfile);
  52 static 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
  57 struct objfile *object_files;   /* Linked list of all objfiles */
  58 struct objfile *current_objfile;        /* For symbol file being read in */
  59 struct objfile *symfile_objfile;        /* Main symbol table loaded from */
  60 struct 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
  75 static void
  76 add_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 *) &section, 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
 116 int
 117 build_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
 151 struct objfile *
 152 allocate_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
 235 /* Create the terminating entry of OBJFILE's minimal symbol table.
 236    If OBJFILE->msymbols is zero, allocate a single entry from
 237    OBJFILE->objfile_obstack; otherwise, just initialize
 238    OBJFILE->msymbols[OBJFILE->minimal_symbol_count].  */
 239 void
 240 terminate_minimal_symbol_table (struct objfile *objfile)
 241 {
 242   if (! objfile->msymbols)
 243     objfile->msymbols = ((struct minimal_symbol *)
 244                          obstack_alloc (&objfile->objfile_obstack,
 245                                         sizeof (objfile->msymbols[0])));
 246
 247   {
 248     struct minimal_symbol *m
 249       = &objfile->msymbols[objfile->minimal_symbol_count];
 250
 251     memset (m, 0, sizeof (*m));
 252     DEPRECATED_SYMBOL_NAME (m) = NULL;
 253     SYMBOL_VALUE_ADDRESS (m) = 0;
 254     MSYMBOL_INFO (m) = NULL;
 255     MSYMBOL_SIZE (m) = 0;
 256     MSYMBOL_TYPE (m) = mst_unknown;
 257     SYMBOL_INIT_LANGUAGE_SPECIFIC (m, language_unknown);
 258   }
 259 }
 260
 261
 262 /* Put one object file before a specified on in the global list.
 263    This can be used to make sure an object file is destroyed before
 264    another when using ALL_OBJFILES_SAFE to free all objfiles. */
 265 void
 266 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
 267 {
 268   struct objfile **objp;
 269
 270   unlink_objfile (objfile);
 271
 272   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
 273     {
 274       if (*objp == before_this)
 275         {
 276           objfile->next = *objp;
 277           *objp = objfile;
 278           return;
 279         }
 280     }
 281
 282   internal_error (__FILE__, __LINE__,
 283                   "put_objfile_before: before objfile not in list");
 284 }
 285
 286 /* Put OBJFILE at the front of the list.  */
 287
 288 void
 289 objfile_to_front (struct objfile *objfile)
 290 {
 291   struct objfile **objp;
 292   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
 293     {
 294       if (*objp == objfile)
 295         {
 296           /* Unhook it from where it is.  */
 297           *objp = objfile->next;
 298           /* Put it in the front.  */
 299           objfile->next = object_files;
 300           object_files = objfile;
 301           break;
 302         }
 303     }
 304 }
 305
 306 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
 307    list.
 308
 309    It is not a bug, or error, to call this function if OBJFILE is not known
 310    to be in the current list.  This is done in the case of mapped objfiles,
 311    for example, just to ensure that the mapped objfile doesn't appear twice
 312    in the list.  Since the list is threaded, linking in a mapped objfile
 313    twice would create a circular list.
 314
 315    If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
 316    unlinking it, just to ensure that we have completely severed any linkages
 317    between the OBJFILE and the list. */
 318
 319 void
 320 unlink_objfile (struct objfile *objfile)
 321 {
 322   struct objfile **objpp;
 323
 324   for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
 325     {
 326       if (*objpp == objfile)
 327         {
 328           *objpp = (*objpp)->next;
 329           objfile->next = NULL;
 330           return;
 331         }
 332     }
 333
 334   internal_error (__FILE__, __LINE__,
 335                   "unlink_objfile: objfile already unlinked");
 336 }
 337
 338
 339 /* Destroy an objfile and all the symtabs and psymtabs under it.  Note
 340    that as much as possible is allocated on the objfile_obstack
 341    so that the memory can be efficiently freed.
 342
 343    Things which we do NOT free because they are not in malloc'd memory
 344    or not in memory specific to the objfile include:
 345
 346    objfile -> sf
 347
 348    FIXME:  If the objfile is using reusable symbol information (via mmalloc),
 349    then we need to take into account the fact that more than one process
 350    may be using the symbol information at the same time (when mmalloc is
 351    extended to support cooperative locking).  When more than one process
 352    is using the mapped symbol info, we need to be more careful about when
 353    we free objects in the reusable area. */
 354
 355 void
 356 free_objfile (struct objfile *objfile)
 357 {
 358   if (objfile->separate_debug_objfile)
 359     {
 360       free_objfile (objfile->separate_debug_objfile);
 361     }
 362
 363   if (objfile->separate_debug_objfile_backlink)
 364     {
 365       /* We freed the separate debug file, make sure the base objfile
 366          doesn't reference it.  */
 367       objfile->separate_debug_objfile_backlink->separate_debug_objfile = NULL;
 368     }
 369
 370   /* First do any symbol file specific actions required when we are
 371      finished with a particular symbol file.  Note that if the objfile
 372      is using reusable symbol information (via mmalloc) then each of
 373      these routines is responsible for doing the correct thing, either
 374      freeing things which are valid only during this particular gdb
 375      execution, or leaving them to be reused during the next one. */
 376
 377   if (objfile->sf != NULL)
 378     {
 379       (*objfile->sf->sym_finish) (objfile);
 380     }
 381
 382   /* We always close the bfd. */
 383
 384   if (objfile->obfd != NULL)
 385     {
 386       char *name = bfd_get_filename (objfile->obfd);
 387       if (!bfd_close (objfile->obfd))
 388         warning ("cannot close \"%s\": %s",
 389                  name, bfd_errmsg (bfd_get_error ()));
 390       xfree (name);
 391     }
 392
 393   /* Remove it from the chain of all objfiles. */
 394
 395   unlink_objfile (objfile);
 396
 397   /* If we are going to free the runtime common objfile, mark it
 398      as unallocated.  */
 399
 400   if (objfile == rt_common_objfile)
 401     rt_common_objfile = NULL;
 402
 403   /* Before the symbol table code was redone to make it easier to
 404      selectively load and remove information particular to a specific
 405      linkage unit, gdb used to do these things whenever the monolithic
 406      symbol table was blown away.  How much still needs to be done
 407      is unknown, but we play it safe for now and keep each action until
 408      it is shown to be no longer needed. */
 409
 410   /* I *think* all our callers call clear_symtab_users.  If so, no need
 411      to call this here.  */
 412   clear_pc_function_cache ();
 413
 414   /* The last thing we do is free the objfile struct itself. */
 415
 416   objfile_free_data (objfile);
 417   if (objfile->name != NULL)
 418     {
 419       xmfree (objfile->md, objfile->name);
 420     }
 421   if (objfile->global_psymbols.list)
 422     xmfree (objfile->md, objfile->global_psymbols.list);
 423   if (objfile->static_psymbols.list)
 424     xmfree (objfile->md, objfile->static_psymbols.list);
 425   /* Free the obstacks for non-reusable objfiles */
 426   bcache_xfree (objfile->psymbol_cache);
 427   bcache_xfree (objfile->macro_cache);
 428   if (objfile->demangled_names_hash)
 429     htab_delete (objfile->demangled_names_hash);
 430   obstack_free (&objfile->objfile_obstack, 0);
 431   xmfree (objfile->md, objfile);
 432   objfile = NULL;
 433 }
 434
 435 static void
 436 do_free_objfile_cleanup (void *obj)
 437 {
 438   free_objfile (obj);
 439 }
 440
 441 struct cleanup *
 442 make_cleanup_free_objfile (struct objfile *obj)
 443 {
 444   return make_cleanup (do_free_objfile_cleanup, obj);
 445 }
 446
 447 /* Free all the object files at once and clean up their users.  */
 448
 449 void
 450 free_all_objfiles (void)
 451 {
 452   struct objfile *objfile, *temp;
 453
 454   ALL_OBJFILES_SAFE (objfile, temp)
 455   {
 456     free_objfile (objfile);
 457   }
 458   clear_symtab_users ();
 459 }
 460 \f
 461 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
 462    entries in new_offsets.  */
 463 void
 464 objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets)
 465 {
 466   struct section_offsets *delta =
 467     ((struct section_offsets *)
 468      alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
 469
 470   {
 471     int i;
 472     int something_changed = 0;
 473     for (i = 0; i < objfile->num_sections; ++i)
 474       {
 475         delta->offsets[i] =
 476           ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
 477         if (ANOFFSET (delta, i) != 0)
 478           something_changed = 1;
 479       }
 480     if (!something_changed)
 481       return;
 482   }
 483
 484   /* OK, get all the symtabs.  */
 485   {
 486     struct symtab *s;
 487
 488     ALL_OBJFILE_SYMTABS (objfile, s)
 489     {
 490       struct linetable *l;
 491       struct blockvector *bv;
 492       int i;
 493
 494       /* First the line table.  */
 495       l = LINETABLE (s);
 496       if (l)
 497         {
 498           for (i = 0; i < l->nitems; ++i)
 499             l->item[i].pc += ANOFFSET (delta, s->block_line_section);
 500         }
 501
 502       /* Don't relocate a shared blockvector more than once.  */
 503       if (!s->primary)
 504         continue;
 505
 506       bv = BLOCKVECTOR (s);
 507       for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
 508         {
 509           struct block *b;
 510           struct symbol *sym;
 511           struct dict_iterator iter;
 512
 513           b = BLOCKVECTOR_BLOCK (bv, i);
 514           BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
 515           BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
 516
 517           ALL_BLOCK_SYMBOLS (b, iter, sym)
 518             {
 519               fixup_symbol_section (sym, objfile);
 520
 521               /* The RS6000 code from which this was taken skipped
 522                  any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
 523                  But I'm leaving out that test, on the theory that
 524                  they can't possibly pass the tests below.  */
 525               if ((SYMBOL_CLASS (sym) == LOC_LABEL
 526                    || SYMBOL_CLASS (sym) == LOC_STATIC
 527                    || SYMBOL_CLASS (sym) == LOC_INDIRECT)
 528                   && SYMBOL_SECTION (sym) >= 0)
 529                 {
 530                   SYMBOL_VALUE_ADDRESS (sym) +=
 531                     ANOFFSET (delta, SYMBOL_SECTION (sym));
 532                 }
 533 #ifdef MIPS_EFI_SYMBOL_NAME
 534               /* Relocate Extra Function Info for ecoff.  */
 535
 536               else if (SYMBOL_CLASS (sym) == LOC_CONST
 537                        && SYMBOL_DOMAIN (sym) == LABEL_DOMAIN
 538                        && strcmp (DEPRECATED_SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0)
 539                 ecoff_relocate_efi (sym, ANOFFSET (delta,
 540                                                    s->block_line_section));
 541 #endif
 542             }
 543         }
 544     }
 545   }
 546
 547   {
 548     struct partial_symtab *p;
 549
 550     ALL_OBJFILE_PSYMTABS (objfile, p)
 551     {
 552       p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 553       p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 554     }
 555   }
 556
 557   {
 558     struct partial_symbol **psym;
 559
 560     for (psym = objfile->global_psymbols.list;
 561          psym < objfile->global_psymbols.next;
 562          psym++)
 563       {
 564         fixup_psymbol_section (*psym, objfile);
 565         if (SYMBOL_SECTION (*psym) >= 0)
 566           SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
 567                                                     SYMBOL_SECTION (*psym));
 568       }
 569     for (psym = objfile->static_psymbols.list;
 570          psym < objfile->static_psymbols.next;
 571          psym++)
 572       {
 573         fixup_psymbol_section (*psym, objfile);
 574         if (SYMBOL_SECTION (*psym) >= 0)
 575           SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
 576                                                     SYMBOL_SECTION (*psym));
 577       }
 578   }
 579
 580   {
 581     struct minimal_symbol *msym;
 582     ALL_OBJFILE_MSYMBOLS (objfile, msym)
 583       if (SYMBOL_SECTION (msym) >= 0)
 584       SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
 585   }
 586   /* Relocating different sections by different amounts may cause the symbols
 587      to be out of order.  */
 588   msymbols_sort (objfile);
 589
 590   {
 591     int i;
 592     for (i = 0; i < objfile->num_sections; ++i)
 593       (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
 594   }
 595
 596   if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
 597     {
 598       /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
 599          only as a fallback.  */
 600       struct obj_section *s;
 601       s = find_pc_section (objfile->ei.entry_point);
 602       if (s)
 603         objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index);
 604       else
 605         objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 606     }
 607
 608   {
 609     struct obj_section *s;
 610     bfd *abfd;
 611
 612     abfd = objfile->obfd;
 613
 614     ALL_OBJFILE_OSECTIONS (objfile, s)
 615       {
 616         int idx = s->the_bfd_section->index;
 617
 618         s->addr += ANOFFSET (delta, idx);
 619         s->endaddr += ANOFFSET (delta, idx);
 620       }
 621   }
 622
 623   if (objfile->ei.entry_func_lowpc != INVALID_ENTRY_LOWPC)
 624     {
 625       objfile->ei.entry_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 626       objfile->ei.entry_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 627     }
 628
 629   if (objfile->ei.deprecated_entry_file_lowpc != INVALID_ENTRY_LOWPC)
 630     {
 631       objfile->ei.deprecated_entry_file_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 632       objfile->ei.deprecated_entry_file_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 633     }
 634
 635   if (objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC)
 636     {
 637       objfile->ei.main_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 638       objfile->ei.main_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 639     }
 640
 641   /* Relocate breakpoints as necessary, after things are relocated. */
 642   breakpoint_re_set ();
 643 }
 644 \f
 645 /* Many places in gdb want to test just to see if we have any partial
 646    symbols available.  This function returns zero if none are currently
 647    available, nonzero otherwise. */
 648
 649 int
 650 have_partial_symbols (void)
 651 {
 652   struct objfile *ofp;
 653
 654   ALL_OBJFILES (ofp)
 655   {
 656     if (ofp->psymtabs != NULL)
 657       {
 658         return 1;
 659       }
 660   }
 661   return 0;
 662 }
 663
 664 /* Many places in gdb want to test just to see if we have any full
 665    symbols available.  This function returns zero if none are currently
 666    available, nonzero otherwise. */
 667
 668 int
 669 have_full_symbols (void)
 670 {
 671   struct objfile *ofp;
 672
 673   ALL_OBJFILES (ofp)
 674   {
 675     if (ofp->symtabs != NULL)
 676       {
 677         return 1;
 678       }
 679   }
 680   return 0;
 681 }
 682
 683
 684 /* This operations deletes all objfile entries that represent solibs that
 685    weren't explicitly loaded by the user, via e.g., the add-symbol-file
 686    command.
 687  */
 688 void
 689 objfile_purge_solibs (void)
 690 {
 691   struct objfile *objf;
 692   struct objfile *temp;
 693
 694   ALL_OBJFILES_SAFE (objf, temp)
 695   {
 696     /* We assume that the solib package has been purged already, or will
 697        be soon.
 698      */
 699     if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
 700       free_objfile (objf);
 701   }
 702 }
 703
 704
 705 /* Many places in gdb want to test just to see if we have any minimal
 706    symbols available.  This function returns zero if none are currently
 707    available, nonzero otherwise. */
 708
 709 int
 710 have_minimal_symbols (void)
 711 {
 712   struct objfile *ofp;
 713
 714   ALL_OBJFILES (ofp)
 715   {
 716     if (ofp->minimal_symbol_count > 0)
 717       {
 718         return 1;
 719       }
 720   }
 721   return 0;
 722 }
 723
 724 /* Returns a section whose range includes PC and SECTION, or NULL if
 725    none found.  Note the distinction between the return type, struct
 726    obj_section (which is defined in gdb), and the input type "struct
 727    bfd_section" (which is a bfd-defined data type).  The obj_section
 728    contains a pointer to the "struct bfd_section".  */
 729
 730 struct obj_section *
 731 find_pc_sect_section (CORE_ADDR pc, struct bfd_section *section)
 732 {
 733   struct obj_section *s;
 734   struct objfile *objfile;
 735
 736   ALL_OBJSECTIONS (objfile, s)
 737     if ((section == 0 || section == s->the_bfd_section) &&
 738         s->addr <= pc && pc < s->endaddr)
 739       return (s);
 740
 741   return (NULL);
 742 }
 743
 744 /* Returns a section whose range includes PC or NULL if none found.
 745    Backward compatibility, no section.  */
 746
 747 struct obj_section *
 748 find_pc_section (CORE_ADDR pc)
 749 {
 750   return find_pc_sect_section (pc, find_pc_mapped_section (pc));
 751 }
 752
 753
 754 /* In SVR4, we recognize a trampoline by it's section name.
 755    That is, if the pc is in a section named ".plt" then we are in
 756    a trampoline.  */
 757
 758 int
 759 in_plt_section (CORE_ADDR pc, char *name)
 760 {
 761   struct obj_section *s;
 762   int retval = 0;
 763
 764   s = find_pc_section (pc);
 765
 766   retval = (s != NULL
 767             && s->the_bfd_section->name != NULL
 768             && strcmp (s->the_bfd_section->name, ".plt") == 0);
 769   return (retval);
 770 }
 771
 772 /* Return nonzero if NAME is in the import list of OBJFILE.  Else
 773    return zero.  */
 774
 775 int
 776 is_in_import_list (char *name, struct objfile *objfile)
 777 {
 778   int i;
 779
 780   if (!objfile || !name || !*name)
 781     return 0;
 782
 783   for (i = 0; i < objfile->import_list_size; i++)
 784     if (objfile->import_list[i] && DEPRECATED_STREQ (name, objfile->import_list[i]))
 785       return 1;
 786   return 0;
 787 }
 788 \f
 789
 790 /* Keep a registry of per-objfile data-pointers required by other GDB
 791    modules.  */
 792
 793 struct objfile_data
 794 {
 795   unsigned index;
 796 };
 797
 798 struct objfile_data_registration
 799 {
 800   struct objfile_data *data;
 801   struct objfile_data_registration *next;
 802 };
 803
 804 struct objfile_data_registry
 805 {
 806   struct objfile_data_registration *registrations;
 807   unsigned num_registrations;
 808 };
 809
 810 static struct objfile_data_registry objfile_data_registry = { NULL, 0 };
 811
 812 const struct objfile_data *
 813 register_objfile_data (void)
 814 {
 815   struct objfile_data_registration **curr;
 816
 817   /* Append new registration.  */
 818   for (curr = &objfile_data_registry.registrations;
 819        *curr != NULL; curr = &(*curr)->next);
 820
 821   *curr = XMALLOC (struct objfile_data_registration);
 822   (*curr)->next = NULL;
 823   (*curr)->data = XMALLOC (struct objfile_data);
 824   (*curr)->data->index = objfile_data_registry.num_registrations++;
 825
 826   return (*curr)->data;
 827 }
 828
 829 static void
 830 objfile_alloc_data (struct objfile *objfile)
 831 {
 832   gdb_assert (objfile->data == NULL);
 833   objfile->num_data = objfile_data_registry.num_registrations;
 834   objfile->data = XCALLOC (objfile->num_data, void *);
 835 }
 836
 837 static void
 838 objfile_free_data (struct objfile *objfile)
 839 {
 840   gdb_assert (objfile->data != NULL);
 841   xfree (objfile->data);
 842   objfile->data = NULL;
 843 }
 844
 845 void
 846 clear_objfile_data (struct objfile *objfile)
 847 {
 848   gdb_assert (objfile->data != NULL);
 849   memset (objfile->data, 0, objfile->num_data * sizeof (void *));
 850 }
 851
 852 void
 853 set_objfile_data (struct objfile *objfile, const struct objfile_data *data,
 854                   void *value)
 855 {
 856   gdb_assert (data->index < objfile->num_data);
 857   objfile->data[data->index] = value;
 858 }
 859
 860 void *
 861 objfile_data (struct objfile *objfile, const struct objfile_data *data)
 862 {
 863   gdb_assert (data->index < objfile->num_data);
 864   return objfile->data[data->index];
 865 }