[deliverable/binutils-gdb.git] / bfd / elf-nacl.c

/* Native Client support for ELF
   Copyright 2012, 2013 Free Software Foundation, Inc.

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

#include "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf-nacl.h"
#include "elf/common.h"
#include "elf/internal.h"

static bfd_boolean
segment_executable (struct elf_segment_map *seg)
{
  if (seg->p_flags_valid)
    return (seg->p_flags & PF_X) != 0;
  else
    {
      /* The p_flags value has not been computed yet,
	 so we have to look through the sections.  */
      unsigned int i;
      for (i = 0; i < seg->count; ++i)
	if (seg->sections[i]->flags & SEC_CODE)
	  return TRUE;
    }
  return FALSE;
}

/* Determine if this segment is eligible to receive the file and program
   headers.  It must be read-only, non-executable, and have contents.
   Its first section must start far enough past the page boundary to
   allow space for the headers.  */
static bfd_boolean
segment_eligible_for_headers (struct elf_segment_map *seg,
			      bfd_vma minpagesize, bfd_vma sizeof_headers)
{
  bfd_boolean any_contents = FALSE;
  unsigned int i;
  if (seg->count == 0 || seg->sections[0]->lma % minpagesize < sizeof_headers)
    return FALSE;
  for (i = 0; i < seg->count; ++i)
    {
      if ((seg->sections[i]->flags & (SEC_CODE|SEC_READONLY)) != SEC_READONLY)
	return FALSE;
      if (seg->sections[i]->flags & SEC_HAS_CONTENTS)
	any_contents = TRUE;
    }
  return any_contents;
}


/* We permute the segment_map to get BFD to do the file layout we want:
   The first non-executable PT_LOAD segment appears first in the file
   and contains the ELF file header and phdrs.  */
