[binutils.git] / bfd / binary.c

/* BFD back-end for binary objects.
   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000
   Free Software Foundation, Inc.
   Written by Ian Lance Taylor, Cygnus Support, <[email protected]>

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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/* This is a BFD backend which may be used to write binary objects.
   It may only be used for output, not input.  The intention is that
   this may be used as an output format for objcopy in order to
   generate raw binary data.

   This is very simple.  The only complication is that the real data
   will start at some address X, and in some cases we will not want to
   include X zeroes just to get to that point.  Since the start
   address is not meaningful for this object file format, we use it
   instead to indicate the number of zeroes to skip at the start of
   the file.  objcopy cooperates by specially setting the start
   address to zero by default.  */

#include <ctype.h>

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

/* Any bfd we create by reading a binary file has three symbols:
   a start symbol, an end symbol, and an absolute length symbol.  */
#define BIN_SYMS 3

static boolean binary_mkobject PARAMS ((bfd *));
static const bfd_target *binary_object_p PARAMS ((bfd *));
static boolean binary_get_section_contents
  PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
static long binary_get_symtab_upper_bound PARAMS ((bfd *));
static char *mangle_name PARAMS ((bfd *, char *));
static long binary_get_symtab PARAMS ((bfd *, asymbol **));
static asymbol *binary_make_empty_symbol PARAMS ((bfd *));
static void binary_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
static boolean binary_set_section_contents
  PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
static int binary_sizeof_headers PARAMS ((bfd *, boolean));

/* Create a binary object.  Invoked via bfd_set_format.  */

static boolean
binary_mkobject (abfd)
     bfd *abfd ATTRIBUTE_UNUSED;
{
  return true;
}

/* Any file may be considered to be a binary file, provided the target
   was not defaulted.  That is, it must be explicitly specified as
   being binary.  */

static const bfd_target *
binary_object_p (abfd)
     bfd *abfd;
{
  struct stat statbuf;
  asection *sec;

  if (abfd->target_defaulted)
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }

  abfd->symcount = BIN_SYMS;

  /* Find the file size.  */
  if (bfd_stat (abfd, &statbuf) < 0)
    {
      bfd_set_error (bfd_error_system_call);
      return NULL;
    }

  /* One data section.  */
  sec = bfd_make_section (abfd, ".data");
  if (sec == NULL)
    return NULL;
  sec->flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS;
  sec->vma = 0;
  sec->_raw_size = statbuf.st_size;
  sec->filepos = 0;

  abfd->tdata.any = (PTR) sec;

  return abfd->xvec;
}

#define binary_close_and_cleanup _bfd_generic_close_and_cleanup
#define binary_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
#define binary_new_section_hook _bfd_generic_new_section_hook

/* Get contents of the only section.  */

static boolean
binary_get_section_contents (abfd, section, location, offset, count)
     bfd *abfd;
     asection *section ATTRIBUTE_UNUSED;
     PTR location;
     file_ptr offset;
     bfd_size_type count;
{
  if (bfd_seek (abfd, offset, SEEK_SET) != 0
      || bfd_read (location, 1, count, abfd) != count)
    return false;
  return true;
}

/* Return the amount of memory needed to read the symbol table.  */

static long
binary_get_symtab_upper_bound (abfd)
     bfd *abfd ATTRIBUTE_UNUSED;
{
  return (BIN_SYMS + 1) * sizeof (asymbol *);
}

/* Create a symbol name based on the bfd's filename.  */

static char *
mangle_name (abfd, suffix)
     bfd *abfd;
     char *suffix;
{
  int size;
  char *buf;
  char *p;

  size = (strlen (bfd_get_filename (abfd))
	  + strlen (suffix)
	  + sizeof "_binary__");

  buf = (char *) bfd_alloc (abfd, size);
  if (buf == NULL)
    return "";

  sprintf (buf, "_binary_%s_%s", bfd_get_filename (abfd), suffix);

  /* Change any non-alphanumeric characters to underscores.  */
  for (p = buf; *p; p++)
    if (! isalnum ((unsigned char) *p))
      *p = '_';

  return buf;
}

/* Return the symbol table.  */

