Contribute sh64-elf.

[deliverable/binutils-gdb.git] / gdb / objfiles.c

diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index 1cdb175e3537dc70203632b071dadbe0a8238693..e2a6f8505546c311271ceabbd5faa01c94c5321c 100644 (file)
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -1,5 +1,6 @@
 /* GDB routines for manipulating objfiles.
 /* GDB routines for manipulating objfiles.

-   Copyright 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+   Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+   Free Software Foundation, Inc.

    Contributed by Cygnus Support, using pieces from other GDB modules.
 
    This file is part of GDB.
    Contributed by Cygnus Support, using pieces from other GDB modules.
 
    This file is part of GDB.


@@ -42,19 +43,17 @@
 
 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
 
 
 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
 

-static int
-open_existing_mapped_file PARAMS ((char *, long, int));
+#include "mmalloc.h"

 
 

-static int
-open_mapped_file PARAMS ((char *filename, long mtime, int flags));
+static int open_existing_mapped_file (char *, long, int);

 
 

-static PTR
-  map_to_file PARAMS ((int));
+static int open_mapped_file (char *filename, long mtime, int flags);
+
+static PTR map_to_file (int);

 
 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
 
 
 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
 

-static void
-add_to_objfile_sections PARAMS ((bfd *, sec_ptr, PTR));
+static void add_to_objfile_sections (bfd *, sec_ptr, PTR);

 
 /* Externally visible variables that are owned by this module.
    See declarations in objfile.h for more info. */
 
 /* Externally visible variables that are owned by this module.
    See declarations in objfile.h for more info. */


@@ -80,10 +79,7 @@ int mapped_symbol_files;     /* Try to use mapped symbol files */
    the end of the table (objfile->sections_end). */
 
 static void
    the end of the table (objfile->sections_end). */
 
 static void

