Subversion Repositories Kolibri OS

/* Generic BFD support for file formats.

/* Generic BFD support for file formats.

   Written by Cygnus Support.

   Written by Cygnus Support.

   This file is part of BFD, the Binary File Descriptor library.

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify

   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

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

   MA 02110-1301, USA.  */

/*

/*

SECTION

SECTION

	File formats

	File formats

	A format is a BFD concept of high level file contents type. The

	A format is a BFD concept of high level file contents type. The

	formats supported by BFD are:

	formats supported by BFD are:

	o <>

	o <>

	The BFD may contain data, symbols, relocations and debug info.

	The BFD may contain data, symbols, relocations and debug info.

	o <>

	o <>

	The BFD contains other BFDs and an optional index.

	The BFD contains other BFDs and an optional index.

	o <>

	o <>

	The BFD contains the result of an executable core dump.

	The BFD contains the result of an executable core dump.

SUBSECTION

SUBSECTION

	File format functions

	File format functions

*/

*/

#include "sysdep.h"

#include "sysdep.h"

#include "bfd.h"

#include "bfd.h"

#include "libbfd.h"

#include "libbfd.h"

/* IMPORT from targets.c.  */

/* IMPORT from targets.c.  */

extern const size_t _bfd_target_vector_entries;

extern const size_t _bfd_target_vector_entries;

/*

/*

FUNCTION

FUNCTION

	bfd_check_format

	bfd_check_format

SYNOPSIS

SYNOPSIS

	bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);

	bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);

DESCRIPTION

DESCRIPTION

	Verify if the file attached to the BFD @var{abfd} is compatible

	Verify if the file attached to the BFD @var{abfd} is compatible

	with the format @var{format} (i.e., one of <>,

	with the format @var{format} (i.e., one of <>,

	<> or <>).

	<> or <>).

	If the BFD has been set to a specific target before the

	If the BFD has been set to a specific target before the

	call, only the named target and format combination is

	call, only the named target and format combination is

	checked. If the target has not been set, or has been set to

	checked. If the target has not been set, or has been set to

	<>, then all the known target backends is

	<>, then all the known target backends is

	interrogated to determine a match.  If the default target

	interrogated to determine a match.  If the default target

	matches, it is used.  If not, exactly one target must recognize

	matches, it is used.  If not, exactly one target must recognize

	the file, or an error results.

	the file, or an error results.

	The function returns <> on success, otherwise <>

	The function returns <> on success, otherwise <>

	with one of the following error codes:

	with one of the following error codes:

	o <> -

	o <> -

	if <> is not one of <>, <> or

	if <> is not one of <>, <> or

	<>.

	<>.

	o <> -

	o <> -

	if an error occured during a read - even some file mismatches

	if an error occured during a read - even some file mismatches

	can cause bfd_error_system_calls.

	can cause bfd_error_system_calls.

	o <> -

	o <> -

	none of the backends recognised the file format.

	none of the backends recognised the file format.

	o <> -

	o <> -

	more than one backend recognised the file format.

	more than one backend recognised the file format.

*/

*/

bfd_boolean

bfd_boolean

bfd_check_format (bfd *abfd, bfd_format format)

bfd_check_format (bfd *abfd, bfd_format format)

{

{

  return bfd_check_format_matches (abfd, format, NULL);

  return bfd_check_format_matches (abfd, format, NULL);

}

}

struct bfd_preserve

struct bfd_preserve

{

{

  void *marker;

  void *marker;

  void *tdata;

  void *tdata;

  flagword flags;

  flagword flags;

  const struct bfd_arch_info *arch_info;

  const struct bfd_arch_info *arch_info;

  struct bfd_section *sections;

  struct bfd_section *sections;

  struct bfd_section *section_last;

  struct bfd_section *section_last;

  unsigned int section_count;

  unsigned int section_count;

  struct bfd_hash_table section_htab;

  struct bfd_hash_table section_htab;

};

};

