Copyright update for binutils
[external/binutils.git] / bfd / elf-nacl.c
1 /* Native Client support for ELF
2    Copyright (C) 2012-2016 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
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,
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.  */
48 static bfd_boolean
49 segment_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.  */
67 bfd_boolean
68 nacl_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.  */
232 bfd_boolean
233 nacl_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
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 }