/* Native Client support for ELF
- Copyright 2012, 2013 Free Software Foundation, Inc.
+ Copyright (C) 2012-2020 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
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, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "sysdep.h"
#include "bfd.h"
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 = info == NULL ? 0 : bfd_sizeof_headers (abfd, info);
- bfd_vma minpagesize = get_elf_backend_data (abfd)->minpagesize;
+ 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 (executable
&& seg->count > 0
- && seg->sections[0]->vma % minpagesize == 0)
+ && seg->sections[0]->vma % bed->minpagesize == 0)
{
asection *lastsec = seg->sections[seg->count - 1];
bfd_vma end = lastsec->vma + lastsec->size;
- if (end % minpagesize != 0)
+ 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
in assign_file_positions_for_load_sections. */
sec->vma = end;
sec->lma = lastsec->lma + lastsec->size;
- sec->size = minpagesize - (end % minpagesize);
+ 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;
}
/* 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;
+ By the normal rules, this will be the lowest-addressed one. */
if (first_load == NULL)
- {
- if (!executable)
- goto next;
- first_load = m;
- }
+ 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, minpagesize,
+ else if (headers == NULL
+ && 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;
- }
+ headers = m;
}
-
- next:
m = &seg->next;
}
- if (first_load != last_load && moved_headers)
+ if (headers != NULL)
{
- /* 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;
+ 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;
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)
+nacl_modify_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)
+ ;
+ else
{
- 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;
+ 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 (p->p_type == PT_LOAD && p->p_vaddr < first_load_phdr->p_vaddr)
- {
- next_load_seg = m;
- next_load_phdr = p;
- break;
- }
+ if ((*m)->p_type == PT_LOAD && (*m)->includes_filehdr)
+ 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)
+ if (*m != 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;
+ 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;
- if (next_load_seg == &first_seg->next)
+ while (*m != NULL)
{
- *first_load_seg = next_seg;
- next_seg->next = first_seg;
- first_seg->next = next_next;
+ 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;
}
- else
+
+ /* 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)
{
- *first_load_seg = first_next;
- *next_load_seg = next_next;
+ 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;
- first_seg->next = *next_load_seg;
- *next_load_seg = first_seg;
+ 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;
- next_seg->next = *first_load_seg;
- *first_load_seg = next_seg;
- }
+ 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;
+ 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;
+ return _bfd_elf_modify_headers (abfd, info);
}
-void
-nacl_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
+bfd_boolean
+nacl_final_write_processing (bfd *abfd)
{
struct elf_segment_map *seg;
for (seg = elf_seg_map (abfd); seg != NULL; seg = seg->next)
free (fill);
}
+ return _bfd_elf_final_write_processing (abfd);
}