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