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, 2010, 2011
   5    Free Software Foundation, Inc.
   6
   7    Contributed by Cygnus Support, using pieces from other GDB modules.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 /* This file contains support routines for creating, manipulating, and
  25    destroying objfile structures.  */
  26
  27 #include "defs.h"
  28 #include "bfd.h"                /* Binary File Description */
  29 #include "symtab.h"
  30 #include "symfile.h"
  31 #include "objfiles.h"
  32 #include "gdb-stabs.h"
  33 #include "target.h"
  34 #include "bcache.h"
  35 #include "mdebugread.h"
  36 #include "expression.h"
  37 #include "parser-defs.h"
  38
  39 #include "gdb_assert.h"
  40 #include <sys/types.h>
  41 #include "gdb_stat.h"
  42 #include <fcntl.h>
  43 #include "gdb_obstack.h"
  44 #include "gdb_string.h"
  45 #include "hashtab.h"
  46
  47 #include "breakpoint.h"
  48 #include "block.h"
  49 #include "dictionary.h"
  50 #include "source.h"
  51 #include "addrmap.h"
  52 #include "arch-utils.h"
  53 #include "exec.h"
  54 #include "observer.h"
  55 #include "complaints.h"
  56 #include "psymtab.h"
  57 #include "solist.h"
  58
  59 /* Prototypes for local functions */
  60
  61 static void objfile_alloc_data (struct objfile *objfile);
  62 static void objfile_free_data (struct objfile *objfile);
  63
  64 /* Externally visible variables that are owned by this module.
  65    See declarations in objfile.h for more info.  */
  66
  67 struct objfile *current_objfile;        /* For symbol file being read in */
  68 struct objfile *rt_common_objfile;      /* For runtime common symbols */
  69
  70 struct objfile_pspace_info
  71 {
  72   int objfiles_changed_p;
  73   struct obj_section **sections;
  74   int num_sections;
  75 };
  76
  77 /* Per-program-space data key.  */
  78 static const struct program_space_data *objfiles_pspace_data;
  79
  80 static void
  81 objfiles_pspace_data_cleanup (struct program_space *pspace, void *arg)
  82 {
  83   struct objfile_pspace_info *info;
  84
  85   info = program_space_data (pspace, objfiles_pspace_data);
  86   if (info != NULL)
  87     {
  88       xfree (info->sections);
  89       xfree (info);
  90     }
  91 }
  92
  93 /* Get the current svr4 data.  If none is found yet, add it now.  This
  94    function always returns a valid object.  */
  95
  96 static struct objfile_pspace_info *
  97 get_objfile_pspace_data (struct program_space *pspace)
  98 {
  99   struct objfile_pspace_info *info;
 100
 101   info = program_space_data (pspace, objfiles_pspace_data);
 102   if (info == NULL)
 103     {
 104       info = XZALLOC (struct objfile_pspace_info);
 105       set_program_space_data (pspace, objfiles_pspace_data, info);
 106     }
 107
 108   return info;
 109 }
 110
 111 /* Records whether any objfiles appeared or disappeared since we last updated
 112    address to obj section map.  */
 113
 114 /* Locate all mappable sections of a BFD file.
 115    objfile_p_char is a char * to get it through
 116    bfd_map_over_sections; we cast it back to its proper type.  */
 117
 118 /* Called via bfd_map_over_sections to build up the section table that
 119    the objfile references.  The objfile contains pointers to the start
 120    of the table (objfile->sections) and to the first location after
 121    the end of the table (objfile->sections_end).  */
 122
 123 static void
 124 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
 125                          void *objfile_p_char)
 126 {
 127   struct objfile *objfile = (struct objfile *) objfile_p_char;
 128   struct obj_section section;
 129   flagword aflag;
 130
 131   aflag = bfd_get_section_flags (abfd, asect);
 132
 133   if (!(aflag & SEC_ALLOC))
 134     return;
 135
 136   if (0 == bfd_section_size (abfd, asect))
 137     return;
 138   section.objfile = objfile;
 139   section.the_bfd_section = asect;
 140   section.ovly_mapped = 0;
 141   obstack_grow (&objfile->objfile_obstack,
 142                 (char *) &section, sizeof (section));
 143   objfile->sections_end
 144     = (struct obj_section *) (((size_t) objfile->sections_end) + 1);
 145 }
 146
 147 /* Builds a section table for OBJFILE.
 148    Returns 0 if OK, 1 on error (in which case bfd_error contains the
 149    error).
 150
 151    Note that while we are building the table, which goes into the
 152    psymbol obstack, we hijack the sections_end pointer to instead hold
 153    a count of the number of sections.  When bfd_map_over_sections
 154    returns, this count is used to compute the pointer to the end of
 155    the sections table, which then overwrites the count.
 156
 157    Also note that the OFFSET and OVLY_MAPPED in each table entry
 158    are initialized to zero.
 159
 160    Also note that if anything else writes to the psymbol obstack while
 161    we are building the table, we're pretty much hosed.  */
 162
 163 int
 164 build_objfile_section_table (struct objfile *objfile)
 165 {
 166   /* objfile->sections can be already set when reading a mapped symbol
 167      file.  I believe that we do need to rebuild the section table in
 168      this case (we rebuild other things derived from the bfd), but we
 169      can't free the old one (it's in the objfile_obstack).  So we just
 170      waste some memory.  */
 171
 172   objfile->sections_end = 0;
 173   bfd_map_over_sections (objfile->obfd,
 174                          add_to_objfile_sections, (void *) objfile);
 175   objfile->sections = obstack_finish (&objfile->objfile_obstack);
 176   objfile->sections_end = objfile->sections + (size_t) objfile->sections_end;
 177   return (0);
 178 }
 179
 180 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
 181    allocate a new objfile struct, fill it in as best we can, link it
 182    into the list of all known objfiles, and return a pointer to the
 183    new objfile struct.
 184
 185    The FLAGS word contains various bits (OBJF_*) that can be taken as
 186    requests for specific operations.  Other bits like OBJF_SHARED are
 187    simply copied through to the new objfile flags member.  */
 188
 189 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
 190    by jv-lang.c, to create an artificial objfile used to hold
 191    information about dynamically-loaded Java classes.  Unfortunately,
 192    that branch of this function doesn't get tested very frequently, so
 193    it's prone to breakage.  (E.g. at one time the name was set to NULL
 194    in that situation, which broke a loop over all names in the dynamic
 195    library loader.)  If you change this function, please try to leave
 196    things in a consistent state even if abfd is NULL.  */
 197
 198 struct objfile *
 199 allocate_objfile (bfd *abfd, int flags)
 200 {
 201   struct objfile *objfile;
 202
 203   objfile = (struct objfile *) xzalloc (sizeof (struct objfile));
 204   objfile->psymbol_cache = psymbol_bcache_init ();
 205   objfile->macro_cache = bcache_xmalloc (NULL, NULL);
 206   objfile->filename_cache = bcache_xmalloc (NULL, NULL);
 207   /* We could use obstack_specify_allocation here instead, but
 208      gdb_obstack.h specifies the alloc/dealloc functions.  */
 209   obstack_init (&objfile->objfile_obstack);
 210   terminate_minimal_symbol_table (objfile);
 211
 212   objfile_alloc_data (objfile);
 213
 214   /* Update the per-objfile information that comes from the bfd, ensuring
 215      that any data that is reference is saved in the per-objfile data
 216      region.  */
 217
 218   objfile->obfd = gdb_bfd_ref (abfd);
 219   if (abfd != NULL)
 220     {
 221       /* Look up the gdbarch associated with the BFD.  */
 222       objfile->gdbarch = gdbarch_from_bfd (abfd);
 223
 224       objfile->name = xstrdup (bfd_get_filename (abfd));
 225       objfile->mtime = bfd_get_mtime (abfd);
 226
 227       /* Build section table.  */
 228
 229       if (build_objfile_section_table (objfile))
 230         {
 231           error (_("Can't find the file sections in `%s': %s"),
 232                  objfile->name, bfd_errmsg (bfd_get_error ()));
 233         }
 234     }
 235   else
 236     {
 237       objfile->name = xstrdup ("<<anonymous objfile>>");
 238     }
 239
 240   objfile->pspace = current_program_space;
 241
 242   /* Initialize the section indexes for this objfile, so that we can
 243      later detect if they are used w/o being properly assigned to.  */
 244
 245   objfile->sect_index_text = -1;
 246   objfile->sect_index_data = -1;
 247   objfile->sect_index_bss = -1;
 248   objfile->sect_index_rodata = -1;
 249
 250   /* We don't yet have a C++-specific namespace symtab.  */
 251
 252   objfile->cp_namespace_symtab = NULL;
 253
 254   /* Add this file onto the tail of the linked list of other such files.  */
 255
 256   objfile->next = NULL;
 257   if (object_files == NULL)
 258     object_files = objfile;
 259   else
 260     {
 261       struct objfile *last_one;
 262
 263       for (last_one = object_files;
 264            last_one->next;
 265            last_one = last_one->next);
 266       last_one->next = objfile;
 267     }
 268
 269   /* Save passed in flag bits.  */
 270   objfile->flags |= flags;
 271
 272   /* Rebuild section map next time we need it.  */
 273   get_objfile_pspace_data (objfile->pspace)->objfiles_changed_p = 1;
 274
 275   return objfile;
 276 }
 277
 278 /* Retrieve the gdbarch associated with OBJFILE.  */
 279 struct gdbarch *
 280 get_objfile_arch (struct objfile *objfile)
 281 {
 282   return objfile->gdbarch;
 283 }
 284
 285 /* Initialize entry point information for this objfile.  */
 286
 287 void
 288 init_entry_point_info (struct objfile *objfile)
 289 {
 290   /* Save startup file's range of PC addresses to help blockframe.c
 291      decide where the bottom of the stack is.  */
 292
 293   if (bfd_get_file_flags (objfile->obfd) & EXEC_P)
 294     {
 295       /* Executable file -- record its entry point so we'll recognize
 296          the startup file because it contains the entry point.  */
 297       objfile->ei.entry_point = bfd_get_start_address (objfile->obfd);
 298       objfile->ei.entry_point_p = 1;
 299     }
 300   else if (bfd_get_file_flags (objfile->obfd) & DYNAMIC
 301            && bfd_get_start_address (objfile->obfd) != 0)
 302     {
 303       /* Some shared libraries may have entry points set and be
 304          runnable.  There's no clear way to indicate this, so just check
 305          for values other than zero.  */
 306       objfile->ei.entry_point = bfd_get_start_address (objfile->obfd);
 307       objfile->ei.entry_point_p = 1;
 308     }
 309   else
 310     {
 311       /* Examination of non-executable.o files.  Short-circuit this stuff.  */
 312       objfile->ei.entry_point_p = 0;
 313     }
 314 }
 315
 316 /* If there is a valid and known entry point, function fills *ENTRY_P with it
 317    and returns non-zero; otherwise it returns zero.  */
 318
 319 int
 320 entry_point_address_query (CORE_ADDR *entry_p)
 321 {
 322   struct gdbarch *gdbarch;
 323   CORE_ADDR entry_point;
 324
 325   if (symfile_objfile == NULL || !symfile_objfile->ei.entry_point_p)
 326     return 0;
 327
 328   gdbarch = get_objfile_arch (symfile_objfile);
 329
 330   entry_point = symfile_objfile->ei.entry_point;
 331
 332   /* Make certain that the address points at real code, and not a
 333      function descriptor.  */
 334   entry_point = gdbarch_convert_from_func_ptr_addr (gdbarch, entry_point,
 335                                                     &current_target);
 336
 337   /* Remove any ISA markers, so that this matches entries in the
 338      symbol table.  */
 339   entry_point = gdbarch_addr_bits_remove (gdbarch, entry_point);
 340
 341   *entry_p = entry_point;
 342   return 1;
 343 }
 344
 345 /* Get current entry point address.  Call error if it is not known.  */
 346
 347 CORE_ADDR
 348 entry_point_address (void)
 349 {
 350   CORE_ADDR retval;
 351
 352   if (!entry_point_address_query (&retval))
 353     error (_("Entry point address is not known."));
 354
 355   return retval;
 356 }
 357
 358 /* Create the terminating entry of OBJFILE's minimal symbol table.
 359    If OBJFILE->msymbols is zero, allocate a single entry from
 360    OBJFILE->objfile_obstack; otherwise, just initialize
 361    OBJFILE->msymbols[OBJFILE->minimal_symbol_count].  */
 362 void
 363 terminate_minimal_symbol_table (struct objfile *objfile)
 364 {
 365   if (! objfile->msymbols)
 366     objfile->msymbols = ((struct minimal_symbol *)
 367                          obstack_alloc (&objfile->objfile_obstack,
 368                                         sizeof (objfile->msymbols[0])));
 369
 370   {
 371     struct minimal_symbol *m
 372       = &objfile->msymbols[objfile->minimal_symbol_count];
 373
 374     memset (m, 0, sizeof (*m));
 375     /* Don't rely on these enumeration values being 0's.  */
 376     MSYMBOL_TYPE (m) = mst_unknown;
 377     SYMBOL_SET_LANGUAGE (m, language_unknown);
 378   }
 379 }
 380
 381 /* Iterator on PARENT and every separate debug objfile of PARENT.
 382    The usage pattern is:
 383      for (objfile = parent;
 384           objfile;
 385           objfile = objfile_separate_debug_iterate (parent, objfile))
 386        ...
 387 */
 388
 389 struct objfile *
 390 objfile_separate_debug_iterate (const struct objfile *parent,
 391                                 const struct objfile *objfile)
 392 {
 393   struct objfile *res;
 394
 395   /* If any, return the first child.  */
 396   res = objfile->separate_debug_objfile;
 397   if (res)
 398     return res;
 399
 400   /* Common case where there is no separate debug objfile.  */
 401   if (objfile == parent)
 402     return NULL;
 403
 404   /* Return the brother if any.  Note that we don't iterate on brothers of
 405      the parents.  */
 406   res = objfile->separate_debug_objfile_link;
 407   if (res)
 408     return res;
 409
 410   for (res = objfile->separate_debug_objfile_backlink;
 411        res != parent;
 412        res = res->separate_debug_objfile_backlink)
 413     {
 414       gdb_assert (res != NULL);
 415       if (res->separate_debug_objfile_link)
 416         return res->separate_debug_objfile_link;
 417     }
 418   return NULL;
 419 }
 420
 421 /* Put one object file before a specified on in the global list.
 422    This can be used to make sure an object file is destroyed before
 423    another when using ALL_OBJFILES_SAFE to free all objfiles.  */
 424 void
 425 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
 426 {
 427   struct objfile **objp;
 428
 429   unlink_objfile (objfile);
 430
 431   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
 432     {
 433       if (*objp == before_this)
 434         {
 435           objfile->next = *objp;
 436           *objp = objfile;
 437           return;
 438         }
 439     }
 440
 441   internal_error (__FILE__, __LINE__,
 442                   _("put_objfile_before: before objfile not in list"));
 443 }
 444
 445 /* Put OBJFILE at the front of the list.  */
 446
 447 void
 448 objfile_to_front (struct objfile *objfile)
 449 {
 450   struct objfile **objp;
 451   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
 452     {
 453       if (*objp == objfile)
 454         {
 455           /* Unhook it from where it is.  */
 456           *objp = objfile->next;
 457           /* Put it in the front.  */
 458           objfile->next = object_files;
 459           object_files = objfile;
 460           break;
 461         }
 462     }
 463 }
 464
 465 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
 466    list.
 467
 468    It is not a bug, or error, to call this function if OBJFILE is not known
 469    to be in the current list.  This is done in the case of mapped objfiles,
 470    for example, just to ensure that the mapped objfile doesn't appear twice
 471    in the list.  Since the list is threaded, linking in a mapped objfile
 472    twice would create a circular list.
 473
 474    If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
 475    unlinking it, just to ensure that we have completely severed any linkages
 476    between the OBJFILE and the list.  */
 477
 478 void
 479 unlink_objfile (struct objfile *objfile)
 480 {
 481   struct objfile **objpp;
 482
 483   for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
 484     {
 485       if (*objpp == objfile)
 486         {
 487           *objpp = (*objpp)->next;
 488           objfile->next = NULL;
 489           return;
 490         }
 491     }
 492
 493   internal_error (__FILE__, __LINE__,
 494                   _("unlink_objfile: objfile already unlinked"));
 495 }
 496
 497 /* Add OBJFILE as a separate debug objfile of PARENT.  */
 498
 499 void
 500 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
 501 {
 502   gdb_assert (objfile && parent);
 503
 504   /* Must not be already in a list.  */
 505   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
 506   gdb_assert (objfile->separate_debug_objfile_link == NULL);
 507
 508   objfile->separate_debug_objfile_backlink = parent;
 509   objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
 510   parent->separate_debug_objfile = objfile;
 511
 512   /* Put the separate debug object before the normal one, this is so that
 513      usage of the ALL_OBJFILES_SAFE macro will stay safe.  */
 514   put_objfile_before (objfile, parent);
 515 }
 516
 517 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
 518    itself.  */
 519
 520 void
 521 free_objfile_separate_debug (struct objfile *objfile)
 522 {
 523   struct objfile *child;
 524
 525   for (child = objfile->separate_debug_objfile; child;)
 526     {
 527       struct objfile *next_child = child->separate_debug_objfile_link;
 528       free_objfile (child);
 529       child = next_child;
 530     }
 531 }
 532
 533 /* Destroy an objfile and all the symtabs and psymtabs under it.  Note
 534    that as much as possible is allocated on the objfile_obstack
 535    so that the memory can be efficiently freed.
 536
 537    Things which we do NOT free because they are not in malloc'd memory
 538    or not in memory specific to the objfile include:
 539
 540    objfile -> sf
 541
 542    FIXME:  If the objfile is using reusable symbol information (via mmalloc),
 543    then we need to take into account the fact that more than one process
 544    may be using the symbol information at the same time (when mmalloc is
 545    extended to support cooperative locking).  When more than one process
 546    is using the mapped symbol info, we need to be more careful about when
 547    we free objects in the reusable area.  */
 548
 549 void
 550 free_objfile (struct objfile *objfile)
 551 {
 552   /* Free all separate debug objfiles.  */
 553   free_objfile_separate_debug (objfile);
 554
 555   if (objfile->separate_debug_objfile_backlink)
 556     {
 557       /* We freed the separate debug file, make sure the base objfile
 558          doesn't reference it.  */
 559       struct objfile *child;
 560
 561       child = objfile->separate_debug_objfile_backlink->separate_debug_objfile;
 562
 563       if (child == objfile)
 564         {
 565           /* OBJFILE is the first child.  */
 566           objfile->separate_debug_objfile_backlink->separate_debug_objfile =
 567             objfile->separate_debug_objfile_link;
 568         }
 569       else
 570         {
 571           /* Find OBJFILE in the list.  */
 572           while (1)
 573             {
 574               if (child->separate_debug_objfile_link == objfile)
 575                 {
 576                   child->separate_debug_objfile_link =
 577                     objfile->separate_debug_objfile_link;
 578                   break;
 579                 }
 580               child = child->separate_debug_objfile_link;
 581               gdb_assert (child);
 582             }
 583         }
 584     }
 585
 586   /* Remove any references to this objfile in the global value
 587      lists.  */
 588   preserve_values (objfile);
 589
 590   /* First do any symbol file specific actions required when we are
 591      finished with a particular symbol file.  Note that if the objfile
 592      is using reusable symbol information (via mmalloc) then each of
 593      these routines is responsible for doing the correct thing, either
 594      freeing things which are valid only during this particular gdb
 595      execution, or leaving them to be reused during the next one.  */
 596
 597   if (objfile->sf != NULL)
 598     {
 599       (*objfile->sf->sym_finish) (objfile);
 600     }
 601
 602   /* Discard any data modules have associated with the objfile.  */
 603   objfile_free_data (objfile);
 604
 605   gdb_bfd_unref (objfile->obfd);
 606
 607   /* Remove it from the chain of all objfiles.  */
 608
 609   unlink_objfile (objfile);
 610
 611   if (objfile == symfile_objfile)
 612     symfile_objfile = NULL;
 613
 614   if (objfile == rt_common_objfile)
 615     rt_common_objfile = NULL;
 616
 617   /* Before the symbol table code was redone to make it easier to
 618      selectively load and remove information particular to a specific
 619      linkage unit, gdb used to do these things whenever the monolithic
 620      symbol table was blown away.  How much still needs to be done
 621      is unknown, but we play it safe for now and keep each action until
 622      it is shown to be no longer needed.  */
 623
 624   /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
 625      for example), so we need to call this here.  */
 626   clear_pc_function_cache ();
 627
 628   /* Clear globals which might have pointed into a removed objfile.
 629      FIXME: It's not clear which of these are supposed to persist
 630      between expressions and which ought to be reset each time.  */
 631   expression_context_block = NULL;
 632   innermost_block = NULL;
 633
 634   /* Check to see if the current_source_symtab belongs to this objfile,
 635      and if so, call clear_current_source_symtab_and_line.  */
 636
 637   {
 638     struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 639     struct symtab *s;
 640
 641     ALL_OBJFILE_SYMTABS (objfile, s)
 642       {
 643         if (s == cursal.symtab)
 644           clear_current_source_symtab_and_line ();
 645       }
 646   }
 647
 648   /* The last thing we do is free the objfile struct itself.  */
 649
 650   xfree (objfile->name);
 651   if (objfile->global_psymbols.list)
 652     xfree (objfile->global_psymbols.list);
 653   if (objfile->static_psymbols.list)
 654     xfree (objfile->static_psymbols.list);
 655   /* Free the obstacks for non-reusable objfiles.  */
 656   psymbol_bcache_free (objfile->psymbol_cache);
 657   bcache_xfree (objfile->macro_cache);
 658   bcache_xfree (objfile->filename_cache);
 659   if (objfile->demangled_names_hash)
 660     htab_delete (objfile->demangled_names_hash);
 661   obstack_free (&objfile->objfile_obstack, 0);
 662
 663   /* Rebuild section map next time we need it.  */
 664   get_objfile_pspace_data (objfile->pspace)->objfiles_changed_p = 1;
 665
 666   xfree (objfile);
 667 }
 668
 669 static void
 670 do_free_objfile_cleanup (void *obj)
 671 {
 672   free_objfile (obj);
 673 }
 674
 675 struct cleanup *
 676 make_cleanup_free_objfile (struct objfile *obj)
 677 {
 678   return make_cleanup (do_free_objfile_cleanup, obj);
 679 }
 680
 681 /* Free all the object files at once and clean up their users.  */
 682
 683 void
 684 free_all_objfiles (void)
 685 {
 686   struct objfile *objfile, *temp;
 687   struct so_list *so;
 688
 689   /* Any objfile referencewould become stale.  */
 690   for (so = master_so_list (); so; so = so->next)
 691     gdb_assert (so->objfile == NULL);
 692
 693   ALL_OBJFILES_SAFE (objfile, temp)
 694   {
 695     free_objfile (objfile);
 696   }
 697   clear_symtab_users (0);
 698 }
 699 \f
 700 /* A helper function for objfile_relocate1 that relocates a single
 701    symbol.  */
 702
 703 static void
 704 relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
 705                      struct section_offsets *delta)
 706 {
 707   fixup_symbol_section (sym, objfile);
 708
 709   /* The RS6000 code from which this was taken skipped
 710      any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
 711      But I'm leaving out that test, on the theory that
 712      they can't possibly pass the tests below.  */
 713   if ((SYMBOL_CLASS (sym) == LOC_LABEL
 714        || SYMBOL_CLASS (sym) == LOC_STATIC)
 715       && SYMBOL_SECTION (sym) >= 0)
 716     {
 717       SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (delta, SYMBOL_SECTION (sym));
 718     }
 719 }
 720
 721 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
 722    entries in new_offsets.  SEPARATE_DEBUG_OBJFILE is not touched here.
 723    Return non-zero iff any change happened.  */
 724
 725 static int
 726 objfile_relocate1 (struct objfile *objfile,
 727                    struct section_offsets *new_offsets)
 728 {
 729   struct obj_section *s;
 730   struct section_offsets *delta =
 731     ((struct section_offsets *)
 732      alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
 733
 734   int i;
 735   int something_changed = 0;
 736
 737   for (i = 0; i < objfile->num_sections; ++i)
 738     {
 739       delta->offsets[i] =
 740         ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
 741       if (ANOFFSET (delta, i) != 0)
 742         something_changed = 1;
 743     }
 744   if (!something_changed)
 745     return 0;
 746
 747   /* OK, get all the symtabs.  */
 748   {
 749     struct symtab *s;
 750
 751     ALL_OBJFILE_SYMTABS (objfile, s)
 752     {
 753       struct linetable *l;
 754       struct blockvector *bv;
 755       int i;
 756
 757       /* First the line table.  */
 758       l = LINETABLE (s);
 759       if (l)
 760         {
 761           for (i = 0; i < l->nitems; ++i)
 762             l->item[i].pc += ANOFFSET (delta, s->block_line_section);
 763         }
 764
 765       /* Don't relocate a shared blockvector more than once.  */
 766       if (!s->primary)
 767         continue;
 768
 769       bv = BLOCKVECTOR (s);
 770       if (BLOCKVECTOR_MAP (bv))
 771         addrmap_relocate (BLOCKVECTOR_MAP (bv),
 772                           ANOFFSET (delta, s->block_line_section));
 773
 774       for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
 775         {
 776           struct block *b;
 777           struct symbol *sym;
 778           struct dict_iterator iter;
 779
 780           b = BLOCKVECTOR_BLOCK (bv, i);
 781           BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
 782           BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
 783
 784           ALL_BLOCK_SYMBOLS (b, iter, sym)
 785             {
 786               relocate_one_symbol (sym, objfile, delta);
 787             }
 788         }
 789     }
 790   }
 791
 792   /* Relocate isolated symbols.  */
 793   {
 794     struct symbol *iter;
 795
 796     for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
 797       relocate_one_symbol (iter, objfile, delta);
 798   }
 799
 800   if (objfile->psymtabs_addrmap)
 801     addrmap_relocate (objfile->psymtabs_addrmap,
 802                       ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
 803
 804   if (objfile->sf)
 805     objfile->sf->qf->relocate (objfile, new_offsets, delta);
 806
 807   {
 808     struct minimal_symbol *msym;
 809
 810     ALL_OBJFILE_MSYMBOLS (objfile, msym)
 811       if (SYMBOL_SECTION (msym) >= 0)
 812       SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
 813   }
 814   /* Relocating different sections by different amounts may cause the symbols
 815      to be out of order.  */
 816   msymbols_sort (objfile);
 817
 818   if (objfile->ei.entry_point_p)
 819     {
 820       /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
 821          only as a fallback.  */
 822       struct obj_section *s;
 823       s = find_pc_section (objfile->ei.entry_point);
 824       if (s)
 825         objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index);
 826       else
 827         objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 828     }
 829
 830   {
 831     int i;
 832
 833     for (i = 0; i < objfile->num_sections; ++i)
 834       (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
 835   }
 836
 837   /* Rebuild section map next time we need it.  */
 838   get_objfile_pspace_data (objfile->pspace)->objfiles_changed_p = 1;
 839
 840   /* Update the table in exec_ops, used to read memory.  */
 841   ALL_OBJFILE_OSECTIONS (objfile, s)
 842     {
 843       int idx = s->the_bfd_section->index;
 844
 845       exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
 846                                 obj_section_addr (s));
 847     }
 848
 849   /* Data changed.  */
 850   return 1;
 851 }
 852
 853 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
 854    entries in new_offsets.  Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
 855
 856    The number and ordering of sections does differ between the two objfiles.
 857    Only their names match.  Also the file offsets will differ (objfile being
 858    possibly prelinked but separate_debug_objfile is probably not prelinked) but
 859    the in-memory absolute address as specified by NEW_OFFSETS must match both
 860    files.  */
 861
 862 void
 863 objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets)
 864 {
 865   struct objfile *debug_objfile;
 866   int changed = 0;
 867
 868   changed |= objfile_relocate1 (objfile, new_offsets);
 869
 870   for (debug_objfile = objfile->separate_debug_objfile;
 871        debug_objfile;
 872        debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
 873     {
 874       struct section_addr_info *objfile_addrs;
 875       struct section_offsets *new_debug_offsets;
 876       struct cleanup *my_cleanups;
 877
 878       objfile_addrs = build_section_addr_info_from_objfile (objfile);
 879       my_cleanups = make_cleanup (xfree, objfile_addrs);
 880
 881       /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
 882          relative ones must be already created according to debug_objfile.  */
 883
 884       addr_info_make_relative (objfile_addrs, debug_objfile->obfd);
 885
 886       gdb_assert (debug_objfile->num_sections
 887                   == bfd_count_sections (debug_objfile->obfd));
 888       new_debug_offsets =
 889         xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
 890       make_cleanup (xfree, new_debug_offsets);
 891       relative_addr_info_to_section_offsets (new_debug_offsets,
 892                                              debug_objfile->num_sections,
 893                                              objfile_addrs);
 894
 895       changed |= objfile_relocate1 (debug_objfile, new_debug_offsets);
 896
 897       do_cleanups (my_cleanups);
 898     }
 899
 900   /* Relocate breakpoints as necessary, after things are relocated.  */
 901   if (changed)
 902     breakpoint_re_set ();
 903 }
 904 \f
 905 /* Return non-zero if OBJFILE has partial symbols.  */
 906
 907 int
 908 objfile_has_partial_symbols (struct objfile *objfile)
 909 {
 910   return objfile->sf ? objfile->sf->qf->has_symbols (objfile) : 0;
 911 }
 912
 913 /* Return non-zero if OBJFILE has full symbols.  */
 914
 915 int
 916 objfile_has_full_symbols (struct objfile *objfile)
 917 {
 918   return objfile->symtabs != NULL;
 919 }
 920
 921 /* Return non-zero if OBJFILE has full or partial symbols, either directly
 922    or through a separate debug file.  */
 923
 924 int
 925 objfile_has_symbols (struct objfile *objfile)
 926 {
 927   struct objfile *o;
 928
 929   for (o = objfile; o; o = objfile_separate_debug_iterate (objfile, o))
 930     if (objfile_has_partial_symbols (o) || objfile_has_full_symbols (o))
 931       return 1;
 932   return 0;
 933 }
 934
 935
 936 /* Many places in gdb want to test just to see if we have any partial
 937    symbols available.  This function returns zero if none are currently
 938    available, nonzero otherwise.  */
 939
 940 int
 941 have_partial_symbols (void)
 942 {
 943   struct objfile *ofp;
 944
 945   ALL_OBJFILES (ofp)
 946   {
 947     if (objfile_has_partial_symbols (ofp))
 948       return 1;
 949   }
 950   return 0;
 951 }
 952
 953 /* Many places in gdb want to test just to see if we have any full
 954    symbols available.  This function returns zero if none are currently
 955    available, nonzero otherwise.  */
 956
 957 int
 958 have_full_symbols (void)
 959 {
 960   struct objfile *ofp;
 961
 962   ALL_OBJFILES (ofp)
 963   {
 964     if (objfile_has_full_symbols (ofp))
 965       return 1;
 966   }
 967   return 0;
 968 }
 969
 970
 971 /* This operations deletes all objfile entries that represent solibs that
 972    weren't explicitly loaded by the user, via e.g., the add-symbol-file
 973    command.  */
 974
 975 void
 976 objfile_purge_solibs (void)
 977 {
 978   struct objfile *objf;
 979   struct objfile *temp;
 980
 981   ALL_OBJFILES_SAFE (objf, temp)
 982   {
 983     /* We assume that the solib package has been purged already, or will
 984        be soon.  */
 985
 986     if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
 987       free_objfile (objf);
 988   }
 989 }
 990
 991
 992 /* Many places in gdb want to test just to see if we have any minimal
 993    symbols available.  This function returns zero if none are currently
 994    available, nonzero otherwise.  */
 995
 996 int
 997 have_minimal_symbols (void)
 998 {
 999   struct objfile *ofp;
1000
1001   ALL_OBJFILES (ofp)
1002   {
1003     if (ofp->minimal_symbol_count > 0)
1004       {
1005         return 1;
1006       }
1007   }
1008   return 0;
1009 }
1010
1011 /* Qsort comparison function.  */
1012
1013 static int
1014 qsort_cmp (const void *a, const void *b)
1015 {
1016   const struct obj_section *sect1 = *(const struct obj_section **) a;
1017   const struct obj_section *sect2 = *(const struct obj_section **) b;
1018   const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1019   const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1020
1021   if (sect1_addr < sect2_addr)
1022     return -1;
1023   else if (sect1_addr > sect2_addr)
1024     return 1;
1025   else
1026     {
1027       /* Sections are at the same address.  This could happen if
1028          A) we have an objfile and a separate debuginfo.
1029          B) we are confused, and have added sections without proper relocation,
1030          or something like that.  */
1031
1032       const struct objfile *const objfile1 = sect1->objfile;
1033       const struct objfile *const objfile2 = sect2->objfile;
1034
1035       if (objfile1->separate_debug_objfile == objfile2
1036           || objfile2->separate_debug_objfile == objfile1)
1037         {
1038           /* Case A.  The ordering doesn't matter: separate debuginfo files
1039              will be filtered out later.  */
1040
1041           return 0;
1042         }
1043
1044       /* Case B.  Maintain stable sort order, so bugs in GDB are easier to
1045          triage.  This section could be slow (since we iterate over all
1046          objfiles in each call to qsort_cmp), but this shouldn't happen
1047          very often (GDB is already in a confused state; one hopes this
1048          doesn't happen at all).  If you discover that significant time is
1049          spent in the loops below, do 'set complaints 100' and examine the
1050          resulting complaints.  */
1051
1052       if (objfile1 == objfile2)
1053         {
1054           /* Both sections came from the same objfile.  We are really confused.
1055              Sort on sequence order of sections within the objfile.  */
1056
1057           const struct obj_section *osect;
1058
1059           ALL_OBJFILE_OSECTIONS (objfile1, osect)
1060             if (osect == sect1)
1061               return -1;
1062             else if (osect == sect2)
1063               return 1;
1064
1065           /* We should have found one of the sections before getting here.  */
1066           gdb_assert_not_reached ("section not found");
1067         }
1068       else
1069         {
1070           /* Sort on sequence number of the objfile in the chain.  */
1071
1072           const struct objfile *objfile;
1073
1074           ALL_OBJFILES (objfile)
1075             if (objfile == objfile1)
1076               return -1;
1077             else if (objfile == objfile2)
1078               return 1;
1079
1080           /* We should have found one of the objfiles before getting here.  */
1081           gdb_assert_not_reached ("objfile not found");
1082         }
1083     }
1084
1085   /* Unreachable.  */
1086   gdb_assert_not_reached ("unexpected code path");
1087   return 0;
1088 }
1089
1090 /* Select "better" obj_section to keep.  We prefer the one that came from
1091    the real object, rather than the one from separate debuginfo.
1092    Most of the time the two sections are exactly identical, but with
1093    prelinking the .rel.dyn section in the real object may have different
1094    size.  */
1095
1096 static struct obj_section *
1097 preferred_obj_section (struct obj_section *a, struct obj_section *b)
1098 {
1099   gdb_assert (obj_section_addr (a) == obj_section_addr (b));
1100   gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
1101               || (b->objfile->separate_debug_objfile == a->objfile));
1102   gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
1103               || (b->objfile->separate_debug_objfile_backlink == a->objfile));
1104
1105   if (a->objfile->separate_debug_objfile != NULL)
1106     return a;
1107   return b;
1108 }
1109
1110 /* Return 1 if SECTION should be inserted into the section map.
1111    We want to insert only non-overlay and non-TLS section.  */
1112
1113 static int
1114 insert_section_p (const struct bfd *abfd,
1115                   const struct bfd_section *section)
1116 {
1117   const bfd_vma lma = bfd_section_lma (abfd, section);
1118
1119   if (lma != 0 && lma != bfd_section_vma (abfd, section)
1120       && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1121     /* This is an overlay section.  IN_MEMORY check is needed to avoid
1122        discarding sections from the "system supplied DSO" (aka vdso)
1123        on some Linux systems (e.g. Fedora 11).  */
1124     return 0;
1125   if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0)
1126     /* This is a TLS section.  */
1127     return 0;
1128
1129   return 1;
1130 }
1131
1132 /* Filter out overlapping sections where one section came from the real
1133    objfile, and the other from a separate debuginfo file.
1134    Return the size of table after redundant sections have been eliminated.  */
1135
1136 static int
1137 filter_debuginfo_sections (struct obj_section **map, int map_size)
1138 {
1139   int i, j;
1140
1141   for (i = 0, j = 0; i < map_size - 1; i++)
1142     {
1143       struct obj_section *const sect1 = map[i];
1144       struct obj_section *const sect2 = map[i + 1];
1145       const struct objfile *const objfile1 = sect1->objfile;
1146       const struct objfile *const objfile2 = sect2->objfile;
1147       const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1148       const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1149
1150       if (sect1_addr == sect2_addr
1151           && (objfile1->separate_debug_objfile == objfile2
1152               || objfile2->separate_debug_objfile == objfile1))
1153         {
1154           map[j++] = preferred_obj_section (sect1, sect2);
1155           ++i;
1156         }
1157       else
1158         map[j++] = sect1;
1159     }
1160
1161   if (i < map_size)
1162     {
1163       gdb_assert (i == map_size - 1);
1164       map[j++] = map[i];
1165     }
1166
1167   /* The map should not have shrunk to less than half the original size.  */
1168   gdb_assert (map_size / 2 <= j);
1169
1170   return j;
1171 }
1172
1173 /* Filter out overlapping sections, issuing a warning if any are found.
1174    Overlapping sections could really be overlay sections which we didn't
1175    classify as such in insert_section_p, or we could be dealing with a
1176    corrupt binary.  */
1177
1178 static int
1179 filter_overlapping_sections (struct obj_section **map, int map_size)
1180 {
1181   int i, j;
1182
1183   for (i = 0, j = 0; i < map_size - 1; )
1184     {
1185       int k;
1186
1187       map[j++] = map[i];
1188       for (k = i + 1; k < map_size; k++)
1189         {
1190           struct obj_section *const sect1 = map[i];
1191           struct obj_section *const sect2 = map[k];
1192           const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1193           const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1194           const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
1195
1196           gdb_assert (sect1_addr <= sect2_addr);
1197
1198           if (sect1_endaddr <= sect2_addr)
1199             break;
1200           else
1201             {
1202               /* We have an overlap.  Report it.  */
1203
1204               struct objfile *const objf1 = sect1->objfile;
1205               struct objfile *const objf2 = sect2->objfile;
1206
1207               const struct bfd *const abfd1 = objf1->obfd;
1208               const struct bfd *const abfd2 = objf2->obfd;
1209
1210               const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1211               const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1212
1213               const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
1214
1215               struct gdbarch *const gdbarch = get_objfile_arch (objf1);
1216
1217               complaint (&symfile_complaints,
1218                          _("unexpected overlap between:\n"
1219                            " (A) section `%s' from `%s' [%s, %s)\n"
1220                            " (B) section `%s' from `%s' [%s, %s).\n"
1221                            "Will ignore section B"),
1222                          bfd_section_name (abfd1, bfds1), objf1->name,
1223                          paddress (gdbarch, sect1_addr),
1224                          paddress (gdbarch, sect1_endaddr),
1225                          bfd_section_name (abfd2, bfds2), objf2->name,
1226                          paddress (gdbarch, sect2_addr),
1227                          paddress (gdbarch, sect2_endaddr));
1228             }
1229         }
1230       i = k;
1231     }
1232
1233   if (i < map_size)
1234     {
1235       gdb_assert (i == map_size - 1);
1236       map[j++] = map[i];
1237     }
1238
1239   return j;
1240 }
1241
1242
1243 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1244    TLS, overlay and overlapping sections.  */
1245
1246 static void
1247 update_section_map (struct program_space *pspace,
1248                     struct obj_section ***pmap, int *pmap_size)
1249 {
1250   int alloc_size, map_size, i;
1251   struct obj_section *s, **map;
1252   struct objfile *objfile;
1253
1254   gdb_assert (get_objfile_pspace_data (pspace)->objfiles_changed_p != 0);
1255
1256   map = *pmap;
1257   xfree (map);
1258
1259   alloc_size = 0;
1260   ALL_PSPACE_OBJFILES (pspace, objfile)
1261     ALL_OBJFILE_OSECTIONS (objfile, s)
1262       if (insert_section_p (objfile->obfd, s->the_bfd_section))
1263         alloc_size += 1;
1264
1265   /* This happens on detach/attach (e.g. in gdb.base/attach.exp).  */
1266   if (alloc_size == 0)
1267     {
1268       *pmap = NULL;
1269       *pmap_size = 0;
1270       return;
1271     }
1272
1273   map = xmalloc (alloc_size * sizeof (*map));
1274
1275   i = 0;
1276   ALL_PSPACE_OBJFILES (pspace, objfile)
1277     ALL_OBJFILE_OSECTIONS (objfile, s)
1278       if (insert_section_p (objfile->obfd, s->the_bfd_section))
1279         map[i++] = s;
1280
1281   qsort (map, alloc_size, sizeof (*map), qsort_cmp);
1282   map_size = filter_debuginfo_sections(map, alloc_size);
1283   map_size = filter_overlapping_sections(map, map_size);
1284
1285   if (map_size < alloc_size)
1286     /* Some sections were eliminated.  Trim excess space.  */
1287     map = xrealloc (map, map_size * sizeof (*map));
1288   else
1289     gdb_assert (alloc_size == map_size);
1290
1291   *pmap = map;
1292   *pmap_size = map_size;
1293 }
1294
1295 /* Bsearch comparison function.  */
1296
1297 static int
1298 bsearch_cmp (const void *key, const void *elt)
1299 {
1300   const CORE_ADDR pc = *(CORE_ADDR *) key;
1301   const struct obj_section *section = *(const struct obj_section **) elt;
1302
1303   if (pc < obj_section_addr (section))
1304     return -1;
1305   if (pc < obj_section_endaddr (section))
1306     return 0;
1307   return 1;
1308 }
1309
1310 /* Returns a section whose range includes PC or NULL if none found.   */
1311
1312 struct obj_section *
1313 find_pc_section (CORE_ADDR pc)
1314 {
1315   struct objfile_pspace_info *pspace_info;
1316   struct obj_section *s, **sp;
1317
1318   /* Check for mapped overlay section first.  */
1319   s = find_pc_mapped_section (pc);
1320   if (s)
1321     return s;
1322
1323   pspace_info = get_objfile_pspace_data (current_program_space);
1324   if (pspace_info->objfiles_changed_p != 0)
1325     {
1326       update_section_map (current_program_space,
1327                           &pspace_info->sections,
1328                           &pspace_info->num_sections);
1329
1330       /* Don't need updates to section map until objfiles are added,
1331          removed or relocated.  */
1332       pspace_info->objfiles_changed_p = 0;
1333     }
1334
1335   /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1336      bsearch be non-NULL.  */
1337   if (pspace_info->sections == NULL)
1338     {
1339       gdb_assert (pspace_info->num_sections == 0);
1340       return NULL;
1341     }
1342
1343   sp = (struct obj_section **) bsearch (&pc,
1344                                         pspace_info->sections,
1345                                         pspace_info->num_sections,
1346                                         sizeof (*pspace_info->sections),
1347                                         bsearch_cmp);
1348   if (sp != NULL)
1349     return *sp;
1350   return NULL;
1351 }
1352
1353
1354 /* In SVR4, we recognize a trampoline by it's section name.
1355    That is, if the pc is in a section named ".plt" then we are in
1356    a trampoline.  */
1357
1358 int
1359 in_plt_section (CORE_ADDR pc, char *name)
1360 {
1361   struct obj_section *s;
1362   int retval = 0;
1363
1364   s = find_pc_section (pc);
1365
1366   retval = (s != NULL
1367             && s->the_bfd_section->name != NULL
1368             && strcmp (s->the_bfd_section->name, ".plt") == 0);
1369   return (retval);
1370 }
1371 \f
1372
1373 /* Keep a registry of per-objfile data-pointers required by other GDB
1374    modules.  */
1375
1376 struct objfile_data
1377 {
1378   unsigned index;
1379   void (*save) (struct objfile *, void *);
1380   void (*free) (struct objfile *, void *);
1381 };
1382
1383 struct objfile_data_registration
1384 {
1385   struct objfile_data *data;
1386   struct objfile_data_registration *next;
1387 };
1388
1389 struct objfile_data_registry
1390 {
1391   struct objfile_data_registration *registrations;
1392   unsigned num_registrations;
1393 };
1394
1395 static struct objfile_data_registry objfile_data_registry = { NULL, 0 };
1396
1397 const struct objfile_data *
1398 register_objfile_data_with_cleanup (void (*save) (struct objfile *, void *),
1399                                     void (*free) (struct objfile *, void *))
1400 {
1401   struct objfile_data_registration **curr;
1402
1403   /* Append new registration.  */
1404   for (curr = &objfile_data_registry.registrations;
1405        *curr != NULL; curr = &(*curr)->next);
1406
1407   *curr = XMALLOC (struct objfile_data_registration);
1408   (*curr)->next = NULL;
1409   (*curr)->data = XMALLOC (struct objfile_data);
1410   (*curr)->data->index = objfile_data_registry.num_registrations++;
1411   (*curr)->data->save = save;
1412   (*curr)->data->free = free;
1413
1414   return (*curr)->data;
1415 }
1416
1417 const struct objfile_data *
1418 register_objfile_data (void)
1419 {
1420   return register_objfile_data_with_cleanup (NULL, NULL);
1421 }
1422
1423 static void
1424 objfile_alloc_data (struct objfile *objfile)
1425 {
1426   gdb_assert (objfile->data == NULL);
1427   objfile->num_data = objfile_data_registry.num_registrations;
1428   objfile->data = XCALLOC (objfile->num_data, void *);
1429 }
1430
1431 static void
1432 objfile_free_data (struct objfile *objfile)
1433 {
1434   gdb_assert (objfile->data != NULL);
1435   clear_objfile_data (objfile);
1436   xfree (objfile->data);
1437   objfile->data = NULL;
1438 }
1439
1440 void
1441 clear_objfile_data (struct objfile *objfile)
1442 {
1443   struct objfile_data_registration *registration;
1444   int i;
1445
1446   gdb_assert (objfile->data != NULL);
1447
1448   /* Process all the save handlers.  */
1449
1450   for (registration = objfile_data_registry.registrations, i = 0;
1451        i < objfile->num_data;
1452        registration = registration->next, i++)
1453     if (objfile->data[i] != NULL && registration->data->save != NULL)
1454       registration->data->save (objfile, objfile->data[i]);
1455
1456   /* Now process all the free handlers.  */
1457
1458   for (registration = objfile_data_registry.registrations, i = 0;
1459        i < objfile->num_data;
1460        registration = registration->next, i++)
1461     if (objfile->data[i] != NULL && registration->data->free != NULL)
1462       registration->data->free (objfile, objfile->data[i]);
1463
1464   memset (objfile->data, 0, objfile->num_data * sizeof (void *));
1465 }
1466
1467 void
1468 set_objfile_data (struct objfile *objfile, const struct objfile_data *data,
1469                   void *value)
1470 {
1471   gdb_assert (data->index < objfile->num_data);
1472   objfile->data[data->index] = value;
1473 }
1474
1475 void *
1476 objfile_data (struct objfile *objfile, const struct objfile_data *data)
1477 {
1478   gdb_assert (data->index < objfile->num_data);
1479   return objfile->data[data->index];
1480 }
1481
1482 /* Set objfiles_changed_p so section map will be rebuilt next time it
1483    is used.  Called by reread_symbols.  */
1484
1485 void
1486 objfiles_changed (void)
1487 {
1488   /* Rebuild section map next time we need it.  */
1489   get_objfile_pspace_data (current_program_space)->objfiles_changed_p = 1;
1490 }
1491
1492 /* Close ABFD, and warn if that fails.  */
1493
1494 int
1495 gdb_bfd_close_or_warn (struct bfd *abfd)
1496 {
1497   int ret;
1498   char *name = bfd_get_filename (abfd);
1499
1500   ret = bfd_close (abfd);
1501
1502   if (!ret)
1503     warning (_("cannot close \"%s\": %s"),
1504              name, bfd_errmsg (bfd_get_error ()));
1505
1506   return ret;
1507 }
1508
1509 /* Add reference to ABFD.  Returns ABFD.  */
1510 struct bfd *
1511 gdb_bfd_ref (struct bfd *abfd)
1512 {
1513   int *p_refcount;
1514
1515   if (abfd == NULL)
1516     return NULL;
1517
1518   p_refcount = bfd_usrdata (abfd);
1519
1520   if (p_refcount != NULL)
1521     {
1522       *p_refcount += 1;
1523       return abfd;
1524     }
1525
1526   p_refcount = xmalloc (sizeof (*p_refcount));
1527   *p_refcount = 1;
1528   bfd_usrdata (abfd) = p_refcount;
1529
1530   return abfd;
1531 }
1532
1533 /* Unreference and possibly close ABFD.  */
1534 void
1535 gdb_bfd_unref (struct bfd *abfd)
1536 {
1537   int *p_refcount;
1538   char *name;
1539
1540   if (abfd == NULL)
1541     return;
1542
1543   p_refcount = bfd_usrdata (abfd);
1544
1545   /* Valid range for p_refcount: a pointer to int counter, which has a
1546      value of 1 (single owner) or 2 (shared).  */
1547   gdb_assert (*p_refcount == 1 || *p_refcount == 2);
1548
1549   *p_refcount -= 1;
1550   if (*p_refcount > 0)
1551     return;
1552
1553   xfree (p_refcount);
1554   bfd_usrdata (abfd) = NULL;  /* Paranoia.  */
1555
1556   name = bfd_get_filename (abfd);
1557   gdb_bfd_close_or_warn (abfd);
1558   xfree (name);
1559 }
1560
1561 /* Provide a prototype to silence -Wmissing-prototypes.  */
1562 extern initialize_file_ftype _initialize_objfiles;
1563
1564 void
1565 _initialize_objfiles (void)
1566 {
1567   objfiles_pspace_data
1568     = register_program_space_data_with_cleanup (objfiles_pspace_data_cleanup);
1569 }