archives with foreign object files

[Alan Modra <amodra at bigpond dot net dot au>]

The idea of this patch is to fix a problem with `ar' when trying to
operate on an archive containing object files of a different format
to the archive itself.

eg.
$ ar crv foo.a ieee_format_obj.o
a - ieee_format_obj.o
$ ar t foo.a
ar: foo.a: File format not recognized

I was going to propose simply removing the `if (bfd_has_map (abfd))'
code from bfd_generic_archive_p, but there may be cases where multiple
targets match the archive format, with finer discrimination being
provided by examining the contained object files.

bfd/ChangeLog
	* bfd.c (enum bfd_error): Add bfd_error_wrong_object_format.
	(bfd_errmsgs): Add corresponding message.
	* archive.c (bfd_generic_archive_p): Don't release bfd_ardata when
	finding an archive that contains different format object files.
	Return bfd_error_wrong_object_format for this case.
	* format.c: Formatting fixes.  s/CONST/const/.
	(bfd_check_format_matches): Accept archives that give
	bfd_error_wrong_object_format if no full match is found.  Tidy
	code handling matching_vector.  Don't return a pointer to freed
	memory in `matching'.  Handle ambiguous matches as for partial
	archive matches.
	* bfd-in2.h: Regenerate.

Comments?  I'll apply it in a day or so if no one has any better idea.

-- 
Alan Modra

Index: bfd/archive.c
===================================================================
RCS file: /cvs/src/src/bfd/archive.c,v
retrieving revision 1.14
diff -u -p -r1.14 archive.c
--- archive.c	2001/03/08 21:03:57	1.14
+++ archive.c	2001/08/16 03:28:20
@@ -684,15 +684,19 @@ bfd_generic_archive_p (abfd)
 	  if (bfd_check_format (first, bfd_object)
 	      && first->xvec != abfd->xvec)
 	    {
+#if 0
+	      /* We ought to close `first' here, but we can't, because
+		 we have no way to remove it from the archive cache.
+		 It's close to impossible to figure out when we can
+		 release bfd_ardata.  FIXME.  */
 	      (void) bfd_close (first);
 	      bfd_release (abfd, bfd_ardata (abfd));
 	      abfd->tdata.aout_ar_data = tdata_hold;
-	      bfd_set_error (bfd_error_wrong_format);
+#endif
+	      bfd_set_error (bfd_error_wrong_object_format);
 	      return NULL;
 	    }
-
-	  /* We ought to close first here, but we can't, because we
-             have no way to remove it from the archive cache.  FIXME.  */
+	  /* And we ought to close `first' here too.  */
 	}
     }
 
Index: bfd/bfd.c
===================================================================
RCS file: /cvs/src/src/bfd/bfd.c,v
retrieving revision 1.18
diff -u -p -r1.18 bfd.c
--- bfd.c	2001/08/11 16:48:15	1.18
+++ bfd.c	2001/08/16 03:28:24
@@ -248,6 +248,7 @@ CODE_FRAGMENT
 .  bfd_error_system_call,
 .  bfd_error_invalid_target,
 .  bfd_error_wrong_format,
+.  bfd_error_wrong_object_format,
 .  bfd_error_invalid_operation,
 .  bfd_error_no_memory,
 .  bfd_error_no_symbols,
@@ -275,6 +276,7 @@ const char *const bfd_errmsgs[] =
   N_("System call error"),
   N_("Invalid bfd target"),
   N_("File in wrong format"),
+  N_("Archive object file in wrong format"),
   N_("Invalid operation"),
   N_("Memory exhausted"),
   N_("No symbols"),