bfd_boolean
nacl_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
{
  struct elf_segment_map **m = &elf_seg_map (abfd);
  struct elf_segment_map **first_load = NULL;
  struct elf_segment_map **last_load = NULL;
  bfd_boolean moved_headers = FALSE;
  int sizeof_headers = info == NULL ? 0 : bfd_sizeof_headers (abfd, info);
  bfd_vma minpagesize = get_elf_backend_data (abfd)->minpagesize;

  if (info != NULL && info->user_phdrs)
    /* The linker script used PHDRS explicitly, so don't change what the
       user asked for.  */
    return TRUE;

  while (*m != NULL)
    {
      struct elf_segment_map *seg = *m;

      if (seg->p_type == PT_LOAD)
	{
	  bfd_boolean executable = segment_executable (seg);

	  if (executable
	      && seg->count > 0
	      && seg->sections[0]->vma % minpagesize == 0)
	    {
	      asection *lastsec = seg->sections[seg->count - 1];
	      bfd_vma end = lastsec->vma + lastsec->size;
	      if (end % minpagesize != 0)
		{
		  /* This is an executable segment that starts on a page
		     boundary but does not end on a page boundary.  Fill
		     it out to a whole page with code fill (the tail of
		     the segment will not be within any section).  Thus
		     the entire code segment can be mapped from the file
		     as whole pages and that mapping will contain only
		     valid instructions.

		     To accomplish this, we must fake out the code in
		     assign_file_positions_for_load_sections (elf.c) so
		     that it advances past the rest of the final page,
		     rather than trying to put the next (unaligned, or
		     unallocated) section.  We do this by appending a
		     dummy section record to this element in the segment
		     map.  No such output section ever actually exists,
		     but this gets the layout logic to advance the file
		     positions past this partial page.  Since we are
		     lying to BFD like this, nothing will ever know to
		     write the section contents.  So we do that by hand
		     after the fact, in nacl_final_write_processing, below.  */

		  struct elf_segment_map *newseg;
		  asection *sec;
		  struct bfd_elf_section_data *secdata;

		  BFD_ASSERT (!seg->p_size_valid);

		  secdata = bfd_zalloc (abfd, sizeof *secdata);
		  if (secdata == NULL)
		    return FALSE;

		  sec = bfd_zalloc (abfd, sizeof *sec);
		  if (sec == NULL)
		    return FALSE;

		  /* Fill in only the fields that actually affect the logic
		     in assign_file_positions_for_load_sections.  */
		  sec->vma = end;
		  sec->lma = lastsec->lma + lastsec->size;
		  sec->size = minpagesize - (end % minpagesize);
		  sec->flags = (SEC_ALLOC | SEC_LOAD
				| SEC_READONLY | SEC_CODE | SEC_LINKER_CREATED);
		  sec->used_by_bfd = secdata;

		  secdata->this_hdr.sh_type = SHT_PROGBITS;
		  secdata->this_hdr.sh_flags = SHF_ALLOC | SHF_EXECINSTR;
		  secdata->this_hdr.sh_addr = sec->vma;
		  secdata->this_hdr.sh_size = sec->size;

		  newseg = bfd_alloc (abfd,
				      sizeof *newseg + ((seg->count + 1)
							* sizeof (asection *)));
		  if (newseg == NULL)
		    return FALSE;
		  memcpy (newseg, seg,
			  sizeof *newseg + (seg->count * sizeof (asection *)));
		  newseg->sections[newseg->count++] = sec;
		  *m = seg = newseg;
		}
	    }

	  /* First, we're just finding the earliest PT_LOAD.
	     By the normal rules, this will be the lowest-addressed one.
	     We only have anything interesting to do if it's executable.  */
	  last_load = m;
	  if (first_load == NULL)
	    {
	      if (!executable)
		goto next;
	      first_load = m;
	    }
	  /* Now that we've noted the first PT_LOAD, we're looking for
	     the first non-executable PT_LOAD with a nonempty p_filesz.  */
	  else if (!moved_headers
		   && segment_eligible_for_headers (seg, minpagesize,
						    sizeof_headers))
	    {
	      /* This is the one we were looking for!

		 First, clear the flags on previous segments that
		 say they include the file header and phdrs.  */
	      struct elf_segment_map *prevseg;
	      for (prevseg = *first_load;
		   prevseg != seg;
		   prevseg = prevseg->next)
		if (prevseg->p_type == PT_LOAD)
		  {
		    prevseg->includes_filehdr = 0;
		    prevseg->includes_phdrs = 0;
		  }

	      /* This segment will include those headers instead.  */
	      seg->includes_filehdr = 1;
	      seg->includes_phdrs = 1;

	      moved_headers = TRUE;
	    }
	}

    next:
      m = &seg->next;
    }

  if (first_load != last_load && moved_headers)
    {
      /* Now swap the first and last PT_LOAD segments'
	 positions in segment_map.  */
      struct elf_segment_map *first = *first_load;
      struct elf_segment_map *last = *last_load;
      *first_load = first->next;
      first->next = last->next;
      last->next = first;
    }

  return TRUE;
}

/* After nacl_modify_segment_map has done its work, the file layout has
   been done as we wanted.  But the PT_LOAD phdrs are no longer in the
   proper order for the ELF rule that they must appear in ascending address
   order.  So find the two segments we swapped before, and swap them back.  */