-add_to_objfile_sections (abfd, asect, objfile_p_char)
-     bfd *abfd;
-     sec_ptr asect;
-     PTR objfile_p_char;
+add_to_objfile_sections (bfd *abfd, sec_ptr asect, PTR objfile_p_char)

 {
   struct objfile *objfile = (struct objfile *) objfile_p_char;
   struct obj_section section;
 {
   struct objfile *objfile = (struct objfile *) objfile_p_char;
   struct obj_section section;


@@ -123,8 +119,7 @@ add_to_objfile_sections (abfd, asect, objfile_p_char)
    we are building the table, we're pretty much hosed. */
 
 int
    we are building the table, we're pretty much hosed. */
 
 int

-build_objfile_section_table (objfile)
-     struct objfile *objfile;
+build_objfile_section_table (struct objfile *objfile)

 {
   /* objfile->sections can be already set when reading a mapped symbol
      file.  I believe that we do need to rebuild the section table in
 {
   /* objfile->sections can be already set when reading a mapped symbol
      file.  I believe that we do need to rebuild the section table in


@@ -152,9 +147,7 @@ build_objfile_section_table (objfile)
    member. */
 
 struct objfile *
    member. */
 
 struct objfile *

-allocate_objfile (abfd, flags)
-     bfd *abfd;
-     int flags;
+allocate_objfile (bfd *abfd, int flags)

 {
   struct objfile *objfile = NULL;
   struct objfile *last_one = NULL;
 {
   struct objfile *objfile = NULL;
   struct objfile *last_one = NULL;


@@ -196,13 +189,13 @@ allocate_objfile (abfd, flags)
              objfile->mmfd = fd;
              /* Update pointers to functions to *our* copies */
              obstack_chunkfun (&objfile->psymbol_cache.cache, xmmalloc);
              objfile->mmfd = fd;
              /* Update pointers to functions to *our* copies */
              obstack_chunkfun (&objfile->psymbol_cache.cache, xmmalloc);

-             obstack_freefun (&objfile->psymbol_cache.cache, mfree);
+             obstack_freefun (&objfile->psymbol_cache.cache, xmfree);

              obstack_chunkfun (&objfile->psymbol_obstack, xmmalloc);
              obstack_chunkfun (&objfile->psymbol_obstack, xmmalloc);

-             obstack_freefun (&objfile->psymbol_obstack, mfree);
+             obstack_freefun (&objfile->psymbol_obstack, xmfree);

              obstack_chunkfun (&objfile->symbol_obstack, xmmalloc);
              obstack_chunkfun (&objfile->symbol_obstack, xmmalloc);

-             obstack_freefun (&objfile->symbol_obstack, mfree);
+             obstack_freefun (&objfile->symbol_obstack, xmfree);

              obstack_chunkfun (&objfile->type_obstack, xmmalloc);
              obstack_chunkfun (&objfile->type_obstack, xmmalloc);

-             obstack_freefun (&objfile->type_obstack, mfree);
+             obstack_freefun (&objfile->type_obstack, xmfree);

              /* If already in objfile list, unlink it. */
              unlink_objfile (objfile);
              /* Forget things specific to a particular gdb, may have changed. */
              /* If already in objfile list, unlink it. */
              unlink_objfile (objfile);
              /* Forget things specific to a particular gdb, may have changed. */


@@ -225,16 +218,16 @@ allocate_objfile (abfd, flags)
              objfile->flags |= OBJF_MAPPED;
              mmalloc_setkey (objfile->md, 0, objfile);
              obstack_specify_allocation_with_arg (&objfile->psymbol_cache.cache,
              objfile->flags |= OBJF_MAPPED;
              mmalloc_setkey (objfile->md, 0, objfile);
              obstack_specify_allocation_with_arg (&objfile->psymbol_cache.cache,

-                                                  0, 0, xmmalloc, mfree,
+                                                  0, 0, xmmalloc, xmfree,

                                                   objfile->md);
              obstack_specify_allocation_with_arg (&objfile->psymbol_obstack,
                                                   objfile->md);
              obstack_specify_allocation_with_arg (&objfile->psymbol_obstack,

-                                                  0, 0, xmmalloc, mfree,
+                                                  0, 0, xmmalloc, xmfree,

                                                   objfile->md);
              obstack_specify_allocation_with_arg (&objfile->symbol_obstack,
                                                   objfile->md);
              obstack_specify_allocation_with_arg (&objfile->symbol_obstack,

-                                                  0, 0, xmmalloc, mfree,
+                                                  0, 0, xmmalloc, xmfree,

                                                   objfile->md);
              obstack_specify_allocation_with_arg (&objfile->type_obstack,
                                                   objfile->md);
              obstack_specify_allocation_with_arg (&objfile->type_obstack,

-                                                  0, 0, xmmalloc, mfree,
+                                                  0, 0, xmmalloc, xmfree,

                                                   objfile->md);
            }
        }
                                                   objfile->md);
            }
        }


@@ -272,13 +265,13 @@ allocate_objfile (abfd, flags)
       memset (objfile, 0, sizeof (struct objfile));
       objfile->md = NULL;
       obstack_specify_allocation (&objfile->psymbol_cache.cache, 0, 0,
       memset (objfile, 0, sizeof (struct objfile));
       objfile->md = NULL;
       obstack_specify_allocation (&objfile->psymbol_cache.cache, 0, 0,

-                                 xmalloc, free);
+                                 xmalloc, xfree);

       obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0, xmalloc,
       obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0, xmalloc,

-                                 free);
+                                 xfree);

       obstack_specify_allocation (&objfile->symbol_obstack, 0, 0, xmalloc,
       obstack_specify_allocation (&objfile->symbol_obstack, 0, 0, xmalloc,

-                                 free);
+                                 xfree);

       obstack_specify_allocation (&objfile->type_obstack, 0, 0, xmalloc,
       obstack_specify_allocation (&objfile->type_obstack, 0, 0, xmalloc,

-                                 free);
+                                 xfree);

       flags &= ~OBJF_MAPPED;
     }
 
       flags &= ~OBJF_MAPPED;
     }
 


@@ -289,7 +282,7 @@ allocate_objfile (abfd, flags)
   objfile->obfd = abfd;
   if (objfile->name != NULL)
     {
   objfile->obfd = abfd;
   if (objfile->name != NULL)
     {

-      mfree (objfile->md, objfile->name);
+      xmfree (objfile->md, objfile->name);

     }
   if (abfd != NULL)
     {
     }
   if (abfd != NULL)
     {


@@ -305,6 +298,14 @@ allocate_objfile (abfd, flags)
        }
     }
 
        }
     }
 