Index: bfd/format.c
===================================================================
RCS file: /cvs/src/src/bfd/format.c,v
retrieving revision 1.4
diff -u -p -r1.4 format.c
--- format.c	2001/03/08 21:04:01	1.4
+++ format.c	2001/08/16 03:28:33
@@ -119,38 +119,40 @@ bfd_check_format_matches (abfd, format, 
      char ***matching;
 {
   extern const bfd_target binary_vec;
-  const bfd_target * const *target, *save_targ, *right_targ;
+  const bfd_target * const *target, *save_targ, *right_targ, *ar_right_targ;
   char **matching_vector = NULL;
   int match_count;
+  int ar_match_index;
 
-  if (!bfd_read_p (abfd) ||
-      ((int)(abfd->format) < (int)bfd_unknown) ||
-      ((int)(abfd->format) >= (int)bfd_type_end))
+  if (!bfd_read_p (abfd)
+      || ((int) abfd->format < (int) bfd_unknown)
+      || ((int) abfd->format >= (int) bfd_type_end))
     {
       bfd_set_error (bfd_error_invalid_operation);
       return false;
     }
 
   if (abfd->format != bfd_unknown)
-    return (abfd->format == format)? true: false;
+    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)
     {
+      *matching = NULL;
       matching_vector =
-	(char **) bfd_malloc (sizeof (char *) *
-			      (_bfd_target_vector_entries + 1));
+	(char **) bfd_malloc (sizeof (char *)
+			      * 2 * _bfd_target_vector_entries);
       if (!matching_vector)
 	return false;
-      matching_vector[0] = NULL;
-      *matching = matching_vector;
     }
 
   right_targ = 0;
+  ar_right_targ = 0;
 
   /* Presume the answer is yes.  */
   abfd->format = format;
@@ -202,6 +204,7 @@ bfd_check_format_matches (abfd, format, 
   for (target = bfd_target_vector; *target != NULL; target++)
     {
       const bfd_target *temp;
+      bfd_error_type err;
 
       if (*target == &binary_vec)
 	continue;
@@ -223,27 +226,20 @@ bfd_check_format_matches (abfd, format, 
 	{		/* This format checks out as ok!  */
 	  right_targ = temp;
 
-	  if (matching)
-	    {
-	      matching_vector[match_count] = temp->name;
-	      matching_vector[match_count + 1] = NULL;
-	    }
-
-	  match_count++;
-
 	  /* If this is the default target, accept it, even if other
 	     targets might match.  People who want those other targets
 	     have to set the GNUTARGET variable.  */
 	  if (temp == bfd_default_vector[0])
 	    {
-	      if (matching)
-		{
-		  matching_vector[0] = temp->name;
-		  matching_vector[1] = NULL;
-		}
 	      match_count = 1;
 	      break;
 	    }
+
+	  if (matching)
+	    matching_vector[match_count] = temp->name;
+
+	  match_count++;
+
 #ifdef GNU960
 	  /* Big- and little-endian b.out archives look the same, but it
 	     doesn't matter: there is no difference in their headers, and
@@ -253,20 +249,51 @@ bfd_check_format_matches (abfd, format, 
 	     first match we find.  */
 	  break;
 #endif
+	}
+      else if ((err = bfd_get_error ()) == bfd_error_wrong_object_format
+	       || err == bfd_error_file_ambiguously_recognized)
+	{
+	  /* An archive with objects of the wrong type, or an
+	     ambiguous match.  We want this target to match if we get
+	     no better matches.  */
+	  if (ar_right_targ != bfd_default_vector[0])
+	    ar_right_targ = *target;
+	  if (matching)
+	    matching_vector[ar_match_index] = (*target)->name;
+	  ar_match_index++;
 	}
-      else if (bfd_get_error () != bfd_error_wrong_format)
+      else if (err != bfd_error_wrong_format)
 	{
 	  abfd->xvec = save_targ;
 	  abfd->format = bfd_unknown;
 
-	  if (matching && bfd_get_error ()
-	      != bfd_error_file_ambiguously_recognized)
+	  if (matching)
 	    free (matching_vector);
 
 	  return false;
 	}
     }
 
+  if (match_count == 0)
+    {
+      /* Try partial matches.  */
+      right_targ = ar_right_targ;
+      if (right_targ == bfd_default_vector[0])
+	{
+	  match_count = 1;
+	}
+      else
+	{
+	  match_count = ar_match_index - _bfd_target_vector_entries;
+	  if (matching && match_count > 1)
+	    {
+	      memcpy (matching_vector,
+		      matching_vector + _bfd_target_vector_entries,
+		      sizeof (char *) * match_count);
+	    }
+	}
+    }
+
   if (match_count == 1)
     {
       abfd->xvec = right_targ;		/* Change BFD's target permanently.  */
@@ -288,7 +315,15 @@ bfd_check_format_matches (abfd, format, 
 	free (matching_vector);
     }
   else
-    bfd_set_error (bfd_error_file_ambiguously_recognized);
+    {
+      bfd_set_error (bfd_error_file_ambiguously_recognized);
+
+      if (matching)
+	{
+	  *matching = matching_vector;
+	  matching_vector[match_count] = NULL;
+	}
+    }
 
   return false;
 }
@@ -312,9 +347,9 @@ bfd_set_format (abfd, format)
      bfd *abfd;
      bfd_format format;
 {
-  if (bfd_read_p (abfd) ||
-      ((int)abfd->format < (int)bfd_unknown) ||
-      ((int)abfd->format >= (int)bfd_type_end))
+  if (bfd_read_p (abfd)
+      || ((int) abfd->format < (int) bfd_unknown)
+      || ((int) abfd->format >= (int) bfd_type_end))
     {
       bfd_set_error (bfd_error_invalid_operation);
       return false;
@@ -340,7 +375,7 @@ FUNCTION
 	bfd_format_string
 
 SYNOPSIS
-	CONST char *bfd_format_string(bfd_format format);
+	const char *bfd_format_string(bfd_format format);
 
 DESCRIPTION
 	Return a pointer to a const string
@@ -348,7 +383,7 @@ DESCRIPTION
 	depending upon the value of @var{format}.
 */
 
-CONST char *
+const char *
 bfd_format_string (format)
      bfd_format format;
 {