[deliverable/binutils-gdb.git] / bfd / format.c

/* Generic BFD support for file formats.
   Copyright (C) 1990-1991 Free Software Foundation, Inc.
   Written by Cygnus Support.

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

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
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/*
SECTION
	File Formats

	A format is a BFD concept of high level file contents type. The
	formats supported by BFD are: 

	o <<bfd_object>>

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

	o <<bfd_archive>>

	The BFD contains other BFDs and an optional index.

	o <<bfd_core>>

	The BFD contains the result of an executable core dump.


*/

#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"

extern bfd_target *target_vector[];
extern bfd_target *default_vector[];


/*
FUNCTION
	bfd_check_format

SYNOPSIS
	boolean bfd_check_format(bfd *abfd, bfd_format format);

DESCRIPTION
	Verify if the file attached to the BFD @var{abfd} is compatible
	with the format @var{format} (i.e., one of <<bfd_object>>,
	<<bfd_archive>> or <<bfd_core>>).

	If the BFD has been set to a specific target before the
	call, only the named target and format combination is
	checked. If the target has not been set, or has been set to
	<<default>>, then all the known target backends is
	interrogated to determine a match.  If the default target
	matches, it is used.  If not, exactly one target must recognize
	the file, or an error results.

	The function returns <<true>> on success, otherwise <<false>>
	with one of the following error codes:  

	o invalid_operation -
	if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
	<<bfd_core>>.

	o system_call_error -
	if an error occured during a read - even some file mismatches
	can cause system_call_errors.

	o file_not_recognised -
	none of the backends recognised the file format.

	o file_ambiguously_recognized -
	more than one backend recognised the file format.

*/

boolean
DEFUN(bfd_check_format,(abfd, format),
      bfd *abfd AND
      bfd_format format)
{
  bfd_target **target, *save_targ, *right_targ;
  int match_count;

  if (!bfd_read_p (abfd) ||
      ((int)(abfd->format) < (int)bfd_unknown) ||
      ((int)(abfd->format) >= (int)bfd_type_end)) {
    bfd_error = invalid_operation;
    return false;
  }

  if (abfd->format != bfd_unknown)
    return (abfd->format == format)? true: false;


  /* 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;
  right_targ = 0;


  /* presume the answer is yes */
  abfd->format = format;

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

  if (!abfd->target_defaulted) {
    bfd_seek (abfd, (file_ptr)0, SEEK_SET);	/* rewind! */

    right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
    if (right_targ) {
      abfd->xvec = right_targ;		/* Set the target as returned */
      return true;			/* File position has moved, BTW */
    }
  }

  for (target = target_vector; *target != NULL; target++) {
    bfd_target *temp;

    abfd->xvec = *target;	/* Change BFD's target temporarily */
    bfd_seek (abfd, (file_ptr)0, SEEK_SET);
    /* If _bfd_check_format neglects to set bfd_error, assume wrong_format.
       We didn't used to even pay any attention to bfd_error, so I suspect
       that some _bfd_check_format might have this problem.  */
    bfd_error = wrong_format;
    temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
    if (temp) {				/* This format checks out as ok! */
      right_targ = temp;
      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 == default_vector[0])
	{
	  match_count = 1;
	  break;
	}
#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 member file byte
       * orders will (I hope) be handled appropriately by bfd.  Ditto for big
       * and little coff archives.  And the 4 coff/b.out object formats are
       * unambiguous.  So accept the first match we find.
       */
      break;
#endif
    } else if (bfd_error != wrong_format) {
      abfd->xvec = save_targ;
      abfd->format = bfd_unknown;
      return false;
    }
  }

  if (match_count == 1) {
    abfd->xvec = right_targ;		/* Change BFD's target permanently */
    return true;			/* File position has moved, BTW */
  }

  abfd->xvec = save_targ;		/* Restore original target type */
  abfd->format = bfd_unknown;		/* Restore original format */
  bfd_error = ((match_count == 0) ? file_not_recognized :
	       file_ambiguously_recognized);
  return false;
}


/*
FUNCTION
	bfd_set_format

SYNOPSIS
	boolean bfd_set_format(bfd *abfd, bfd_format format);

DESCRIPTION
	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
	support the format requested, the format is invalid, or the BFD
	is not open for writing, then an error occurs.

*/

boolean
DEFUN(bfd_set_format,(abfd, format),
      bfd *abfd AND
      bfd_format format)
{

  if (bfd_read_p (abfd) ||
      ((int)abfd->format < (int)bfd_unknown) ||
      ((int)abfd->format >= (int)bfd_type_end)) {
    bfd_error = invalid_operation;
    return false;
  }

  if (abfd->format != bfd_unknown)
    return (abfd->format == format) ? true:false;

  /* presume the answer is yes */
  abfd->format = format;

  if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd))) {
    abfd->format = bfd_unknown;
    return false;
  }

  return true;
}