+  /* Initialize the section indexes for this objfile, so that we can
+     later detect if they are used w/o being properly assigned to. */
+
+    objfile->sect_index_text = -1;
+    objfile->sect_index_data = -1;
+    objfile->sect_index_bss = -1;
+    objfile->sect_index_rodata = -1;
+

   /* Add this file onto the tail of the linked list of other such files. */
 
   objfile->next = NULL;
   /* Add this file onto the tail of the linked list of other such files. */
 
   objfile->next = NULL;


@@ -327,8 +328,7 @@ allocate_objfile (abfd, flags)
 /* Put OBJFILE at the front of the list.  */
 
 void
 /* Put OBJFILE at the front of the list.  */
 
 void

-objfile_to_front (objfile)
-     struct objfile *objfile;
+objfile_to_front (struct objfile *objfile)

 {
   struct objfile **objp;
   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
 {
   struct objfile **objp;
   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))


@@ -359,8 +359,7 @@ objfile_to_front (objfile)
    between the OBJFILE and the list. */
 
 void
    between the OBJFILE and the list. */
 
 void

-unlink_objfile (objfile)
-     struct objfile *objfile;
+unlink_objfile (struct objfile *objfile)

 {
   struct objfile **objpp;
 
 {
   struct objfile **objpp;
 


@@ -370,9 +369,12 @@ unlink_objfile (objfile)
        {
          *objpp = (*objpp)->next;
          objfile->next = NULL;
        {
          *objpp = (*objpp)->next;
          objfile->next = NULL;

-         break;
+         return;

        }
     }
        }
     }

+
+  internal_error (__FILE__, __LINE__,
+                 "unlink_objfile: objfile already unlinked");

 }
 
 
 }
 
 


@@ -393,8 +395,7 @@ unlink_objfile (objfile)
    we free objects in the reusable area. */
 
 void
    we free objects in the reusable area. */
 
 void

-free_objfile (objfile)
-     struct objfile *objfile;
+free_objfile (struct objfile *objfile)

 {
   /* First do any symbol file specific actions required when we are
      finished with a particular symbol file.  Note that if the objfile
 {
   /* First do any symbol file specific actions required when we are
      finished with a particular symbol file.  Note that if the objfile


@@ -416,7 +417,7 @@ free_objfile (objfile)
       if (!bfd_close (objfile->obfd))
        warning ("cannot close \"%s\": %s",
                 name, bfd_errmsg (bfd_get_error ()));
       if (!bfd_close (objfile->obfd))
        warning ("cannot close \"%s\": %s",
                 name, bfd_errmsg (bfd_get_error ()));

-      free (name);
+      xfree (name);

     }
 
   /* Remove it from the chain of all objfiles. */
     }
 
   /* Remove it from the chain of all objfiles. */


@@ -436,25 +437,14 @@ free_objfile (objfile)
      is unknown, but we play it safe for now and keep each action until
      it is shown to be no longer needed. */
 
      is unknown, but we play it safe for now and keep each action until
      it is shown to be no longer needed. */
 

-#if defined (CLEAR_SOLIB)
-  CLEAR_SOLIB ();
-  /* CLEAR_SOLIB closes the bfd's for any shared libraries.  But
-     the to_sections for a core file might refer to those bfd's.  So
-     detach any core file.  */
-  {
-    struct target_ops *t = find_core_target ();
-    if (t != NULL)
-      (t->to_detach) (NULL, 0);
-  }
-#endif

   /* I *think* all our callers call clear_symtab_users.  If so, no need
      to call this here.  */
   clear_pc_function_cache ();
 
   /* The last thing we do is free the objfile struct itself for the
   /* I *think* all our callers call clear_symtab_users.  If so, no need
      to call this here.  */
   clear_pc_function_cache ();
 
   /* The last thing we do is free the objfile struct itself for the

-     non-reusable case, or detach from the mapped file for the reusable
-     case.  Note that the mmalloc_detach or the mfree is the last thing
-     we can do with this objfile. */
+     non-reusable case, or detach from the mapped file for the
+     reusable case.  Note that the mmalloc_detach or the xmfree() is
+     the last thing we can do with this objfile. */

 
 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
 
 
 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
 


