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