/*
FUNCTION
	bfd_format_string

SYNOPSIS
	CONST char *bfd_format_string(bfd_format format);

DESCRIPTION
	Return a pointer to a const string
	<<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
	depending upon the value of @var{format}.
*/

CONST char *
DEFUN(bfd_format_string,(format),
     bfd_format format)
{
  if (((int)format <(int) bfd_unknown) 
      || ((int)format >=(int) bfd_type_end)) 
    return "invalid";
  
  switch (format) {
  case bfd_object:
    return "object";		/* linker/assember/compiler output */
  case bfd_archive: 
    return "archive";		/* object archive file */
  case bfd_core: 
    return "core";		/* core dump */
  default: 
    return "unknown";
  }
}
Commit	Line	Data
6724ff46 RP	1	/* Generic BFD support for file formats.
	2	Copyright (C) 1990-1991 Free Software Foundation, Inc.
	3	Written by Cygnus Support.
	4
	5	This file is part of BFD, the Binary File Descriptor library.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	20
c188b0be DM	21	/*
	22	SECTION
	23	File Formats
	24
	25	A format is a BFD concept of high level file contents type. The
	26	formats supported by BFD are:
	27
	28	o <<bfd_object>>
	29
	30	The BFD may contain data, symbols, relocations and debug info.
	31
	32	o <<bfd_archive>>
	33
	34	The BFD contains other BFDs and an optional index.
	35
	36	o <<bfd_core>>
	37
	38	The BFD contains the result of an executable core dump.
	39
	40
6724ff46	41	*/
c188b0be	42
6724ff46	43	#include "bfd.h"
c188b0be	44	#include "sysdep.h"
6724ff46 RP	45	#include "libbfd.h"
6724ff46 RP	46
6724ff46 RP	47	extern bfd_target *target_vector[];
	48	extern bfd_target *default_vector[];
	49
	50
c188b0be DM	51	/*
	52	FUNCTION
	53	bfd_check_format
	54
	55	SYNOPSIS
	56	boolean bfd_check_format(bfd *abfd, bfd_format format);
	57
	58	DESCRIPTION
	59	Verify if the file attached to the BFD @var{abfd} is compatible
	60	with the format @var{format} (i.e., one of <<bfd_object>>,
	61	<<bfd_archive>> or <<bfd_core>>).
	62
	63	If the BFD has been set to a specific target before the
	64	call, only the named target and format combination is
	65	checked. If the target has not been set, or has been set to
	66	<<default>>, then all the known target backends is
	67	interrogated to determine a match. If the default target
	68	matches, it is used. If not, exactly one target must recognize
	69	the file, or an error results.
	70
	71	The function returns <<true>> on success, otherwise <<false>>
	72	with one of the following error codes:
	73
	74	o invalid_operation -
	75	if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
	76	<<bfd_core>>.
	77
	78	o system_call_error -
	79	if an error occured during a read - even some file mismatches
	80	can cause system_call_errors.
	81
	82	o file_not_recognised -
	83	none of the backends recognised the file format.
	84
	85	o file_ambiguously_recognized -
	86	more than one backend recognised the file format.
	87
	88	*/
