gdb/objfiles.c

   1 /* GDB routines for manipulating objfiles.
   2
   3    Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   4    2001, 2002, 2003 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 2 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, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 /* This file contains support routines for creating, manipulating, and
  26    destroying objfile structures. */
  27
  28 #include "defs.h"
  29 #include "bfd.h"                /* Binary File Description */
  30 #include "symtab.h"
  31 #include "symfile.h"
  32 #include "objfiles.h"
  33 #include "gdb-stabs.h"
  34 #include "target.h"
  35 #include "bcache.h"
  36
  37 #include "gdb_assert.h"
  38 #include <sys/types.h>
  39 #include "gdb_stat.h"
  40 #include <fcntl.h>
  41 #include "gdb_obstack.h"
  42 #include "gdb_string.h"
  43 #include "hashtab.h"
  44
  45 #include "breakpoint.h"
  46 #include "block.h"
  47 #include "dictionary.h"
  48
  49 /* Prototypes for local functions */
  50
  51 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
  52
  53 #include "mmalloc.h"
  54
  55 static int open_existing_mapped_file (char *, long, int);
  56
  57 static int open_mapped_file (char *filename, long mtime, int flags);
  58
  59 static void *map_to_file (int);
  60
  61 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
  62
  63 static void add_to_objfile_sections (bfd *, sec_ptr, void *);
  64
  65 static void objfile_alloc_data (struct objfile *objfile);
  66 static void objfile_free_data (struct objfile *objfile);
  67
  68 /* Externally visible variables that are owned by this module.
  69    See declarations in objfile.h for more info. */
  70
  71 struct objfile *object_files;   /* Linked list of all objfiles */
  72 struct objfile *current_objfile;        /* For symbol file being read in */
  73 struct objfile *symfile_objfile;        /* Main symbol table loaded from */
  74 struct objfile *rt_common_objfile;      /* For runtime common symbols */
  75
  76 int mapped_symbol_files;        /* Try to use mapped symbol files */
  77
  78 /* Locate all mappable sections of a BFD file.
  79    objfile_p_char is a char * to get it through
  80    bfd_map_over_sections; we cast it back to its proper type.  */
  81
  82 #ifndef TARGET_KEEP_SECTION
  83 #define TARGET_KEEP_SECTION(ASECT)      0
  84 #endif
  85
  86 /* Called via bfd_map_over_sections to build up the section table that
  87    the objfile references.  The objfile contains pointers to the start
  88    of the table (objfile->sections) and to the first location after
  89    the end of the table (objfile->sections_end). */
  90
  91 static void
  92 add_to_objfile_sections (bfd *abfd, sec_ptr asect, void *objfile_p_char)
  93 {
  94   struct objfile *objfile = (struct objfile *) objfile_p_char;
  95   struct obj_section section;
  96   flagword aflag;
  97
  98   aflag = bfd_get_section_flags (abfd, asect);
  99
 100   if (!(aflag & SEC_ALLOC) && !(TARGET_KEEP_SECTION (asect)))
 101     return;
 102
 103   if (0 == bfd_section_size (abfd, asect))
 104     return;
 105   section.offset = 0;
 106   section.objfile = objfile;
 107   section.the_bfd_section = asect;
 108   section.ovly_mapped = 0;
 109   section.addr = bfd_section_vma (abfd, asect);
 110   section.endaddr = section.addr + bfd_section_size (abfd, asect);
 111   obstack_grow (&objfile->psymbol_obstack, (char *) &section, sizeof (section));
 112   objfile->sections_end = (struct obj_section *) (((unsigned long) objfile->sections_end) + 1);
 113 }
 114
 115 /* Builds a section table for OBJFILE.
 116    Returns 0 if OK, 1 on error (in which case bfd_error contains the
 117    error).
 118
 119    Note that while we are building the table, which goes into the
 120    psymbol obstack, we hijack the sections_end pointer to instead hold
 121    a count of the number of sections.  When bfd_map_over_sections
 122    returns, this count is used to compute the pointer to the end of
 123    the sections table, which then overwrites the count.
 124
 125    Also note that the OFFSET and OVLY_MAPPED in each table entry
 126    are initialized to zero.
 127
 128    Also note that if anything else writes to the psymbol obstack while
 129    we are building the table, we're pretty much hosed. */
 130
 131 int
 132 build_objfile_section_table (struct objfile *objfile)
 133 {
 134   /* objfile->sections can be already set when reading a mapped symbol
 135      file.  I believe that we do need to rebuild the section table in
 136      this case (we rebuild other things derived from the bfd), but we
 137      can't free the old one (it's in the psymbol_obstack).  So we just
 138      waste some memory.  */
 139
 140   objfile->sections_end = 0;
 141   bfd_map_over_sections (objfile->obfd, add_to_objfile_sections, (char *) objfile);
 142   objfile->sections = (struct obj_section *)
 143     obstack_finish (&objfile->psymbol_obstack);
 144   objfile->sections_end = objfile->sections + (unsigned long) objfile->sections_end;
 145   return (0);
 146 }
 147
 148 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
 149    allocate a new objfile struct, fill it in as best we can, link it
 150    into the list of all known objfiles, and return a pointer to the
 151    new objfile struct.
 152
 153    The FLAGS word contains various bits (OBJF_*) that can be taken as
 154    requests for specific operations, like trying to open a mapped
 155    version of the objfile (OBJF_MAPPED).  Other bits like
 156    OBJF_SHARED are simply copied through to the new objfile flags
 157    member. */
 158
 159 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
 160    by jv-lang.c, to create an artificial objfile used to hold
 161    information about dynamically-loaded Java classes.  Unfortunately,
 162    that branch of this function doesn't get tested very frequently, so
 163    it's prone to breakage.  (E.g. at one time the name was set to NULL
 164    in that situation, which broke a loop over all names in the dynamic
 165    library loader.)  If you change this function, please try to leave
 166    things in a consistent state even if abfd is NULL.  */
 167
 168 struct objfile *
 169 allocate_objfile (bfd *abfd, int flags)
 170 {
 171   struct objfile *objfile = NULL;
 172   struct objfile *last_one = NULL;
 173
 174   if (mapped_symbol_files)
 175     flags |= OBJF_MAPPED;
 176
 177 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
 178   if (abfd != NULL)
 179     {
 180
 181       /* If we can support mapped symbol files, try to open/reopen the
 182          mapped file that corresponds to the file from which we wish to
 183          read symbols.  If the objfile is to be mapped, we must malloc
 184          the structure itself using the mmap version, and arrange that
 185          all memory allocation for the objfile uses the mmap routines.
 186          If we are reusing an existing mapped file, from which we get
 187          our objfile pointer, we have to make sure that we update the
 188          pointers to the alloc/free functions in the obstack, in case
 189          these functions have moved within the current gdb.  */
 190
 191       int fd;
 192
 193       fd = open_mapped_file (bfd_get_filename (abfd), bfd_get_mtime (abfd),
 194                              flags);
 195       if (fd >= 0)
 196         {
 197           void *md;
 198
 199           if ((md = map_to_file (fd)) == NULL)
 200             {
 201               close (fd);
 202             }
 203           else if ((objfile = (struct objfile *) mmalloc_getkey (md, 0)) != NULL)
 204             {
 205               /* Update memory corruption handler function addresses. */
 206               init_malloc (md);
 207               objfile->md = md;
 208               objfile->mmfd = fd;
 209               /* Update pointers to functions to *our* copies */
 210               if (objfile->demangled_names_hash)
 211                 htab_set_functions_ex
 212                   (objfile->demangled_names_hash, htab_hash_string,
 213                    (int (*) (const void *, const void *)) streq, NULL,
 214                    objfile->md, xmcalloc, xmfree);
 215               obstack_chunkfun (&objfile->psymbol_cache.cache, xmmalloc);
 216               obstack_freefun (&objfile->psymbol_cache.cache, xmfree);
 217               obstack_chunkfun (&objfile->macro_cache.cache, xmmalloc);
 218               obstack_freefun (&objfile->macro_cache.cache, xmfree);
 219               obstack_chunkfun (&objfile->psymbol_obstack, xmmalloc);
 220               obstack_freefun (&objfile->psymbol_obstack, xmfree);
 221               obstack_chunkfun (&objfile->symbol_obstack, xmmalloc);
 222               obstack_freefun (&objfile->symbol_obstack, xmfree);
 223               obstack_chunkfun (&objfile->type_obstack, xmmalloc);
 224               obstack_freefun (&objfile->type_obstack, xmfree);
 225               /* If already in objfile list, unlink it. */
 226               unlink_objfile (objfile);
 227               /* Forget things specific to a particular gdb, may have changed. */
 228               objfile->sf = NULL;
 229             }
 230           else
 231             {
 232
 233               /* Set up to detect internal memory corruption.  MUST be
 234                  done before the first malloc.  See comments in
 235                  init_malloc() and mmcheck().  */
 236
 237               init_malloc (md);
 238
 239               objfile = (struct objfile *)
 240                 xmmalloc (md, sizeof (struct objfile));
 241               memset (objfile, 0, sizeof (struct objfile));
 242               objfile->md = md;
 243               objfile->mmfd = fd;
 244               objfile->flags |= OBJF_MAPPED;
 245               mmalloc_setkey (objfile->md, 0, objfile);
 246               obstack_specify_allocation_with_arg (&objfile->psymbol_cache.cache,
 247                                                    0, 0, xmmalloc, xmfree,
 248                                                    objfile->md);
 249               obstack_specify_allocation_with_arg (&objfile->macro_cache.cache,
 250                                                    0, 0, xmmalloc, xmfree,
 251                                                    objfile->md);
 252               obstack_specify_allocation_with_arg (&objfile->psymbol_obstack,
 253                                                    0, 0, xmmalloc, xmfree,
 254                                                    objfile->md);
 255               obstack_specify_allocation_with_arg (&objfile->symbol_obstack,
 256                                                    0, 0, xmmalloc, xmfree,
 257                                                    objfile->md);
 258               obstack_specify_allocation_with_arg (&objfile->type_obstack,
 259                                                    0, 0, xmmalloc, xmfree,
 260                                                    objfile->md);
 261             }
 262         }
 263
 264       if ((flags & OBJF_MAPPED) && (objfile == NULL))
 265         {
 266           warning ("symbol table for '%s' will not be mapped",
 267                    bfd_get_filename (abfd));
 268           flags &= ~OBJF_MAPPED;
 269         }
 270     }
 271 #else /* !defined(USE_MMALLOC) || !defined(HAVE_MMAP) */
 272
 273   if (flags & OBJF_MAPPED)
 274     {
 275       warning ("mapped symbol tables are not supported on this machine; missing or broken mmap().");
 276
 277       /* Turn off the global flag so we don't try to do mapped symbol tables
 278          any more, which shuts up gdb unless the user specifically gives the
 279          "mapped" keyword again. */
 280
 281       mapped_symbol_files = 0;
 282       flags &= ~OBJF_MAPPED;
 283     }
 284
 285 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
 286
 287   /* If we don't support mapped symbol files, didn't ask for the file to be
 288      mapped, or failed to open the mapped file for some reason, then revert
 289      back to an unmapped objfile. */
 290
 291   if (objfile == NULL)
 292     {
 293       objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
 294       memset (objfile, 0, sizeof (struct objfile));
 295       objfile->md = NULL;
 296       objfile->psymbol_cache = bcache_xmalloc ();
 297       objfile->macro_cache = bcache_xmalloc ();
 298       obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0, xmalloc,
 299                                   xfree);
 300       obstack_specify_allocation (&objfile->symbol_obstack, 0, 0, xmalloc,
 301                                   xfree);
 302       obstack_specify_allocation (&objfile->type_obstack, 0, 0, xmalloc,
 303                                   xfree);
 304       flags &= ~OBJF_MAPPED;
 305
 306       terminate_minimal_symbol_table (objfile);
 307     }
 308
 309   objfile_alloc_data (objfile);
 310
 311   /* Update the per-objfile information that comes from the bfd, ensuring
 312      that any data that is reference is saved in the per-objfile data
 313      region. */
 314
 315   objfile->obfd = abfd;
 316   if (objfile->name != NULL)
 317     {
 318       xmfree (objfile->md, objfile->name);
 319     }
 320   if (abfd != NULL)
 321     {
 322       objfile->name = mstrsave (objfile->md, bfd_get_filename (abfd));
 323       objfile->mtime = bfd_get_mtime (abfd);
 324
 325       /* Build section table.  */
 326
 327       if (build_objfile_section_table (objfile))
 328         {
 329           error ("Can't find the file sections in `%s': %s",
 330                  objfile->name, bfd_errmsg (bfd_get_error ()));
 331         }
 332     }
 333   else
 334     {
 335       objfile->name = mstrsave (objfile->md, "<<anonymous objfile>>");
 336     }
 337
 338   /* Initialize the section indexes for this objfile, so that we can
 339      later detect if they are used w/o being properly assigned to. */
 340
 341   objfile->sect_index_text = -1;
 342   objfile->sect_index_data = -1;
 343   objfile->sect_index_bss = -1;
 344   objfile->sect_index_rodata = -1;
 345
 346   /* We don't yet have a C++-specific namespace symtab.  */
 347
 348   objfile->cp_namespace_symtab = NULL;
 349
 350   /* Add this file onto the tail of the linked list of other such files. */
 351
 352   objfile->next = NULL;
 353   if (object_files == NULL)
 354     object_files = objfile;
 355   else
 356     {
 357       for (last_one = object_files;
 358            last_one->next;
 359            last_one = last_one->next);
 360       last_one->next = objfile;
 361     }
 362
 363   /* Save passed in flag bits. */
 364   objfile->flags |= flags;
 365
 366   return (objfile);
 367 }
 368
 369
 370 /* Create the terminating entry of OBJFILE's minimal symbol table.
 371    If OBJFILE->msymbols is zero, allocate a single entry from
 372    OBJFILE->symbol_obstack; otherwise, just initialize
 373    OBJFILE->msymbols[OBJFILE->minimal_symbol_count].  */
 374 void
 375 terminate_minimal_symbol_table (struct objfile *objfile)
 376 {
 377   if (! objfile->msymbols)
 378     objfile->msymbols = ((struct minimal_symbol *)
 379                          obstack_alloc (&objfile->symbol_obstack,
 380                                         sizeof (objfile->msymbols[0])));
 381
 382   {
 383     struct minimal_symbol *m
 384       = &objfile->msymbols[objfile->minimal_symbol_count];
 385
 386     memset (m, 0, sizeof (*m));
 387     DEPRECATED_SYMBOL_NAME (m) = NULL;
 388     SYMBOL_VALUE_ADDRESS (m) = 0;
 389     MSYMBOL_INFO (m) = NULL;
 390     MSYMBOL_TYPE (m) = mst_unknown;
 391     SYMBOL_INIT_LANGUAGE_SPECIFIC (m, language_unknown);
 392   }
 393 }
 394
 395
 396 /* Put one object file before a specified on in the global list.
 397    This can be used to make sure an object file is destroyed before
 398    another when using ALL_OBJFILES_SAFE to free all objfiles. */
 399 void
 400 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
 401 {
 402   struct objfile **objp;
 403
 404   unlink_objfile (objfile);
 405
 406   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
 407     {
 408       if (*objp == before_this)
 409         {
 410           objfile->next = *objp;
 411           *objp = objfile;
 412           return;
 413         }
 414     }
 415
 416   internal_error (__FILE__, __LINE__,
 417                   "put_objfile_before: before objfile not in list");
 418 }
 419
 420 /* Put OBJFILE at the front of the list.  */
 421
 422 void
 423 objfile_to_front (struct objfile *objfile)
 424 {
 425   struct objfile **objp;
 426   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
 427     {
 428       if (*objp == objfile)
 429         {
 430           /* Unhook it from where it is.  */
 431           *objp = objfile->next;
 432           /* Put it in the front.  */
 433           objfile->next = object_files;
 434           object_files = objfile;
 435           break;
 436         }
 437     }
 438 }
 439
 440 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
 441    list.
 442
 443    It is not a bug, or error, to call this function if OBJFILE is not known
 444    to be in the current list.  This is done in the case of mapped objfiles,
 445    for example, just to ensure that the mapped objfile doesn't appear twice
 446    in the list.  Since the list is threaded, linking in a mapped objfile
 447    twice would create a circular list.
 448
 449    If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
 450    unlinking it, just to ensure that we have completely severed any linkages
 451    between the OBJFILE and the list. */
 452
 453 void
 454 unlink_objfile (struct objfile *objfile)
 455 {
 456   struct objfile **objpp;
 457
 458   for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
 459     {
 460       if (*objpp == objfile)
 461         {
 462           *objpp = (*objpp)->next;
 463           objfile->next = NULL;
 464           return;
 465         }
 466     }
 467
 468   internal_error (__FILE__, __LINE__,
 469                   "unlink_objfile: objfile already unlinked");
 470 }
 471
 472
 473 /* Destroy an objfile and all the symtabs and psymtabs under it.  Note
 474    that as much as possible is allocated on the symbol_obstack and
 475    psymbol_obstack, so that the memory can be efficiently freed.
 476
 477    Things which we do NOT free because they are not in malloc'd memory
 478    or not in memory specific to the objfile include:
 479
 480    objfile -> sf
 481
 482    FIXME:  If the objfile is using reusable symbol information (via mmalloc),
 483    then we need to take into account the fact that more than one process
 484    may be using the symbol information at the same time (when mmalloc is
 485    extended to support cooperative locking).  When more than one process
 486    is using the mapped symbol info, we need to be more careful about when
 487    we free objects in the reusable area. */
 488
 489 void
 490 free_objfile (struct objfile *objfile)
 491 {
 492   if (objfile->separate_debug_objfile)
 493     {
 494       free_objfile (objfile->separate_debug_objfile);
 495     }
 496
 497   if (objfile->separate_debug_objfile_backlink)
 498     {
 499       /* We freed the separate debug file, make sure the base objfile
 500          doesn't reference it.  */
 501       objfile->separate_debug_objfile_backlink->separate_debug_objfile = NULL;
 502     }
 503
 504   /* First do any symbol file specific actions required when we are
 505      finished with a particular symbol file.  Note that if the objfile
 506      is using reusable symbol information (via mmalloc) then each of
 507      these routines is responsible for doing the correct thing, either
 508      freeing things which are valid only during this particular gdb
 509      execution, or leaving them to be reused during the next one. */
 510
 511   if (objfile->sf != NULL)
 512     {
 513       (*objfile->sf->sym_finish) (objfile);
 514     }
 515
 516   /* We always close the bfd. */
 517
 518   if (objfile->obfd != NULL)
 519     {
 520       char *name = bfd_get_filename (objfile->obfd);
 521       if (!bfd_close (objfile->obfd))
 522         warning ("cannot close \"%s\": %s",
 523                  name, bfd_errmsg (bfd_get_error ()));
 524       xfree (name);
 525     }
 526
 527   /* Remove it from the chain of all objfiles. */
 528
 529   unlink_objfile (objfile);
 530
 531   /* If we are going to free the runtime common objfile, mark it
 532      as unallocated.  */
 533
 534   if (objfile == rt_common_objfile)
 535     rt_common_objfile = NULL;
 536
 537   /* Before the symbol table code was redone to make it easier to
 538      selectively load and remove information particular to a specific
 539      linkage unit, gdb used to do these things whenever the monolithic
 540      symbol table was blown away.  How much still needs to be done
 541      is unknown, but we play it safe for now and keep each action until
 542      it is shown to be no longer needed. */
 543
 544   /* I *think* all our callers call clear_symtab_users.  If so, no need
 545      to call this here.  */
 546   clear_pc_function_cache ();
 547
 548   /* The last thing we do is free the objfile struct itself for the
 549      non-reusable case, or detach from the mapped file for the
 550      reusable case.  Note that the mmalloc_detach or the xmfree() is
 551      the last thing we can do with this objfile. */
 552
 553 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
 554
 555   if (objfile->flags & OBJF_MAPPED)
 556     {
 557       /* Remember the fd so we can close it.  We can't close it before
 558          doing the detach, and after the detach the objfile is gone. */
 559       int mmfd;
 560
 561       mmfd = objfile->mmfd;
 562       mmalloc_detach (objfile->md);
 563       objfile = NULL;
 564       close (mmfd);
 565     }
 566
 567 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
 568
 569   /* If we still have an objfile, then either we don't support reusable
 570      objfiles or this one was not reusable.  So free it normally. */
 571
 572   if (objfile != NULL)
 573     {
 574       objfile_free_data (objfile);
 575       if (objfile->name != NULL)
 576         {
 577           xmfree (objfile->md, objfile->name);
 578         }
 579       if (objfile->global_psymbols.list)
 580         xmfree (objfile->md, objfile->global_psymbols.list);
 581       if (objfile->static_psymbols.list)
 582         xmfree (objfile->md, objfile->static_psymbols.list);
 583       /* Free the obstacks for non-reusable objfiles */
 584       bcache_xfree (objfile->psymbol_cache);
 585       bcache_xfree (objfile->macro_cache);
 586       if (objfile->demangled_names_hash)
 587         htab_delete (objfile->demangled_names_hash);
 588       obstack_free (&objfile->psymbol_obstack, 0);
 589       obstack_free (&objfile->symbol_obstack, 0);
 590       obstack_free (&objfile->type_obstack, 0);
 591       xmfree (objfile->md, objfile);
 592       objfile = NULL;
 593     }
 594 }
 595
 596 static void
 597 do_free_objfile_cleanup (void *obj)
 598 {
 599   free_objfile (obj);
 600 }
 601
 602 struct cleanup *
 603 make_cleanup_free_objfile (struct objfile *obj)
 604 {
 605   return make_cleanup (do_free_objfile_cleanup, obj);
 606 }
 607
 608 /* Free all the object files at once and clean up their users.  */
 609
 610 void
 611 free_all_objfiles (void)
 612 {
 613   struct objfile *objfile, *temp;
 614
 615   ALL_OBJFILES_SAFE (objfile, temp)
 616   {
 617     free_objfile (objfile);
 618   }
 619   clear_symtab_users ();
 620 }
 621 \f
 622 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
 623    entries in new_offsets.  */
 624 void
 625 objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets)
 626 {
 627   struct section_offsets *delta =
 628     ((struct section_offsets *)
 629      alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
 630
 631   {
 632     int i;
 633     int something_changed = 0;
 634     for (i = 0; i < objfile->num_sections; ++i)
 635       {
 636         delta->offsets[i] =
 637           ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
 638         if (ANOFFSET (delta, i) != 0)
 639           something_changed = 1;
 640       }
 641     if (!something_changed)
 642       return;
 643   }
 644
 645   /* OK, get all the symtabs.  */
 646   {
 647     struct symtab *s;
 648
 649     ALL_OBJFILE_SYMTABS (objfile, s)
 650     {
 651       struct linetable *l;
 652       struct blockvector *bv;
 653       int i;
 654
 655       /* First the line table.  */
 656       l = LINETABLE (s);
 657       if (l)
 658         {
 659           for (i = 0; i < l->nitems; ++i)
 660             l->item[i].pc += ANOFFSET (delta, s->block_line_section);
 661         }
 662
 663       /* Don't relocate a shared blockvector more than once.  */
 664       if (!s->primary)
 665         continue;
 666
 667       bv = BLOCKVECTOR (s);
 668       for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
 669         {
 670           struct block *b;
 671           struct symbol *sym;
 672           struct dict_iterator iter;
 673
 674           b = BLOCKVECTOR_BLOCK (bv, i);
 675           BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
 676           BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
 677
 678           ALL_BLOCK_SYMBOLS (b, iter, sym)
 679             {
 680               fixup_symbol_section (sym, objfile);
 681
 682               /* The RS6000 code from which this was taken skipped
 683                  any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
 684                  But I'm leaving out that test, on the theory that
 685                  they can't possibly pass the tests below.  */
 686               if ((SYMBOL_CLASS (sym) == LOC_LABEL
 687                    || SYMBOL_CLASS (sym) == LOC_STATIC
 688                    || SYMBOL_CLASS (sym) == LOC_INDIRECT)
 689                   && SYMBOL_SECTION (sym) >= 0)
 690                 {
 691                   SYMBOL_VALUE_ADDRESS (sym) +=
 692                     ANOFFSET (delta, SYMBOL_SECTION (sym));
 693                 }
 694 #ifdef MIPS_EFI_SYMBOL_NAME
 695               /* Relocate Extra Function Info for ecoff.  */
 696
 697               else if (SYMBOL_CLASS (sym) == LOC_CONST
 698                        && SYMBOL_DOMAIN (sym) == LABEL_DOMAIN
 699                        && strcmp (DEPRECATED_SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0)
 700                 ecoff_relocate_efi (sym, ANOFFSET (delta,
 701                                                    s->block_line_section));
 702 #endif
 703             }
 704         }
 705     }
 706   }
 707
 708   {
 709     struct partial_symtab *p;
 710
 711     ALL_OBJFILE_PSYMTABS (objfile, p)
 712     {
 713       p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 714       p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 715     }
 716   }
 717
 718   {
 719     struct partial_symbol **psym;
 720
 721     for (psym = objfile->global_psymbols.list;
 722          psym < objfile->global_psymbols.next;
 723          psym++)
 724       {
 725         fixup_psymbol_section (*psym, objfile);
 726         if (SYMBOL_SECTION (*psym) >= 0)
 727           SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
 728                                                     SYMBOL_SECTION (*psym));
 729       }
 730     for (psym = objfile->static_psymbols.list;
 731          psym < objfile->static_psymbols.next;
 732          psym++)
 733       {
 734         fixup_psymbol_section (*psym, objfile);
 735         if (SYMBOL_SECTION (*psym) >= 0)
 736           SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
 737                                                     SYMBOL_SECTION (*psym));
 738       }
 739   }
 740
 741   {
 742     struct minimal_symbol *msym;
 743     ALL_OBJFILE_MSYMBOLS (objfile, msym)
 744       if (SYMBOL_SECTION (msym) >= 0)
 745       SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
 746   }
 747   /* Relocating different sections by different amounts may cause the symbols
 748      to be out of order.  */
 749   msymbols_sort (objfile);
 750
 751   {
 752     int i;
 753     for (i = 0; i < objfile->num_sections; ++i)
 754       (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
 755   }
 756
 757   if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
 758     {
 759       /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
 760          only as a fallback.  */
 761       struct obj_section *s;
 762       s = find_pc_section (objfile->ei.entry_point);
 763       if (s)
 764         objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index);
 765       else
 766         objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 767     }
 768
 769   {
 770     struct obj_section *s;
 771     bfd *abfd;
 772
 773     abfd = objfile->obfd;
 774
 775     ALL_OBJFILE_OSECTIONS (objfile, s)
 776       {
 777         int idx = s->the_bfd_section->index;
 778
 779         s->addr += ANOFFSET (delta, idx);
 780         s->endaddr += ANOFFSET (delta, idx);
 781       }
 782   }
 783
 784   if (objfile->ei.entry_func_lowpc != INVALID_ENTRY_LOWPC)
 785     {
 786       objfile->ei.entry_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 787       objfile->ei.entry_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 788     }
 789
 790   if (objfile->ei.deprecated_entry_file_lowpc != INVALID_ENTRY_LOWPC)
 791     {
 792       objfile->ei.deprecated_entry_file_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 793       objfile->ei.deprecated_entry_file_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 794     }
 795
 796   if (objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC)
 797     {
 798       objfile->ei.main_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 799       objfile->ei.main_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
 800     }
 801
 802   /* Relocate breakpoints as necessary, after things are relocated. */
 803   breakpoint_re_set ();
 804 }
 805 \f
 806 /* Many places in gdb want to test just to see if we have any partial
 807    symbols available.  This function returns zero if none are currently
 808    available, nonzero otherwise. */
 809
 810 int
 811 have_partial_symbols (void)
 812 {
 813   struct objfile *ofp;
 814
 815   ALL_OBJFILES (ofp)
 816   {
 817     if (ofp->psymtabs != NULL)
 818       {
 819         return 1;
 820       }
 821   }
 822   return 0;
 823 }
 824
 825 /* Many places in gdb want to test just to see if we have any full
 826    symbols available.  This function returns zero if none are currently
 827    available, nonzero otherwise. */
 828
 829 int
 830 have_full_symbols (void)
 831 {
 832   struct objfile *ofp;
 833
 834   ALL_OBJFILES (ofp)
 835   {
 836     if (ofp->symtabs != NULL)
 837       {
 838         return 1;
 839       }
 840   }
 841   return 0;
 842 }
 843
 844
 845 /* This operations deletes all objfile entries that represent solibs that
 846    weren't explicitly loaded by the user, via e.g., the add-symbol-file
 847    command.
 848  */
 849 void
 850 objfile_purge_solibs (void)
 851 {
 852   struct objfile *objf;
 853   struct objfile *temp;
 854
 855   ALL_OBJFILES_SAFE (objf, temp)
 856   {
 857     /* We assume that the solib package has been purged already, or will
 858        be soon.
 859      */
 860     if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
 861       free_objfile (objf);
 862   }
 863 }
 864
 865
 866 /* Many places in gdb want to test just to see if we have any minimal
 867    symbols available.  This function returns zero if none are currently
 868    available, nonzero otherwise. */
 869
 870 int
 871 have_minimal_symbols (void)
 872 {
 873   struct objfile *ofp;
 874
 875   ALL_OBJFILES (ofp)
 876   {
 877     if (ofp->minimal_symbol_count > 0)
 878       {
 879         return 1;
 880       }
 881   }
 882   return 0;
 883 }
 884
 885 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
 886
 887 /* Given the name of a mapped symbol file in SYMSFILENAME, and the timestamp
 888    of the corresponding symbol file in MTIME, try to open an existing file
 889    with the name SYMSFILENAME and verify it is more recent than the base
 890    file by checking it's timestamp against MTIME.
 891
 892    If SYMSFILENAME does not exist (or can't be stat'd), simply returns -1.
 893
 894    If SYMSFILENAME does exist, but is out of date, we check to see if the
 895    user has specified creation of a mapped file.  If so, we don't issue
 896    any warning message because we will be creating a new mapped file anyway,
 897    overwriting the old one.  If not, then we issue a warning message so that
 898    the user will know why we aren't using this existing mapped symbol file.
 899    In either case, we return -1.
 900
 901    If SYMSFILENAME does exist and is not out of date, but can't be opened for
 902    some reason, then prints an appropriate system error message and returns -1.
 903
 904    Otherwise, returns the open file descriptor.  */
 905
 906 static int
 907 open_existing_mapped_file (char *symsfilename, long mtime, int flags)
 908 {
 909   int fd = -1;
 910   struct stat sbuf;
 911
 912   if (stat (symsfilename, &sbuf) == 0)
 913     {
 914       if (sbuf.st_mtime < mtime)
 915         {
 916           if (!(flags & OBJF_MAPPED))
 917             {
 918               warning ("mapped symbol file `%s' is out of date, ignored it",
 919                        symsfilename);
 920             }
 921         }
 922       else if ((fd = open (symsfilename, O_RDWR)) < 0)
 923         {
 924           if (error_pre_print)
 925             {
 926               printf_unfiltered (error_pre_print);
 927             }
 928           print_sys_errmsg (symsfilename, errno);
 929         }
 930     }
 931   return (fd);
 932 }
 933
 934 /* Look for a mapped symbol file that corresponds to FILENAME and is more
 935    recent than MTIME.  If MAPPED is nonzero, the user has asked that gdb
 936    use a mapped symbol file for this file, so create a new one if one does
 937    not currently exist.
 938
 939    If found, then return an open file descriptor for the file, otherwise
 940    return -1.
 941
 942    This routine is responsible for implementing the policy that generates
 943    the name of the mapped symbol file from the name of a file containing
 944    symbols that gdb would like to read.  Currently this policy is to append
 945    ".syms" to the name of the file.
 946
 947    This routine is also responsible for implementing the policy that
 948    determines where the mapped symbol file is found (the search path).
 949    This policy is that when reading an existing mapped file, a file of
 950    the correct name in the current directory takes precedence over a
 951    file of the correct name in the same directory as the symbol file.
 952    When creating a new mapped file, it is always created in the current
 953    directory.  This helps to minimize the chances of a user unknowingly
 954    creating big mapped files in places like /bin and /usr/local/bin, and
 955    allows a local copy to override a manually installed global copy (in
 956    /bin for example).  */
 957
 958 static int
 959 open_mapped_file (char *filename, long mtime, int flags)
 960 {
 961   int fd;
 962   char *symsfilename;
 963
 964   /* First try to open an existing file in the current directory, and
 965      then try the directory where the symbol file is located. */
 966
 967   symsfilename = concat ("./", lbasename (filename), ".syms", (char *) NULL);
 968   if ((fd = open_existing_mapped_file (symsfilename, mtime, flags)) < 0)
 969     {
 970       xfree (symsfilename);
 971       symsfilename = concat (filename, ".syms", (char *) NULL);
 972       fd = open_existing_mapped_file (symsfilename, mtime, flags);
 973     }
 974
 975   /* If we don't have an open file by now, then either the file does not
 976      already exist, or the base file has changed since it was created.  In
 977      either case, if the user has specified use of a mapped file, then
 978      create a new mapped file, truncating any existing one.  If we can't
 979      create one, print a system error message saying why we can't.
 980
 981      By default the file is rw for everyone, with the user's umask taking
 982      care of turning off the permissions the user wants off. */
 983
 984   if ((fd < 0) && (flags & OBJF_MAPPED))
 985     {
 986       xfree (symsfilename);
 987       symsfilename = concat ("./", lbasename (filename), ".syms",
 988                              (char *) NULL);
 989       if ((fd = open (symsfilename, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
 990         {
 991           if (error_pre_print)
 992             {
 993               printf_unfiltered (error_pre_print);
 994             }
 995           print_sys_errmsg (symsfilename, errno);
 996         }
 997     }
 998
 999   xfree (symsfilename);
1000   return (fd);
1001 }
1002
1003 static void *
1004 map_to_file (int fd)
1005 {
1006   void *md;
1007   CORE_ADDR mapto;
1008
1009   md = mmalloc_attach (fd, 0);
1010   if (md != NULL)
1011     {
1012       mapto = (CORE_ADDR) mmalloc_getkey (md, 1);
1013       md = mmalloc_detach (md);
1014       if (md != NULL)
1015         {
1016           /* FIXME: should figure out why detach failed */
1017           md = NULL;
1018         }
1019       else if (mapto != (CORE_ADDR) NULL)
1020         {
1021           /* This mapping file needs to be remapped at "mapto" */
1022           md = mmalloc_attach (fd, mapto);
1023         }
1024       else
1025         {
1026           /* This is a freshly created mapping file. */
1027           mapto = (CORE_ADDR) mmalloc_findbase (20 * 1024 * 1024);
1028           if (mapto != 0)
1029             {
1030               /* To avoid reusing the freshly created mapping file, at the
1031                  address selected by mmap, we must truncate it before trying
1032                  to do an attach at the address we want. */
1033               ftruncate (fd, 0);
1034               md = mmalloc_attach (fd, mapto);
1035               if (md != NULL)
1036                 {
1037                   mmalloc_setkey (md, 1, mapto);
1038                 }
1039             }
1040         }
1041     }
1042   return (md);
1043 }
1044
1045 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
1046
1047 /* Returns a section whose range includes PC and SECTION,
1048    or NULL if none found.  Note the distinction between the return type,
1049    struct obj_section (which is defined in gdb), and the input type
1050    struct sec (which is a bfd-defined data type).  The obj_section
1051    contains a pointer to the bfd struct sec section.  */
1052
1053 struct obj_section *
1054 find_pc_sect_section (CORE_ADDR pc, struct sec *section)
1055 {
1056   struct obj_section *s;
1057   struct objfile *objfile;
1058
1059   ALL_OBJSECTIONS (objfile, s)
1060     if ((section == 0 || section == s->the_bfd_section) &&
1061         s->addr <= pc && pc < s->endaddr)
1062       return (s);
1063
1064   return (NULL);
1065 }
1066
1067 /* Returns a section whose range includes PC or NULL if none found.
1068    Backward compatibility, no section.  */
1069
1070 struct obj_section *
1071 find_pc_section (CORE_ADDR pc)
1072 {
1073   return find_pc_sect_section (pc, find_pc_mapped_section (pc));
1074 }
1075
1076
1077 /* In SVR4, we recognize a trampoline by it's section name.
1078    That is, if the pc is in a section named ".plt" then we are in
1079    a trampoline.  */
1080
1081 int
1082 in_plt_section (CORE_ADDR pc, char *name)
1083 {
1084   struct obj_section *s;
1085   int retval = 0;
1086
1087   s = find_pc_section (pc);
1088
1089   retval = (s != NULL
1090             && s->the_bfd_section->name != NULL
1091             && STREQ (s->the_bfd_section->name, ".plt"));
1092   return (retval);
1093 }
1094
1095 /* Return nonzero if NAME is in the import list of OBJFILE.  Else
1096    return zero.  */
1097
1098 int
1099 is_in_import_list (char *name, struct objfile *objfile)
1100 {
1101   int i;
1102
1103   if (!objfile || !name || !*name)
1104     return 0;
1105
1106   for (i = 0; i < objfile->import_list_size; i++)
1107     if (objfile->import_list[i] && STREQ (name, objfile->import_list[i]))
1108       return 1;
1109   return 0;
1110 }
1111 \f
1112
1113 /* Keep a registry of per-objfile data-pointers required by other GDB
1114    modules.  */
1115
1116 struct objfile_data
1117 {
1118   unsigned index;
1119 };
1120
1121 struct objfile_data_registration
1122 {
1123   struct objfile_data *data;
1124   struct objfile_data_registration *next;
1125 };
1126
1127 struct objfile_data_registry
1128 {
1129   struct objfile_data_registration *registrations;
1130   unsigned num_registrations;
1131 };
1132
1133 static struct objfile_data_registry objfile_data_registry = { NULL, 0 };
1134
1135 const struct objfile_data *
1136 register_objfile_data (void)
1137 {
1138   struct objfile_data_registration **curr;
1139
1140   /* Append new registration.  */
1141   for (curr = &objfile_data_registry.registrations;
1142        *curr != NULL; curr = &(*curr)->next);
1143
1144   *curr = XMALLOC (struct objfile_data_registration);
1145   (*curr)->next = NULL;
1146   (*curr)->data = XMALLOC (struct objfile_data);
1147   (*curr)->data->index = objfile_data_registry.num_registrations++;
1148
1149   return (*curr)->data;
1150 }
1151
1152 static void
1153 objfile_alloc_data (struct objfile *objfile)
1154 {
1155   gdb_assert (objfile->data == NULL);
1156   objfile->num_data = objfile_data_registry.num_registrations;
1157   objfile->data = XCALLOC (objfile->num_data, void *);
1158 }
1159
1160 static void
1161 objfile_free_data (struct objfile *objfile)
1162 {
1163   gdb_assert (objfile->data != NULL);
1164   xfree (objfile->data);
1165   objfile->data = NULL;
1166 }
1167
1168 void
1169 set_objfile_data (struct objfile *objfile, const struct objfile_data *data,
1170                   void *value)
1171 {
1172   gdb_assert (data->index < objfile->num_data);
1173   objfile->data[data->index] = value;
1174 }
1175
1176 void *
1177 objfile_data (struct objfile *objfile, const struct objfile_data *data)
1178 {
1179   gdb_assert (data->index < objfile->num_data);
1180   return objfile->data[data->index];
1181 }