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