gdb/objfiles.c

   1 /* GDB routines for manipulating objfiles.
   2
   3    Copyright (C) 1992-2021 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 "expression.h"
  34 #include "parser-defs.h"
  35
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38 #include <fcntl.h>
  39 #include "gdb_obstack.h"
  40 #include "hashtab.h"
  41
  42 #include "breakpoint.h"
  43 #include "block.h"
  44 #include "dictionary.h"
  45 #include "source.h"
  46 #include "addrmap.h"
  47 #include "arch-utils.h"
  48 #include "exec.h"
  49 #include "observable.h"
  50 #include "complaints.h"
  51 #include "psymtab.h"
  52 #include "solist.h"
  53 #include "gdb_bfd.h"
  54 #include "btrace.h"
  55 #include "gdbsupport/pathstuff.h"
  56
  57 #include <algorithm>
  58 #include <vector>
  59
  60 /* Keep a registry of per-objfile data-pointers required by other GDB
  61    modules.  */
  62
  63 DEFINE_REGISTRY (objfile, REGISTRY_ACCESS_FIELD)
  64
  65 /* Externally visible variables that are owned by this module.
  66    See declarations in objfile.h for more info.  */
  67
  68 struct objfile_pspace_info
  69 {
  70   objfile_pspace_info () = default;
  71   ~objfile_pspace_info ();
  72
  73   struct obj_section **sections = nullptr;
  74   int num_sections = 0;
  75
  76   /* Nonzero if object files have been added since the section map
  77      was last updated.  */
  78   int new_objfiles_available = 0;
  79
  80   /* Nonzero if the section map MUST be updated before use.  */
  81   int section_map_dirty = 0;
  82
  83   /* Nonzero if section map updates should be inhibited if possible.  */
  84   int inhibit_updates = 0;
  85 };
  86
  87 /* Per-program-space data key.  */
  88 static const struct program_space_key<objfile_pspace_info>
  89   objfiles_pspace_data;
  90
  91 objfile_pspace_info::~objfile_pspace_info ()
  92 {
  93   xfree (sections);
  94 }
  95
  96 /* Get the current svr4 data.  If none is found yet, add it now.  This
  97    function always returns a valid object.  */
  98
  99 static struct objfile_pspace_info *
 100 get_objfile_pspace_data (struct program_space *pspace)
 101 {
 102   struct objfile_pspace_info *info;
 103
 104   info = objfiles_pspace_data.get (pspace);
 105   if (info == NULL)
 106     info = objfiles_pspace_data.emplace (pspace);
 107
 108   return info;
 109 }
 110
 111 \f
 112
 113 /* Per-BFD data key.  */
 114
 115 static const struct bfd_key<objfile_per_bfd_storage> objfiles_bfd_data;
 116
 117 objfile_per_bfd_storage::~objfile_per_bfd_storage ()
 118 {
 119 }
 120
 121 /* Create the per-BFD storage object for OBJFILE.  If ABFD is not
 122    NULL, and it already has a per-BFD storage object, use that.
 123    Otherwise, allocate a new per-BFD storage object.  Note that it is
 124    not safe to call this multiple times for a given OBJFILE -- it can
 125    only be called when allocating or re-initializing OBJFILE.  */
 126
 127 static struct objfile_per_bfd_storage *
 128 get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd)
 129 {
 130   struct objfile_per_bfd_storage *storage = NULL;
 131
 132   if (abfd != NULL)
 133     storage = objfiles_bfd_data.get (abfd);
 134
 135   if (storage == NULL)
 136     {
 137       storage = new objfile_per_bfd_storage;
 138       /* If the object requires gdb to do relocations, we simply fall
 139          back to not sharing data across users.  These cases are rare
 140          enough that this seems reasonable.  */
 141       if (abfd != NULL && !gdb_bfd_requires_relocations (abfd))
 142         objfiles_bfd_data.set (abfd, storage);
 143
 144       /* Look up the gdbarch associated with the BFD.  */
 145       if (abfd != NULL)
 146         storage->gdbarch = gdbarch_from_bfd (abfd);
 147     }
 148
 149   return storage;
 150 }
 151
 152 /* See objfiles.h.  */
 153
 154 void
 155 set_objfile_per_bfd (struct objfile *objfile)
 156 {
 157   objfile->per_bfd = get_objfile_bfd_data (objfile, objfile->obfd);
 158 }
 159
 160 /* Set the objfile's per-BFD notion of the "main" name and
 161    language.  */
 162
 163 void
 164 set_objfile_main_name (struct objfile *objfile,
 165                        const char *name, enum language lang)
 166 {
 167   if (objfile->per_bfd->name_of_main == NULL
 168       || strcmp (objfile->per_bfd->name_of_main, name) != 0)
 169     objfile->per_bfd->name_of_main
 170       = obstack_strdup (&objfile->per_bfd->storage_obstack, name);
 171   objfile->per_bfd->language_of_main = lang;
 172 }
 173
 174 /* Helper structure to map blocks to static link properties in hash tables.  */
 175
 176 struct static_link_htab_entry
 177 {
 178   const struct block *block;
 179   const struct dynamic_prop *static_link;
 180 };
 181
 182 /* Return a hash code for struct static_link_htab_entry *P.  */
 183
 184 static hashval_t
 185 static_link_htab_entry_hash (const void *p)
 186 {
 187   const struct static_link_htab_entry *e
 188     = (const struct static_link_htab_entry *) p;
 189
 190   return htab_hash_pointer (e->block);
 191 }
 192
 193 /* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
 194    mappings for the same block.  */
 195
 196 static int
 197 static_link_htab_entry_eq (const void *p1, const void *p2)
 198 {
 199   const struct static_link_htab_entry *e1
 200     = (const struct static_link_htab_entry *) p1;
 201   const struct static_link_htab_entry *e2
 202     = (const struct static_link_htab_entry *) p2;
 203
 204   return e1->block == e2->block;
 205 }
 206
 207 /* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
 208    Must not be called more than once for each BLOCK.  */
 209
 210 void
 211 objfile_register_static_link (struct objfile *objfile,
 212                               const struct block *block,
 213                               const struct dynamic_prop *static_link)
 214 {
 215   void **slot;
 216   struct static_link_htab_entry lookup_entry;
 217   struct static_link_htab_entry *entry;
 218
 219   if (objfile->static_links == NULL)
 220     objfile->static_links.reset (htab_create_alloc
 221       (1, &static_link_htab_entry_hash, static_link_htab_entry_eq, NULL,
 222        xcalloc, xfree));
 223
 224   /* Create a slot for the mapping, make sure it's the first mapping for this
 225      block and then create the mapping itself.  */
 226   lookup_entry.block = block;
 227   slot = htab_find_slot (objfile->static_links.get (), &lookup_entry, INSERT);
 228   gdb_assert (*slot == NULL);
 229
 230   entry = XOBNEW (&objfile->objfile_obstack, static_link_htab_entry);
 231   entry->block = block;
 232   entry->static_link = static_link;
 233   *slot = (void *) entry;
 234 }
 235
 236 /* Look for a static link for BLOCK, which is part of OBJFILE.  Return NULL if
 237    none was found.  */
 238
 239 const struct dynamic_prop *
 240 objfile_lookup_static_link (struct objfile *objfile,
 241                             const struct block *block)
 242 {
 243   struct static_link_htab_entry *entry;
 244   struct static_link_htab_entry lookup_entry;
 245
 246   if (objfile->static_links == NULL)
 247     return NULL;
 248   lookup_entry.block = block;
 249   entry = ((struct static_link_htab_entry *)
 250            htab_find (objfile->static_links.get (), &lookup_entry));
 251   if (entry == NULL)
 252     return NULL;
 253
 254   gdb_assert (entry->block == block);
 255   return entry->static_link;
 256 }
 257
 258 \f
 259
 260 /* Build up the section table that the objfile references.  The
 261    objfile contains pointers to the start of the table
 262    (objfile->sections) and to the first location after the end of the
 263    table (objfile->sections_end).  */
 264
 265 static void
 266 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
 267                               struct objfile *objfile, int force)
 268 {
 269   struct obj_section *section;
 270
 271   if (!force)
 272     {
 273       flagword aflag;
 274
 275       aflag = bfd_section_flags (asect);
 276       if (!(aflag & SEC_ALLOC))
 277         return;
 278     }
 279
 280   section = &objfile->sections[gdb_bfd_section_index (abfd, asect)];
 281   section->objfile = objfile;
 282   section->the_bfd_section = asect;
 283   section->ovly_mapped = 0;
 284 }
 285
 286 /* Builds a section table for OBJFILE.
 287
 288    Note that the OFFSET and OVLY_MAPPED in each table entry are
 289    initialized to zero.  */
 290
 291 void
 292 build_objfile_section_table (struct objfile *objfile)
 293 {
 294   int count = gdb_bfd_count_sections (objfile->obfd);
 295
 296   objfile->sections = OBSTACK_CALLOC (&objfile->objfile_obstack,
 297                                       count,
 298                                       struct obj_section);
 299   objfile->sections_end = (objfile->sections + count);
 300   for (asection *sect : gdb_bfd_sections (objfile->obfd))
 301     add_to_objfile_sections (objfile->obfd, sect, objfile, 0);
 302
 303   /* See gdb_bfd_section_index.  */
 304   add_to_objfile_sections (objfile->obfd, bfd_com_section_ptr, objfile, 1);
 305   add_to_objfile_sections (objfile->obfd, bfd_und_section_ptr, objfile, 1);
 306   add_to_objfile_sections (objfile->obfd, bfd_abs_section_ptr, objfile, 1);
 307   add_to_objfile_sections (objfile->obfd, bfd_ind_section_ptr, objfile, 1);
 308 }
 309
 310 /* Given a pointer to an initialized bfd (ABFD) and some flag bits,
 311    initialize the new objfile as best we can and link it into the list
 312    of all known objfiles.
 313
 314    NAME should contain original non-canonicalized filename or other
 315    identifier as entered by user.  If there is no better source use
 316    bfd_get_filename (ABFD).  NAME may be NULL only if ABFD is NULL.
 317    NAME content is copied into returned objfile.
 318
 319    The FLAGS word contains various bits (OBJF_*) that can be taken as
 320    requests for specific operations.  Other bits like OBJF_SHARED are
 321    simply copied through to the new objfile flags member.  */
 322
 323 objfile::objfile (bfd *abfd, const char *name, objfile_flags flags_)
 324   : flags (flags_),
 325     pspace (current_program_space),
 326     partial_symtabs (new psymtab_storage ()),
 327     obfd (abfd)
 328 {
 329   const char *expanded_name;
 330
 331   /* We could use obstack_specify_allocation here instead, but
 332      gdb_obstack.h specifies the alloc/dealloc functions.  */
 333   obstack_init (&objfile_obstack);
 334
 335   objfile_alloc_data (this);
 336
 337   gdb::unique_xmalloc_ptr<char> name_holder;
 338   if (name == NULL)
 339     {
 340       gdb_assert (abfd == NULL);
 341       gdb_assert ((flags & OBJF_NOT_FILENAME) != 0);
 342       expanded_name = "<<anonymous objfile>>";
 343     }
 344   else if ((flags & OBJF_NOT_FILENAME) != 0
 345            || is_target_filename (name))
 346     expanded_name = name;
 347   else
 348     {
 349       name_holder = gdb_abspath (name);
 350       expanded_name = name_holder.get ();
 351     }
 352   original_name = obstack_strdup (&objfile_obstack, expanded_name);
 353
 354   /* Update the per-objfile information that comes from the bfd, ensuring
 355      that any data that is reference is saved in the per-objfile data
 356      region.  */
 357
 358   gdb_bfd_ref (abfd);
 359   if (abfd != NULL)
 360     {
 361       mtime = bfd_get_mtime (abfd);
 362
 363       /* Build section table.  */
 364       build_objfile_section_table (this);
 365     }
 366
 367   per_bfd = get_objfile_bfd_data (this, abfd);
 368 }
 369
 370 /* If there is a valid and known entry point, function fills *ENTRY_P with it
 371    and returns non-zero; otherwise it returns zero.  */
 372
 373 int
 374 entry_point_address_query (CORE_ADDR *entry_p)
 375 {
 376   objfile *objf = current_program_space->symfile_object_file;
 377   if (objf == NULL || !objf->per_bfd->ei.entry_point_p)
 378     return 0;
 379
 380   int idx = objf->per_bfd->ei.the_bfd_section_index;
 381   *entry_p = objf->per_bfd->ei.entry_point + objf->section_offsets[idx];
 382
 383   return 1;
 384 }
 385
 386 /* Get current entry point address.  Call error if it is not known.  */
 387
 388 CORE_ADDR
 389 entry_point_address (void)
 390 {
 391   CORE_ADDR retval;
 392
 393   if (!entry_point_address_query (&retval))
 394     error (_("Entry point address is not known."));
 395
 396   return retval;
 397 }
 398
 399 separate_debug_iterator &
 400 separate_debug_iterator::operator++ ()
 401 {
 402   gdb_assert (m_objfile != nullptr);
 403
 404   struct objfile *res;
 405
 406   /* If any, return the first child.  */
 407   res = m_objfile->separate_debug_objfile;
 408   if (res != nullptr)
 409     {
 410       m_objfile = res;
 411       return *this;
 412     }
 413
 414   /* Common case where there is no separate debug objfile.  */
 415   if (m_objfile == m_parent)
 416     {
 417       m_objfile = nullptr;
 418       return *this;
 419     }
 420
 421   /* Return the brother if any.  Note that we don't iterate on brothers of
 422      the parents.  */
 423   res = m_objfile->separate_debug_objfile_link;
 424   if (res != nullptr)
 425     {
 426       m_objfile = res;
 427       return *this;
 428     }
 429
 430   for (res = m_objfile->separate_debug_objfile_backlink;
 431        res != m_parent;
 432        res = res->separate_debug_objfile_backlink)
 433     {
 434       gdb_assert (res != nullptr);
 435       if (res->separate_debug_objfile_link != nullptr)
 436         {
 437           m_objfile = res->separate_debug_objfile_link;
 438           return *this;
 439         }
 440     }
 441   m_objfile = nullptr;
 442   return *this;
 443 }
 444
 445 /* Add OBJFILE as a separate debug objfile of PARENT.  */
 446
 447 static void
 448 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
 449 {
 450   gdb_assert (objfile && parent);
 451
 452   /* Must not be already in a list.  */
 453   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
 454   gdb_assert (objfile->separate_debug_objfile_link == NULL);
 455   gdb_assert (objfile->separate_debug_objfile == NULL);
 456   gdb_assert (parent->separate_debug_objfile_backlink == NULL);
 457   gdb_assert (parent->separate_debug_objfile_link == NULL);
 458
 459   objfile->separate_debug_objfile_backlink = parent;
 460   objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
 461   parent->separate_debug_objfile = objfile;
 462 }
 463
 464 /* See objfiles.h.  */
 465
 466 objfile *
 467 objfile::make (bfd *bfd_, const char *name_, objfile_flags flags_,
 468                objfile *parent)
 469 {
 470   objfile *result = new objfile (bfd_, name_, flags_);
 471   if (parent != nullptr)
 472     add_separate_debug_objfile (result, parent);
 473
 474   /* Using std::make_shared might be a bit nicer here, but that would
 475      require making the constructor public.  */
 476   current_program_space->add_objfile (std::shared_ptr<objfile> (result),
 477                                       parent);
 478
 479   /* Rebuild section map next time we need it.  */
 480   get_objfile_pspace_data (current_program_space)->new_objfiles_available = 1;
 481
 482   return result;
 483 }
 484
 485 /* See objfiles.h.  */
 486
 487 void
 488 objfile::unlink ()
 489 {
 490   current_program_space->remove_objfile (this);
 491 }
 492
 493 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
 494    itself.  */
 495
 496 void
 497 free_objfile_separate_debug (struct objfile *objfile)
 498 {
 499   struct objfile *child;
 500
 501   for (child = objfile->separate_debug_objfile; child;)
 502     {
 503       struct objfile *next_child = child->separate_debug_objfile_link;
 504       child->unlink ();
 505       child = next_child;
 506     }
 507 }
 508
 509 /* Destroy an objfile and all the symtabs and psymtabs under it.  */
 510
 511 objfile::~objfile ()
 512 {
 513   /* First notify observers that this objfile is about to be freed.  */
 514   gdb::observers::free_objfile.notify (this);
 515
 516   /* Free all separate debug objfiles.  */
 517   free_objfile_separate_debug (this);
 518
 519   if (separate_debug_objfile_backlink)
 520     {
 521       /* We freed the separate debug file, make sure the base objfile
 522          doesn't reference it.  */
 523       struct objfile *child;
 524
 525       child = separate_debug_objfile_backlink->separate_debug_objfile;
 526
 527       if (child == this)
 528         {
 529           /* THIS is the first child.  */
 530           separate_debug_objfile_backlink->separate_debug_objfile =
 531             separate_debug_objfile_link;
 532         }
 533       else
 534         {
 535           /* Find THIS in the list.  */
 536           while (1)
 537             {
 538               if (child->separate_debug_objfile_link == this)
 539                 {
 540                   child->separate_debug_objfile_link =
 541                     separate_debug_objfile_link;
 542                   break;
 543                 }
 544               child = child->separate_debug_objfile_link;
 545               gdb_assert (child);
 546             }
 547         }
 548     }
 549
 550   /* Remove any references to this objfile in the global value
 551      lists.  */
 552   preserve_values (this);
 553
 554   /* It still may reference data modules have associated with the objfile and
 555      the symbol file data.  */
 556   forget_cached_source_info_for_objfile (this);
 557
 558   breakpoint_free_objfile (this);
 559   btrace_free_objfile (this);
 560
 561   /* First do any symbol file specific actions required when we are
 562      finished with a particular symbol file.  Note that if the objfile
 563      is using reusable symbol information (via mmalloc) then each of
 564      these routines is responsible for doing the correct thing, either
 565      freeing things which are valid only during this particular gdb
 566      execution, or leaving them to be reused during the next one.  */
 567
 568   if (sf != NULL)
 569     (*sf->sym_finish) (this);
 570
 571   /* Discard any data modules have associated with the objfile.  The function
 572      still may reference obfd.  */
 573   objfile_free_data (this);
 574
 575   if (obfd)
 576     gdb_bfd_unref (obfd);
 577   else
 578     delete per_bfd;
 579
 580   /* Before the symbol table code was redone to make it easier to
 581      selectively load and remove information particular to a specific
 582      linkage unit, gdb used to do these things whenever the monolithic
 583      symbol table was blown away.  How much still needs to be done
 584      is unknown, but we play it safe for now and keep each action until
 585      it is shown to be no longer needed.  */
 586
 587   /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
 588      for example), so we need to call this here.  */
 589   clear_pc_function_cache ();
 590
 591   /* Check to see if the current_source_symtab belongs to this objfile,
 592      and if so, call clear_current_source_symtab_and_line.  */
 593
 594   {
 595     struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 596
 597     if (cursal.symtab && SYMTAB_OBJFILE (cursal.symtab) == this)
 598       clear_current_source_symtab_and_line ();
 599   }
 600
 601   /* Free the obstacks for non-reusable objfiles.  */
 602   obstack_free (&objfile_obstack, 0);
 603
 604   /* Rebuild section map next time we need it.  */
 605   get_objfile_pspace_data (pspace)->section_map_dirty = 1;
 606 }
 607
 608 \f
 609 /* A helper function for objfile_relocate1 that relocates a single
 610    symbol.  */
 611
 612 static void
 613 relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
 614                      const section_offsets &delta)
 615 {
 616   fixup_symbol_section (sym, objfile);
 617
 618   /* The RS6000 code from which this was taken skipped
 619      any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
 620      But I'm leaving out that test, on the theory that
 621      they can't possibly pass the tests below.  */
 622   if ((SYMBOL_CLASS (sym) == LOC_LABEL
 623        || SYMBOL_CLASS (sym) == LOC_STATIC)
 624       && sym->section_index () >= 0)
 625     {
 626       SET_SYMBOL_VALUE_ADDRESS (sym,
 627                                 SYMBOL_VALUE_ADDRESS (sym)
 628                                 + delta[sym->section_index ()]);
 629     }
 630 }
 631
 632 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
 633    entries in new_offsets.  SEPARATE_DEBUG_OBJFILE is not touched here.
 634    Return non-zero iff any change happened.  */
 635
 636 static int
 637 objfile_relocate1 (struct objfile *objfile,
 638                    const section_offsets &new_offsets)
 639 {
 640   section_offsets delta (objfile->section_offsets.size ());
 641
 642   int something_changed = 0;
 643
 644   for (int i = 0; i < objfile->section_offsets.size (); ++i)
 645     {
 646       delta[i] = new_offsets[i] - objfile->section_offsets[i];
 647       if (delta[i] != 0)
 648         something_changed = 1;
 649     }
 650   if (!something_changed)
 651     return 0;
 652
 653   /* OK, get all the symtabs.  */
 654   {
 655     for (compunit_symtab *cust : objfile->compunits ())
 656       {
 657         for (symtab *s : compunit_filetabs (cust))
 658           {
 659             struct linetable *l;
 660
 661             /* First the line table.  */
 662             l = SYMTAB_LINETABLE (s);
 663             if (l)
 664               {
 665                 for (int i = 0; i < l->nitems; ++i)
 666                   l->item[i].pc += delta[COMPUNIT_BLOCK_LINE_SECTION (cust)];
 667               }
 668           }
 669       }
 670
 671     for (compunit_symtab *cust : objfile->compunits ())
 672       {
 673         const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
 674         int block_line_section = COMPUNIT_BLOCK_LINE_SECTION (cust);
 675
 676         if (BLOCKVECTOR_MAP (bv))
 677           addrmap_relocate (BLOCKVECTOR_MAP (bv), delta[block_line_section]);
 678
 679         for (int i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
 680           {
 681             struct block *b;
 682             struct symbol *sym;
 683             struct mdict_iterator miter;
 684
 685             b = BLOCKVECTOR_BLOCK (bv, i);
 686             BLOCK_START (b) += delta[block_line_section];
 687             BLOCK_END (b) += delta[block_line_section];
 688
 689             if (BLOCK_RANGES (b) != nullptr)
 690               for (int j = 0; j < BLOCK_NRANGES (b); j++)
 691                 {
 692                   BLOCK_RANGE_START (b, j) += delta[block_line_section];
 693                   BLOCK_RANGE_END (b, j) += delta[block_line_section];
 694                 }
 695
 696             /* We only want to iterate over the local symbols, not any
 697                symbols in included symtabs.  */
 698             ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
 699               {
 700                 relocate_one_symbol (sym, objfile, delta);
 701               }
 702           }
 703       }
 704   }
 705
 706   /* Notify the quick symbol object.  */
 707   if (objfile->qf)
 708     objfile->qf->relocated ();
 709
 710   /* Relocate isolated symbols.  */
 711   {
 712     struct symbol *iter;
 713
 714     for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
 715       relocate_one_symbol (iter, objfile, delta);
 716   }
 717
 718   {
 719     int i;
 720
 721     for (i = 0; i < objfile->section_offsets.size (); ++i)
 722       objfile->section_offsets[i] = new_offsets[i];
 723   }
 724
 725   /* Rebuild section map next time we need it.  */
 726   get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
 727
 728   /* Update the table in exec_ops, used to read memory.  */
 729   struct obj_section *s;
 730   ALL_OBJFILE_OSECTIONS (objfile, s)
 731     {
 732       int idx = s - objfile->sections;
 733
 734       exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
 735                                 obj_section_addr (s));
 736     }
 737
 738   /* Data changed.  */
 739   return 1;
 740 }
 741
 742 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
 743    entries in new_offsets.  Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
 744
 745    The number and ordering of sections does differ between the two objfiles.
 746    Only their names match.  Also the file offsets will differ (objfile being
 747    possibly prelinked but separate_debug_objfile is probably not prelinked) but
 748    the in-memory absolute address as specified by NEW_OFFSETS must match both
 749    files.  */
 750
 751 void
 752 objfile_relocate (struct objfile *objfile,
 753                   const section_offsets &new_offsets)
 754 {
 755   int changed = 0;
 756
 757   changed |= objfile_relocate1 (objfile, new_offsets);
 758
 759   for (::objfile *debug_objfile : objfile->separate_debug_objfiles ())
 760     {
 761       if (debug_objfile == objfile)
 762         continue;
 763
 764       section_addr_info objfile_addrs
 765         = build_section_addr_info_from_objfile (objfile);
 766
 767       /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
 768          relative ones must be already created according to debug_objfile.  */
 769
 770       addr_info_make_relative (&objfile_addrs, debug_objfile->obfd);
 771
 772       gdb_assert (debug_objfile->section_offsets.size ()
 773                   == gdb_bfd_count_sections (debug_objfile->obfd));
 774       section_offsets new_debug_offsets
 775         (debug_objfile->section_offsets.size ());
 776       relative_addr_info_to_section_offsets (new_debug_offsets, objfile_addrs);
 777
 778       changed |= objfile_relocate1 (debug_objfile, new_debug_offsets);
 779     }
 780
 781   /* Relocate breakpoints as necessary, after things are relocated.  */
 782   if (changed)
 783     breakpoint_re_set ();
 784 }
 785
 786 /* Rebase (add to the offsets) OBJFILE by SLIDE.  SEPARATE_DEBUG_OBJFILE is
 787    not touched here.
 788    Return non-zero iff any change happened.  */
 789
 790 static int
 791 objfile_rebase1 (struct objfile *objfile, CORE_ADDR slide)
 792 {
 793   section_offsets new_offsets (objfile->section_offsets.size (), slide);
 794   return objfile_relocate1 (objfile, new_offsets);
 795 }
 796
 797 /* Rebase (add to the offsets) OBJFILE by SLIDE.  Process also OBJFILE's
 798    SEPARATE_DEBUG_OBJFILEs.  */
 799
 800 void
 801 objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
 802 {
 803   int changed = 0;
 804
 805   for (::objfile *debug_objfile : objfile->separate_debug_objfiles ())
 806     changed |= objfile_rebase1 (debug_objfile, slide);
 807
 808   /* Relocate breakpoints as necessary, after things are relocated.  */
 809   if (changed)
 810     breakpoint_re_set ();
 811 }
 812 \f
 813 /* Return non-zero if OBJFILE has full symbols.  */
 814
 815 int
 816 objfile_has_full_symbols (struct objfile *objfile)
 817 {
 818   return objfile->compunit_symtabs != NULL;
 819 }
 820
 821 /* Return non-zero if OBJFILE has full or partial symbols, either directly
 822    or through a separate debug file.  */
 823
 824 int
 825 objfile_has_symbols (struct objfile *objfile)
 826 {
 827   for (::objfile *o : objfile->separate_debug_objfiles ())
 828     if (o->has_partial_symbols () || objfile_has_full_symbols (o))
 829       return 1;
 830   return 0;
 831 }
 832
 833
 834 /* Many places in gdb want to test just to see if we have any partial
 835    symbols available.  This function returns zero if none are currently
 836    available, nonzero otherwise.  */
 837
 838 int
 839 have_partial_symbols (void)
 840 {
 841   for (objfile *ofp : current_program_space->objfiles ())
 842     {
 843       if (ofp->has_partial_symbols ())
 844         return 1;
 845     }
 846   return 0;
 847 }
 848
 849 /* Many places in gdb want to test just to see if we have any full
 850    symbols available.  This function returns zero if none are currently
 851    available, nonzero otherwise.  */
 852
 853 int
 854 have_full_symbols (void)
 855 {
 856   for (objfile *ofp : current_program_space->objfiles ())
 857     {
 858       if (objfile_has_full_symbols (ofp))
 859         return 1;
 860     }
 861   return 0;
 862 }
 863
 864
 865 /* This operations deletes all objfile entries that represent solibs that
 866    weren't explicitly loaded by the user, via e.g., the add-symbol-file
 867    command.  */
 868
 869 void
 870 objfile_purge_solibs (void)
 871 {
 872   for (objfile *objf : current_program_space->objfiles_safe ())
 873     {
 874       /* We assume that the solib package has been purged already, or will
 875          be soon.  */
 876
 877       if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
 878         objf->unlink ();
 879     }
 880 }
 881
 882
 883 /* Many places in gdb want to test just to see if we have any minimal
 884    symbols available.  This function returns zero if none are currently
 885    available, nonzero otherwise.  */
 886
 887 int
 888 have_minimal_symbols (void)
 889 {
 890   for (objfile *ofp : current_program_space->objfiles ())
 891     {
 892       if (ofp->per_bfd->minimal_symbol_count > 0)
 893         {
 894           return 1;
 895         }
 896     }
 897   return 0;
 898 }
 899
 900 /* Qsort comparison function.  */
 901
 902 static bool
 903 sort_cmp (const struct obj_section *sect1, const obj_section *sect2)
 904 {
 905   const CORE_ADDR sect1_addr = obj_section_addr (sect1);
 906   const CORE_ADDR sect2_addr = obj_section_addr (sect2);
 907
 908   if (sect1_addr < sect2_addr)
 909     return true;
 910   else if (sect1_addr > sect2_addr)
 911     return false;
 912   else
 913     {
 914       /* Sections are at the same address.  This could happen if
 915          A) we have an objfile and a separate debuginfo.
 916          B) we are confused, and have added sections without proper relocation,
 917          or something like that.  */
 918
 919       const struct objfile *const objfile1 = sect1->objfile;
 920       const struct objfile *const objfile2 = sect2->objfile;
 921
 922       if (objfile1->separate_debug_objfile == objfile2
 923           || objfile2->separate_debug_objfile == objfile1)
 924         {
 925           /* Case A.  The ordering doesn't matter: separate debuginfo files
 926              will be filtered out later.  */
 927
 928           return false;
 929         }
 930
 931       /* Case B.  Maintain stable sort order, so bugs in GDB are easier to
 932          triage.  This section could be slow (since we iterate over all
 933          objfiles in each call to sort_cmp), but this shouldn't happen
 934          very often (GDB is already in a confused state; one hopes this
 935          doesn't happen at all).  If you discover that significant time is
 936          spent in the loops below, do 'set complaints 100' and examine the
 937          resulting complaints.  */
 938       if (objfile1 == objfile2)
 939         {
 940           /* Both sections came from the same objfile.  We are really
 941              confused.  Sort on sequence order of sections within the
 942              objfile.  The order of checks is important here, if we find a
 943              match on SECT2 first then either SECT2 is before SECT1, or,
 944              SECT2 == SECT1, in both cases we should return false.  The
 945              second case shouldn't occur during normal use, but std::sort
 946              does check that '!(a < a)' when compiled in debug mode.  */
 947
 948           const struct obj_section *osect;
 949
 950           ALL_OBJFILE_OSECTIONS (objfile1, osect)
 951             if (osect == sect2)
 952               return false;
 953             else if (osect == sect1)
 954               return true;
 955
 956           /* We should have found one of the sections before getting here.  */
 957           gdb_assert_not_reached ("section not found");
 958         }
 959       else
 960         {
 961           /* Sort on sequence number of the objfile in the chain.  */
 962
 963           for (objfile *objfile : current_program_space->objfiles ())
 964             if (objfile == objfile1)
 965               return true;
 966             else if (objfile == objfile2)
 967               return false;
 968
 969           /* We should have found one of the objfiles before getting here.  */
 970           gdb_assert_not_reached ("objfile not found");
 971         }
 972     }
 973
 974   /* Unreachable.  */
 975   gdb_assert_not_reached ("unexpected code path");
 976   return false;
 977 }
 978
 979 /* Select "better" obj_section to keep.  We prefer the one that came from
 980    the real object, rather than the one from separate debuginfo.
 981    Most of the time the two sections are exactly identical, but with
 982    prelinking the .rel.dyn section in the real object may have different
 983    size.  */
 984
 985 static struct obj_section *
 986 preferred_obj_section (struct obj_section *a, struct obj_section *b)
 987 {
 988   gdb_assert (obj_section_addr (a) == obj_section_addr (b));
 989   gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
 990               || (b->objfile->separate_debug_objfile == a->objfile));
 991   gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
 992               || (b->objfile->separate_debug_objfile_backlink == a->objfile));
 993
 994   if (a->objfile->separate_debug_objfile != NULL)
 995     return a;
 996   return b;
 997 }
 998
 999 /* Return 1 if SECTION should be inserted into the section map.
1000    We want to insert only non-overlay and non-TLS section.  */
1001
1002 static int
1003 insert_section_p (const struct bfd *abfd,
1004                   const struct bfd_section *section)
1005 {
1006   const bfd_vma lma = bfd_section_lma (section);
1007
1008   if (overlay_debugging && lma != 0 && lma != bfd_section_vma (section)
1009       && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1010     /* This is an overlay section.  IN_MEMORY check is needed to avoid
1011        discarding sections from the "system supplied DSO" (aka vdso)
1012        on some Linux systems (e.g. Fedora 11).  */
1013     return 0;
1014   if ((bfd_section_flags (section) & SEC_THREAD_LOCAL) != 0)
1015     /* This is a TLS section.  */
1016     return 0;
1017
1018   return 1;
1019 }
1020
1021 /* Filter out overlapping sections where one section came from the real
1022    objfile, and the other from a separate debuginfo file.
1023    Return the size of table after redundant sections have been eliminated.  */
1024
1025 static int
1026 filter_debuginfo_sections (struct obj_section **map, int map_size)
1027 {
1028   int i, j;
1029
1030   for (i = 0, j = 0; i < map_size - 1; i++)
1031     {
1032       struct obj_section *const sect1 = map[i];
1033       struct obj_section *const sect2 = map[i + 1];
1034       const struct objfile *const objfile1 = sect1->objfile;
1035       const struct objfile *const objfile2 = sect2->objfile;
1036       const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1037       const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1038
1039       if (sect1_addr == sect2_addr
1040           && (objfile1->separate_debug_objfile == objfile2
1041               || objfile2->separate_debug_objfile == objfile1))
1042         {
1043           map[j++] = preferred_obj_section (sect1, sect2);
1044           ++i;
1045         }
1046       else
1047         map[j++] = sect1;
1048     }
1049
1050   if (i < map_size)
1051     {
1052       gdb_assert (i == map_size - 1);
1053       map[j++] = map[i];
1054     }
1055
1056   /* The map should not have shrunk to less than half the original size.  */
1057   gdb_assert (map_size / 2 <= j);
1058
1059   return j;
1060 }
1061
1062 /* Filter out overlapping sections, issuing a warning if any are found.
1063    Overlapping sections could really be overlay sections which we didn't
1064    classify as such in insert_section_p, or we could be dealing with a
1065    corrupt binary.  */
1066
1067 static int
1068 filter_overlapping_sections (struct obj_section **map, int map_size)
1069 {
1070   int i, j;
1071
1072   for (i = 0, j = 0; i < map_size - 1; )
1073     {
1074       int k;
1075
1076       map[j++] = map[i];
1077       for (k = i + 1; k < map_size; k++)
1078         {
1079           struct obj_section *const sect1 = map[i];
1080           struct obj_section *const sect2 = map[k];
1081           const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1082           const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1083           const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
1084
1085           gdb_assert (sect1_addr <= sect2_addr);
1086
1087           if (sect1_endaddr <= sect2_addr)
1088             break;
1089           else
1090             {
1091               /* We have an overlap.  Report it.  */
1092
1093               struct objfile *const objf1 = sect1->objfile;
1094               struct objfile *const objf2 = sect2->objfile;
1095
1096               const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1097               const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1098
1099               const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
1100
1101               struct gdbarch *const gdbarch = objf1->arch ();
1102
1103               complaint (_("unexpected overlap between:\n"
1104                            " (A) section `%s' from `%s' [%s, %s)\n"
1105                            " (B) section `%s' from `%s' [%s, %s).\n"
1106                            "Will ignore section B"),
1107                          bfd_section_name (bfds1), objfile_name (objf1),
1108                          paddress (gdbarch, sect1_addr),
1109                          paddress (gdbarch, sect1_endaddr),
1110                          bfd_section_name (bfds2), objfile_name (objf2),
1111                          paddress (gdbarch, sect2_addr),
1112                          paddress (gdbarch, sect2_endaddr));
1113             }
1114         }
1115       i = k;
1116     }
1117
1118   if (i < map_size)
1119     {
1120       gdb_assert (i == map_size - 1);
1121       map[j++] = map[i];
1122     }
1123
1124   return j;
1125 }
1126
1127
1128 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1129    TLS, overlay and overlapping sections.  */
1130
1131 static void
1132 update_section_map (struct program_space *pspace,
1133                     struct obj_section ***pmap, int *pmap_size)
1134 {
1135   struct objfile_pspace_info *pspace_info;
1136   int alloc_size, map_size, i;
1137   struct obj_section *s, **map;
1138
1139   pspace_info = get_objfile_pspace_data (pspace);
1140   gdb_assert (pspace_info->section_map_dirty != 0
1141               || pspace_info->new_objfiles_available != 0);
1142
1143   map = *pmap;
1144   xfree (map);
1145
1146   alloc_size = 0;
1147   for (objfile *objfile : pspace->objfiles ())
1148     ALL_OBJFILE_OSECTIONS (objfile, s)
1149       if (insert_section_p (objfile->obfd, s->the_bfd_section))
1150         alloc_size += 1;
1151
1152   /* This happens on detach/attach (e.g. in gdb.base/attach.exp).  */
1153   if (alloc_size == 0)
1154     {
1155       *pmap = NULL;
1156       *pmap_size = 0;
1157       return;
1158     }
1159
1160   map = XNEWVEC (struct obj_section *, alloc_size);
1161
1162   i = 0;
1163   for (objfile *objfile : pspace->objfiles ())
1164     ALL_OBJFILE_OSECTIONS (objfile, s)
1165       if (insert_section_p (objfile->obfd, s->the_bfd_section))
1166         map[i++] = s;
1167
1168   std::sort (map, map + alloc_size, sort_cmp);
1169   map_size = filter_debuginfo_sections(map, alloc_size);
1170   map_size = filter_overlapping_sections(map, map_size);
1171
1172   if (map_size < alloc_size)
1173     /* Some sections were eliminated.  Trim excess space.  */
1174     map = XRESIZEVEC (struct obj_section *, map, map_size);
1175   else
1176     gdb_assert (alloc_size == map_size);
1177
1178   *pmap = map;
1179   *pmap_size = map_size;
1180 }
1181
1182 /* Bsearch comparison function.  */
1183
1184 static int
1185 bsearch_cmp (const void *key, const void *elt)
1186 {
1187   const CORE_ADDR pc = *(CORE_ADDR *) key;
1188   const struct obj_section *section = *(const struct obj_section **) elt;
1189
1190   if (pc < obj_section_addr (section))
1191     return -1;
1192   if (pc < obj_section_endaddr (section))
1193     return 0;
1194   return 1;
1195 }
1196
1197 /* Returns a section whose range includes PC or NULL if none found.   */
1198
1199 struct obj_section *
1200 find_pc_section (CORE_ADDR pc)
1201 {
1202   struct objfile_pspace_info *pspace_info;
1203   struct obj_section *s, **sp;
1204
1205   /* Check for mapped overlay section first.  */
1206   s = find_pc_mapped_section (pc);
1207   if (s)
1208     return s;
1209
1210   pspace_info = get_objfile_pspace_data (current_program_space);
1211   if (pspace_info->section_map_dirty
1212       || (pspace_info->new_objfiles_available
1213           && !pspace_info->inhibit_updates))
1214     {
1215       update_section_map (current_program_space,
1216                           &pspace_info->sections,
1217                           &pspace_info->num_sections);
1218
1219       /* Don't need updates to section map until objfiles are added,
1220          removed or relocated.  */
1221       pspace_info->new_objfiles_available = 0;
1222       pspace_info->section_map_dirty = 0;
1223     }
1224
1225   /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1226      bsearch be non-NULL.  */
1227   if (pspace_info->sections == NULL)
1228     {
1229       gdb_assert (pspace_info->num_sections == 0);
1230       return NULL;
1231     }
1232
1233   sp = (struct obj_section **) bsearch (&pc,
1234                                         pspace_info->sections,
1235                                         pspace_info->num_sections,
1236                                         sizeof (*pspace_info->sections),
1237                                         bsearch_cmp);
1238   if (sp != NULL)
1239     return *sp;
1240   return NULL;
1241 }
1242
1243
1244 /* Return non-zero if PC is in a section called NAME.  */
1245
1246 int
1247 pc_in_section (CORE_ADDR pc, const char *name)
1248 {
1249   struct obj_section *s;
1250   int retval = 0;
1251
1252   s = find_pc_section (pc);
1253
1254   retval = (s != NULL
1255             && s->the_bfd_section->name != NULL
1256             && strcmp (s->the_bfd_section->name, name) == 0);
1257   return (retval);
1258 }
1259 \f
1260
1261 /* Set section_map_dirty so section map will be rebuilt next time it
1262    is used.  Called by reread_symbols.  */
1263
1264 void
1265 objfiles_changed (void)
1266 {
1267   /* Rebuild section map next time we need it.  */
1268   get_objfile_pspace_data (current_program_space)->section_map_dirty = 1;
1269 }
1270
1271 /* See comments in objfiles.h.  */
1272
1273 scoped_restore_tmpl<int>
1274 inhibit_section_map_updates (struct program_space *pspace)
1275 {
1276   return scoped_restore_tmpl<int>
1277     (&get_objfile_pspace_data (pspace)->inhibit_updates, 1);
1278 }
1279
1280 /* See objfiles.h.  */
1281
1282 bool
1283 is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile)
1284 {
1285   struct obj_section *osect;
1286
1287   if (objfile == NULL)
1288     return false;
1289
1290   ALL_OBJFILE_OSECTIONS (objfile, osect)
1291     {
1292       if (section_is_overlay (osect) && !section_is_mapped (osect))
1293         continue;
1294
1295       if (obj_section_addr (osect) <= addr
1296           && addr < obj_section_endaddr (osect))
1297         return true;
1298     }
1299   return false;
1300 }
1301
1302 /* See objfiles.h.  */
1303
1304 bool
1305 shared_objfile_contains_address_p (struct program_space *pspace,
1306                                    CORE_ADDR address)
1307 {
1308   for (objfile *objfile : pspace->objfiles ())
1309     {
1310       if ((objfile->flags & OBJF_SHARED) != 0
1311           && is_addr_in_objfile (address, objfile))
1312         return true;
1313     }
1314
1315   return false;
1316 }
1317
1318 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1319    gdbarch method.  It is equivalent to use the objfiles iterable,
1320    searching the objfiles in the order they are stored internally,
1321    ignoring CURRENT_OBJFILE.
1322
1323    On most platforms, it should be close enough to doing the best
1324    we can without some knowledge specific to the architecture.  */
1325
1326 void
1327 default_iterate_over_objfiles_in_search_order
1328   (struct gdbarch *gdbarch,
1329    iterate_over_objfiles_in_search_order_cb_ftype *cb,
1330    void *cb_data, struct objfile *current_objfile)
1331 {
1332   int stop = 0;
1333
1334   for (objfile *objfile : current_program_space->objfiles ())
1335     {
1336        stop = cb (objfile, cb_data);
1337        if (stop)
1338          return;
1339     }
1340 }
1341
1342 /* See objfiles.h.  */
1343
1344 const char *
1345 objfile_name (const struct objfile *objfile)
1346 {
1347   if (objfile->obfd != NULL)
1348     return bfd_get_filename (objfile->obfd);
1349
1350   return objfile->original_name;
1351 }
1352
1353 /* See objfiles.h.  */
1354
1355 const char *
1356 objfile_filename (const struct objfile *objfile)
1357 {
1358   if (objfile->obfd != NULL)
1359     return bfd_get_filename (objfile->obfd);
1360
1361   return NULL;
1362 }
1363
1364 /* See objfiles.h.  */
1365
1366 const char *
1367 objfile_debug_name (const struct objfile *objfile)
1368 {
1369   return lbasename (objfile->original_name);
1370 }
1371
1372 /* See objfiles.h.  */
1373
1374 const char *
1375 objfile_flavour_name (struct objfile *objfile)
1376 {
1377   if (objfile->obfd != NULL)
1378     return bfd_flavour_name (bfd_get_flavour (objfile->obfd));
1379   return NULL;
1380 }