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

/* Native Client support for ELF
   Copyright (C) 2012-2024 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 bool
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 bool
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.  */
bool
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 **headers = NULL;
  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)
	{
	  bool 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 * sizeof (asection *)));
		  if (newseg == NULL)
		    return false;
		  memcpy (newseg, seg, (sizeof (*newseg) - sizeof (asection *)
					+ 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.  */
	  if (first_load == NULL)
	    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 (headers == NULL
		   && segment_eligible_for_headers (seg, bed->minpagesize,
						    sizeof_headers))
	    headers = m;
	}
      m = &seg->next;
    }

  if (headers != NULL)
    {
      struct elf_segment_map **last_load = NULL;
      struct elf_segment_map *seg;

      m = first_load;
      while ((seg = *m) != NULL)
	{
	  if (seg->p_type == PT_LOAD)
	    {
	      /* Clear the flags on any previous segment that
		 included the file header and phdrs.  */
	      seg->includes_filehdr = 0;
	      seg->includes_phdrs = 0;
	      seg->no_sort_lma = 1;
	      /* Also strip out empty segments.  */
	      if (seg->count == 0)
		{
		  if (headers == &seg->next)
		    headers = m;
		  *m = seg->next;
		  continue;
		}
	      last_load = m;
	    }
	  m = &seg->next;
	}

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

      if (last_load != NULL && first_load != last_load && first_load != headers)
	{
	  /* Put the first PT_LOAD header last.  */
	  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.  */
bool
nacl_modify_headers (bfd *abfd, struct bfd_link_info *info)
{
  if (info != NULL && info->user_phdrs)
    /* The linker script used PHDRS explicitly, so don't change what the
       user asked for.  */
    ;
  else
    {
      struct elf_segment_map **m = &elf_seg_map (abfd);
      Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
      Elf_Internal_Phdr *p = phdr;

      /* 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 _bfd_elf_modify_headers (abfd, info);
}

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