gdb/objfiles.c

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