gdb/objfiles.c

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