bfd_boolean
nacl_modify_program_headers (bfd *abfd, struct bfd_link_info *info)
{
  struct elf_segment_map **m = &elf_seg_map (abfd);
  Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
  Elf_Internal_Phdr *p = phdr;

  if (info != NULL && info->user_phdrs)
    /* The linker script used PHDRS explicitly, so don't change what the
       user asked for.  */
    return TRUE;

  /* Find the PT_LOAD that contains the headers (should be the first).  */
  while (*m != NULL)
    {
      if ((*m)->p_type == PT_LOAD && (*m)->includes_filehdr)
	break;

      m = &(*m)->next;
      ++p;
    }

  if (*m != NULL)
    {
      struct elf_segment_map **first_load_seg = m;
      Elf_Internal_Phdr *first_load_phdr = p;
      struct elf_segment_map **next_load_seg = NULL;
      Elf_Internal_Phdr *next_load_phdr = NULL;

      /* Now move past that first one and find the PT_LOAD that should be
	 before it by address order.  */

      m = &(*m)->next;
      ++p;

      while (*m != NULL)
	{
	  if (p->p_type == PT_LOAD && p->p_vaddr < first_load_phdr->p_vaddr)
	    {
	      next_load_seg = m;
	      next_load_phdr = p;
	      break;
	    }

	  m = &(*m)->next;
	  ++p;
	}

      /* Swap their positions in the segment_map back to how they used to be.
	 The phdrs have already been set up by now, so we have to slide up
	 the earlier ones to insert the one that should be first.  */
      if (next_load_seg != NULL)
	{
	  Elf_Internal_Phdr move_phdr;
	  struct elf_segment_map *first_seg = *first_load_seg;
	  struct elf_segment_map *next_seg = *next_load_seg;
	  struct elf_segment_map *first_next = first_seg->next;
	  struct elf_segment_map *next_next = next_seg->next;

	  if (next_load_seg == &first_seg->next)
	    {
	      *first_load_seg = next_seg;
	      next_seg->next = first_seg;
	      first_seg->next = next_next;
	    }
	  else
	    {
	      *first_load_seg = first_next;
	      *next_load_seg = next_next;

	      first_seg->next = *next_load_seg;
	      *next_load_seg = first_seg;

	      next_seg->next = *first_load_seg;
	      *first_load_seg = next_seg;
	    }

	  move_phdr = *next_load_phdr;
	  memmove (first_load_phdr + 1, first_load_phdr,
		   (next_load_phdr - first_load_phdr) * sizeof move_phdr);
	  *first_load_phdr = move_phdr;
	}
    }

  return TRUE;
}

void
nacl_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
{
  struct elf_segment_map *seg;
  for (seg = elf_seg_map (abfd); seg != NULL; seg = seg->next)
    if (seg->p_type == PT_LOAD
	&& seg->count > 1
	&& seg->sections[seg->count - 1]->owner == NULL)
      {
	/* This is a fake section added in nacl_modify_segment_map, above.
	   It's not a real BFD section, so nothing wrote its contents.
	   Now write out its contents.  */

	asection *sec = seg->sections[seg->count - 1];
	char *fill;

	BFD_ASSERT (sec->flags & SEC_LINKER_CREATED);
	BFD_ASSERT (sec->flags & SEC_CODE);
	BFD_ASSERT (sec->size > 0);

	fill = abfd->arch_info->fill (sec->size, bfd_big_endian (abfd), TRUE);

	if (fill == NULL
	    || bfd_seek (abfd, sec->filepos, SEEK_SET) != 0
	    || bfd_bwrite (fill, sec->size, abfd) != sec->size)
	  {
	    /* We don't have a proper way to report an error here.  So
	       instead fudge things so that elf_write_shdrs_and_ehdr will
	       fail.  */
	    elf_elfheader (abfd)->e_shoff = (file_ptr) -1;
	  }

	free (fill);
      }
}
Commit	Line	Data
5a68afcf	1	/* Native Client support for ELF
887badb3	2	Copyright 2012, 2013 Free Software Foundation, Inc.
5a68afcf RM	3
	4	This file is part of BFD, the Binary File Descriptor library.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 3 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	19	MA 02111-1307, USA. */
	20
	21	#include "sysdep.h"
	22	#include "bfd.h"
887badb3	23	#include "libbfd.h"
5a68afcf RM	24	#include "elf-bfd.h"
	25	#include "elf-nacl.h"
	26	#include "elf/common.h"
	27	#include "elf/internal.h"
	28
	29	static bfd_boolean
	30	segment_executable (struct elf_segment_map *seg)
	31	{
	32	if (seg->p_flags_valid)
	33	return (seg->p_flags & PF_X) != 0;
	34	else
	35	{
	36	/* The p_flags value has not been computed yet,
887badb3	37	so we have to look through the sections. */
5a68afcf RM	38	unsigned int i;
5a68afcf RM	39	for (i = 0; i < seg->count; ++i)
887badb3 RM	40	if (seg->sections[i]->flags & SEC_CODE)
887badb3 RM	41	return TRUE;
5a68afcf RM	42	}
	43	return FALSE;
	44	}
	45