/* When testing an object for compatibility with a particular target

/* When testing an object for compatibility with a particular target

   back-end, the back-end object_p function needs to set up certain

   back-end, the back-end object_p function needs to set up certain

   fields in the bfd on successfully recognizing the object.  This

   fields in the bfd on successfully recognizing the object.  This

   typically happens in a piecemeal fashion, with failures possible at

   typically happens in a piecemeal fashion, with failures possible at

   many points.  On failure, the bfd is supposed to be restored to its

   many points.  On failure, the bfd is supposed to be restored to its

   initial state, which is virtually impossible.  However, restoring a

   initial state, which is virtually impossible.  However, restoring a

   subset of the bfd state works in practice.  This function stores

   subset of the bfd state works in practice.  This function stores

   the subset.  */

   the subset.  */

static bfd_boolean

static bfd_boolean

bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)

bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)

{

{

  preserve->tdata = abfd->tdata.any;

  preserve->tdata = abfd->tdata.any;

  preserve->arch_info = abfd->arch_info;

  preserve->arch_info = abfd->arch_info;

  preserve->flags = abfd->flags;

  preserve->flags = abfd->flags;

  preserve->sections = abfd->sections;

  preserve->sections = abfd->sections;

  preserve->section_last = abfd->section_last;

  preserve->section_last = abfd->section_last;

  preserve->section_count = abfd->section_count;

  preserve->section_count = abfd->section_count;

  preserve->section_htab = abfd->section_htab;

  preserve->section_htab = abfd->section_htab;

  preserve->marker = bfd_alloc (abfd, 1);

  preserve->marker = bfd_alloc (abfd, 1);

  if (preserve->marker == NULL)

  if (preserve->marker == NULL)

    return FALSE;

    return FALSE;

  return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,

  return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,

			      sizeof (struct section_hash_entry));

			      sizeof (struct section_hash_entry));

}

}

/* Clear out a subset of BFD state.  */

/* Clear out a subset of BFD state.  */

static void

static void

bfd_reinit (bfd *abfd)

bfd_reinit (bfd *abfd)

{

{

  abfd->tdata.any = NULL;

  abfd->tdata.any = NULL;

  abfd->arch_info = &bfd_default_arch_struct;

  abfd->arch_info = &bfd_default_arch_struct;

  abfd->flags &= BFD_FLAGS_SAVED;

  abfd->flags &= BFD_FLAGS_SAVED;

  bfd_section_list_clear (abfd);

  bfd_section_list_clear (abfd);

}

}

/* Restores bfd state saved by bfd_preserve_save.  */

/* Restores bfd state saved by bfd_preserve_save.  */

static void

static void

bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)

bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)

{

{

  bfd_hash_table_free (&abfd->section_htab);

  bfd_hash_table_free (&abfd->section_htab);

  abfd->tdata.any = preserve->tdata;

  abfd->tdata.any = preserve->tdata;

  abfd->arch_info = preserve->arch_info;

  abfd->arch_info = preserve->arch_info;

  abfd->flags = preserve->flags;

  abfd->flags = preserve->flags;

  abfd->section_htab = preserve->section_htab;

  abfd->section_htab = preserve->section_htab;

  abfd->sections = preserve->sections;

  abfd->sections = preserve->sections;

  abfd->section_last = preserve->section_last;

  abfd->section_last = preserve->section_last;

  abfd->section_count = preserve->section_count;

  abfd->section_count = preserve->section_count;

  /* bfd_release frees all memory more recently bfd_alloc'd than

  /* bfd_release frees all memory more recently bfd_alloc'd than

     its arg, as well as its arg.  */

     its arg, as well as its arg.  */

  bfd_release (abfd, preserve->marker);

  bfd_release (abfd, preserve->marker);

  preserve->marker = NULL;

  preserve->marker = NULL;

}

}

/* Called when the bfd state saved by bfd_preserve_save is no longer

/* Called when the bfd state saved by bfd_preserve_save is no longer

   needed.  */

   needed.  */

static void

static void

bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)

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

  /* 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

     tdata, but that's not possible since these blocks are sitting

     inside bfd_alloc'd memory.  The section hash is on a separate

     inside bfd_alloc'd memory.  The section hash is on a separate

     objalloc.  */

     objalloc.  */

  bfd_hash_table_free (&preserve->section_htab);

  bfd_hash_table_free (&preserve->section_htab);

  preserve->marker = NULL;

  preserve->marker = NULL;

}

}

/*

/*

FUNCTION

FUNCTION

	bfd_check_format_matches

	bfd_check_format_matches

SYNOPSIS

SYNOPSIS

	bfd_boolean bfd_check_format_matches

	bfd_boolean bfd_check_format_matches

	  (bfd *abfd, bfd_format format, char ***matching);

	  (bfd *abfd, bfd_format format, char ***matching);

DESCRIPTION

DESCRIPTION

	Like <>, except when it returns FALSE with

	Like <>, except when it returns FALSE with

	<> set to <>.  In that

	<> set to <>.  In that

	case, if @var{matching} is not NULL, it will be filled in with

	case, if @var{matching} is not NULL, it will be filled in with

	a NULL-terminated list of the names of the formats that matched,

	a NULL-terminated list of the names of the formats that matched,

	allocated with <>.

	allocated with <>.

	Then the user may choose a format and try again.

	Then the user may choose a format and try again.

	When done with the list that @var{matching} points to, the caller

	When done with the list that @var{matching} points to, the caller

	should free it.

	should free it.

*/

*/

bfd_boolean

bfd_boolean

bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)

bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)

