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_changed_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   objfiles_changed_p = 1;  /* Rebuild section map next time we need it.  */
 239
 240   return (objfile);
 241 }
 242
 243 /* Retrieve the gdbarch associated with OBJFILE.  */
 244 struct gdbarch *
 245 get_objfile_arch (struct objfile *objfile)
 246 {
 247   return objfile->gdbarch;
 248 }
 249
 250 /* Initialize entry point information for this objfile. */
 251
 252 void
 253 init_entry_point_info (struct objfile *objfile)
 254 {
 255   /* Save startup file's range of PC addresses to help blockframe.c
 256      decide where the bottom of the stack is.  */
 257
 258   if (bfd_get_file_flags (objfile->obfd) & EXEC_P)
 259     {
 260       /* Executable file -- record its entry point so we'll recognize
 261          the startup file because it contains the entry point.  */
 262       objfile->ei.entry_point = bfd_get_start_address (objfile->obfd);
 263     }
 264   else if (bfd_get_file_flags (objfile->obfd) & DYNAMIC
 265            && bfd_get_start_address (objfile->obfd) != 0)
 266     /* Some shared libraries may have entry points set and be
 267        runnable.  There's no clear way to indicate this, so just check
 268        for values other than zero.  */
 269     objfile->ei.entry_point = bfd_get_start_address (objfile->obfd);
 270   else
 271     {
 272       /* Examination of non-executable.o files.  Short-circuit this stuff.  */
 273       objfile->ei.entry_point = INVALID_ENTRY_POINT;
 274     }
 275 }
 276
 277 /* Get current entry point address.  */
 278
 279 CORE_ADDR
 280 entry_point_address (void)
 281 {
 282   struct gdbarch *gdbarch;
 283   CORE_ADDR entry_point;
 284
 285   if (symfile_objfile == NULL)
 286     return 0;
 287
 288   gdbarch = get_objfile_arch (symfile_objfile);
 289
 290   entry_point = symfile_objfile->ei.entry_point;
 291
 292   /* Make certain that the address points at real code, and not a
 293      function descriptor.  */
 294   entry_point = gdbarch_convert_from_func_ptr_addr (gdbarch, entry_point,
 295                                                     &current_target);
 296
 297   /* Remove any ISA markers, so that this matches entries in the
 298      symbol table.  */
 299   entry_point = gdbarch_addr_bits_remove (gdbarch, entry_point);
 300
 301   return entry_point;
 302 }
 303
 304 /* Create the terminating entry of OBJFILE's minimal symbol table.
 305    If OBJFILE->msymbols is zero, allocate a single entry from
 306    OBJFILE->objfile_obstack; otherwise, just initialize
 307    OBJFILE->msymbols[OBJFILE->minimal_symbol_count].  */
 308 void
 309 terminate_minimal_symbol_table (struct objfile *objfile)
 310 {
 311   if (! objfile->msymbols)
 312     objfile->msymbols = ((struct minimal_symbol *)
 313                          obstack_alloc (&objfile->objfile_obstack,
 314                                         sizeof (objfile->msymbols[0])));
 315
 316   {
 317     struct minimal_symbol *m
 318       = &objfile->msymbols[objfile->minimal_symbol_count];
 319
 320     memset (m, 0, sizeof (*m));
 321     /* Don't rely on these enumeration values being 0's.  */
 322     MSYMBOL_TYPE (m) = mst_unknown;
 323     SYMBOL_INIT_LANGUAGE_SPECIFIC (m, language_unknown);
 324   }
 325 }
 326
 327
 328 /* Put one object file before a specified on in the global list.
 329    This can be used to make sure an object file is destroyed before
 330    another when using ALL_OBJFILES_SAFE to free all objfiles. */
 331 void
 332 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
 333 {
 334   struct objfile **objp;
 335
 336   unlink_objfile (objfile);
 337
 338   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
 339     {
 340       if (*objp == before_this)
 341         {
 342           objfile->next = *objp;
 343           *objp = objfile;
 344           return;
 345         }
 346     }
 347
 348   internal_error (__FILE__, __LINE__,
 349                   _("put_objfile_before: before objfile not in list"));
 350 }
 351
 352 /* Put OBJFILE at the front of the list.  */
 353
 354 void
 355 objfile_to_front (struct objfile *objfile)
 356 {
 357   struct objfile **objp;
 358   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
 359     {
 360       if (*objp == objfile)
 361         {
 362           /* Unhook it from where it is.  */
 363           *objp = objfile->next;
 364           /* Put it in the front.  */
 365           objfile->next = object_files;
 366           object_files = objfile;
 367           break;
 368         }
 369     }
 370 }
 371
 372 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
 373    list.
 374
 375    It is not a bug, or error, to call this function if OBJFILE is not known
 376    to be in the current list.  This is done in the case of mapped objfiles,
 377    for example, just to ensure that the mapped objfile doesn't appear twice
 378    in the list.  Since the list is threaded, linking in a mapped objfile
 379    twice would create a circular list.
 380
 381    If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
 382    unlinking it, just to ensure that we have completely severed any linkages
 383    between the OBJFILE and the list. */
 384
 385 void
 386 unlink_objfile (struct objfile *objfile)
 387 {
 388   struct objfile **objpp;
 389
 390   for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
 391     {
 392       if (*objpp == objfile)
 393         {
 394           *objpp = (*objpp)->next;
 395           objfile->next = NULL;
 396           return;
 397         }
 398     }
 399
 400   internal_error (__FILE__, __LINE__,
 401                   _("unlink_objfile: objfile already unlinked"));
 402 }
 403
 404
 405 /* Destroy an objfile and all the symtabs and psymtabs under it.  Note
 406    that as much as possible is allocated on the objfile_obstack
 407    so that the memory can be efficiently freed.
 408
 409    Things which we do NOT free because they are not in malloc'd memory
 410    or not in memory specific to the objfile include:
 411
 412    objfile -> sf
 413
 414    FIXME:  If the objfile is using reusable symbol information (via mmalloc),
 415    then we need to take into account the fact that more than one process
 416    may be using the symbol information at the same time (when mmalloc is
 417    extended to support cooperative locking).  When more than one process
 418    is using the mapped symbol info, we need to be more careful about when
 419    we free objects in the reusable area. */
 420
 421 void
 422 free_objfile (struct objfile *objfile)
 423 {
 424   if (objfile->separate_debug_objfile)
 425     {
 426       free_objfile (objfile->separate_debug_objfile);
 427     }
 428
 429   if (objfile->separate_debug_objfile_backlink)
 430     {
 431       /* We freed the separate debug file, make sure the base objfile
 432          doesn't reference it.  */
 433       objfile->separate_debug_objfile_backlink->separate_debug_objfile = NULL;
 434     }
 435
 436   /* Remove any references to this objfile in the global value
 437      lists.  */
 438   preserve_values (objfile);
 439
 440   /* First do any symbol file specific actions required when we are
 441      finished with a particular symbol file.  Note that if the objfile
 442      is using reusable symbol information (via mmalloc) then each of
 443      these routines is responsible for doing the correct thing, either
 444      freeing things which are valid only during this particular gdb
 445      execution, or leaving them to be reused during the next one. */
 446
 447   if (objfile->sf != NULL)
 448     {
 449       (*objfile->sf->sym_finish) (objfile);
 450     }
 451
 452   /* Discard any data modules have associated with the objfile.  */
 453   objfile_free_data (objfile);
 454
 455   /* We always close the bfd, unless the OBJF_KEEPBFD flag is set.  */
 456
 457   if (objfile->obfd != NULL && !(objfile->flags & OBJF_KEEPBFD))
 458     {
 459       char *name = bfd_get_filename (objfile->obfd);
 460       if (!bfd_close (objfile->obfd))
 461         warning (_("cannot close \"%s\": %s"),
 462                  name, bfd_errmsg (bfd_get_error ()));
 463       xfree (name);
 464     }
 465
 466   /* Remove it from the chain of all objfiles. */
 467
 468   unlink_objfile (objfile);
 469
 470   /* If we are going to free the runtime common objfile, mark it
 471      as unallocated.  */
 472
 473   if (objfile == rt_common_objfile)
 474     rt_common_objfile = NULL;
 475
 476   /* Before the symbol table code was redone to make it easier to
 477      selectively load and remove information particular to a specific
 478      linkage unit, gdb used to do these things whenever the monolithic
 479      symbol table was blown away.  How much still needs to be done
 480      is unknown, but we play it safe for now and keep each action until
 481      it is shown to be no longer needed. */
 482
 483   /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
 484      for example), so we need to call this here.  */
 485   clear_pc_function_cache ();
 486
 487   /* Clear globals which might have pointed into a removed objfile.
 488      FIXME: It's not clear which of these are supposed to persist
 489      between expressions and which ought to be reset each time.  */
 490   expression_context_block = NULL;
 491   innermost_block = NULL;
 492
 493   /* Check to see if the current_source_symtab belongs to this objfile,
 494      and if so, call clear_current_source_symtab_and_line. */
 495
 496   {
 497     struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 498     struct symtab *s;
 499
 500     ALL_OBJFILE_SYMTABS (objfile, s)
 501       {
 502         if (s == cursal.symtab)
 503           clear_current_source_symtab_and_line ();
 504       }
 505   }
 506
 507   /* The last thing we do is free the objfile struct itself. */
 508
 509   if (objfile->name != NULL)
 510     {
 511       xfree (objfile->name);
 512     }
 513   if (objfile->global_psymbols.list)
 514     xfree (objfile->global_psymbols.list);
 515   if (objfile->static_psymbols.list)
 516     xfree (objfile->static_psymbols.list);
 517   /* Free the obstacks for non-reusable objfiles */
 518   bcache_xfree (objfile->psymbol_cache);
 519   bcache_xfree (objfile->macro_cache);
 520   if (objfile->demangled_names_hash)
 521     htab_delete (objfile->demangled_names_hash);
 522   obstack_free (&objfile->objfile_obstack, 0);
 523   xfree (objfile);
 524   objfile = NULL;
 525   objfiles_changed_p = 1;  /* Rebuild section map next time we need it.  */
 526 }
 527
 528 static void
 529 do_free_objfile_cleanup (void *obj)
 530 {
 531   free_objfile (obj);
 532 }
 533
 534 struct cleanup *
 535 make_cleanup_free_objfile (struct objfile *obj)
 536 {
 537   return make_cleanup (do_free_objfile_cleanup, obj);
 538 }
 539
 540 /* Free all the object files at once and clean up their users.  */
 541
 542 void
 543 free_all_objfiles (void)
 544 {
 545   struct objfile *objfile, *temp;
 546
 547   ALL_OBJFILES_SAFE (objfile, temp)
 548   {
 549     free_objfile (objfile);
 550   }
 551   clear_symtab_users ();
 552 }
 553 \f
 554 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
 555    entries in new_offsets.  */
 556 void
 557 objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets)
 558 {
 559   struct obj_section *s;
 560   struct section_offsets *delta =
 561     ((struct section_offsets *)
 562      alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
 563
 564   {
 565     int i;
 566     int something_changed = 0;
 567     for (i = 0; i < objfile->num_sections; ++i)
 568       {
 569         delta->offsets[i] =
 570           ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
 571         if (ANOFFSET (delta, i) != 0)
 572           something_changed = 1;
 573       }
 574     if (!something_changed)
 575       return;
 576   }
 577
 578   /* OK, get all the symtabs.  */
 579   {
 580     struct symtab *s;
 581
 582     ALL_OBJFILE_SYMTABS (objfile, s)
 583     {
 584       struct linetable *l;
 585       struct blockvector *bv;
 586       int i;
 587
 588       /* First the line table.  */
 589       l = LINETABLE (s);
 590       if (l)
 591         {
 592           for (i = 0; i < l->nitems; ++i)
 593             l->item[i].pc += ANOFFSET (delta, s->block_line_section);
 594         }
 595
 596       /* Don't relocate a shared blockvector more than once.  */
 597       if (!s->primary)
 598         continue;
 599
 600       bv = BLOCKVECTOR (s);
 601       if (BLOCKVECTOR_MAP (bv))
 602         addrmap_relocate (BLOCKVECTOR_MAP (bv),
 603                           ANOFFSET (delta, s->block_line_section));
 604
 605       for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
 606         {
 607           struct block *b;
 608           struct symbol *sym;
 609           struct dict_iterator iter;
 610
 611           b = BLOCKVECTOR_BLOCK (bv, i);
 612           BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
 613           BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
 614
 615           ALL_BLOCK_SYMBOLS (b, iter, sym)
 616             {
 617               fixup_symbol_section (sym, objfile);
 618
 619               /* The RS6000 code from which this was taken skipped
 620                  any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
 621                  But I'm leaving out that test, on the theory that
 622                  they can't possibly pass the tests below.  */
 623               if ((SYMBOL_CLASS (sym) == LOC_LABEL
 624                    || SYMBOL_CLASS (sym) == LOC_STATIC)
 625                   && SYMBOL_SECTION (sym) >= 0)
 626                 {
 627                   SYMBOL_VALUE_ADDRESS (sym) +=
 628                     ANOFFSET (delta, SYMBOL_SECTION (sym));
 629                 }
 630             }
 631         }
 632     }
 633   }
 634
 635   {
 636     struct partial_symtab *p;
 637
 638     ALL_OBJFILE_PSYMTABS (objfile, p)
 639     {
 640       p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 641       p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 642     }
 643   }
 644
 645   {
 646     struct partial_symbol **psym;
 647
 648     for (psym = objfile->global_psymbols.list;
 649          psym < objfile->global_psymbols.next;
 650          psym++)
 651       {
 652         fixup_psymbol_section (*psym, objfile);
 653         if (SYMBOL_SECTION (*psym) >= 0)
 654           SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
 655                                                     SYMBOL_SECTION (*psym));
 656       }
 657     for (psym = objfile->static_psymbols.list;
 658          psym < objfile->static_psymbols.next;
 659          psym++)
 660       {
 661         fixup_psymbol_section (*psym, objfile);
 662         if (SYMBOL_SECTION (*psym) >= 0)
 663           SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
 664                                                     SYMBOL_SECTION (*psym));
 665       }
 666   }
 667
 668   {
 669     struct minimal_symbol *msym;
 670     ALL_OBJFILE_MSYMBOLS (objfile, msym)
 671       if (SYMBOL_SECTION (msym) >= 0)
 672       SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
 673   }
 674   /* Relocating different sections by different amounts may cause the symbols
 675      to be out of order.  */
 676   msymbols_sort (objfile);
 677
 678   {
 679     int i;
 680     for (i = 0; i < objfile->num_sections; ++i)
 681       (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
 682   }
 683
 684   if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
 685     {
 686       /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
 687          only as a fallback.  */
 688       struct obj_section *s;
 689       s = find_pc_section (objfile->ei.entry_point);
 690       if (s)
 691         objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index);
 692       else
 693         objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 694     }
 695
 696   /* Update the table in exec_ops, used to read memory.  */
 697   ALL_OBJFILE_OSECTIONS (objfile, s)
 698     {
 699       int idx = s->the_bfd_section->index;
 700
 701       exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
 702                                 obj_section_addr (s));
 703     }
 704
 705   /* Relocate breakpoints as necessary, after things are relocated. */
 706   breakpoint_re_set ();
 707   objfiles_changed_p = 1;  /* Rebuild section map next time we need it.  */
 708 }
 709 \f
 710 /* Many places in gdb want to test just to see if we have any partial
 711    symbols available.  This function returns zero if none are currently
 712    available, nonzero otherwise. */
 713
 714 int
 715 have_partial_symbols (void)
 716 {
 717   struct objfile *ofp;
 718
 719   ALL_OBJFILES (ofp)
 720   {
 721     if (ofp->psymtabs != NULL)
 722       {
 723         return 1;
 724       }
 725   }
 726   return 0;
 727 }
 728
 729 /* Many places in gdb want to test just to see if we have any full
 730    symbols available.  This function returns zero if none are currently
 731    available, nonzero otherwise. */
 732
 733 int
 734 have_full_symbols (void)
 735 {
 736   struct objfile *ofp;
 737
 738   ALL_OBJFILES (ofp)
 739   {
 740     if (ofp->symtabs != NULL)
 741       {
 742         return 1;
 743       }
 744   }
 745   return 0;
 746 }
 747
 748
 749 /* This operations deletes all objfile entries that represent solibs that
 750    weren't explicitly loaded by the user, via e.g., the add-symbol-file
 751    command.
 752  */
 753 void
 754 objfile_purge_solibs (void)
 755 {
 756   struct objfile *objf;
 757   struct objfile *temp;
 758
 759   ALL_OBJFILES_SAFE (objf, temp)
 760   {
 761     /* We assume that the solib package has been purged already, or will
 762        be soon.
 763      */
 764     if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
 765       free_objfile (objf);
 766   }
 767 }
 768
 769
 770 /* Many places in gdb want to test just to see if we have any minimal
 771    symbols available.  This function returns zero if none are currently
 772    available, nonzero otherwise. */
 773
 774 int
 775 have_minimal_symbols (void)
 776 {
 777   struct objfile *ofp;
 778
 779   ALL_OBJFILES (ofp)
 780   {
 781     if (ofp->minimal_symbol_count > 0)
 782       {
 783         return 1;
 784       }
 785   }
 786   return 0;
 787 }
 788
 789 /* Qsort comparison function.  */
 790
 791 static int
 792 qsort_cmp (const void *a, const void *b)
 793 {
 794   const struct obj_section *sect1 = *(const struct obj_section **) a;
 795   const struct obj_section *sect2 = *(const struct obj_section **) b;
 796   const CORE_ADDR sect1_addr = obj_section_addr (sect1);
 797   const CORE_ADDR sect2_addr = obj_section_addr (sect2);
 798
 799   if (sect1_addr < sect2_addr)
 800     {
 801       gdb_assert (obj_section_endaddr (sect1) <= sect2_addr);
 802       return -1;
 803     }
 804   else if (sect1_addr > sect2_addr)
 805     {
 806       gdb_assert (sect1_addr >= obj_section_endaddr (sect2));
 807       return 1;
 808     }
 809   /* This can happen for separate debug-info files.  */
 810   gdb_assert (obj_section_endaddr (sect1) == obj_section_endaddr (sect2));
 811
 812   return 0;
 813 }
 814
 815 /* Update PMAP, PMAP_SIZE with non-TLS sections from all objfiles.  */
 816
 817 static void
 818 update_section_map (struct obj_section ***pmap, int *pmap_size)
 819 {
 820   int map_size, idx;
 821   struct obj_section *s, **map;
 822   struct objfile *objfile;
 823
 824   gdb_assert (objfiles_changed_p != 0);
 825
 826   map = *pmap;
 827   xfree (map);
 828
 829 #define insert_p(objf, sec) \
 830   ((bfd_get_section_flags ((objf)->obfd, (sec)->the_bfd_section) \
 831     & SEC_THREAD_LOCAL) == 0)
 832
 833   map_size = 0;
 834   ALL_OBJSECTIONS (objfile, s)
 835     if (insert_p (objfile, s))
 836       map_size += 1;
 837
 838   map = xmalloc (map_size * sizeof (*map));
 839
 840   idx = 0;
 841   ALL_OBJSECTIONS (objfile, s)
 842     if (insert_p (objfile, s))
 843       map[idx++] = s;
 844
 845 #undef insert_p
 846
 847   qsort (map, map_size, sizeof (*map), qsort_cmp);
 848
 849   *pmap = map;
 850   *pmap_size = map_size;
 851 }
 852
 853 /* Bsearch comparison function. */
 854
 855 static int
 856 bsearch_cmp (const void *key, const void *elt)
 857 {
 858   const CORE_ADDR pc = *(CORE_ADDR *) key;
 859   const struct obj_section *section = *(const struct obj_section **) elt;
 860
 861   if (pc < obj_section_addr (section))
 862     return -1;
 863   if (pc < obj_section_endaddr (section))
 864     return 0;
 865   return 1;
 866 }
 867
 868 /* Returns a section whose range includes PC or NULL if none found.   */
 869
 870 struct obj_section *
 871 find_pc_section (CORE_ADDR pc)
 872 {
 873   static struct obj_section **sections;
 874   static int num_sections;
 875
 876   struct obj_section *s, **sp;
 877
 878   /* Check for mapped overlay section first.  */
 879   s = find_pc_mapped_section (pc);
 880   if (s)
 881     return s;
 882
 883   if (objfiles_changed_p != 0)
 884     {
 885       update_section_map (&sections, &num_sections);
 886
 887       /* Don't need updates to section map until objfiles are added
 888          or removed.  */
 889       objfiles_changed_p = 0;
 890     }
 891
 892   sp = (struct obj_section **) bsearch (&pc, sections, num_sections,
 893                                         sizeof (*sections), bsearch_cmp);
 894   if (sp != NULL)
 895     return *sp;
 896   return NULL;
 897 }
 898
 899
 900 /* In SVR4, we recognize a trampoline by it's section name.
 901    That is, if the pc is in a section named ".plt" then we are in
 902    a trampoline.  */
 903
 904 int
 905 in_plt_section (CORE_ADDR pc, char *name)
 906 {
 907   struct obj_section *s;
 908   int retval = 0;
 909
 910   s = find_pc_section (pc);
 911
 912   retval = (s != NULL
 913             && s->the_bfd_section->name != NULL
 914             && strcmp (s->the_bfd_section->name, ".plt") == 0);
 915   return (retval);
 916 }
 917 \f
 918
 919 /* Keep a registry of per-objfile data-pointers required by other GDB
 920    modules.  */
 921
 922 struct objfile_data
 923 {
 924   unsigned index;
 925   void (*cleanup) (struct objfile *, void *);
 926 };
 927
 928 struct objfile_data_registration
 929 {
 930   struct objfile_data *data;
 931   struct objfile_data_registration *next;
 932 };
 933
 934 struct objfile_data_registry
 935 {
 936   struct objfile_data_registration *registrations;
 937   unsigned num_registrations;
 938 };
 939
 940 static struct objfile_data_registry objfile_data_registry = { NULL, 0 };
 941
 942 const struct objfile_data *
 943 register_objfile_data_with_cleanup (void (*cleanup) (struct objfile *, void *))
 944 {
 945   struct objfile_data_registration **curr;
 946
 947   /* Append new registration.  */
 948   for (curr = &objfile_data_registry.registrations;
 949        *curr != NULL; curr = &(*curr)->next);
 950
 951   *curr = XMALLOC (struct objfile_data_registration);
 952   (*curr)->next = NULL;
 953   (*curr)->data = XMALLOC (struct objfile_data);
 954   (*curr)->data->index = objfile_data_registry.num_registrations++;
 955   (*curr)->data->cleanup = cleanup;
 956
 957   return (*curr)->data;
 958 }
 959
 960 const struct objfile_data *
 961 register_objfile_data (void)
 962 {
 963   return register_objfile_data_with_cleanup (NULL);
 964 }
 965
 966 static void
 967 objfile_alloc_data (struct objfile *objfile)
 968 {
 969   gdb_assert (objfile->data == NULL);
 970   objfile->num_data = objfile_data_registry.num_registrations;
 971   objfile->data = XCALLOC (objfile->num_data, void *);
 972 }
 973
 974 static void
 975 objfile_free_data (struct objfile *objfile)
 976 {
 977   gdb_assert (objfile->data != NULL);
 978   clear_objfile_data (objfile);
 979   xfree (objfile->data);
 980   objfile->data = NULL;
 981 }
 982
 983 void
 984 clear_objfile_data (struct objfile *objfile)
 985 {
 986   struct objfile_data_registration *registration;
 987   int i;
 988
 989   gdb_assert (objfile->data != NULL);
 990
 991   for (registration = objfile_data_registry.registrations, i = 0;
 992        i < objfile->num_data;
 993        registration = registration->next, i++)
 994     if (objfile->data[i] != NULL && registration->data->cleanup)
 995       registration->data->cleanup (objfile, objfile->data[i]);
 996
 997   memset (objfile->data, 0, objfile->num_data * sizeof (void *));
 998 }
 999
1000 void
1001 set_objfile_data (struct objfile *objfile, const struct objfile_data *data,
1002                   void *value)
1003 {
1004   gdb_assert (data->index < objfile->num_data);
1005   objfile->data[data->index] = value;
1006 }
1007
1008 void *
1009 objfile_data (struct objfile *objfile, const struct objfile_data *data)
1010 {
1011   gdb_assert (data->index < objfile->num_data);
1012   return objfile->data[data->index];
1013 }
1014
1015 /* Set objfiles_changed_p so section map will be rebuilt next time it
1016    is used.  Called by reread_symbols.  */
1017
1018 void
1019 objfiles_changed (void)
1020 {
1021   objfiles_changed_p = 1;  /* Rebuild section map next time we need it.  */
1022 }