a3f548ed	46	/* Determine if this segment is eligible to receive the file and program
a0c82a2b RM	47	headers. It must be read-only, non-executable, and have contents.
	48	Its first section must start far enough past the page boundary to
	49	allow space for the headers. */
5a68afcf	50	static bfd_boolean
a3f548ed	51	segment_eligible_for_headers (struct elf_segment_map *seg,
887badb3	52	bfd_vma minpagesize, bfd_vma sizeof_headers)
5a68afcf RM	53	{
	54	bfd_boolean any_contents = FALSE;
	55	unsigned int i;
887badb3	56	if (seg->count == 0 \|\| seg->sections[0]->lma % minpagesize < sizeof_headers)
a3f548ed	57	return FALSE;
5a68afcf RM	58	for (i = 0; i < seg->count; ++i)
5a68afcf RM	59	{
a0c82a2b	60	if ((seg->sections[i]->flags & (SEC_CODE\|SEC_READONLY)) != SEC_READONLY)
887badb3	61	return FALSE;
5a68afcf	62	if (seg->sections[i]->flags & SEC_HAS_CONTENTS)
887badb3	63	any_contents = TRUE;
5a68afcf RM	64	}
	65	return any_contents;
	66	}
	67
	68
	69	/* We permute the segment_map to get BFD to do the file layout we want:
	70	The first non-executable PT_LOAD segment appears first in the file
	71	and contains the ELF file header and phdrs. */
	72	bfd_boolean