static long
binary_get_symtab (abfd, alocation)
     bfd *abfd;
     asymbol **alocation;
{
  asection *sec = (asection *) abfd->tdata.any;
  asymbol *syms;
  unsigned int i;

  syms = (asymbol *) bfd_alloc (abfd, BIN_SYMS * sizeof (asymbol));
  if (syms == NULL)
    return false;

  /* Start symbol.  */
  syms[0].the_bfd = abfd;
  syms[0].name = mangle_name (abfd, "start");
  syms[0].value = 0;
  syms[0].flags = BSF_GLOBAL;
  syms[0].section = sec;
  syms[0].udata.p = NULL;

  /* End symbol.  */
  syms[1].the_bfd = abfd;
  syms[1].name = mangle_name (abfd, "end");
  syms[1].value = sec->_raw_size;
  syms[1].flags = BSF_GLOBAL;
  syms[1].section = sec;
  syms[1].udata.p = NULL;

  /* Size symbol.  */
  syms[2].the_bfd = abfd;
  syms[2].name = mangle_name (abfd, "size");
  syms[2].value = sec->_raw_size;
  syms[2].flags = BSF_GLOBAL;
  syms[2].section = bfd_abs_section_ptr;
  syms[2].udata.p = NULL;

  for (i = 0; i < BIN_SYMS; i++)
    *alocation++ = syms++;
  *alocation = NULL;

  return BIN_SYMS;
}

/* Make an empty symbol.  */

static asymbol *
binary_make_empty_symbol (abfd)
     bfd *abfd;
{
  return (asymbol *) bfd_alloc (abfd, sizeof (asymbol));
}

#define binary_print_symbol _bfd_nosymbols_print_symbol

/* Get information about a symbol.  */

static void
binary_get_symbol_info (ignore_abfd, symbol, ret)
     bfd *ignore_abfd ATTRIBUTE_UNUSED;
     asymbol *symbol;
     symbol_info *ret;
{
  bfd_symbol_info (symbol, ret);
}

#define binary_bfd_is_local_label_name bfd_generic_is_local_label_name
#define binary_get_lineno _bfd_nosymbols_get_lineno
#define binary_find_nearest_line _bfd_nosymbols_find_nearest_line
#define binary_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
#define binary_read_minisymbols _bfd_generic_read_minisymbols
#define binary_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol

#define binary_get_reloc_upper_bound \
  ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
#define binary_canonicalize_reloc \
  ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
#define binary_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup

/* Set the architecture of a binary file.  */
#define binary_set_arch_mach _bfd_generic_set_arch_mach

/* Write section contents of a binary file.  */