{

{

  extern const bfd_target binary_vec;

  extern const bfd_target binary_vec;

  const bfd_target * const *target;

  const bfd_target * const *target;

  const bfd_target **matching_vector = NULL;

  const bfd_target **matching_vector = NULL;

  const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;

  const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;

  int match_count, best_count, best_match;

  int match_count, best_count, best_match;

  int ar_match_index;

  int ar_match_index;

  struct bfd_preserve preserve;

  struct bfd_preserve preserve;

  if (matching != NULL)

  if (matching != NULL)

    *matching = NULL;

    *matching = NULL;

  if (!bfd_read_p (abfd)

  if (!bfd_read_p (abfd)

      || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)

      || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)

    {

    {

      bfd_set_error (bfd_error_invalid_operation);

      bfd_set_error (bfd_error_invalid_operation);

      return FALSE;

      return FALSE;

    }

    }

  if (abfd->format != bfd_unknown)

  if (abfd->format != bfd_unknown)

    return abfd->format == format;

    return abfd->format == format;

  if (matching != NULL || *bfd_associated_vector != NULL)

  if (matching != NULL || *bfd_associated_vector != NULL)

    {

    {

      bfd_size_type amt;

      bfd_size_type amt;

      amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;

      amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;

      matching_vector = (const bfd_target **) bfd_malloc (amt);

      matching_vector = (const bfd_target **) bfd_malloc (amt);

      if (!matching_vector)

      if (!matching_vector)

	return FALSE;

	return FALSE;

    }

    }

  /* Presume the answer is yes.  */

  /* Presume the answer is yes.  */

  abfd->format = format;

  abfd->format = format;

  save_targ = abfd->xvec;

  save_targ = abfd->xvec;

  preserve.marker = NULL;

  preserve.marker = NULL;

  /* If the target type was explicitly specified, just check that target.  */

  /* If the target type was explicitly specified, just check that target.  */

  if (!abfd->target_defaulted)

  if (!abfd->target_defaulted)

    {

    {

      if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)	/* rewind! */

      if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)	/* rewind! */

	goto err_ret;

	goto err_ret;

      right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));

      right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));

      if (right_targ)

      if (right_targ)

	goto ok_ret;

	goto ok_ret;

      /* For a long time the code has dropped through to check all

      /* For a long time the code has dropped through to check all

	 targets if the specified target was wrong.  I don't know why,

	 targets if the specified target was wrong.  I don't know why,

	 and I'm reluctant to change it.  However, in the case of an

	 and I'm reluctant to change it.  However, in the case of an

	 archive, it can cause problems.  If the specified target does

	 archive, it can cause problems.  If the specified target does

	 not permit archives (e.g., the binary target), then we should

	 not permit archives (e.g., the binary target), then we should

	 not allow some other target to recognize it as an archive, but

	 not allow some other target to recognize it as an archive, but

	 should instead allow the specified target to recognize it as an

	 should instead allow the specified target to recognize it as an

	 object.  When I first made this change, it broke the PE target,

	 object.  When I first made this change, it broke the PE target,

	 because the specified pei-i386 target did not recognize the

	 because the specified pei-i386 target did not recognize the

	 actual pe-i386 archive.  Since there may be other problems of

	 actual pe-i386 archive.  Since there may be other problems of

	 this sort, I changed this test to check only for the binary

	 this sort, I changed this test to check only for the binary

	 target.  */

	 target.  */

      if (format == bfd_archive && save_targ == &binary_vec)

      if (format == bfd_archive && save_targ == &binary_vec)

	goto err_unrecog;

	goto err_unrecog;

    }

    }

  /* Since the target type was defaulted, check them all in the hope

  /* Since the target type was defaulted, check them all in the hope

     that one will be uniquely recognized.  */

     that one will be uniquely recognized.  */

  right_targ = NULL;

  right_targ = NULL;

  ar_right_targ = NULL;

  ar_right_targ = NULL;

  match_targ = NULL;

  match_targ = NULL;

  best_match = 256;

  best_match = 256;

  best_count = 0;

  best_count = 0;

  match_count = 0;

  match_count = 0;

  ar_match_index = _bfd_target_vector_entries;

  ar_match_index = _bfd_target_vector_entries;

  for (target = bfd_target_vector; *target != NULL; target++)

  for (target = bfd_target_vector; *target != NULL; target++)

    {

    {

      const bfd_target *temp;

      const bfd_target *temp;

      /* Don't check the default target twice.  */

      /* Don't check the default target twice.  */

      if (*target == &binary_vec

      if (*target == &binary_vec

	  || (!abfd->target_defaulted && *target == save_targ)

	  || (!abfd->target_defaulted && *target == save_targ)

	  || (*target)->match_priority > best_match)

	  || (*target)->match_priority > best_match)

	continue;

	continue;

      /* If we already tried a match, the bfd is modified and may

      /* If we already tried a match, the bfd is modified and may

	 have sections attached, which will confuse the next

	 have sections attached, which will confuse the next

	 _bfd_check_format call.  */

	 _bfd_check_format call.  */

      bfd_reinit (abfd);

      bfd_reinit (abfd);

      /* Change BFD's target temporarily.  */

      /* Change BFD's target temporarily.  */

      abfd->xvec = *target;

      abfd->xvec = *target;

      if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)

      if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)

	goto err_ret;

	goto err_ret;

      /* If _bfd_check_format neglects to set bfd_error, assume

      /* If _bfd_check_format neglects to set bfd_error, assume

	 bfd_error_wrong_format.  We didn't used to even pay any

	 bfd_error_wrong_format.  We didn't used to even pay any

	 attention to bfd_error, so I suspect that some

	 attention to bfd_error, so I suspect that some

	 _bfd_check_format might have this problem.  */

	 _bfd_check_format might have this problem.  */

      bfd_set_error (bfd_error_wrong_format);

      bfd_set_error (bfd_error_wrong_format);

      temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));

      temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));

      if (temp)

      if (temp)

	{

	{

	  match_targ = temp;

	  match_targ = temp;

	  if (preserve.marker != NULL)

	  if (preserve.marker != NULL)

	    bfd_preserve_finish (abfd, &preserve);

	    bfd_preserve_finish (abfd, &preserve);

	  if (abfd->format != bfd_archive

	  if (abfd->format != bfd_archive

	      || (bfd_has_map (abfd)

	      || (bfd_has_map (abfd)

		  && bfd_get_error () != bfd_error_wrong_object_format))

		  && bfd_get_error () != bfd_error_wrong_object_format))

	    {

	    {

	      /* This format checks out as ok!  */

	      /* This format checks out as ok!  */

	      right_targ = temp;

	      right_targ = temp;

	      /* If this is the default target, accept it, even if

	      /* If this is the default target, accept it, even if

		 other targets might match.  People who want those

		 other targets might match.  People who want those

		 other targets have to set the GNUTARGET variable.  */

		 other targets have to set the GNUTARGET variable.  */

	      if (temp == bfd_default_vector[0])

	      if (temp == bfd_default_vector[0])

		goto ok_ret;

		goto ok_ret;

	      if (matching_vector)

	      if (matching_vector)

		matching_vector[match_count] = temp;

		matching_vector[match_count] = temp;

	      match_count++;

	      match_count++;

	      if (temp->match_priority < best_match)

	      if (temp->match_priority < best_match)

		{

		{

		  best_match = temp->match_priority;

		  best_match = temp->match_priority;

		  best_count = 0;

		  best_count = 0;

		}

		}

	      best_count++;

	      best_count++;

	    }

	    }

	  else

	  else

	    {

	    {

	      /* An archive with no armap or objects of the wrong

	      /* An archive with no armap or objects of the wrong

		 type.  We want this target to match if we get no

		 type.  We want this target to match if we get no

		 better matches.  */

		 better matches.  */

	      if (ar_right_targ != bfd_default_vector[0])

	      if (ar_right_targ != bfd_default_vector[0])

		ar_right_targ = *target;

		ar_right_targ = *target;

	      if (matching_vector)

	      if (matching_vector)

		matching_vector[ar_match_index] = *target;

		matching_vector[ar_match_index] = *target;

	      ar_match_index++;

	      ar_match_index++;

	    }

	    }

	  if (!bfd_preserve_save (abfd, &preserve))

	  if (!bfd_preserve_save (abfd, &preserve))

	    goto err_ret;

	    goto err_ret;

	}

	}

      else if (bfd_get_error () != bfd_error_wrong_format)

      else if (bfd_get_error () != bfd_error_wrong_format)

	goto err_ret;

	goto err_ret;

    }

    }

  if (best_count == 1)

  if (best_count == 1)

    match_count = 1;

    match_count = 1;

  if (match_count == 0)

  if (match_count == 0)

    {

    {

      /* Try partial matches.  */

      /* Try partial matches.  */

      right_targ = ar_right_targ;

      right_targ = ar_right_targ;

      if (right_targ == bfd_default_vector[0])

      if (right_targ == bfd_default_vector[0])

	{

	{

	  match_count = 1;

	  match_count = 1;

	}

	}

      else

      else

	{

	{

	  match_count = ar_match_index - _bfd_target_vector_entries;

	  match_count = ar_match_index - _bfd_target_vector_entries;

	  if (matching_vector && match_count > 1)

	  if (matching_vector && match_count > 1)

	    memcpy (matching_vector,

	    memcpy (matching_vector,

		    matching_vector + _bfd_target_vector_entries,

		    matching_vector + _bfd_target_vector_entries,

		    sizeof (*matching_vector) * match_count);

		    sizeof (*matching_vector) * match_count);

	}

	}

    }

    }

  /* We have more than one equally good match.  If any of the best

  /* We have more than one equally good match.  If any of the best

     matches is a target in config.bfd targ_defvec or targ_selvecs,

     matches is a target in config.bfd targ_defvec or targ_selvecs,

     choose it.  */

     choose it.  */

  if (match_count > 1)

  if (match_count > 1)

    {

    {

      const bfd_target * const *assoc = bfd_associated_vector;

      const bfd_target * const *assoc = bfd_associated_vector;

      while ((right_targ = *assoc++) != NULL)

      while ((right_targ = *assoc++) != NULL)

	{

	{

	  int i = match_count;

	  int i = match_count;

	  while (--i >= 0)

	  while (--i >= 0)

	    if (matching_vector[i] == right_targ

	    if (matching_vector[i] == right_targ

		&& right_targ->match_priority <= best_match)

		&& right_targ->match_priority <= best_match)

	      break;

	      break;

	  if (i >= 0)

	  if (i >= 0)

	    {

	    {

	      match_count = 1;

	      match_count = 1;

	      break;

	      break;

	    }

	    }

	}

	}

    }

    }

  /* We still have more than one equally good match, and at least some

  /* We still have more than one equally good match, and at least some

     of the targets support match priority.  Choose the first of the

     of the targets support match priority.  Choose the first of the

     best matches.  */

     best matches.  */

    {

    {

      int i;

      int i;

      for (i = 0; i < match_count; i++)

      for (i = 0; i < match_count; i++)

	{

	{

	  right_targ = matching_vector[i];

	  right_targ = matching_vector[i];

	  if (right_targ->match_priority <= best_match)

	  if (right_targ->match_priority <= best_match)

	    break;

	    break;

	}

	}

      match_count = 1;

      match_count = 1;

    }

    }

  /* There is way too much undoing of half-known state here.  We

  /* There is way too much undoing of half-known state here.  We

     really shouldn't iterate on live bfd's.  Note that saving the

     really shouldn't iterate on live bfd's.  Note that saving the

     whole bfd and restoring it would be even worse; the first thing

     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.  */

     you notice is that the cached bfd file position gets out of sync.  */

  if (preserve.marker != NULL)

  if (preserve.marker != NULL)

    bfd_preserve_restore (abfd, &preserve);

    bfd_preserve_restore (abfd, &preserve);

  if (match_count == 1)

  if (match_count == 1)

    {

    {

      abfd->xvec = right_targ;

      abfd->xvec = right_targ;

      /* If we come out of the loop knowing that the last target that

      /* If we come out of the loop knowing that the last target that

	 matched is the one we want, then ABFD should still be in a usable

	 matched is the one we want, then ABFD should still be in a usable

	 state (except possibly for XVEC).  */

	 state (except possibly for XVEC).  */

      if (match_targ != right_targ)

      if (match_targ != right_targ)

	{

	{

	  bfd_reinit (abfd);

	  bfd_reinit (abfd);

	  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)

	  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)

	    goto err_ret;

	    goto err_ret;

	  match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));

	  match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));

	  BFD_ASSERT (match_targ != NULL);

	  BFD_ASSERT (match_targ != NULL);

	}

	}

    ok_ret:

    ok_ret:

      /* If the file was opened for update, then `output_has_begun'

      /* If the file was opened for update, then `output_has_begun'

	 some time ago when the file was created.  Do not recompute

	 some time ago when the file was created.  Do not recompute

	 sections sizes or alignments in _bfd_set_section_contents.

	 sections sizes or alignments in _bfd_set_section_contents.

	 We can not set this flag until after checking the format,

	 We can not set this flag until after checking the format,

	 because it will interfere with creation of BFD sections.  */

	 because it will interfere with creation of BFD sections.  */

      if (abfd->direction == both_direction)

      if (abfd->direction == both_direction)

	abfd->output_has_begun = TRUE;

	abfd->output_has_begun = TRUE;

      if (matching_vector)

      if (matching_vector)

	free (matching_vector);

	free (matching_vector);

      /* File position has moved, BTW.  */

      /* File position has moved, BTW.  */

      return TRUE;

      return TRUE;

    }

    }

  if (match_count == 0)

  if (match_count == 0)

    {

    {

    err_unrecog:

    err_unrecog:

      bfd_set_error (bfd_error_file_not_recognized);

      bfd_set_error (bfd_error_file_not_recognized);

    err_ret:

    err_ret:

      abfd->xvec = save_targ;

      abfd->xvec = save_targ;

      abfd->format = bfd_unknown;

      abfd->format = bfd_unknown;

      if (matching_vector)

      if (matching_vector)

	free (matching_vector);

	free (matching_vector);

      if (preserve.marker != NULL)

      if (preserve.marker != NULL)

	bfd_preserve_restore (abfd, &preserve);

	bfd_preserve_restore (abfd, &preserve);

      return FALSE;

      return FALSE;

    }

    }

  /* Restore original target type and format.  */

  /* Restore original target type and format.  */

  abfd->xvec = save_targ;

  abfd->xvec = save_targ;

  abfd->format = bfd_unknown;

  abfd->format = bfd_unknown;

  bfd_set_error (bfd_error_file_ambiguously_recognized);

  bfd_set_error (bfd_error_file_ambiguously_recognized);

  if (matching)

  if (matching)

    {

    {

      *matching = (char **) matching_vector;

      *matching = (char **) matching_vector;

      matching_vector[match_count] = NULL;

      matching_vector[match_count] = NULL;

      /* Return target names.  This is a little nasty.  Maybe we

      /* Return target names.  This is a little nasty.  Maybe we

	 should do another bfd_malloc?  */

	 should do another bfd_malloc?  */

      while (--match_count >= 0)

      while (--match_count >= 0)

	{

	{

	  const char *name = matching_vector[match_count]->name;

	  const char *name = matching_vector[match_count]->name;

	  *(const char **) &matching_vector[match_count] = name;

	  *(const char **) &matching_vector[match_count] = name;

	}

	}

    }

    }

  return FALSE;

  return FALSE;

}

}

