* bfd.c (struct bfd_preserve, bfd_preserve_save, bfd_preserve_restore,

	bfd_preserve_finish): Move to..
	* format.c: ..here, splitting out..
	(bfd_reinit): ..this.  New function.
	(bfd_check_format_matches): Use bfd_preserve_save/restore to
	keep bfd state for a match.
	* elfcode.h (elf_object_p): Don't use bfd_preserve_save/restore.
	* elfcore.h (elf_core_file_p): Likewise.
	* mach-o.c (bfd_mach_o_header_p): Likewise.
	* pef.c (bfd_pef_object_p, bfd_pef_xlib_object_p): Likewise.
	* xsym.c (bfd_sym_object_p): Likewise.
	* mmo.c (mmo_scan): Clear abfd->symcount.
	* opncls.c (_bfd_new_bfd): Use a smaller section hash table.
	* section.c (bfd_section_list_clear): Clear section_htab.count.
	* bfd-in2.h: Regenerate.

1 files changed, 130 insertions, 17 deletions

diff --git a/bfd/format.c b/bfd/format.c
index 66b9051..36eeb85 100644
--- a/bfd/format.c
+++ b/bfd/format.c
@@ -95,6 +95,91 @@ bfd_check_format (bfd *abfd, bfd_format format)
   return bfd_check_format_matches (abfd, format, NULL);
 }
 
+struct bfd_preserve
+{
+  void *marker;
+  void *tdata;
+  flagword flags;
+  const struct bfd_arch_info *arch_info;
+  struct bfd_section *sections;
+  struct bfd_section *section_last;
+  unsigned int section_count;
+  struct bfd_hash_table section_htab;
+};
+
+/* When testing an object for compatibility with a particular target
+   back-end, the back-end object_p function needs to set up certain
+   fields in the bfd on successfully recognizing the object.  This
+   typically happens in a piecemeal fashion, with failures possible at
+   many points.  On failure, the bfd is supposed to be restored to its
+   initial state, which is virtually impossible.  However, restoring a
+   subset of the bfd state works in practice.  This function stores
+   the subset.  */
+
+static bfd_boolean
+bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
+{
+  preserve->tdata = abfd->tdata.any;
+  preserve->arch_info = abfd->arch_info;
+  preserve->flags = abfd->flags;
+  preserve->sections = abfd->sections;
+  preserve->section_last = abfd->section_last;
+  preserve->section_count = abfd->section_count;
+  preserve->section_htab = abfd->section_htab;
+  preserve->marker = bfd_alloc (abfd, 1);
+  if (preserve->marker == NULL)
+    return FALSE;
+
+  return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
+			      sizeof (struct section_hash_entry));
+}
+
+/* Clear out a subset of BFD state.  */
+
+static void
+bfd_reinit (bfd *abfd)
+{
+  abfd->tdata.any = NULL;
+  abfd->arch_info = &bfd_default_arch_struct;
+  abfd->flags &= BFD_FLAGS_SAVED;
+  bfd_section_list_clear (abfd);
+}
+
+/* Restores bfd state saved by bfd_preserve_save.  */
+
+static void
+bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
+{
+  bfd_hash_table_free (&abfd->section_htab);
+
+  abfd->tdata.any = preserve->tdata;
+  abfd->arch_info = preserve->arch_info;
+  abfd->flags = preserve->flags;
+  abfd->section_htab = preserve->section_htab;
+  abfd->sections = preserve->sections;
+  abfd->section_last = preserve->section_last;
+  abfd->section_count = preserve->section_count;
+
+  /* bfd_release frees all memory more recently bfd_alloc'd than
+     its arg, as well as its arg.  */
+  bfd_release (abfd, preserve->marker);
+  preserve->marker = NULL;
+}
+
+/* Called when the bfd state saved by bfd_preserve_save is no longer
+   needed.  */
+
+static void
+bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
+{
+  /* It would be nice to be able to free more memory here, eg. old
+     tdata, but that's not possible since these blocks are sitting
+     inside bfd_alloc'd memory.  The section hash is on a separate
+     objalloc.  */
+  bfd_hash_table_free (&preserve->section_htab);
+  preserve->marker = NULL;
+}
+
 /*
 FUNCTION
 	bfd_check_format_matches
@@ -124,6 +209,7 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
   const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;
   int match_count, best_count, best_match;
   int ar_match_index;
+  struct bfd_preserve preserve;
 
   if (matching != NULL)
     *matching = NULL;
@@ -138,12 +224,6 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
   if (abfd->format != bfd_unknown)
     return abfd->format == format;
 
-  /* Since the target type was defaulted, check them
-     all in the hope that one will be uniquely recognized.  */
-  save_targ = abfd->xvec;
-  match_count = 0;
-  ar_match_index = _bfd_target_vector_entries;
-
   if (matching != NULL || *bfd_associated_vector != NULL)
     {
       bfd_size_type amt;
@@ -154,14 +234,10 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
 	return FALSE;
     }
 