static boolean
binary_set_section_contents (abfd, sec, data, offset, size)
     bfd *abfd;
     asection *sec;
     PTR data;
     file_ptr offset;
     bfd_size_type size;
{
  if (size == 0)
    return true;

  if (! abfd->output_has_begun)
    {
      boolean found_low;
      bfd_vma low;
      asection *s;

      /* The lowest section LMA sets the virtual address of the start
         of the file.  We use this to set the file position of all the
         sections.  */
      found_low = false;
      low = 0;
      for (s = abfd->sections; s != NULL; s = s->next)
	if (((s->flags
	      & (SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_NEVER_LOAD))
	     == (SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC))
	    && (s->_raw_size > 0)
	    && (! found_low || s->lma < low))
	  {
	    low = s->lma;
	    found_low = true;
	  }

      for (s = abfd->sections; s != NULL; s = s->next)
	{
	  s->filepos = s->lma - low;

	  /* Skip following warning check for sections that will not
	     occupy file space.  */
	  if ((s->flags
	       & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_NEVER_LOAD))
	      != (SEC_HAS_CONTENTS | SEC_ALLOC)
	      || (s->_raw_size == 0))
	    continue;

	  /* If attempting to generate a binary file from a bfd with
	     LMA's all over the place, huge (sparse?) binary files may
	     result.  This condition attempts to detect this situation
	     and print a warning.  Better heuristics would be nice to
	     have.  */

	  if (s->filepos < 0)
	    (*_bfd_error_handler)
	      (_("Warning: Writing section `%s' to huge (ie negative) file offset 0x%lx."),
	       bfd_get_section_name (abfd, s),
	       (unsigned long) s->filepos);
	}

      abfd->output_has_begun = true;
    }

  /* We don't want to output anything for a section that is neither
     loaded nor allocated.  The contents of such a section are not
     meaningful in the binary format.  */
  if ((sec->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
    return true;
  if ((sec->flags & SEC_NEVER_LOAD) != 0)
    return true;

  return _bfd_generic_set_section_contents (abfd, sec, data, offset, size);
}

/* No space is required for header information.  */

static int
binary_sizeof_headers (abfd, exec)
     bfd *abfd ATTRIBUTE_UNUSED;
     boolean exec ATTRIBUTE_UNUSED;
{
  return 0;
}

#define binary_bfd_get_relocated_section_contents \
  bfd_generic_get_relocated_section_contents
#define binary_bfd_relax_section bfd_generic_relax_section
#define binary_bfd_gc_sections bfd_generic_gc_sections
#define binary_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
#define binary_bfd_link_add_symbols _bfd_generic_link_add_symbols
#define binary_bfd_final_link _bfd_generic_final_link
#define binary_bfd_link_split_section _bfd_generic_link_split_section
#define binary_get_section_contents_in_window \
  _bfd_generic_get_section_contents_in_window

const bfd_target binary_vec =
{
  "binary",			/* name */
  bfd_target_unknown_flavour,	/* flavour */
  BFD_ENDIAN_UNKNOWN,		/* byteorder */
  BFD_ENDIAN_UNKNOWN,		/* header_byteorder */
  EXEC_P,			/* object_flags */
  (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA
   | SEC_ROM | SEC_HAS_CONTENTS), /* section_flags */
  0,				/* symbol_leading_char */
  ' ',				/* ar_pad_char */
  16,				/* ar_max_namelen */
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
  bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* data */
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
  bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* hdrs */
  {				/* bfd_check_format */
    _bfd_dummy_target,
    binary_object_p,		/* bfd_check_format */
    _bfd_dummy_target,
    _bfd_dummy_target,
  },
  {				/* bfd_set_format */
    bfd_false,
    binary_mkobject,
    bfd_false,
    bfd_false,
  },
  {				/* bfd_write_contents */
    bfd_false,
    bfd_true,
    bfd_false,
    bfd_false,
  },

  BFD_JUMP_TABLE_GENERIC (binary),
  BFD_JUMP_TABLE_COPY (_bfd_generic),
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
  BFD_JUMP_TABLE_SYMBOLS (binary),
  BFD_JUMP_TABLE_RELOCS (binary),
  BFD_JUMP_TABLE_WRITE (binary),
  BFD_JUMP_TABLE_LINK (binary),
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),

  NULL,

  NULL
};
Commit	Line	Data
252b5132	1	/* BFD back-end for binary objects.
7898deda NC	2	Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000
7898deda NC	3	Free Software Foundation, Inc.
252b5132 RH	4	Written by Ian Lance Taylor, Cygnus Support, <[email protected]>
	5
	6	This file is part of BFD, the Binary File Descriptor library.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	21
	22	/* This is a BFD backend which may be used to write binary objects.
	23	It may only be used for output, not input. The intention is that
	24	this may be used as an output format for objcopy in order to
	25	generate raw binary data.
	26
	27	This is very simple. The only complication is that the real data
	28	will start at some address X, and in some cases we will not want to
	29	include X zeroes just to get to that point. Since the start
	30	address is not meaningful for this object file format, we use it
	31	instead to indicate the number of zeroes to skip at the start of
	32	the file. objcopy cooperates by specially setting the start
	33	address to zero by default. */
	34
	35	#include <ctype.h>
	36
	37	#include "bfd.h"
	38	#include "sysdep.h"
	39	#include "libbfd.h"
	40
	41	/* Any bfd we create by reading a binary file has three symbols:
	42	a start symbol, an end symbol, and an absolute length symbol. */
	43	#define BIN_SYMS 3
	44
	45	static boolean binary_mkobject PARAMS ((bfd *));
	46	static const bfd_target binary_object_p PARAMS ((bfd ));
	47	static boolean binary_get_section_contents
	48	PARAMS ((bfd , asection , PTR, file_ptr, bfd_size_type));
	49	static long binary_get_symtab_upper_bound PARAMS ((bfd *));
	50	static char mangle_name PARAMS ((bfd , char *));
	51	static long binary_get_symtab PARAMS ((bfd , asymbol *));
	52	static asymbol binary_make_empty_symbol PARAMS ((bfd ));
	53	static void binary_get_symbol_info PARAMS ((bfd , asymbol , symbol_info *));
	54	static boolean binary_set_section_contents
	55	PARAMS ((bfd , asection , PTR, file_ptr, bfd_size_type));
	56	static int binary_sizeof_headers PARAMS ((bfd *, boolean));
	57
	58	/* Create a binary object. Invoked via bfd_set_format. */
	59
	60	static boolean
	61	binary_mkobject (abfd)
