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