Merge GDB 7.5.1

gdb/objfiles.c

 /* GDB routines for manipulating objfiles.
 
    Copyright (C) 1992-2004, 2007-2012 Free Software Foundation, Inc.
 
    Contributed by Cygnus Support, using pieces from other GDB modules.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ skipping 87 matching lines @@
   info = program_space_data (pspace, objfiles_pspace_data);
   if (info == NULL)
     {
       info = XZALLOC (struct objfile_pspace_info);
       set_program_space_data (pspace, objfiles_pspace_data, info);
     }
 
   return info;
 }
 
-/* Records whether any objfiles appeared or disappeared since we last updated
-   address to obj section map.  */
-
-/* Locate all mappable sections of a BFD file.
-   objfile_p_char is a char * to get it through
-   bfd_map_over_sections; we cast it back to its proper type.  */
-
 /* Called via bfd_map_over_sections to build up the section table that
    the objfile references.  The objfile contains pointers to the start
    of the table (objfile->sections) and to the first location after
    the end of the table (objfile->sections_end).  */
 
 static void
 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
-                         void *objfile_p_char)
+                         void *objfilep)
 {
-  struct objfile *objfile = (struct objfile *) objfile_p_char;
+  struct objfile *objfile = (struct objfile *) objfilep;
   struct obj_section section;
   flagword aflag;
 
   aflag = bfd_get_section_flags (abfd, asect);
-
   if (!(aflag & SEC_ALLOC))
     return;
+  if (bfd_section_size (abfd, asect) == 0)
+    return;
 
-  if (0 == bfd_section_size (abfd, asect))
-    return;
   section.objfile = objfile;
   section.the_bfd_section = asect;
   section.ovly_mapped = 0;
   obstack_grow (&objfile->objfile_obstack,
                 (char *) &section, sizeof (section));
   objfile->sections_end
     = (struct obj_section *) (((size_t) objfile->sections_end) + 1);
 }
 
 /* Builds a section table for OBJFILE.
-   Returns 0 if OK, 1 on error (in which case bfd_error contains the
-   error).
 
    Note that while we are building the table, which goes into the
-   psymbol obstack, we hijack the sections_end pointer to instead hold
+   objfile obstack, we hijack the sections_end pointer to instead hold
    a count of the number of sections.  When bfd_map_over_sections
    returns, this count is used to compute the pointer to the end of
    the sections table, which then overwrites the count.
 
    Also note that the OFFSET and OVLY_MAPPED in each table entry
    are initialized to zero.
 
-   Also note that if anything else writes to the psymbol obstack while
+   Also note that if anything else writes to the objfile obstack while
    we are building the table, we're pretty much hosed.  */
 
-int
+void
 build_objfile_section_table (struct objfile *objfile)
 {
   objfile->sections_end = 0;
   bfd_map_over_sections (objfile->obfd,
                          add_to_objfile_sections, (void *) objfile);
   objfile->sections = obstack_finish (&objfile->objfile_obstack);
   objfile->sections_end = objfile->sections + (size_t) objfile->sections_end;
-  return (0);
 }
 
 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
    allocate a new objfile struct, fill it in as best we can, link it
    into the list of all known objfiles, and return a pointer to the
    new objfile struct.
 
    The FLAGS word contains various bits (OBJF_*) that can be taken as
    requests for specific operations.  Other bits like OBJF_SHARED are
    simply copied through to the new objfile flags member.  */
@@ skipping 30 matching lines @@
   objfile->obfd = gdb_bfd_ref (abfd);
   if (abfd != NULL)
     {
       /* Look up the gdbarch associated with the BFD.  */
       objfile->gdbarch = gdbarch_from_bfd (abfd);
 
       objfile->name = xstrdup (bfd_get_filename (abfd));
       objfile->mtime = bfd_get_mtime (abfd);
 
       /* Build section table.  */
-
-      if (build_objfile_section_table (objfile))
-        {
-          error (_("Can't find the file sections in `%s': %s"),
-                 objfile->name, bfd_errmsg (bfd_get_error ()));
-        }
+      build_objfile_section_table (objfile);
     }
   else
     {
       objfile->name = xstrdup ("<<anonymous objfile>>");
     }
 
   objfile->pspace = current_program_space;
 
   /* Initialize the section indexes for this objfile, so that we can
      later detect if they are used w/o being properly assigned to.  */
@@ skipping 100 matching lines @@
 entry_point_address (void)
 {
   CORE_ADDR retval;
 
   if (!entry_point_address_query (&retval))
     error (_("Entry point address is not known."));
 
   return retval;
 }
 
-/* Create the terminating entry of OBJFILE's minimal symbol table.
-   If OBJFILE->msymbols is zero, allocate a single entry from
-   OBJFILE->objfile_obstack; otherwise, just initialize
-   OBJFILE->msymbols[OBJFILE->minimal_symbol_count].  */
-void
-terminate_minimal_symbol_table (struct objfile *objfile)
-{
-  if (! objfile->msymbols)
-    objfile->msymbols = ((struct minimal_symbol *)
-                         obstack_alloc (&objfile->objfile_obstack,
-                                        sizeof (objfile->msymbols[0])));
-
-  {
-    struct minimal_symbol *m
-      = &objfile->msymbols[objfile->minimal_symbol_count];
-
-    memset (m, 0, sizeof (*m));
-    /* Don't rely on these enumeration values being 0's.  */
-    MSYMBOL_TYPE (m) = mst_unknown;
-    SYMBOL_SET_LANGUAGE (m, language_unknown);
-  }
-}
-
 /* Iterator on PARENT and every separate debug objfile of PARENT.
    The usage pattern is:
      for (objfile = parent;
           objfile;
           objfile = objfile_separate_debug_iterate (parent, objfile))
        ...
 */
 
 struct objfile *
 objfile_separate_debug_iterate (const struct objfile *parent,
@@ skipping 381 matching lines @@
       if (BLOCKVECTOR_MAP (bv))
         addrmap_relocate (BLOCKVECTOR_MAP (bv),
                           ANOFFSET (delta, s->block_line_section));
 
       for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
         {
           struct block *b;
           struct symbol *sym;
           struct dict_iterator iter;