7442e600	62	bfd *abfd ATTRIBUTE_UNUSED;
252b5132 RH	63	{
	64	return true;
	65	}
	66
	67	/* Any file may be considered to be a binary file, provided the target
	68	was not defaulted. That is, it must be explicitly specified as
	69	being binary. */
	70
	71	static const bfd_target *
	72	binary_object_p (abfd)
	73	bfd *abfd;
	74	{
	75	struct stat statbuf;
	76	asection *sec;
	77
	78	if (abfd->target_defaulted)
	79	{
	80	bfd_set_error (bfd_error_wrong_format);
	81	return NULL;
	82	}
	83
	84	abfd->symcount = BIN_SYMS;
	85
	86	/* Find the file size. */
	87	if (bfd_stat (abfd, &statbuf) < 0)
	88	{
	89	bfd_set_error (bfd_error_system_call);
	90	return NULL;
	91	}
	92
	93	/* One data section. */
	94	sec = bfd_make_section (abfd, ".data");
	95	if (sec == NULL)
	96	return NULL;
	97	sec->flags = SEC_ALLOC \| SEC_LOAD \| SEC_DATA \| SEC_HAS_CONTENTS;
	98	sec->vma = 0;
	99	sec->_raw_size = statbuf.st_size;
	100	sec->filepos = 0;
	101
	102	abfd->tdata.any = (PTR) sec;
	103
	104	return abfd->xvec;
	105	}
	106
	107	#define binary_close_and_cleanup _bfd_generic_close_and_cleanup
	108	#define binary_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
	109	#define binary_new_section_hook _bfd_generic_new_section_hook
	110
	111	/* Get contents of the only section. */
	112
	113	static boolean
	114	binary_get_section_contents (abfd, section, location, offset, count)
	115	bfd *abfd;
7442e600	116	asection *section ATTRIBUTE_UNUSED;
252b5132 RH	117	PTR location;
	118	file_ptr offset;
	119	bfd_size_type count;
	120	{
	121	if (bfd_seek (abfd, offset, SEEK_SET) != 0
	122	\|\| bfd_read (location, 1, count, abfd) != count)
	123	return false;
	124	return true;
	125	}
	126
	127	/* Return the amount of memory needed to read the symbol table. */
	128
	129	static long
	130	binary_get_symtab_upper_bound (abfd)
