gdb/objfiles.c

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