gdb/objfiles.c

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