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 } 354
