1/* Native Client support for ELF
2   Copyright (C) 2012-2017 Free Software Foundation, Inc.
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, see <http://www.gnu.org/licenses/>.  */
18
19#include "sysdep.h"
20#include "bfd.h"
21#include "libbfd.h"
22#include "elf-bfd.h"
23#include "elf-nacl.h"
24#include "elf/common.h"
25#include "elf/internal.h"
26
27static bfd_boolean
28segment_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,
35	 so we have to look through the sections.  */
36      unsigned int i;
37      for (i = 0; i < seg->count; ++i)
38	if (seg->sections[i]->flags & SEC_CODE)
39	  return TRUE;
40    }
41  return FALSE;
42}
43
44/* Determine if this segment is eligible to receive the file and program
45   headers.  It must be read-only and non-executable.
46   Its first section must start far enough past the page boundary to
47   allow space for the headers.  */
48static bfd_boolean
49segment_eligible_for_headers (struct elf_segment_map *seg,
50			      bfd_vma minpagesize, bfd_vma sizeof_headers)
51{
52  unsigned int i;
53  if (seg->count == 0 || seg->sections[0]->lma % minpagesize < sizeof_headers)
54    return FALSE;
55  for (i = 0; i < seg->count; ++i)
56    {
57      if ((seg->sections[i]->flags & (SEC_CODE|SEC_READONLY)) != SEC_READONLY)
58	return FALSE;
59    }
60  return TRUE;
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.  */
67bfd_boolean
68nacl_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
69{
70  const struct elf_backend_data *const bed = get_elf_backend_data (abfd);
71  struct elf_segment_map **m = &elf_seg_map (abfd);
72  struct elf_segment_map **first_load = NULL;
73  struct elf_segment_map **last_load = NULL;
74  bfd_boolean moved_headers = FALSE;
75  int sizeof_headers;
76
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
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
95  while (*m != NULL)
96    {
97      struct elf_segment_map *seg = *m;
98
99      if (seg->p_type == PT_LOAD)
100	{
101	  bfd_boolean executable = segment_executable (seg);
102
103	  if (executable
104	      && seg->count > 0
105	      && seg->sections[0]->vma % bed->minpagesize == 0)
106	    {
107	      asection *lastsec = seg->sections[seg->count - 1];
108	      bfd_vma end = lastsec->vma + lastsec->size;
109	      if (end % bed->minpagesize != 0)
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;
150		  sec->size = bed->minpagesize - (end % bed->minpagesize);
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
185		   && segment_eligible_for_headers (seg, bed->minpagesize,
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:
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'
217	 positions in segment_map.  */
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.  */
232bfd_boolean
233nacl_modify_program_headers (bfd *abfd, struct bfd_link_info *info)
234{
235  struct elf_segment_map **m = &elf_seg_map (abfd);
236  Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
237  Elf_Internal_Phdr *p = phdr;
238
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
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)
248	break;
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
262	 before it by address order.  */
263
264      m = &(*m)->next;
265      ++p;
266
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	    }
275
276	  m = &(*m)->next;
277	  ++p;
278	}
279
280      /* Swap their positions in the segment_map back to how they used to be.
281	 The phdrs have already been set up by now, so we have to slide up
282	 the earlier ones to insert the one that should be first.  */
283      if (next_load_seg != NULL)
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	}
314    }
315
316  return TRUE;
317}
318
319void
320nacl_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}
354