@@ -479,27 +469,38 @@ free_objfile (objfile)
     {
       if (objfile->name != NULL)
        {
     {
       if (objfile->name != NULL)
        {

-         mfree (objfile->md, objfile->name);
+         xmfree (objfile->md, objfile->name);

        }
       if (objfile->global_psymbols.list)
        }
       if (objfile->global_psymbols.list)

-       mfree (objfile->md, objfile->global_psymbols.list);
+       xmfree (objfile->md, objfile->global_psymbols.list);

       if (objfile->static_psymbols.list)
       if (objfile->static_psymbols.list)

-       mfree (objfile->md, objfile->static_psymbols.list);
+       xmfree (objfile->md, objfile->static_psymbols.list);

       /* Free the obstacks for non-reusable objfiles */
       /* Free the obstacks for non-reusable objfiles */

-      obstack_free (&objfile->psymbol_cache.cache, 0);
+      free_bcache (&objfile->psymbol_cache);

       obstack_free (&objfile->psymbol_obstack, 0);
       obstack_free (&objfile->symbol_obstack, 0);
       obstack_free (&objfile->type_obstack, 0);
       obstack_free (&objfile->psymbol_obstack, 0);
       obstack_free (&objfile->symbol_obstack, 0);
       obstack_free (&objfile->type_obstack, 0);

-      mfree (objfile->md, objfile);
+      xmfree (objfile->md, objfile);

       objfile = NULL;
     }
 }
 
       objfile = NULL;
     }
 }
 

+static void
+do_free_objfile_cleanup (void *obj)
+{
+  free_objfile (obj);
+}
+
+struct cleanup *
+make_cleanup_free_objfile (struct objfile *obj)
+{
+  return make_cleanup (do_free_objfile_cleanup, obj);
+}

 
 /* Free all the object files at once and clean up their users.  */
 
 void
 
 /* Free all the object files at once and clean up their users.  */
 
 void