/*

/*

FUNCTION

FUNCTION

	bfd_set_format

	bfd_set_format

SYNOPSIS

SYNOPSIS

	bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);

	bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);

DESCRIPTION

DESCRIPTION

	This function sets the file format of the BFD @var{abfd} to the

	This function sets the file format of the BFD @var{abfd} to the

	format @var{format}. If the target set in the BFD does not

	format @var{format}. If the target set in the BFD does not

	support the format requested, the format is invalid, or the BFD

	support the format requested, the format is invalid, or the BFD

	is not open for writing, then an error occurs.

	is not open for writing, then an error occurs.

*/

*/

bfd_boolean

bfd_boolean

bfd_set_format (bfd *abfd, bfd_format format)

bfd_set_format (bfd *abfd, bfd_format format)

{

{

  if (bfd_read_p (abfd)

  if (bfd_read_p (abfd)

      || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)

      || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)

    {

    {

      bfd_set_error (bfd_error_invalid_operation);

      bfd_set_error (bfd_error_invalid_operation);

      return FALSE;

      return FALSE;

    }

    }

  if (abfd->format != bfd_unknown)

  if (abfd->format != bfd_unknown)

    return abfd->format == format;

    return abfd->format == format;

  /* Presume the answer is yes.  */

  /* Presume the answer is yes.  */

  abfd->format = format;

  abfd->format = format;

  if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))

  if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))

    {

    {

      abfd->format = bfd_unknown;

      abfd->format = bfd_unknown;

      return FALSE;

      return FALSE;

    }

    }

  return TRUE;

  return TRUE;

}

}