7442e600	131	bfd *abfd ATTRIBUTE_UNUSED;
252b5132 RH	132	{
	133	return (BIN_SYMS + 1) * sizeof (asymbol *);
	134	}
	135
	136	/* Create a symbol name based on the bfd's filename. */
	137
	138	static char *
	139	mangle_name (abfd, suffix)
	140	bfd *abfd;
	141	char *suffix;
	142	{
	143	int size;
	144	char *buf;
	145	char *p;
	146
	147	size = (strlen (bfd_get_filename (abfd))
	148	+ strlen (suffix)
	149	+ sizeof "_binary__");
	150
	151	buf = (char *) bfd_alloc (abfd, size);
	152	if (buf == NULL)
	153	return "";
	154
	155	sprintf (buf, "_binary_%s_%s", bfd_get_filename (abfd), suffix);
	156
	157	/* Change any non-alphanumeric characters to underscores. */
	158	for (p = buf; *p; p++)
	159	if (! isalnum ((unsigned char) *p))
	160	*p = '_';
	161
	162	return buf;
	163	}
	164
	165	/* Return the symbol table. */
	166
	167	static long
	168	binary_get_symtab (abfd, alocation)
	169	bfd *abfd;
	170	asymbol **alocation;
	171	{
	172	asection sec = (asection ) abfd->tdata.any;
	173	asymbol *syms;
	174	unsigned int i;
	175
	176	syms = (asymbol ) bfd_alloc (abfd, BIN_SYMS sizeof (asymbol));
	177	if (syms == NULL)
	178	return false;
	179
	180	/* Start symbol. */
	181	syms[0].the_bfd = abfd;
	182	syms[0].name = mangle_name (abfd, "start");
	183	syms[0].value = 0;
	184	syms[0].flags = BSF_GLOBAL;
	185	syms[0].section = sec;
	186	syms[0].udata.p = NULL;
	187
	188	/* End symbol. */
	189	syms[1].the_bfd = abfd;
	190	syms[1].name = mangle_name (abfd, "end");
	191	syms[1].value = sec->_raw_size;
	192	syms[1].flags = BSF_GLOBAL;
	193	syms[1].section = sec;
	194	syms[1].udata.p = NULL;
	195
196	/* Size symbol. */
197	syms[2].the_bfd = abfd;
198	syms[2].name = mangle_name (abfd, "size");
199	syms[2].value = sec->_raw_size;
200	syms[2].flags = BSF_GLOBAL;
201	syms[2].section = bfd_abs_section_ptr;
202	syms[2].udata.p = NULL;
203
204	for (i = 0; i < BIN_SYMS; i++)
205	*alocation++ = syms++;
206	*alocation = NULL;
207
208	return BIN_SYMS;
209	}
210
211	/* Make an empty symbol. */
212
213	static asymbol *
214	binary_make_empty_symbol (abfd)
215	bfd *abfd;
216	{
217	return (asymbol *) bfd_alloc (abfd, sizeof (asymbol));
218	}
219
220	#define binary_print_symbol _bfd_nosymbols_print_symbol
221
222	/* Get information about a symbol. */
223
224	static void
225	binary_get_symbol_info (ignore_abfd, symbol, ret)
7442e600	226	bfd *ignore_abfd ATTRIBUTE_UNUSED;
252b5132 RH	227	asymbol *symbol;
	228	symbol_info *ret;
	229	{
	230	bfd_symbol_info (symbol, ret);
	231	}
	232
	233	#define binary_bfd_is_local_label_name bfd_generic_is_local_label_name
	234	#define binary_get_lineno _bfd_nosymbols_get_lineno
	235	#define binary_find_nearest_line _bfd_nosymbols_find_nearest_line
	236	#define binary_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
	237	#define binary_read_minisymbols _bfd_generic_read_minisymbols
	238	#define binary_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
	239
	240	#define binary_get_reloc_upper_bound \
	241	((long () PARAMS ((bfd , asection *))) bfd_0l)
	242	#define binary_canonicalize_reloc \
	243	((long () PARAMS ((bfd , asection , arelent , asymbol *))) bfd_0l)
	244	#define binary_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
	245
	246	/* Set the architecture of a binary file. */
	247	#define binary_set_arch_mach _bfd_generic_set_arch_mach
	248
	249	/* Write section contents of a binary file. */
	250
	251	static boolean
	252	binary_set_section_contents (abfd, sec, data, offset, size)
	253	bfd *abfd;
	254	asection *sec;
	255	PTR data;
	256	file_ptr offset;
	257	bfd_size_type size;
	258	{
3a71aec8 NC	259	if (size == 0)
	260	return true;
	261
252b5132 RH	262	if (! abfd->output_has_begun)
	263	{
	264	boolean found_low;
	265	bfd_vma low;
	266	asection *s;
	267
	268	/* The lowest section LMA sets the virtual address of the start
	269	of the file. We use this to set the file position of all the
	270	sections. */
	271	found_low = false;
	272	low = 0;
	273	for (s = abfd->sections; s != NULL; s = s->next)
	274	if (((s->flags
	275	& (SEC_HAS_CONTENTS \| SEC_LOAD \| SEC_ALLOC \| SEC_NEVER_LOAD))
	276	== (SEC_HAS_CONTENTS \| SEC_LOAD \| SEC_ALLOC))
3a71aec8	277	&& (s->_raw_size > 0)
252b5132 RH	278	&& (! found_low \|\| s->lma < low))
	279	{
	280	low = s->lma;
	281	found_low = true;
	282	}
	283
	284	for (s = abfd->sections; s != NULL; s = s->next)
	285	{
	286	s->filepos = s->lma - low;
	287
	288	/* Skip following warning check for sections that will not
aebad5fe	289	occupy file space. */
252b5132 RH	290	if ((s->flags
252b5132 RH	291	& (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_NEVER_LOAD))
3a71aec8 NC	292	!= (SEC_HAS_CONTENTS \| SEC_ALLOC)
3a71aec8 NC	293	\|\| (s->_raw_size == 0))
252b5132 RH	294	continue;
	295
	296	/* If attempting to generate a binary file from a bfd with
	297	LMA's all over the place, huge (sparse?) binary files may
	298	result. This condition attempts to detect this situation
	299	and print a warning. Better heuristics would be nice to
aebad5fe	300	have. */
252b5132 RH	301
	302	if (s->filepos < 0)
	303	(*_bfd_error_handler)
	304	(_("Warning: Writing section `%s' to huge (ie negative) file offset 0x%lx."),
	305	bfd_get_section_name (abfd, s),
	306	(unsigned long) s->filepos);
	307	}
	308
	309	abfd->output_has_begun = true;
	310	}
	311
	312	/* We don't want to output anything for a section that is neither
	313	loaded nor allocated. The contents of such a section are not
	314	meaningful in the binary format. */
	315	if ((sec->flags & (SEC_LOAD \| SEC_ALLOC)) == 0)
	316	return true;
	317	if ((sec->flags & SEC_NEVER_LOAD) != 0)
	318	return true;
	319
	320	return _bfd_generic_set_section_contents (abfd, sec, data, offset, size);
	321	}
	322
	323	/* No space is required for header information. */
	324
	325	static int
	326	binary_sizeof_headers (abfd, exec)