-free_all_objfiles ()
+free_all_objfiles (void)

 {
   struct objfile *objfile, *temp;
 
 {
   struct objfile *objfile, *temp;
 


@@ -513,9 +514,7 @@ free_all_objfiles ()
 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
    entries in new_offsets.  */
 void
 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
    entries in new_offsets.  */
 void

-objfile_relocate (objfile, new_offsets)
-     struct objfile *objfile;
-     struct section_offsets *new_offsets;
+objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets)

 {
   struct section_offsets *delta =
     (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
 {
   struct section_offsets *delta =
     (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);


@@ -525,7 +524,7 @@ objfile_relocate (objfile, new_offsets)
     int something_changed = 0;
     for (i = 0; i < objfile->num_sections; ++i)
       {
     int something_changed = 0;
     for (i = 0; i < objfile->num_sections; ++i)
       {

-       ANOFFSET (delta, i) =
+       delta->offsets[i] =

          ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
        if (ANOFFSET (delta, i) != 0)
          something_changed = 1;
          ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
        if (ANOFFSET (delta, i) != 0)
          something_changed = 1;


@@ -560,15 +559,17 @@ objfile_relocate (objfile, new_offsets)
       for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
        {
          struct block *b;
       for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
        {
          struct block *b;

+         struct symbol *sym;

          int j;
 
          b = BLOCKVECTOR_BLOCK (bv, i);
          BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
          BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
 
          int j;
 
          b = BLOCKVECTOR_BLOCK (bv, i);
          BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
          BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
 

-         for (j = 0; j < BLOCK_NSYMS (b); ++j)
+         ALL_BLOCK_SYMBOLS (b, j, sym)

            {
            {

-             struct symbol *sym = BLOCK_SYM (b, j);
+             fixup_symbol_section (sym, objfile);
+

              /* The RS6000 code from which this was taken skipped
                 any symbols in STRUCT_NAMESPACE or UNDEF_NAMESPACE.
                 But I'm leaving out that test, on the theory that
              /* The RS6000 code from which this was taken skipped
                 any symbols in STRUCT_NAMESPACE or UNDEF_NAMESPACE.
                 But I'm leaving out that test, on the theory that


@@ -586,7 +587,7 @@ objfile_relocate (objfile, new_offsets)
 
              else if (SYMBOL_CLASS (sym) == LOC_CONST
                       && SYMBOL_NAMESPACE (sym) == LABEL_NAMESPACE
 
              else if (SYMBOL_CLASS (sym) == LOC_CONST
                       && SYMBOL_NAMESPACE (sym) == LABEL_NAMESPACE

-                  && STRCMP (SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0)
+                      && strcmp (SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0)

                ecoff_relocate_efi (sym, ANOFFSET (delta,
                                                   s->block_line_section));
 #endif
                ecoff_relocate_efi (sym, ANOFFSET (delta,
                                                   s->block_line_section));
 #endif


@@ -600,8 +601,8 @@ objfile_relocate (objfile, new_offsets)
 
     ALL_OBJFILE_PSYMTABS (objfile, p)
     {
 
     ALL_OBJFILE_PSYMTABS (objfile, p)
     {

-      p->textlow += ANOFFSET (delta, SECT_OFF_TEXT);
-      p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT);
+      p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+      p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));

     }
   }
 
     }
   }
 


@@ -611,15 +612,21 @@ objfile_relocate (objfile, new_offsets)
     for (psym = objfile->global_psymbols.list;
         psym < objfile->global_psymbols.next;
         psym++)
     for (psym = objfile->global_psymbols.list;
         psym < objfile->global_psymbols.next;
         psym++)

-      if (SYMBOL_SECTION (*psym) >= 0)
-       SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
-                                                 SYMBOL_SECTION (*psym));
+      {
+       fixup_psymbol_section (*psym, objfile);
+       if (SYMBOL_SECTION (*psym) >= 0)
+         SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
+                                                   SYMBOL_SECTION (*psym));
+      }

     for (psym = objfile->static_psymbols.list;
         psym < objfile->static_psymbols.next;
         psym++)
     for (psym = objfile->static_psymbols.list;
         psym < objfile->static_psymbols.next;
         psym++)

-      if (SYMBOL_SECTION (*psym) >= 0)
-       SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
-                                                 SYMBOL_SECTION (*psym));
+      {
+       fixup_psymbol_section (*psym, objfile);
+       if (SYMBOL_SECTION (*psym) >= 0)
+         SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
+                                                   SYMBOL_SECTION (*psym));
+      }

   }
 
   {
   }
 
   {


@@ -635,9 +642,21 @@ objfile_relocate (objfile, new_offsets)
   {
     int i;
     for (i = 0; i < objfile->num_sections; ++i)
   {
     int i;
     for (i = 0; i < objfile->num_sections; ++i)

-      ANOFFSET (objfile->section_offsets, i) = ANOFFSET (new_offsets, i);
+      (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);

   }
 
   }
 

+  if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
+    {
+      /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
+        only as a fallback.  */
+      struct obj_section *s;
+      s = find_pc_section (objfile->ei.entry_point);
+      if (s)
+        objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index);
+      else
+        objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+    }
+

   {
     struct obj_section *s;
     bfd *abfd;
   {
     struct obj_section *s;
     bfd *abfd;


@@ -646,47 +665,29 @@ objfile_relocate (objfile, new_offsets)
 
     ALL_OBJFILE_OSECTIONS (objfile, s)
       {
 
     ALL_OBJFILE_OSECTIONS (objfile, s)
       {

-       flagword flags;
-
-       flags = bfd_get_section_flags (abfd, s->the_bfd_section);
-
-       if (flags & SEC_CODE)
-         {
-           s->addr += ANOFFSET (delta, SECT_OFF_TEXT);
-           s->endaddr += ANOFFSET (delta, SECT_OFF_TEXT);
-         }
-       else if (flags & (SEC_DATA | SEC_LOAD))
-         {
-           s->addr += ANOFFSET (delta, SECT_OFF_DATA);
-           s->endaddr += ANOFFSET (delta, SECT_OFF_DATA);
-         }
-       else if (flags & SEC_ALLOC)
-         {
-           s->addr += ANOFFSET (delta, SECT_OFF_BSS);
-           s->endaddr += ANOFFSET (delta, SECT_OFF_BSS);
-         }
+       int idx = s->the_bfd_section->index;
+       
+       s->addr += ANOFFSET (delta, idx);
+       s->endaddr += ANOFFSET (delta, idx);

       }
   }
 
       }
   }
 

-  if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
-    objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT);
-

   if (objfile->ei.entry_func_lowpc != INVALID_ENTRY_LOWPC)
     {
   if (objfile->ei.entry_func_lowpc != INVALID_ENTRY_LOWPC)
     {

-      objfile->ei.entry_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT);
-      objfile->ei.entry_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT);
+      objfile->ei.entry_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+      objfile->ei.entry_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));

     }
 
   if (objfile->ei.entry_file_lowpc != INVALID_ENTRY_LOWPC)
     {
     }
 
   if (objfile->ei.entry_file_lowpc != INVALID_ENTRY_LOWPC)
     {

-      objfile->ei.entry_file_lowpc += ANOFFSET (delta, SECT_OFF_TEXT);
-      objfile->ei.entry_file_highpc += ANOFFSET (delta, SECT_OFF_TEXT);
+      objfile->ei.entry_file_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+      objfile->ei.entry_file_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));

     }
 
   if (objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC)
     {
     }
 
   if (objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC)
     {

-      objfile->ei.main_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT);
-      objfile->ei.main_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT);
+      objfile->ei.main_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+      objfile->ei.main_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));

     }
 
   /* Relocate breakpoints as necessary, after things are relocated. */
     }
 
   /* Relocate breakpoints as necessary, after things are relocated. */


