gdb/objfiles.c

   1 /* GDB routines for manipulating objfiles.
   2    Copyright 1992 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* This file contains support routines for creating, manipulating, and
  22    destroying objfile structures. */
  23
  24 #include "defs.h"
  25 #include "bfd.h"                /* Binary File Description */
  26 #include "symtab.h"
  27 #include "symfile.h"
  28 #include "objfiles.h"
  29 #include "gdb-stabs.h"
  30
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <fcntl.h>
  34 #include <obstack.h>
  35
  36 /* Prototypes for local functions */
  37
  38 #if !defined(NO_MMALLOC) && defined(HAVE_MMAP)
  39
  40 static int
  41 open_existing_mapped_file PARAMS ((char *, long, int));
  42
  43 static int
  44 open_mapped_file PARAMS ((char *filename, long mtime, int mapped));
  45
  46 static CORE_ADDR
  47 map_to_address PARAMS ((void));
  48
  49 #endif  /* !defined(NO_MMALLOC) && defined(HAVE_MMAP) */
  50
  51 /* Message to be printed before the error message, when an error occurs.  */
  52
  53 extern char *error_pre_print;
  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
  62 int mapped_symbol_files;                /* Try to use mapped symbol files */
  63
  64 /* Locate all mappable sections of a BFD file.
  65    objfile_p_char is a char * to get it through
  66    bfd_map_over_sections; we cast it back to its proper type.  */
  67
  68 static void
  69 add_to_objfile_sections (abfd, asect, objfile_p_char)
  70      bfd *abfd;
  71      sec_ptr asect;
  72      PTR objfile_p_char;
  73 {
  74   struct objfile *objfile = (struct objfile *) objfile_p_char;
  75   struct obj_section section;
  76   flagword aflag;
  77
  78   aflag = bfd_get_section_flags (abfd, asect);
  79   /* FIXME, we need to handle BSS segment here...it alloc's but doesn't load */
  80   if (!(aflag & SEC_LOAD))
  81     return;
  82   if (0 == bfd_section_size (abfd, asect))
  83     return;
  84   section.offset = 0;
  85   section.objfile = objfile;
  86   section.sec_ptr = asect;
  87   section.addr = bfd_section_vma (abfd, asect);
  88   section.endaddr = section.addr + bfd_section_size (abfd, asect);
  89   obstack_grow (&objfile->psymbol_obstack, &section, sizeof(section));
  90   objfile->sections_end = (struct obj_section *) (((int) objfile->sections_end) + 1);
  91 }
  92
  93 /* Builds a section table for OBJFILE.
  94    Returns 0 if OK, 1 on error.  */
  95
  96 static int
  97 build_objfile_section_table (objfile)
  98      struct objfile *objfile;
  99 {
 100   if (objfile->sections)
 101     abort();
 102
 103   objfile->sections_end = 0;
 104   bfd_map_over_sections (objfile->obfd, add_to_objfile_sections, (char *)objfile);
 105   objfile->sections = (struct obj_section *)
 106     obstack_finish (&objfile->psymbol_obstack);
 107   objfile->sections_end = objfile->sections + (int) objfile->sections_end;
 108   return(0);
 109 }
 110
 111 /* Given a pointer to an initialized bfd (ABFD) and a flag that indicates
 112    whether or not an objfile is to be mapped (MAPPED), allocate a new objfile
 113    struct, fill it in as best we can, link it into the list of all known
 114    objfiles, and return a pointer to the new objfile struct. */
 115
 116 struct objfile *
 117 allocate_objfile (abfd, mapped)
 118      bfd *abfd;
 119      int mapped;
 120 {
 121   struct objfile *objfile = NULL;
 122   int fd;
 123   void *md;
 124   CORE_ADDR mapto;
 125
 126   mapped |= mapped_symbol_files;
 127
 128 #if !defined(NO_MMALLOC) && defined(HAVE_MMAP)
 129
 130   /* If we can support mapped symbol files, try to open/reopen the mapped file
 131      that corresponds to the file from which we wish to read symbols.  If the
 132      objfile is to be mapped, we must malloc the structure itself using the
 133      mmap version, and arrange that all memory allocation for the objfile uses
 134      the mmap routines.  If we are reusing an existing mapped file, from which
 135      we get our objfile pointer, we have to make sure that we update the
 136      pointers to the alloc/free functions in the obstack, in case these
 137      functions have moved within the current gdb. */
 138
 139   fd = open_mapped_file (bfd_get_filename (abfd), bfd_get_mtime (abfd),
 140                          mapped);
 141   if (fd >= 0)
 142     {
 143       if (((mapto = map_to_address ()) == 0) ||
 144           ((md = mmalloc_attach (fd, (void *) mapto)) == NULL))
 145         {
 146           close (fd);
 147         }
 148       else if ((objfile = (struct objfile *) mmalloc_getkey (md, 0)) != NULL)
 149         {
 150           /* Update memory corruption handler function addresses. */
 151           init_malloc (md);
 152           objfile -> md = md;
 153           objfile -> mmfd = fd;
 154           /* Update pointers to functions to *our* copies */
 155           obstack_chunkfun (&objfile -> psymbol_obstack, xmmalloc);
 156           obstack_freefun (&objfile -> psymbol_obstack, mfree);
 157           obstack_chunkfun (&objfile -> symbol_obstack, xmmalloc);
 158           obstack_freefun (&objfile -> symbol_obstack, mfree);
 159           obstack_chunkfun (&objfile -> type_obstack, xmmalloc);
 160           obstack_freefun (&objfile -> type_obstack, mfree);
 161           /* If already in objfile list, unlink it. */
 162           unlink_objfile (objfile);
 163           /* Forget things specific to a particular gdb, may have changed. */
 164           objfile -> sf = NULL;
 165         }
 166       else
 167         {
 168           /* Set up to detect internal memory corruption.  MUST be done before
 169              the first malloc.  See comments in init_malloc() and mmcheck(). */
 170           init_malloc (md);
 171           objfile = (struct objfile *) xmmalloc (md, sizeof (struct objfile));
 172           memset (objfile, 0, sizeof (struct objfile));
 173           objfile -> md = md;
 174           objfile -> mmfd = fd;
 175           objfile -> flags |= OBJF_MAPPED;
 176           mmalloc_setkey (objfile -> md, 0, objfile);
 177           obstack_specify_allocation_with_arg (&objfile -> psymbol_obstack,
 178                                                0, 0, xmmalloc, mfree,
 179                                                objfile -> md);
 180           obstack_specify_allocation_with_arg (&objfile -> symbol_obstack,
 181                                                0, 0, xmmalloc, mfree,
 182                                                objfile -> md);
 183           obstack_specify_allocation_with_arg (&objfile -> type_obstack,
 184                                                0, 0, xmmalloc, mfree,
 185                                                objfile -> md);
 186         }
 187     }
 188
 189   if (mapped && (objfile == NULL))
 190     {
 191       warning ("symbol table for '%s' will not be mapped",
 192                bfd_get_filename (abfd));
 193     }
 194
 195 #else   /* defined(NO_MMALLOC) || !defined(HAVE_MMAP) */
 196
 197   if (mapped)
 198     {
 199       warning ("this version of gdb does not support mapped symbol tables.");
 200
 201       /* Turn off the global flag so we don't try to do mapped symbol tables
 202          any more, which shuts up gdb unless the user specifically gives the
 203          "mapped" keyword again. */
 204
 205       mapped_symbol_files = 0;
 206     }
 207
 208 #endif  /* !defined(NO_MMALLOC) && defined(HAVE_MMAP) */
 209
 210   /* If we don't support mapped symbol files, didn't ask for the file to be
 211      mapped, or failed to open the mapped file for some reason, then revert
 212      back to an unmapped objfile. */
 213
 214   if (objfile == NULL)
 215     {
 216       objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
 217       memset (objfile, 0, sizeof (struct objfile));
 218       objfile -> md = NULL;
 219       obstack_specify_allocation (&objfile -> psymbol_obstack, 0, 0, xmalloc,
 220                                   free);
 221       obstack_specify_allocation (&objfile -> symbol_obstack, 0, 0, xmalloc,
 222                                   free);
 223       obstack_specify_allocation (&objfile -> type_obstack, 0, 0, xmalloc,
 224                                   free);
 225     }
 226
 227   /* Update the per-objfile information that comes from the bfd, ensuring
 228      that any data that is reference is saved in the per-objfile data
 229      region. */
 230
 231   objfile -> obfd = abfd;
 232   if (objfile -> name != NULL)
 233     {
 234       mfree (objfile -> md, objfile -> name);
 235     }
 236   objfile -> name = mstrsave (objfile -> md, bfd_get_filename (abfd));
 237   objfile -> mtime = bfd_get_mtime (abfd);
 238
 239   /* Build section table.  */
 240
 241   if (build_objfile_section_table (objfile))
 242     {
 243       error ("Can't find the file sections in `%s': %s",
 244              objfile -> name, bfd_errmsg (bfd_error));
 245     }
 246
 247   /* Push this file onto the head of the linked list of other such files. */
 248
 249   objfile -> next = object_files;
 250   object_files = objfile;
 251
 252   return (objfile);
 253 }
 254
 255 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
 256    list.
 257
 258    It is not a bug, or error, to call this function if OBJFILE is not known
 259    to be in the current list.  This is done in the case of mapped objfiles,
 260    for example, just to ensure that the mapped objfile doesn't appear twice
 261    in the list.  Since the list is threaded, linking in a mapped objfile
 262    twice would create a circular list.
 263
 264    If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
 265    unlinking it, just to ensure that we have completely severed any linkages
 266    between the OBJFILE and the list. */
 267
 268 void
 269 unlink_objfile (objfile)
 270      struct objfile *objfile;
 271 {
 272   struct objfile** objpp;
 273
 274   for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp) -> next))
 275     {
 276       if (*objpp == objfile)
 277         {
 278           *objpp = (*objpp) -> next;
 279           objfile -> next = NULL;
 280           break;
 281         }
 282     }
 283 }
 284
 285
 286 /* Destroy an objfile and all the symtabs and psymtabs under it.  Note
 287    that as much as possible is allocated on the symbol_obstack and
 288    psymbol_obstack, so that the memory can be efficiently freed.
 289
 290    Things which we do NOT free because they are not in malloc'd memory
 291    or not in memory specific to the objfile include:
 292
 293         objfile -> sf
 294
 295    FIXME:  If the objfile is using reusable symbol information (via mmalloc),
 296    then we need to take into account the fact that more than one process
 297    may be using the symbol information at the same time (when mmalloc is
 298    extended to support cooperative locking).  When more than one process
 299    is using the mapped symbol info, we need to be more careful about when
 300    we free objects in the reusable area. */
 301
 302 void
 303 free_objfile (objfile)
 304      struct objfile *objfile;
 305 {
 306   int mmfd;
 307
 308   /* First do any symbol file specific actions required when we are
 309      finished with a particular symbol file.  Note that if the objfile
 310      is using reusable symbol information (via mmalloc) then each of
 311      these routines is responsible for doing the correct thing, either
 312      freeing things which are valid only during this particular gdb
 313      execution, or leaving them to be reused during the next one. */
 314
 315   if (objfile -> sf != NULL)
 316     {
 317       (*objfile -> sf -> sym_finish) (objfile);
 318     }
 319
 320   /* We always close the bfd. */
 321
 322   if (objfile -> obfd != NULL)
 323     {
 324       char *name = bfd_get_filename (objfile->obfd);
 325       bfd_close (objfile -> obfd);
 326       free (name);
 327     }
 328
 329   /* Remove it from the chain of all objfiles. */
 330
 331   unlink_objfile (objfile);
 332
 333   /* Before the symbol table code was redone to make it easier to
 334      selectively load and remove information particular to a specific
 335      linkage unit, gdb used to do these things whenever the monolithic
 336      symbol table was blown away.  How much still needs to be done
 337      is unknown, but we play it safe for now and keep each action until
 338      it is shown to be no longer needed. */
 339
 340 #if defined (CLEAR_SOLIB)
 341   CLEAR_SOLIB ();
 342 #endif
 343   clear_pc_function_cache ();
 344
 345   /* The last thing we do is free the objfile struct itself for the
 346      non-reusable case, or detach from the mapped file for the reusable
 347      case.  Note that the mmalloc_detach or the mfree is the last thing
 348      we can do with this objfile. */
 349
 350 #if !defined(NO_MMALLOC) && defined(HAVE_MMAP)
 351
 352   if (objfile -> flags & OBJF_MAPPED)
 353     {
 354       /* Remember the fd so we can close it.  We can't close it before
 355          doing the detach, and after the detach the objfile is gone. */
 356       mmfd = objfile -> mmfd;
 357       mmalloc_detach (objfile -> md);
 358       objfile = NULL;
 359       close (mmfd);
 360     }
 361
 362 #endif  /* !defined(NO_MMALLOC) && defined(HAVE_MMAP) */
 363
 364   /* If we still have an objfile, then either we don't support reusable
 365      objfiles or this one was not reusable.  So free it normally. */
 366
 367   if (objfile != NULL)
 368     {
 369       if (objfile -> name != NULL)
 370         {
 371           mfree (objfile -> md, objfile -> name);
 372         }
 373       if (objfile->global_psymbols.list)
 374         mfree (objfile->md, objfile->global_psymbols.list);
 375       if (objfile->static_psymbols.list)
 376         mfree (objfile->md, objfile->static_psymbols.list);
 377       /* Free the obstacks for non-reusable objfiles */
 378       obstack_free (&objfile -> psymbol_obstack, 0);
 379       obstack_free (&objfile -> symbol_obstack, 0);
 380       obstack_free (&objfile -> type_obstack, 0);
 381       mfree (objfile -> md, objfile);
 382       objfile = NULL;
 383     }
 384 }
 385
 386
 387 /* Free all the object files at once and clean up their users.  */
 388
 389 void
 390 free_all_objfiles ()
 391 {
 392   struct objfile *objfile, *temp;
 393
 394   ALL_OBJFILES_SAFE (objfile, temp)
 395     {
 396       free_objfile (objfile);
 397     }
 398   clear_symtab_users ();
 399 }
 400 \f
 401 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
 402    entries in new_offsets.  */
 403 void
 404 objfile_relocate (objfile, new_offsets)
 405      struct objfile *objfile;
 406      struct section_offsets *new_offsets;
 407 {
 408   struct section_offsets *delta = (struct section_offsets *) alloca
 409     (sizeof (struct section_offsets)
 410      + objfile->num_sections * sizeof (delta->offsets));
 411
 412   {
 413     int i;
 414     int something_changed = 0;
 415     for (i = 0; i < objfile->num_sections; ++i)
 416       {
 417         ANOFFSET (delta, i) =
 418           ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
 419         if (ANOFFSET (delta, i) != 0)
 420           something_changed = 1;
 421       }
 422     if (!something_changed)
 423       return;
 424   }
 425
 426   /* OK, get all the symtabs.  */
 427   {
 428     struct symtab *s;
 429
 430     for (s = objfile->symtabs; s; s = s->next)
 431       {
 432         struct linetable *l;
 433         struct blockvector *bv;
 434         int i;
 435
 436         /* First the line table.  */
 437         l = LINETABLE (s);
 438         if (l)
 439           {
 440             for (i = 0; i < l->nitems; ++i)
 441               l->item[i].pc += ANOFFSET (delta, s->block_line_section);
 442           }
 443
 444         /* Don't relocate a shared blockvector more than once.  */
 445         if (!s->primary)
 446           continue;
 447
 448         bv = BLOCKVECTOR (s);
 449         for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
 450           {
 451             struct block *b;
 452             int j;
 453
 454             b = BLOCKVECTOR_BLOCK (bv, i);
 455             BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
 456             BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
 457
 458             for (j = 0; j < BLOCK_NSYMS (b); ++j)
 459               {
 460                 struct symbol *sym = BLOCK_SYM (b, j);
 461                 /* The RS6000 code from which this was taken skipped
 462                    any symbols in STRUCT_NAMESPACE or UNDEF_NAMESPACE.
 463                    But I'm leaving out that test, on the theory that
 464                    they can't possibly pass the tests below.  */
 465                 if ((SYMBOL_CLASS (sym) == LOC_LABEL
 466                      || SYMBOL_CLASS (sym) == LOC_STATIC)
 467                     && SYMBOL_SECTION (sym) >= 0)
 468                   {
 469                     SYMBOL_VALUE_ADDRESS (sym) +=
 470                       ANOFFSET (delta, SYMBOL_SECTION (sym));
 471                   }
 472               }
 473           }
 474       }
 475   }
 476
 477   {
 478     struct partial_symtab *p;
 479
 480     ALL_OBJFILE_PSYMTABS (objfile, p)
 481       {
 482         p->textlow += ANOFFSET (delta, SECT_OFF_TEXT);
 483         p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT);
 484       }
 485   }
 486
 487   {
 488     struct partial_symbol *psym;
 489
 490     for (psym = objfile->global_psymbols.list;
 491          psym < objfile->global_psymbols.next;
 492          psym++)
 493       if (SYMBOL_SECTION (psym) >= 0)
 494         SYMBOL_VALUE_ADDRESS (psym) += ANOFFSET (delta, SYMBOL_SECTION (psym));
 495     for (psym = objfile->static_psymbols.list;
 496          psym < objfile->static_psymbols.next;
 497          psym++)
 498       if (SYMBOL_SECTION (psym) >= 0)
 499         SYMBOL_VALUE_ADDRESS (psym) += ANOFFSET (delta, SYMBOL_SECTION (psym));
 500   }
 501
 502   {
 503     struct minimal_symbol *msym;
 504     ALL_OBJFILE_MSYMBOLS (objfile, msym)
 505       if (SYMBOL_SECTION (msym) >= 0)
 506         SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
 507   }
 508
 509   {
 510     int i;
 511     for (i = 0; i < objfile->num_sections; ++i)
 512       ANOFFSET (objfile->section_offsets, i) = ANOFFSET (new_offsets, i);
 513   }
 514 }
 515 \f
 516 /* Many places in gdb want to test just to see if we have any partial
 517    symbols available.  This function returns zero if none are currently
 518    available, nonzero otherwise. */
 519
 520 int
 521 have_partial_symbols ()
 522 {
 523   struct objfile *ofp;
 524
 525   ALL_OBJFILES (ofp)
 526     {
 527       if (ofp -> psymtabs != NULL)
 528         {
 529           return 1;
 530         }
 531     }
 532   return 0;
 533 }
 534
 535 /* Many places in gdb want to test just to see if we have any full
 536    symbols available.  This function returns zero if none are currently
 537    available, nonzero otherwise. */
 538
 539 int
 540 have_full_symbols ()
 541 {
 542   struct objfile *ofp;
 543
 544   ALL_OBJFILES (ofp)
 545     {
 546       if (ofp -> symtabs != NULL)
 547         {
 548           return 1;
 549         }
 550     }
 551   return 0;
 552 }
 553
 554 /* Many places in gdb want to test just to see if we have any minimal
 555    symbols available.  This function returns zero if none are currently
 556    available, nonzero otherwise. */
 557
 558 int
 559 have_minimal_symbols ()
 560 {
 561   struct objfile *ofp;
 562
 563   ALL_OBJFILES (ofp)
 564     {
 565       if (ofp -> msymbols != NULL)
 566         {
 567           return 1;
 568         }
 569     }
 570   return 0;
 571 }
 572
 573 #if !defined(NO_MMALLOC) && defined(HAVE_MMAP)
 574
 575 /* Given the name of a mapped symbol file in SYMSFILENAME, and the timestamp
 576    of the corresponding symbol file in MTIME, try to open an existing file
 577    with the name SYMSFILENAME and verify it is more recent than the base
 578    file by checking it's timestamp against MTIME.
 579
 580    If SYMSFILENAME does not exist (or can't be stat'd), simply returns -1.
 581
 582    If SYMSFILENAME does exist, but is out of date, we check to see if the
 583    user has specified creation of a mapped file.  If so, we don't issue
 584    any warning message because we will be creating a new mapped file anyway,
 585    overwriting the old one.  If not, then we issue a warning message so that
 586    the user will know why we aren't using this existing mapped symbol file.
 587    In either case, we return -1.
 588
 589    If SYMSFILENAME does exist and is not out of date, but can't be opened for
 590    some reason, then prints an appropriate system error message and returns -1.
 591
 592    Otherwise, returns the open file descriptor.  */
 593
 594 static int
 595 open_existing_mapped_file (symsfilename, mtime, mapped)
 596      char *symsfilename;
 597      long mtime;
 598      int mapped;
 599 {
 600   int fd = -1;
 601   struct stat sbuf;
 602
 603   if (stat (symsfilename, &sbuf) == 0)
 604     {
 605       if (sbuf.st_mtime < mtime)
 606         {
 607           if (!mapped)
 608             {
 609               warning ("mapped symbol file `%s' is out of date, ignored it",
 610                        symsfilename);
 611             }
 612         }
 613       else if ((fd = open (symsfilename, O_RDWR)) < 0)
 614         {
 615           if (error_pre_print)
 616             {
 617               printf (error_pre_print);
 618             }
 619           print_sys_errmsg (symsfilename, errno);
 620         }
 621     }
 622   return (fd);
 623 }
 624
 625 /* Look for a mapped symbol file that corresponds to FILENAME and is more
 626    recent than MTIME.  If MAPPED is nonzero, the user has asked that gdb
 627    use a mapped symbol file for this file, so create a new one if one does
 628    not currently exist.
 629
 630    If found, then return an open file descriptor for the file, otherwise
 631    return -1.
 632
 633    This routine is responsible for implementing the policy that generates
 634    the name of the mapped symbol file from the name of a file containing
 635    symbols that gdb would like to read.  Currently this policy is to append
 636    ".syms" to the name of the file.
 637
 638    This routine is also responsible for implementing the policy that
 639    determines where the mapped symbol file is found (the search path).
 640    This policy is that when reading an existing mapped file, a file of
 641    the correct name in the current directory takes precedence over a
 642    file of the correct name in the same directory as the symbol file.
 643    When creating a new mapped file, it is always created in the current
 644    directory.  This helps to minimize the chances of a user unknowingly
 645    creating big mapped files in places like /bin and /usr/local/bin, and
 646    allows a local copy to override a manually installed global copy (in
 647    /bin for example).  */
 648
 649 static int
 650 open_mapped_file (filename, mtime, mapped)
 651      char *filename;
 652      long mtime;
 653      int mapped;
 654 {
 655   int fd;
 656   char *symsfilename;
 657
 658   /* First try to open an existing file in the current directory, and
 659      then try the directory where the symbol file is located. */
 660
 661   symsfilename = concat ("./", basename (filename), ".syms", (char *) NULL);
 662   if ((fd = open_existing_mapped_file (symsfilename, mtime, mapped)) < 0)
 663     {
 664       free (symsfilename);
 665       symsfilename = concat (filename, ".syms", (char *) NULL);
 666       fd = open_existing_mapped_file (symsfilename, mtime, mapped);
 667     }
 668
 669   /* If we don't have an open file by now, then either the file does not
 670      already exist, or the base file has changed since it was created.  In
 671      either case, if the user has specified use of a mapped file, then
 672      create a new mapped file, truncating any existing one.  If we can't
 673      create one, print a system error message saying why we can't.
 674
 675      By default the file is rw for everyone, with the user's umask taking
 676      care of turning off the permissions the user wants off. */
 677
 678   if ((fd < 0) && mapped)
 679     {
 680       free (symsfilename);
 681       symsfilename = concat ("./", basename (filename), ".syms",
 682                              (char *) NULL);
 683       if ((fd = open (symsfilename, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
 684         {
 685           if (error_pre_print)
 686             {
 687               printf (error_pre_print);
 688             }
 689           print_sys_errmsg (symsfilename, errno);
 690         }
 691     }
 692
 693   free (symsfilename);
 694   return (fd);
 695 }
 696
 697 /* Return the base address at which we would like the next objfile's
 698    mapped data to start.
 699
 700    For now, we use the kludge that the configuration specifies a base
 701    address to which it is safe to map the first mmalloc heap, and an
 702    increment to add to this address for each successive heap.  There are
 703    a lot of issues to deal with here to make this work reasonably, including:
 704
 705      Avoid memory collisions with existing mapped address spaces
 706
 707      Reclaim address spaces when their mmalloc heaps are unmapped
 708
 709      When mmalloc heaps are shared between processes they have to be
 710      mapped at the same addresses in each
 711
 712      Once created, a mmalloc heap that is to be mapped back in must be
 713      mapped at the original address.  I.E. each objfile will expect to
 714      be remapped at it's original address.  This becomes a problem if
 715      the desired address is already in use.
 716
 717      etc, etc, etc.
 718
 719  */
 720
 721
 722 static CORE_ADDR
 723 map_to_address ()
 724 {
 725
 726 #if defined(MMAP_BASE_ADDRESS) && defined (MMAP_INCREMENT)
 727
 728   static CORE_ADDR next = MMAP_BASE_ADDRESS;
 729   CORE_ADDR mapto = next;
 730
 731   next += MMAP_INCREMENT;
 732   return (mapto);
 733
 734 #else
 735
 736   return (0);
 737
 738 #endif
 739
 740 }
 741
 742 #endif  /* !defined(NO_MMALLOC) && defined(HAVE_MMAP) */
 743
 744 /* Returns a section whose range includes PC or NULL if none found. */
 745
 746 struct obj_section *
 747 find_pc_section(pc)
 748      CORE_ADDR pc;
 749 {
 750   struct obj_section *s;
 751   struct objfile *objfile;
 752
 753   ALL_OBJFILES (objfile)
 754     for (s = objfile->sections; s < objfile->sections_end; ++s)
 755       if (s->addr <= pc
 756           && pc < s->endaddr)
 757         return(s);
 758
 759   return(NULL);
 760 }