/*

/*

FUNCTION

FUNCTION

	bfd_format_string

	bfd_format_string

SYNOPSIS

SYNOPSIS

	const char *bfd_format_string (bfd_format format);

	const char *bfd_format_string (bfd_format format);

DESCRIPTION

DESCRIPTION

	Return a pointer to a const string

	Return a pointer to a const string

	<>, <

	<>, <

	depending upon the value of @var{format}.

	depending upon the value of @var{format}.

*/

*/

const char *

const char *

bfd_format_string (bfd_format format)

bfd_format_string (bfd_format format)

{

{

  if (((int) format < (int) bfd_unknown)

  if (((int) format < (int) bfd_unknown)

      || ((int) format >= (int) bfd_type_end))

      || ((int) format >= (int) bfd_type_end))

    return "invalid";

    return "invalid";

  switch (format)

  switch (format)

    {

    {

    case bfd_object:

    case bfd_object:

      return "object";		/* Linker/assembler/compiler output.  */

      return "object";		/* Linker/assembler/compiler output.  */

    case bfd_archive:

    case bfd_archive:

      return "archive";		/* Object archive file.  */

      return "archive";		/* Object archive file.  */

    case bfd_core:

    case bfd_core:

      return "core";		/* Core dump.  */

      return "core";		/* Core dump.  */

    default:

    default:

      return "unknown";

      return "unknown";

    }

    }

}

}