gdb/objfiles.c

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