7442e600 ILT	327	bfd *abfd ATTRIBUTE_UNUSED;
7442e600 ILT	328	boolean exec ATTRIBUTE_UNUSED;
252b5132 RH	329	{
	330	return 0;
	331	}
	332
	333	#define binary_bfd_get_relocated_section_contents \
	334	bfd_generic_get_relocated_section_contents
	335	#define binary_bfd_relax_section bfd_generic_relax_section
	336	#define binary_bfd_gc_sections bfd_generic_gc_sections
	337	#define binary_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
	338	#define binary_bfd_link_add_symbols _bfd_generic_link_add_symbols
	339	#define binary_bfd_final_link _bfd_generic_final_link
	340	#define binary_bfd_link_split_section _bfd_generic_link_split_section
	341	#define binary_get_section_contents_in_window \
	342	_bfd_generic_get_section_contents_in_window
	343
	344	const bfd_target binary_vec =
	345	{
	346	"binary", /* name */
	347	bfd_target_unknown_flavour, /* flavour */
	348	BFD_ENDIAN_UNKNOWN, /* byteorder */
	349	BFD_ENDIAN_UNKNOWN, /* header_byteorder */
	350	EXEC_P, /* object_flags */
	351	(SEC_ALLOC \| SEC_LOAD \| SEC_READONLY \| SEC_CODE \| SEC_DATA
	352	\| SEC_ROM \| SEC_HAS_CONTENTS), /* section_flags */
	353	0, /* symbol_leading_char */
	354	' ', /* ar_pad_char */
	355	16, /* ar_max_namelen */
	356	bfd_getb64, bfd_getb_signed_64, bfd_putb64,
	357	bfd_getb32, bfd_getb_signed_32, bfd_putb32,
	358	bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
	359	bfd_getb64, bfd_getb_signed_64, bfd_putb64,
	360	bfd_getb32, bfd_getb_signed_32, bfd_putb32,
	361	bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
	362	{ /* bfd_check_format */
	363	_bfd_dummy_target,
	364	binary_object_p, /* bfd_check_format */
	365	_bfd_dummy_target,
	366	_bfd_dummy_target,
	367	},
	368	{ /* bfd_set_format */
	369	bfd_false,
	370	binary_mkobject,
	371	bfd_false,
	372	bfd_false,
	373	},
	374	{ /* bfd_write_contents */
	375	bfd_false,
	376	bfd_true,
	377	bfd_false,
	378	bfd_false,
	379	},
	380
	381	BFD_JUMP_TABLE_GENERIC (binary),
	382	BFD_JUMP_TABLE_COPY (_bfd_generic),
	383	BFD_JUMP_TABLE_CORE (_bfd_nocore),
	384	BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
	385	BFD_JUMP_TABLE_SYMBOLS (binary),
	386	BFD_JUMP_TABLE_RELOCS (binary),
	387	BFD_JUMP_TABLE_WRITE (binary),
	388	BFD_JUMP_TABLE_LINK (binary),
	389	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
	390
c3c89269	391	NULL,
aebad5fe	392
252b5132 RH	393	NULL
252b5132 RH	394	};