d324f6d6	73	nacl_modify_segment_map (bfd abfd, struct bfd_link_info info)
5a68afcf	74	{
12bd6957	75	struct elf_segment_map **m = &elf_seg_map (abfd);
5a68afcf RM	76	struct elf_segment_map **first_load = NULL;
	77	struct elf_segment_map **last_load = NULL;
	78	bfd_boolean moved_headers = FALSE;
aa6407c6	79	int sizeof_headers = info == NULL ? 0 : bfd_sizeof_headers (abfd, info);
887badb3	80	bfd_vma minpagesize = get_elf_backend_data (abfd)->minpagesize;
5a68afcf	81
d324f6d6 RM	82	if (info != NULL && info->user_phdrs)
	83	/* The linker script used PHDRS explicitly, so don't change what the
	84	user asked for. */
	85	return TRUE;
	86
5a68afcf RM	87	while (*m != NULL)
	88	{
	89	struct elf_segment_map seg = m;
	90
	91	if (seg->p_type == PT_LOAD)
887badb3 RM	92	{
	93	bfd_boolean executable = segment_executable (seg);
	94
	95	if (executable
	96	&& seg->count > 0
	97	&& seg->sections[0]->vma % minpagesize == 0)
	98	{
	99	asection *lastsec = seg->sections[seg->count - 1];
	100	bfd_vma end = lastsec->vma + lastsec->size;
	101	if (end % minpagesize != 0)
	102	{
	103	/* This is an executable segment that starts on a page
	104	boundary but does not end on a page boundary. Fill
	105	it out to a whole page with code fill (the tail of
	106	the segment will not be within any section). Thus
	107	the entire code segment can be mapped from the file
	108	as whole pages and that mapping will contain only
	109	valid instructions.
	110
	111	To accomplish this, we must fake out the code in
	112	assign_file_positions_for_load_sections (elf.c) so
	113	that it advances past the rest of the final page,
	114	rather than trying to put the next (unaligned, or
	115	unallocated) section. We do this by appending a
	116	dummy section record to this element in the segment
	117	map. No such output section ever actually exists,
	118	but this gets the layout logic to advance the file
	119	positions past this partial page. Since we are
	120	lying to BFD like this, nothing will ever know to
	121	write the section contents. So we do that by hand
	122	after the fact, in nacl_final_write_processing, below. */
	123
	124	struct elf_segment_map *newseg;
	125	asection *sec;
	126	struct bfd_elf_section_data *secdata;
	127
	128	BFD_ASSERT (!seg->p_size_valid);
	129
	130	secdata = bfd_zalloc (abfd, sizeof *secdata);
	131	if (secdata == NULL)
	132	return FALSE;
	133
	134	sec = bfd_zalloc (abfd, sizeof *sec);
	135	if (sec == NULL)
	136	return FALSE;
	137
	138	/* Fill in only the fields that actually affect the logic
	139	in assign_file_positions_for_load_sections. */
	140	sec->vma = end;
	141	sec->lma = lastsec->lma + lastsec->size;
	142	sec->size = minpagesize - (end % minpagesize);
	143	sec->flags = (SEC_ALLOC \| SEC_LOAD
	144	\| SEC_READONLY \| SEC_CODE \| SEC_LINKER_CREATED);
	145	sec->used_by_bfd = secdata;
	146
	147	secdata->this_hdr.sh_type = SHT_PROGBITS;
	148	secdata->this_hdr.sh_flags = SHF_ALLOC \| SHF_EXECINSTR;
	149	secdata->this_hdr.sh_addr = sec->vma;
	150	secdata->this_hdr.sh_size = sec->size;
	151
	152	newseg = bfd_alloc (abfd,
	153	sizeof *newseg + ((seg->count + 1)
	154	* sizeof (asection *)));
	155	if (newseg == NULL)
156	return FALSE;
157	memcpy (newseg, seg,
158	sizeof newseg + (seg->count sizeof (asection *)));
159	newseg->sections[newseg->count++] = sec;
160	*m = seg = newseg;
161	}
162	}
163
164	/* First, we're just finding the earliest PT_LOAD.
165	By the normal rules, this will be the lowest-addressed one.
166	We only have anything interesting to do if it's executable. */
167	last_load = m;
168	if (first_load == NULL)
169	{
170	if (!executable)
171	goto next;
172	first_load = m;
173	}
174	/* Now that we've noted the first PT_LOAD, we're looking for
175	the first non-executable PT_LOAD with a nonempty p_filesz. */
176	else if (!moved_headers
177	&& segment_eligible_for_headers (seg, minpagesize,
178	sizeof_headers))
179	{
180	/* This is the one we were looking for!
181
182	First, clear the flags on previous segments that
183	say they include the file header and phdrs. */
184	struct elf_segment_map *prevseg;
185	for (prevseg = *first_load;
186	prevseg != seg;
187	prevseg = prevseg->next)
188	if (prevseg->p_type == PT_LOAD)
189	{
190	prevseg->includes_filehdr = 0;
191	prevseg->includes_phdrs = 0;
192	}
193
194	/* This segment will include those headers instead. */
195	seg->includes_filehdr = 1;
196	seg->includes_phdrs = 1;
197
198	moved_headers = TRUE;
199	}
200	}
201
202	next:
5a68afcf RM	203	m = &seg->next;
	204	}
	205
	206	if (first_load != last_load && moved_headers)
	207	{
	208	/* Now swap the first and last PT_LOAD segments'
887badb3	209	positions in segment_map. */
5a68afcf RM	210	struct elf_segment_map first = first_load;
	211	struct elf_segment_map last = last_load;
	212	*first_load = first->next;
	213	first->next = last->next;
	214	last->next = first;
	215	}
	216
	217	return TRUE;
	218	}
	219
	220	/* After nacl_modify_segment_map has done its work, the file layout has
	221	been done as we wanted. But the PT_LOAD phdrs are no longer in the
	222	proper order for the ELF rule that they must appear in ascending address
	223	order. So find the two segments we swapped before, and swap them back. */
	224	bfd_boolean