6724ff46 RP	89
	90	boolean
	91	DEFUN(bfd_check_format,(abfd, format),
	92	bfd *abfd AND
	93	bfd_format format)
	94	{
	95	bfd_target *target, save_targ, *right_targ;
	96	int match_count;
	97
	98	if (!bfd_read_p (abfd) \|\|
	99	((int)(abfd->format) < (int)bfd_unknown) \|\|
	100	((int)(abfd->format) >= (int)bfd_type_end)) {
	101	bfd_error = invalid_operation;
	102	return false;
	103	}
	104
	105	if (abfd->format != bfd_unknown)
	106	return (abfd->format == format)? true: false;
	107
c188b0be DM	108
	109	/* Since the target type was defaulted, check them
	110	all in the hope that one will be uniquely recognized. */
	111
	112	save_targ = abfd->xvec;
	113	match_count = 0;
	114	right_targ = 0;
	115
	116
6724ff46 RP	117	/* presume the answer is yes */
	118	abfd->format = format;
	119
	120	/* If the target type was explicitly specified, just check that target. */
	121
	122	if (!abfd->target_defaulted) {
	123	bfd_seek (abfd, (file_ptr)0, SEEK_SET); /* rewind! */
	124
	125	right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
	126	if (right_targ) {
	127	abfd->xvec = right_targ; /* Set the target as returned */
	128	return true; /* File position has moved, BTW */
	129	}
6724ff46 RP	130	}
6724ff46 RP	131
6724ff46 RP	132	for (target = target_vector; *target != NULL; target++) {
	133	bfd_target *temp;
	134
	135	abfd->xvec = target; / Change BFD's target temporarily */
	136	bfd_seek (abfd, (file_ptr)0, SEEK_SET);
c188b0be DM	137	/* If _bfd_check_format neglects to set bfd_error, assume wrong_format.
	138	We didn't used to even pay any attention to bfd_error, so I suspect
	139	that some _bfd_check_format might have this problem. */
	140	bfd_error = wrong_format;
6724ff46 RP	141	temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
	142	if (temp) { /* This format checks out as ok! */
	143	right_targ = temp;
	144	match_count++;
	145	/* If this is the default target, accept it, even if other targets
	146	might match. People who want those other targets have to set
	147	the GNUTARGET variable. */
	148	if (temp == default_vector[0])
c188b0be DM	149	{
	150	match_count = 1;
	151	break;
	152	}
6724ff46 RP	153	#ifdef GNU960
	154	/* Big- and little-endian b.out archives look the same, but it doesn't
	155	* matter: there is no difference in their headers, and member file byte
	156	* orders will (I hope) be handled appropriately by bfd. Ditto for big
	157	* and little coff archives. And the 4 coff/b.out object formats are
	158	* unambiguous. So accept the first match we find.
	159	*/
	160	break;
	161	#endif
c188b0be DM	162	} else if (bfd_error != wrong_format) {
	163	abfd->xvec = save_targ;
	164	abfd->format = bfd_unknown;
	165	return false;
6724ff46 RP	166	}
	167	}
	168
	169	if (match_count == 1) {
	170	abfd->xvec = right_targ; /* Change BFD's target permanently */
	171	return true; /* File position has moved, BTW */
	172	}
	173
	174	abfd->xvec = save_targ; /* Restore original target type */
	175	abfd->format = bfd_unknown; /* Restore original format */
	176	bfd_error = ((match_count == 0) ? file_not_recognized :
	177	file_ambiguously_recognized);
	178	return false;
	179	}
c188b0be DM	180
	181
	182	/*
	183	FUNCTION
	184	bfd_set_format
	185
	186	SYNOPSIS
	187	boolean bfd_set_format(bfd *abfd, bfd_format format);
	188
	189	DESCRIPTION
	190	This function sets the file format of the BFD @var{abfd} to the
	191	format @var{format}. If the target set in the BFD does not
	192	support the format requested, the format is invalid, or the BFD
	193	is not open for writing, then an error occurs.
	194
	195	*/
	196
6724ff46 RP	197	boolean
	198	DEFUN(bfd_set_format,(abfd, format),
	199	bfd *abfd AND
	200	bfd_format format)
	201	{
	202
	203	if (bfd_read_p (abfd) \|\|
	204	((int)abfd->format < (int)bfd_unknown) \|\|
	205	((int)abfd->format >= (int)bfd_type_end)) {
	206	bfd_error = invalid_operation;
	207	return false;
	208	}
	209
	210	if (abfd->format != bfd_unknown)
	211	return (abfd->format == format) ? true:false;
	212
	213	/* presume the answer is yes */
	214	abfd->format = format;
	215
	216	if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd))) {
	217	abfd->format = bfd_unknown;
	218	return false;
	219	}
	220
	221	return true;
	222	}
	223
	224
c188b0be DM	225	/*
	226	FUNCTION
	227	bfd_format_string
	228
	229	SYNOPSIS
	230	CONST char *bfd_format_string(bfd_format format);
	231
	232	DESCRIPTION
	233	Return a pointer to a const string
	234	<<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
	235	depending upon the value of @var{format}.
	236	*/
6724ff46 RP	237
	238	CONST char *
	239	DEFUN(bfd_format_string,(format),
	240	bfd_format format)
	241	{
	242	if (((int)format <(int) bfd_unknown)
	243	\|\| ((int)format >=(int) bfd_type_end))
	244	return "invalid";
	245
	246	switch (format) {
	247	case bfd_object:
	248	return "object"; /* linker/assember/compiler output */
	249	case bfd_archive:
	250	return "archive"; /* object archive file */
	251	case bfd_core:
	252	return "core"; /* core dump */
	253	default:
	254	return "unknown";
	255	}
	256	}