@@ -698,7 +699,7 @@ objfile_relocate (objfile, new_offsets)
    available, nonzero otherwise. */
 
 int
    available, nonzero otherwise. */
 
 int

-have_partial_symbols ()
+have_partial_symbols (void)

 {
   struct objfile *ofp;
 
 {
   struct objfile *ofp;
 


@@ -717,7 +718,7 @@ have_partial_symbols ()
    available, nonzero otherwise. */
 
 int
    available, nonzero otherwise. */
 
 int

-have_full_symbols ()
+have_full_symbols (void)

 {
   struct objfile *ofp;
 
 {
   struct objfile *ofp;
 


@@ -737,7 +738,7 @@ have_full_symbols ()
    command.
  */
 void
    command.
  */
 void

-objfile_purge_solibs ()
+objfile_purge_solibs (void)

 {
   struct objfile *objf;
   struct objfile *temp;
 {
   struct objfile *objf;
   struct objfile *temp;


@@ -758,7 +759,7 @@ objfile_purge_solibs ()
    available, nonzero otherwise. */
 
 int
    available, nonzero otherwise. */
 
 int

-have_minimal_symbols ()
+have_minimal_symbols (void)

 {
   struct objfile *ofp;
 
 {
   struct objfile *ofp;
 


@@ -794,10 +795,7 @@ have_minimal_symbols ()
    Otherwise, returns the open file descriptor.  */
 
 static int
    Otherwise, returns the open file descriptor.  */
 
 static int

-open_existing_mapped_file (symsfilename, mtime, flags)
-     char *symsfilename;
-     long mtime;
-     int flags;
+open_existing_mapped_file (char *symsfilename, long mtime, int flags)

 {
   int fd = -1;
   struct stat sbuf;
 {
   int fd = -1;
   struct stat sbuf;


@@ -849,10 +847,7 @@ open_existing_mapped_file (symsfilename, mtime, flags)
    /bin for example).  */
 
 static int
    /bin for example).  */
 
 static int

-open_mapped_file (filename, mtime, flags)
-     char *filename;
-     long mtime;
-     int flags;
+open_mapped_file (char *filename, long mtime, int flags)

 {
   int fd;
   char *symsfilename;
 {
   int fd;
   char *symsfilename;


@@ -860,12 +855,12 @@ open_mapped_file (filename, mtime, flags)
   /* First try to open an existing file in the current directory, and
      then try the directory where the symbol file is located. */
 
   /* First try to open an existing file in the current directory, and
      then try the directory where the symbol file is located. */
 

-  symsfilename = concat ("./", basename (filename), ".syms", (char *) NULL);
+  symsfilename = concat ("./", lbasename (filename), ".syms", (char *) NULL);

   if ((fd = open_existing_mapped_file (symsfilename, mtime, flags)) < 0)
     {
   if ((fd = open_existing_mapped_file (symsfilename, mtime, flags)) < 0)
     {

-      free (symsfilename);
+      xfree (symsfilename);

       symsfilename = concat (filename, ".syms", (char *) NULL);
       symsfilename = concat (filename, ".syms", (char *) NULL);

-      fd = open_existing_mapped_file (symsfilename, mtime, mapped);
+      fd = open_existing_mapped_file (symsfilename, mtime, flags);

     }
 
   /* If we don't have an open file by now, then either the file does not
     }
 
   /* If we don't have an open file by now, then either the file does not


@@ -877,10 +872,10 @@ open_mapped_file (filename, mtime, flags)
      By default the file is rw for everyone, with the user's umask taking
      care of turning off the permissions the user wants off. */
 
      By default the file is rw for everyone, with the user's umask taking
      care of turning off the permissions the user wants off. */
 

-  if ((fd < 0) && mapped)
+  if ((fd < 0) && (flags & OBJF_MAPPED))

     {
     {

-      free (symsfilename);
-      symsfilename = concat ("./", basename (filename), ".syms",
+      xfree (symsfilename);
+      symsfilename = concat ("./", lbasename (filename), ".syms",

                             (char *) NULL);
       if ((fd = open (symsfilename, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
        {
                             (char *) NULL);
       if ((fd = open (symsfilename, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
        {


@@ -892,13 +887,12 @@ open_mapped_file (filename, mtime, flags)
        }
     }
 
        }
     }
 

-  free (symsfilename);
+  xfree (symsfilename);

   return (fd);
 }
 
 static PTR
   return (fd);
 }
 
 static PTR

-map_to_file (fd)
-     int fd;
+map_to_file (int fd)

 {
   PTR md;
   CORE_ADDR mapto;
 {
   PTR md;
   CORE_ADDR mapto;


@@ -948,9 +942,7 @@ map_to_file (fd)
    contains a pointer to the bfd struct sec section.  */
 
 struct obj_section *
    contains a pointer to the bfd struct sec section.  */
 
 struct obj_section *

-find_pc_sect_section (pc, section)
-     CORE_ADDR pc;
-     struct sec *section;
+find_pc_sect_section (CORE_ADDR pc, struct sec *section)

 {
   struct obj_section *s;
   struct objfile *objfile;
 {
   struct obj_section *s;
   struct objfile *objfile;


@@ -967,8 +959,7 @@ find_pc_sect_section (pc, section)
    Backward compatibility, no section.  */
 
 struct obj_section *
    Backward compatibility, no section.  */
 
 struct obj_section *

-find_pc_section (pc)
-     CORE_ADDR pc;
+find_pc_section (CORE_ADDR pc)

 {
   return find_pc_sect_section (pc, find_pc_mapped_section (pc));
 }
 {
   return find_pc_sect_section (pc, find_pc_mapped_section (pc));
 }


@@ -979,9 +970,7 @@ find_pc_section (pc)
    a trampoline.  */
 
 int
    a trampoline.  */
 
 int

-in_plt_section (pc, name)
-     CORE_ADDR pc;
-     char *name;
+in_plt_section (CORE_ADDR pc, char *name)

 {
   struct obj_section *s;
   int retval = 0;
 {
   struct obj_section *s;
   int retval = 0;


@@ -998,9 +987,7 @@ in_plt_section (pc, name)
    return zero.  */
 
 int
    return zero.  */
 
 int

-is_in_import_list (name, objfile)
-     char *name;
-     struct objfile *objfile;
+is_in_import_list (char *name, struct objfile *objfile)

 {
   register int i;
 
 {
   register int i;