-  right_targ = 0;
-  ar_right_targ = 0;
-  match_targ = 0;
-  best_match = 256;
-  best_count = 0;
-
   /* Presume the answer is yes.  */
   abfd->format = format;
+  save_targ = abfd->xvec;
+  preserve.marker = NULL;
 
   /* If the target type was explicitly specified, just check that target.  */
   if (!abfd->target_defaulted)
@@ -190,6 +266,16 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
 	goto err_unrecog;
     }
 
+  /* Since the target type was defaulted, check them all in the hope
+     that one will be uniquely recognized.  */
+  right_targ = NULL;
+  ar_right_targ = NULL;
+  match_targ = NULL;
+  best_match = 256;
+  best_count = 0;
+  match_count = 0;
+  ar_match_index = _bfd_target_vector_entries;
+
   for (target = bfd_target_vector; *target != NULL; target++)
     {
       const bfd_target *temp;
@@ -201,7 +287,13 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
 	  || (*target)->match_priority > best_match)
 	continue;
 
-      abfd->xvec = *target;	/* Change BFD's target temporarily.  */
+      /* If we already tried a match, the bfd is modified and may
+	 have sections attached, which will confuse the next
+	 _bfd_check_format call.  */
+      bfd_reinit (abfd);
+
+      /* Change BFD's target temporarily.  */
+      abfd->xvec = *target;
 
       if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 	goto err_ret;
@@ -214,7 +306,11 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
 
       temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
       if (temp)
-	match_targ = temp;
+	{
+	  match_targ = temp;
+	  if (preserve.marker != NULL)
+	    bfd_preserve_finish (abfd, &preserve);
+	}
 
       if (temp && (abfd->format != bfd_archive || bfd_has_map (abfd)))
 	{
@@ -253,6 +349,9 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
 	}
       else if (err != bfd_error_wrong_format)
 	goto err_ret;
+
+      if (temp && !bfd_preserve_save (abfd, &preserve))
+	goto err_ret;
     }
 
   if (best_count == 1)
@@ -298,6 +397,13 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
 	}
     }
 
+  /* There is way too much undoing of half-known state here.  We
+     really shouldn't iterate on live bfd's.  Note that saving the
+     whole bfd and restoring it would be even worse; the first thing
+     you notice is that the cached bfd file position gets out of sync.  */
+  if (preserve.marker != NULL)
+    bfd_preserve_restore (abfd, &preserve);
+
   if (match_count == 1)
     {
       abfd->xvec = right_targ;
@@ -306,9 +412,11 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
 	 state (except possibly for XVEC).  */
       if (match_targ != right_targ)
 	{
+	  bfd_reinit (abfd);
 	  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 	    goto err_ret;
 	  match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
+	  BFD_ASSERT (match_targ != NULL);
 	}
 
     ok_ret:
@@ -322,7 +430,9 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
 
       if (matching_vector)
 	free (matching_vector);
-      return TRUE;			/* File position has moved, BTW.  */
+
+      /* File position has moved, BTW.  */
+      return TRUE;
     }
 
   if (match_count == 0)
@@ -334,11 +444,14 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
       abfd->format = bfd_unknown;
       if (matching_vector)
 	free (matching_vector);
+      if (preserve.marker != NULL)
+	bfd_preserve_restore (abfd, &preserve);
       return FALSE;
     }
 
-  abfd->xvec = save_targ;		/* Restore original target type.  */
-  abfd->format = bfd_unknown;		/* Restore original format.  */
+  /* Restore original target type and format.  */
+  abfd->xvec = save_targ;
+  abfd->format = bfd_unknown;
   bfd_set_error (bfd_error_file_ambiguously_recognized);
 
   if (matching)