aa6407c6	225	nacl_modify_program_headers (bfd abfd, struct bfd_link_info info)
5a68afcf	226	{
12bd6957	227	struct elf_segment_map **m = &elf_seg_map (abfd);
5a68afcf RM	228	Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
	229	Elf_Internal_Phdr *p = phdr;
	230
d324f6d6 RM	231	if (info != NULL && info->user_phdrs)
	232	/* The linker script used PHDRS explicitly, so don't change what the
	233	user asked for. */
	234	return TRUE;
	235
5a68afcf RM	236	/* Find the PT_LOAD that contains the headers (should be the first). */
	237	while (*m != NULL)
	238	{
	239	if ((m)->p_type == PT_LOAD && (m)->includes_filehdr)
887badb3	240	break;
5a68afcf RM	241
	242	m = &(*m)->next;
	243	++p;
	244	}
	245
	246	if (*m != NULL)
	247	{
	248	struct elf_segment_map **first_load_seg = m;
	249	Elf_Internal_Phdr *first_load_phdr = p;
	250	struct elf_segment_map **next_load_seg = NULL;
	251	Elf_Internal_Phdr *next_load_phdr = NULL;
	252
	253	/* Now move past that first one and find the PT_LOAD that should be
887badb3	254	before it by address order. */
5a68afcf RM	255
	256	m = &(*m)->next;
	257	++p;
	258
887badb3 RM	259	while (*m != NULL)
	260	{
	261	if (p->p_type == PT_LOAD && p->p_vaddr < first_load_phdr->p_vaddr)
	262	{
	263	next_load_seg = m;
	264	next_load_phdr = p;
	265	break;
	266	}
5a68afcf	267
887badb3 RM	268	m = &(*m)->next;
	269	++p;
	270	}
5a68afcf RM	271
5a68afcf RM	272	/* Swap their positions in the segment_map back to how they used to be.
887badb3 RM	273	The phdrs have already been set up by now, so we have to slide up
887badb3 RM	274	the earlier ones to insert the one that should be first. */
5a68afcf	275	if (next_load_seg != NULL)
887badb3 RM	276	{
	277	Elf_Internal_Phdr move_phdr;
	278	struct elf_segment_map first_seg = first_load_seg;
	279	struct elf_segment_map next_seg = next_load_seg;
	280	struct elf_segment_map *first_next = first_seg->next;
	281	struct elf_segment_map *next_next = next_seg->next;
	282
	283	if (next_load_seg == &first_seg->next)
	284	{
	285	*first_load_seg = next_seg;
	286	next_seg->next = first_seg;
	287	first_seg->next = next_next;
	288	}
	289	else
	290	{
	291	*first_load_seg = first_next;
	292	*next_load_seg = next_next;
	293
	294	first_seg->next = *next_load_seg;
	295	*next_load_seg = first_seg;
	296
	297	next_seg->next = *first_load_seg;
	298	*first_load_seg = next_seg;
	299	}
	300
	301	move_phdr = *next_load_phdr;
	302	memmove (first_load_phdr + 1, first_load_phdr,
	303	(next_load_phdr - first_load_phdr) * sizeof move_phdr);
	304	*first_load_phdr = move_phdr;
	305	}
5a68afcf RM	306	}
	307
	308	return TRUE;
	309	}
887badb3 RM	310
	311	void
	312	nacl_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
	313	{
	314	struct elf_segment_map *seg;
	315	for (seg = elf_seg_map (abfd); seg != NULL; seg = seg->next)
	316	if (seg->p_type == PT_LOAD
	317	&& seg->count > 1
	318	&& seg->sections[seg->count - 1]->owner == NULL)
	319	{
	320	/* This is a fake section added in nacl_modify_segment_map, above.
	321	It's not a real BFD section, so nothing wrote its contents.
	322	Now write out its contents. */
	323
	324	asection *sec = seg->sections[seg->count - 1];
	325	char *fill;
	326
	327	BFD_ASSERT (sec->flags & SEC_LINKER_CREATED);
	328	BFD_ASSERT (sec->flags & SEC_CODE);
	329	BFD_ASSERT (sec->size > 0);
	330
	331	fill = abfd->arch_info->fill (sec->size, bfd_big_endian (abfd), TRUE);
	332
	333	if (fill == NULL
	334	\|\| bfd_seek (abfd, sec->filepos, SEEK_SET) != 0
	335	\|\| bfd_bwrite (fill, sec->size, abfd) != sec->size)
	336	{
	337	/* We don't have a proper way to report an error here. So
	338	instead fudge things so that elf_write_shdrs_and_ehdr will
	339	fail. */
	340	elf_elfheader (abfd)->e_shoff = (file_ptr) -1;
	341	}
	342
	343	free (fill);
	344	}
	345	}