Cherry pick some binutils NaCl strip/objcopy fixes in pnacl 2.23 branch.

bfd/elf-nacl.c

 /* Native Client support for ELF
    Copyright 2012, 2013 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.
 
@@ skipping 26 matching lines @@
          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, non-executable, and have contents.
+   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 bfd_boolean
 segment_eligible_for_headers (struct elf_segment_map *seg,
                               bfd_vma minpagesize, bfd_vma sizeof_headers)
 {
-  bfd_boolean any_contents = FALSE;
   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;
-      if (seg->sections[i]->flags & SEC_HAS_CONTENTS)
-        any_contents = TRUE;
     }
-  return any_contents;
+  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.  */
 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_tdata (abfd)->segment_map;
   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;
+  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)
         {
           bfd_boolean executable = segment_executable (seg);
 
           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
                      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
@@ skipping 20 matching lines @@
                     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 = 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;
 
                   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,
@@ skipping 14 matching lines @@
           last_load = m;
           if (first_load == NULL)
             {
               if (!executable)
                 goto next;
               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,
+                   && 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)
@@ skipping 148 matching lines @@
           {
             /* 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);
       }
 }