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

/* Native Client support for ELF
   Copyright (C) 2012-2015 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, see <http://www.gnu.org/licenses/>.  */

#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 and non-executable.
   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)
{
  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;
    }
  return TRUE;
}


/* 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)
{
  const struct elf_backend_data *const bed = get_elf_backend_data (abfd);
  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;

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

  if (info != NULL)
    /* We're doing linking, so evalute SIZEOF_HEADERS as in a linker script.  */
    sizeof_headers = bfd_sizeof_headers (abfd, info);
  else
    {
      /* We're not doing linking, so this is objcopy or suchlike.
	 We just need to collect the size of the existing headers.  */
      struct elf_segment_map *seg;
      sizeof_headers = bed->s->sizeof_ehdr;
      for (seg = *m; seg != NULL; seg = seg->next)
	sizeof_headers += bed->s->sizeof_phdr;
    }

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