On Tue, 4 Jul 2017, Richard Biener wrote:

> On Tue, 20 Jun 2017, Richard Biener wrote:
> 
> > On Wed, 7 Jun 2017, Richard Biener wrote:
> > 
> > > On Fri, 19 May 2017, Richard Biener wrote:
> > > 
> > > > 
> > > > This is a repost (unchanged) of the simple-object ELF support for
> > > > early LTO debug transfer from IL object to a separate debug-only object 
> > > > file.
> > > > 
> > > > Bootstrapped and tested on x86_64-unknown-linux-gnu.
> > > 
> > > Ping.
> > 
> > Ping^2.
> 
> Ping^3.

Ping^4.  Adding some more global reviewers to CC.

Richard.

> > > > Richard.
> > > > 
> > > > 2017-05-19  Richard Biener  <rguent...@suse.de>
> > > > 
> > > >         include/
> > > >         * simple-object.h (simple_object_copy_lto_debug_sections): New
> > > >         function.
> > > > 
> > > >         libiberty/
> > > >         * simple-object-common.h (struct simple_object_functions): Add
> > > >         copy_lto_debug_sections hook.
> > > >         * simple-object.c: Include fcntl.h.
> > > >         (handle_lto_debug_sections): New helper function.
> > > >         (simple_object_copy_lto_debug_sections): New function copying
> > > >         early LTO debug sections to regular debug sections in a new 
> > > > file.
> > > >         (simple_object_start_write): Handle NULL segment_name.
> > > >         * simple-object-coff.c (simple_object_coff_functions): Adjust
> > > >         for not implemented copy_lto_debug_sections hook.
> > > >         * simple-object-mach-o.c (simple_object_mach_o_functions): 
> > > > Likewise.
> > > >         * simple-object-xcoff.c (simple_object_xcoff_functions): 
> > > > Likewise.
> > > >         * simple-object-elf.c (SHT_NULL, SHT_SYMTAB, SHT_RELA, SHT_REL,
> > > >         SHT_GROUP): Add various sectopn header types.
> > > >         (SHF_EXCLUDE): Add flag.
> > > >         (Elf32_External_Sym, Elf64_External_Sym): Add symbol struct.
> > > >         (ELF_ST_BIND, ELF_ST_TYPE, ELF_ST_INFO): Add accessors.
> > > >         (STT_OBJECT, STT_FUNC, STT_TLS, STT_GNU_IFUNC): Add Symbol 
> > > > types.
> > > >         (STV_DEFAULT): Add symbol visibility.
> > > >         (SHN_COMMON): Add special section index name.
> > > >         (struct simple_object_elf_write): New.
> > > >         (simple_object_elf_start_write): Adjust for new private data.
> > > >         (simple_object_elf_write_shdr): Pass in values for all fields
> > > >         we write.
> > > >         (simple_object_elf_write_to_file): Adjust.  Copy from recorded
> > > >         section headers if requested.
> > > >         (simple_object_elf_release_write): Release private data.
> > > >         (simple_object_elf_copy_lto_debug_sections): Copy and rename 
> > > > sections
> > > >         as denoted by PFN and all their dependences, symbols and 
> > > > relocations
> > > >         to the empty destination file.
> > > >         (simple_object_elf_functions): Adjust for 
> > > > copy_lto_debug_sections hook.
> > > > 
> > > > Index: early-lto-debug/include/simple-object.h
> > > > ===================================================================
> > > > --- early-lto-debug.orig/include/simple-object.h        2016-10-19 
> > > > 13:19:58.012326431 +0200
> > > > +++ early-lto-debug/include/simple-object.h     2016-10-20 
> > > > 10:51:49.861722998 +0200
> > > > @@ -197,6 +197,14 @@ simple_object_write_to_file (simple_obje
> > > >  extern void
> > > >  simple_object_release_write (simple_object_write *);
> > > >  
> > > > +/* Copy LTO debug sections from SRC_OBJECT to DEST.
> > > > +   If an error occurs, return the errno value in ERR and an error 
> > > > string.  */
> > > > +
> > > > +extern const char *
> > > > +simple_object_copy_lto_debug_sections (simple_object_read *src_object,
> > > > +                                      const char *dest,
> > > > +                                      int *err);
> > > > +
> > > >  #ifdef __cplusplus
> > > >  }
> > > >  #endif
> > > > Index: early-lto-debug/libiberty/simple-object-common.h
> > > > ===================================================================
> > > > --- early-lto-debug.orig/libiberty/simple-object-common.h       
> > > > 2016-10-19 13:19:58.012326431 +0200
> > > > +++ early-lto-debug/libiberty/simple-object-common.h    2016-10-20 
> > > > 10:51:49.865723045 +0200
> > > > @@ -141,6 +141,12 @@ struct simple_object_functions
> > > >  
> > > >    /* Release the private data for an simple_object_write.  */
> > > >    void (*release_write) (void *);
> > > > +
> > > > +  /* Copy LTO debug sections.  */
> > > > +  const char *(*copy_lto_debug_sections) (simple_object_read *sobj,
> > > > +                                         simple_object_write *dobj,
> > > > +                                         int (*pfn) (const char **),
> > > > +                                         int *err);
> > > >  };
> > > >  
> > > >  /* The known object file formats.  */
> > > > Index: early-lto-debug/libiberty/simple-object-elf.c
> > > > ===================================================================
> > > > --- early-lto-debug.orig/libiberty/simple-object-elf.c  2016-10-19 
> > > > 13:19:58.012326431 +0200
> > > > +++ early-lto-debug/libiberty/simple-object-elf.c       2016-10-20 
> > > > 10:51:49.865723045 +0200
> > > > @@ -183,8 +183,55 @@ typedef struct {
> > > >  
> > > >  /* Values for sh_type field.  */
> > > >  
> > > > +#define SHT_NULL       0               /* Section header table entry 
> > > > unused */
> > > >  #define SHT_PROGBITS   1               /* Program data */
> > > > +#define SHT_SYMTAB     2               /* Link editing symbol table */
> > > >  #define SHT_STRTAB     3               /* A string table */
> > > > +#define SHT_RELA       4               /* Relocation entries with 
> > > > addends */
> > > > +#define SHT_REL                9               /* Relocation entries, 
> > > > no addends */
> > > > +#define SHT_GROUP      17              /* Section contains a section 
> > > > group */
> > > > +
> > > > +/* Values for sh_flags field.  */
> > > > +
> > > > +#define SHF_EXCLUDE    0x80000000      /* Link editor is to exclude 
> > > > this
> > > > +                                          section from executable and
> > > > +                                          shared library that it builds
> > > > +                                          when those objects are not 
> > > > to be
> > > > +                                          further relocated.  */
> > > > +/* Symbol table entry.  */
> > > > +
> > > > +typedef struct
> > > > +{
> > > > +  unsigned char st_name[4];                /* Symbol name (string tbl 
> > > > index) */
> > > > +  unsigned char st_value[4];               /* Symbol value */
> > > > +  unsigned char st_size[4];                /* Symbol size */
> > > > +  unsigned char st_info;                /* Symbol type and binding */
> > > > +  unsigned char st_other;               /* Symbol visibility */
> > > > +  unsigned char st_shndx[2];               /* Section index */
> > > > +} Elf32_External_Sym;
> > > > +
> > > > +typedef struct
> > > > +{
> > > > +  unsigned char st_name[4];                /* Symbol name (string tbl 
> > > > index) */
> > > > +  unsigned char st_info;                /* Symbol type and binding */
> > > > +  unsigned char st_other;               /* Symbol visibility */
> > > > +  unsigned char st_shndx[2];               /* Section index */
> > > > +  unsigned char st_value[8];               /* Symbol value */
> > > > +  unsigned char st_size[8];                /* Symbol size */
> > > > +} Elf64_External_Sym;
> > > > +
> > > > +#define ELF_ST_BIND(val)              (((unsigned char) (val)) >> 4)
> > > > +#define ELF_ST_TYPE(val)              ((val) & 0xf)
> > > > +#define ELF_ST_INFO(bind, type)       (((bind) << 4) + ((type) & 0xf))
> > > > +
> > > > +#define STT_OBJECT     1       /* Symbol is a data object */
> > > > +#define STT_FUNC       2       /* Symbol is a code object */
> > > > +#define STT_TLS                6       /* Thread local data object */
> > > > +#define STT_GNU_IFUNC  10      /* Symbol is an indirect code object */
> > > > +
> > > > +#define STV_DEFAULT    0       /* Visibility is specified by binding 
> > > > type */
> > > > +
> > > > +#define SHN_COMMON     0xFFF2  /* Associated symbol is in common */
> > > >  
> > > >  /* Functions to fetch and store different ELF types, depending on the
> > > >     endianness and size.  */
> > > > @@ -348,6 +395,14 @@ struct simple_object_elf_attributes
> > > >    unsigned int flags;
> > > >  };
> > > >  
> > > > +/* Private data for an simple_object_write.  */
> > > > +
> > > > +struct simple_object_elf_write
> > > > +{
> > > > +  struct simple_object_elf_attributes attrs;
> > > > +  unsigned char *shdrs;
> > > > +};
> > > > +
> > > >  /* See if we have an ELF file.  */
> > > >  
> > > >  static void *
> > > > @@ -675,12 +730,13 @@ simple_object_elf_start_write (void *att
> > > >  {
> > > >    struct simple_object_elf_attributes *attrs =
> > > >      (struct simple_object_elf_attributes *) attributes_data;
> > > > -  struct simple_object_elf_attributes *ret;
> > > > +  struct simple_object_elf_write *ret;
> > > >  
> > > >    /* We're just going to record the attributes, but we need to make a
> > > >       copy because the user may delete them.  */
> > > > -  ret = XNEW (struct simple_object_elf_attributes);
> > > > -  *ret = *attrs;
> > > > +  ret = XNEW (struct simple_object_elf_write);
> > > > +  ret->attrs = *attrs;
> > > > +  ret->shdrs = NULL;
> > > >    return ret;
> > > >  }
> > > >  
> > > > @@ -766,8 +822,11 @@ static int
> > > >  simple_object_elf_write_shdr (simple_object_write *sobj, int 
> > > > descriptor,
> > > >                               off_t offset, unsigned int sh_name,
> > > >                               unsigned int sh_type, unsigned int 
> > > > sh_flags,
> > > > +                             off_t sh_addr,
> > > >                               unsigned int sh_offset, unsigned int 
> > > > sh_size,
> > > > -                             unsigned int sh_link, unsigned int 
> > > > sh_addralign,
> > > > +                             unsigned int sh_link, unsigned int 
> > > > sh_info,
> > > > +                             unsigned int sh_addralign,
> > > > +                             unsigned int sh_entsize,
> > > >                               const char **errmsg, int *err)
> > > >  {
> > > >    struct simple_object_elf_attributes *attrs =
> > > > @@ -788,12 +847,13 @@ simple_object_elf_write_shdr (simple_obj
> > > >    ELF_SET_FIELD (fns, cl, Shdr, buf, sh_name, Elf_Word, sh_name);
> > > >    ELF_SET_FIELD (fns, cl, Shdr, buf, sh_type, Elf_Word, sh_type);
> > > >    ELF_SET_FIELD (fns, cl, Shdr, buf, sh_flags, Elf_Addr, sh_flags);
> > > > +  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addr, Elf_Addr, sh_addr);
> > > >    ELF_SET_FIELD (fns, cl, Shdr, buf, sh_offset, Elf_Addr, sh_offset);
> > > >    ELF_SET_FIELD (fns, cl, Shdr, buf, sh_size, Elf_Addr, sh_size);
> > > >    ELF_SET_FIELD (fns, cl, Shdr, buf, sh_link, Elf_Word, sh_link);
> > > > -  /* sh_info left as zero.  */
> > > > +  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_info, Elf_Word, sh_info);
> > > >    ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addralign, Elf_Addr, 
> > > > sh_addralign);
> > > > -  /* sh_entsize left as zero.  */
> > > > +  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_entsize, Elf_Word, sh_entsize);
> > > >  
> > > >    return simple_object_internal_write (descriptor, offset, buf, 
> > > > shdr_size,
> > > >                                        errmsg, err);
> > > > @@ -811,8 +871,9 @@ static const char *
> > > >  simple_object_elf_write_to_file (simple_object_write *sobj, int 
> > > > descriptor,
> > > >                                  int *err)
> > > >  {
> > > > -  struct simple_object_elf_attributes *attrs =
> > > > -    (struct simple_object_elf_attributes *) sobj->data;
> > > > +  struct simple_object_elf_write *eow =
> > > > +    (struct simple_object_elf_write *) sobj->data;
> > > > +  struct simple_object_elf_attributes *attrs = &eow->attrs;
> > > >    unsigned char cl;
> > > >    size_t ehdr_size;
> > > >    size_t shdr_size;
> > > > @@ -825,6 +886,7 @@ simple_object_elf_write_to_file (simple_
> > > >    unsigned int first_sh_link;
> > > >    size_t sh_name;
> > > >    unsigned char zero;
> > > > +  unsigned secnum;
> > > >  
> > > >    if (!simple_object_elf_write_ehdr (sobj, descriptor, &errmsg, err))
> > > >      return errmsg;
> > > > @@ -862,21 +924,54 @@ simple_object_elf_write_to_file (simple_
> > > >    else
> > > >      first_sh_link = shnum - 1;
> > > >    if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
> > > > -                                    0, 0, 0, 0, first_sh_size, 
> > > > first_sh_link,
> > > > -                                    0, &errmsg, err))
> > > > +                                    0, 0, 0, 0, 0, first_sh_size, 
> > > > first_sh_link,
> > > > +                                    0, 0, 0, &errmsg, err))
> > > >      return errmsg;
> > > >  
> > > >    shdr_offset += shdr_size;
> > > >  
> > > >    sh_name = 1;
> > > > +  secnum = 0;
> > > >    for (section = sobj->sections; section != NULL; section = 
> > > > section->next)
> > > >      {
> > > >        size_t mask;
> > > >        size_t new_sh_offset;
> > > >        size_t sh_size;
> > > >        struct simple_object_write_section_buffer *buffer;
> > > > +      unsigned int sh_type = SHT_PROGBITS;
> > > > +      unsigned int sh_flags = 0;
> > > > +      off_t sh_addr = 0;
> > > > +      unsigned int sh_link = 0;
> > > > +      unsigned int sh_info = 0;
> > > > +      unsigned int sh_addralign = 1U << section->align;
> > > > +      unsigned int sh_entsize = 0;
> > > > +      if (eow->shdrs)
> > > > +       {
> > > > +         sh_type = ELF_FETCH_FIELD (attrs->type_functions, 
> > > > attrs->ei_class, Shdr,
> > > > +                                    eow->shdrs + secnum * shdr_size,
> > > > +                                    sh_type, Elf_Word);
> > > > +         sh_flags = ELF_FETCH_FIELD (attrs->type_functions, 
> > > > attrs->ei_class, Shdr,
> > > > +                                     eow->shdrs + secnum * shdr_size,
> > > > +                                     sh_flags, Elf_Addr);
> > > > +         sh_addr = ELF_FETCH_FIELD (attrs->type_functions, 
> > > > attrs->ei_class, Shdr,
> > > > +                                    eow->shdrs + secnum * shdr_size,
> > > > +                                    sh_addr, Elf_Addr);
> > > > +         sh_link = ELF_FETCH_FIELD (attrs->type_functions, 
> > > > attrs->ei_class, Shdr,
> > > > +                                    eow->shdrs + secnum * shdr_size,
> > > > +                                    sh_link, Elf_Word);
> > > > +         sh_info = ELF_FETCH_FIELD (attrs->type_functions, 
> > > > attrs->ei_class, Shdr,
> > > > +                                    eow->shdrs + secnum * shdr_size,
> > > > +                                    sh_info, Elf_Word);
> > > > +         sh_addralign = ELF_FETCH_FIELD (attrs->type_functions, 
> > > > attrs->ei_class, Shdr,
> > > > +                                         eow->shdrs + secnum * 
> > > > shdr_size,
> > > > +                                         sh_addralign, Elf_Addr);
> > > > +         sh_entsize = ELF_FETCH_FIELD (attrs->type_functions, 
> > > > attrs->ei_class, Shdr,
> > > > +                                       eow->shdrs + secnum * shdr_size,
> > > > +                                       sh_entsize, Elf_Word);
> > > > +         secnum++;
> > > > +       }
> > > >  
> > > > -      mask = (1U << section->align) - 1;
> > > > +      mask = sh_addralign - 1;
> > > >        new_sh_offset = sh_offset + mask;
> > > >        new_sh_offset &= ~ mask;
> > > >        while (new_sh_offset > sh_offset)
> > > > @@ -906,8 +1001,10 @@ simple_object_elf_write_to_file (simple_
> > > >         }
> > > >  
> > > >        if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
> > > > -                                        sh_name, SHT_PROGBITS, 0, 
> > > > sh_offset,
> > > > -                                        sh_size, 0, 1U << 
> > > > section->align,
> > > > +                                        sh_name, sh_type, sh_flags,
> > > > +                                        sh_addr, sh_offset,
> > > > +                                        sh_size, sh_link, sh_info,
> > > > +                                        sh_addralign, sh_entsize,
> > > >                                          &errmsg, err))
> > > >         return errmsg;
> > > >  
> > > > @@ -917,9 +1014,9 @@ simple_object_elf_write_to_file (simple_
> > > >      }
> > > >  
> > > >    if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
> > > > -                                    sh_name, SHT_STRTAB, 0, sh_offset,
> > > > -                                    sh_name + strlen (".shstrtab") + 
> > > > 1, 0,
> > > > -                                    1, &errmsg, err))
> > > > +                                    sh_name, SHT_STRTAB, 0, 0, 
> > > > sh_offset,
> > > > +                                    sh_name + strlen (".shstrtab") + 
> > > > 1, 0, 0,
> > > > +                                    1, 0, &errmsg, err))
> > > >      return errmsg;
> > > >  
> > > >    /* .shstrtab has a leading zero byte.  */
> > > > @@ -954,9 +1051,363 @@ simple_object_elf_write_to_file (simple_
> > > >  static void
> > > >  simple_object_elf_release_write (void *data)
> > > >  {
> > > > +  struct simple_object_elf_write *eow = (struct 
> > > > simple_object_elf_write *) data;
> > > > +  if (eow->shdrs)
> > > > +    XDELETE (eow->shdrs);
> > > >    XDELETE (data);
> > > >  }
> > > >  
> > > > +/* Copy all sections in an ELF file.  */
> > > > +
> > > > +static const char *
> > > > +simple_object_elf_copy_lto_debug_sections (simple_object_read *sobj,
> > > > +                                          simple_object_write *dobj,
> > > > +                                          int (*pfn) (const char **),
> > > > +                                          int *err)
> > > > +{
> > > > +  struct simple_object_elf_read *eor =
> > > > +    (struct simple_object_elf_read *) sobj->data;
> > > > +  const struct elf_type_functions *type_functions = 
> > > > eor->type_functions;
> > > > +  struct simple_object_elf_write *eow =
> > > > +    (struct simple_object_elf_write *) dobj->data;
> > > > +  unsigned char ei_class = eor->ei_class;
> > > > +  size_t shdr_size;
> > > > +  unsigned int shnum;
> > > > +  unsigned char *shdrs;
> > > > +  const char *errmsg;
> > > > +  unsigned char *shstrhdr;
> > > > +  size_t name_size;
> > > > +  off_t shstroff;
> > > > +  unsigned char *names;
> > > > +  unsigned int i;
> > > > +  int *pfnret;
> > > > +  const char **pfnname;
> > > > +
> > > > +  shdr_size = (ei_class == ELFCLASS32
> > > > +              ? sizeof (Elf32_External_Shdr)
> > > > +              : sizeof (Elf64_External_Shdr));
> > > > +
> > > > +  /* Read the section headers.  We skip section 0, which is not a
> > > > +     useful section.  */
> > > > +
> > > > +  shnum = eor->shnum;
> > > > +  shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
> > > > +
> > > > +  if (!simple_object_internal_read (sobj->descriptor,
> > > > +                                   sobj->offset + eor->shoff + 
> > > > shdr_size,
> > > > +                                   shdrs,
> > > > +                                   shdr_size * (shnum - 1),
> > > > +                                   &errmsg, err))
> > > > +    {
> > > > +      XDELETEVEC (shdrs);
> > > > +      return errmsg;
> > > > +    }
> > > > +
> > > > +  /* Read the section names.  */
> > > > +
> > > > +  shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
> > > > +  name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                              shstrhdr, sh_size, Elf_Addr);
> > > > +  shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                             shstrhdr, sh_offset, Elf_Addr);
> > > > +  names = XNEWVEC (unsigned char, name_size);
> > > > +  if (!simple_object_internal_read (sobj->descriptor,
> > > > +                                   sobj->offset + shstroff,
> > > > +                                   names, name_size, &errmsg, err))
> > > > +    {
> > > > +      XDELETEVEC (names);
> > > > +      XDELETEVEC (shdrs);
> > > > +      return errmsg;
> > > > +    }
> > > > +
> > > > +  eow->shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
> > > > +  pfnret = XNEWVEC (int, shnum);
> > > > +  pfnname = XNEWVEC (const char *, shnum);
> > > > +
> > > > +  /* First perform the callbacks to know which sections to preserve and
> > > > +     what name to use for those.  */
> > > > +  for (i = 1; i < shnum; ++i)
> > > > +    {
> > > > +      unsigned char *shdr;
> > > > +      unsigned int sh_name;
> > > > +      const char *name;
> > > > +      int ret;
> > > > +
> > > > +      shdr = shdrs + (i - 1) * shdr_size;
> > > > +      sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                                shdr, sh_name, Elf_Word);
> > > > +      if (sh_name >= name_size)
> > > > +       {
> > > > +         *err = 0;
> > > > +         XDELETEVEC (names);
> > > > +         XDELETEVEC (shdrs);
> > > > +         return "ELF section name out of range";
> > > > +       }
> > > > +
> > > > +      name = (const char *) names + sh_name;
> > > > +
> > > > +      ret = (*pfn) (&name);
> > > > +      pfnret[i - 1] = ret == 1 ? 0 : -1;
> > > > +      pfnname[i - 1] = name;
> > > > +    }
> > > > +
> > > > +  /* Mark sections as preserved that are required by to be preserved
> > > > +     sections.  */
> > > > +  for (i = 1; i < shnum; ++i)
> > > > +    {
> > > > +      unsigned char *shdr;
> > > > +      unsigned int sh_type, sh_info, sh_link;
> > > > +      off_t offset;
> > > > +      off_t length;
> > > > +
> > > > +      shdr = shdrs + (i - 1) * shdr_size;
> > > > +      sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                                shdr, sh_type, Elf_Word);
> > > > +      sh_info = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                                shdr, sh_info, Elf_Word);
> > > > +      sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                                shdr, sh_link, Elf_Word);
> > > > +      if (sh_type == SHT_GROUP)
> > > > +       {
> > > > +         /* Mark groups containing copied sections.  */
> > > > +         unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class, 
> > > > Shdr,
> > > > +                                             shdr, sh_entsize, 
> > > > Elf_Addr);
> > > > +         unsigned char *ent, *buf;
> > > > +         int keep = 0;
> > > > +         offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                                   shdr, sh_offset, Elf_Addr);
> > > > +         length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                                   shdr, sh_size, Elf_Addr);
> > > > +         buf = XNEWVEC (unsigned char, length);
> > > > +         if (!simple_object_internal_read (sobj->descriptor,
> > > > +                                           sobj->offset + offset, buf,
> > > > +                                           (size_t) length, &errmsg, 
> > > > err))
> > > > +           {
> > > > +             XDELETEVEC (buf);
> > > > +             XDELETEVEC (names);
> > > > +             XDELETEVEC (shdrs);
> > > > +             return errmsg;
> > > > +           }
> > > > +         for (ent = buf + entsize; ent < buf + length; ent += entsize)
> > > > +           {
> > > > +             unsigned sec = type_functions->fetch_Elf_Word (ent);
> > > > +             if (pfnret[sec - 1] == 0)
> > > > +               keep = 1;
> > > > +           }
> > > > +         if (keep)
> > > > +           {
> > > > +             pfnret[sh_link - 1] = 0;
> > > > +             pfnret[i - 1] = 0;
> > > > +           }
> > > > +       }
> > > > +      if (sh_type == SHT_RELA
> > > > +         || sh_type == SHT_REL)
> > > > +       {
> > > > +         /* Mark relocation sections and symtab of copied sections.  */
> > > > +         if (pfnret[sh_info - 1] == 0)
> > > > +           {
> > > > +             pfnret[sh_link - 1] = 0;
> > > > +             pfnret[i - 1] = 0;
> > > > +           }
> > > > +       }
> > > > +      if (sh_type == SHT_SYMTAB)
> > > > +       {
> > > > +         /* Mark strings sections of copied symtabs.  */
> > > > +         if (pfnret[i - 1] == 0)
> > > > +           pfnret[sh_link - 1] = 0;
> > > > +       }
> > > > +    }
> > > > +
> > > > +  /* Then perform the actual copying.  */
> > > > +  for (i = 1; i < shnum; ++i)
> > > > +    {
> > > > +      unsigned char *shdr;
> > > > +      unsigned int sh_name, sh_type;
> > > > +      const char *name;
> > > > +      off_t offset;
> > > > +      off_t length;
> > > > +      int ret;
> > > > +      const char *errmsg;
> > > > +      simple_object_write_section *dest;
> > > > +      off_t flags;
> > > > +      unsigned char *buf;
> > > > +
> > > > +      shdr = shdrs + (i - 1) * shdr_size;
> > > > +      sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                                shdr, sh_name, Elf_Word);
> > > > +      if (sh_name >= name_size)
> > > > +       {
> > > > +         *err = 0;
> > > > +         XDELETEVEC (names);
> > > > +         XDELETEVEC (shdrs);
> > > > +         return "ELF section name out of range";
> > > > +       }
> > > > +
> > > > +      name = (const char *) names + sh_name;
> > > > +      offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                               shdr, sh_offset, Elf_Addr);
> > > > +      length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                               shdr, sh_size, Elf_Addr);
> > > > +      sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                                shdr, sh_type, Elf_Word);
> > > > +
> > > > +      ret = pfnret[i - 1];
> > > > +      name = ret == 0 ? pfnname[i - 1] : "";
> > > > +
> > > > +      dest = simple_object_write_create_section (dobj, name, 0, 
> > > > &errmsg, err);
> > > > +      if (dest == NULL)
> > > > +       {
> > > > +         XDELETEVEC (names);
> > > > +         XDELETEVEC (shdrs);
> > > > +         return errmsg;
> > > > +       }
> > > > +
> > > > +      /* Record the SHDR of the source.  */
> > > > +      memcpy (eow->shdrs + (i - 1) * shdr_size, shdr, shdr_size);
> > > > +      shdr = eow->shdrs + (i - 1) * shdr_size;
> > > > +
> > > > +      /* Copy the data.
> > > > +        ???  This is quite wasteful and ideally would be delayed until
> > > > +        write_to_file ().  Thus it questions the interfacing
> > > > +        which eventually should contain destination creation plus
> > > > +        writing.  */
> > > > +      /* Keep empty sections for sections we should discard.  This 
> > > > avoids
> > > > +         the need to rewrite section indices in symtab and relocation
> > > > +        sections.  */
> > > > +      if (ret == 0)
> > > > +       {
> > > > +         buf = XNEWVEC (unsigned char, length);
> > > > +         if (!simple_object_internal_read (sobj->descriptor,
> > > > +                                           sobj->offset + offset, buf,
> > > > +                                           (size_t) length, &errmsg, 
> > > > err))
> > > > +           {
> > > > +             XDELETEVEC (buf);
> > > > +             XDELETEVEC (names);
> > > > +             XDELETEVEC (shdrs);
> > > > +             return errmsg;
> > > > +           }
> > > > +
> > > > +         /* If we are processing .symtab purge __gnu_lto_v1 and
> > > > +            __gnu_lto_slim symbols from it.  */
> > > > +         if (sh_type == SHT_SYMTAB)
> > > > +           {
> > > > +             unsigned entsize = ELF_FETCH_FIELD (type_functions, 
> > > > ei_class, Shdr,
> > > > +                                                 shdr, sh_entsize, 
> > > > Elf_Addr);
> > > > +             unsigned strtab = ELF_FETCH_FIELD (type_functions, 
> > > > ei_class, Shdr,
> > > > +                                                shdr, sh_link, 
> > > > Elf_Word);
> > > > +             unsigned char *strshdr = shdrs + (strtab - 1) * shdr_size;
> > > > +             off_t stroff = ELF_FETCH_FIELD (type_functions, ei_class, 
> > > > Shdr,
> > > > +                                             strshdr, sh_offset, 
> > > > Elf_Addr);
> > > > +             size_t strsz = ELF_FETCH_FIELD (type_functions, ei_class, 
> > > > Shdr,
> > > > +                                             strshdr, sh_size, 
> > > > Elf_Addr);
> > > > +             char *strings = XNEWVEC (char, strsz);
> > > > +             unsigned char *ent;
> > > > +             simple_object_internal_read (sobj->descriptor,
> > > > +                                          sobj->offset + stroff,
> > > > +                                          (unsigned char *)strings,
> > > > +                                          strsz, &errmsg, err);
> > > > +             for (ent = buf; ent < buf + length; ent += entsize)
> > > > +               {
> > > > +                 unsigned st_shndx = ELF_FETCH_FIELD (type_functions, 
> > > > ei_class,
> > > > +                                                      Sym, ent,
> > > > +                                                      st_shndx, 
> > > > Elf_Half);
> > > > +                 unsigned char *st_info;
> > > > +                 unsigned char *st_other;
> > > > +                 if (ei_class == ELFCLASS32)
> > > > +                   {
> > > > +                     st_info = &((Elf32_External_Sym *)ent)->st_info;
> > > > +                     st_other = &((Elf32_External_Sym *)ent)->st_other;
> > > > +                   }
> > > > +                 else
> > > > +                   {
> > > > +                     st_info = &((Elf64_External_Sym *)ent)->st_info;
> > > > +                     st_other = &((Elf64_External_Sym *)ent)->st_other;
> > > > +                   }
> > > > +                 /* Eliminate all COMMONs - this includes __gnu_lto_v1
> > > > +                    and __gnu_lto_slim which otherwise cause endless
> > > > +                    LTO plugin invocation.  */
> > > > +                 if (st_shndx == SHN_COMMON)
> > > > +                   /* Setting st_name to "" seems to work to purge
> > > > +                      COMMON symbols (in addition to setting their
> > > > +                      size to zero).  */
> > > > +                   ;
> > > > +                 /* We also need to remove symbols refering to sections
> > > > +                    we'll eventually remove as with fat LTO objects
> > > > +                    we otherwise get duplicate symbols at final link
> > > > +                    (with GNU ld, gold is fine and ignores symbols in
> > > > +                    sections marked as EXCLUDE).  ld/20513  */
> > > > +                 else if (st_shndx != 0
> > > > +                          && st_shndx < shnum
> > > > +                          && pfnret[st_shndx - 1] == -1)
> > > > +                   /* Messing with st_shndx doesn't seem to work very
> > > > +                      well.  Likewise changing the symbol type to
> > > > +                      a section symbol or making it local.
> > > > +                      So just keep with making it unnamed.
> > > > +                      Also make all regular symbols STT_OBJECT and
> > > > +                      have default visibility, otherwise GNU ld warns
> > > > +                      about mismatches for the same `' named symbol.  
> > > > */
> > > > +                   {
> > > > +                     if (ELF_ST_TYPE (*st_info) == STT_FUNC
> > > > +                         || ELF_ST_TYPE (*st_info) == STT_TLS
> > > > +                         || ELF_ST_TYPE (*st_info) == STT_GNU_IFUNC)
> > > > +                       *st_info = ELF_ST_INFO (ELF_ST_BIND (*st_info),
> > > > +                                               STT_OBJECT);
> > > > +                     *st_other = STV_DEFAULT;
> > > > +                   }
> > > > +                 else
> > > > +                   continue;
> > > > +
> > > > +                 /* For all purged symbols make the symbol unnamed.  */
> > > > +                 ELF_SET_FIELD (type_functions, ei_class, Sym,
> > > > +                                ent, st_name, Elf_Word, 0);
> > > > +
> > > > +                 /* At least set st_value and st_size to zero to not go
> > > > +                    out of bounds.  */
> > > > +                 ELF_SET_FIELD (type_functions, ei_class, Sym,
> > > > +                                ent, st_value, Elf_Addr, 0);
> > > > +                 ELF_SET_FIELD (type_functions, ei_class, Sym,
> > > > +                                ent, st_size, Elf_Word, 0);
> > > > +               }
> > > > +             XDELETEVEC (strings);
> > > > +           }
> > > > +
> > > > +         errmsg = simple_object_write_add_data (dobj, dest, buf, 
> > > > length, 1, err);
> > > > +         XDELETEVEC (buf);
> > > > +         if (errmsg)
> > > > +           {
> > > > +             XDELETEVEC (names);
> > > > +             XDELETEVEC (shdrs);
> > > > +             return errmsg;
> > > > +           }
> > > > +       }
> > > > +      else
> > > > +       {
> > > > +         /* For deleted sections mark the section header table entry as
> > > > +            unused.  That allows the link editor to remove it in a 
> > > > partial
> > > > +            link.  */
> > > > +         ELF_SET_FIELD (type_functions, ei_class, Shdr,
> > > > +                        shdr, sh_type, Elf_Addr, SHT_NULL);
> > > > +       }
> > > > +
> > > > +      flags = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
> > > > +                              shdr, sh_flags, Elf_Addr);
> > > > +      if (ret == 0)
> > > > +       flags &= ~SHF_EXCLUDE;
> > > > +      else if (ret == -1)
> > > > +       flags |= SHF_EXCLUDE;
> > > > +      ELF_SET_FIELD (type_functions, ei_class, Shdr,
> > > > +                    shdr, sh_flags, Elf_Addr, flags);
> > > > +    }
> > > > +
> > > > +  XDELETEVEC (names);
> > > > +  XDELETEVEC (shdrs);
> > > > +  XDELETEVEC (pfnret);
> > > > +  XDELETEVEC (pfnname);
> > > > +
> > > > +  return NULL;
> > > > +}
> > > > +
> > > > +
> > > >  /* The ELF functions.  */
> > > >  
> > > >  const struct simple_object_functions simple_object_elf_functions =
> > > > @@ -969,5 +1420,6 @@ const struct simple_object_functions sim
> > > >    simple_object_elf_release_attributes,
> > > >    simple_object_elf_start_write,
> > > >    simple_object_elf_write_to_file,
> > > > -  simple_object_elf_release_write
> > > > +  simple_object_elf_release_write,
> > > > +  simple_object_elf_copy_lto_debug_sections
> > > >  };
> > > > Index: early-lto-debug/libiberty/simple-object.c
> > > > ===================================================================
> > > > --- early-lto-debug.orig/libiberty/simple-object.c      2016-10-19 
> > > > 13:19:58.012326431 +0200
> > > > +++ early-lto-debug/libiberty/simple-object.c   2016-10-20 
> > > > 13:58:11.722714041 +0200
> > > > @@ -22,6 +22,7 @@ Boston, MA 02110-1301, USA.  */
> > > >  #include "simple-object.h"
> > > >  
> > > >  #include <errno.h>
> > > > +#include <fcntl.h>
> > > >  
> > > >  #ifdef HAVE_STDLIB_H
> > > >  #include <stdlib.h>
> > > > @@ -249,6 +250,86 @@ simple_object_find_section (simple_objec
> > > >    return 1;
> > > >  }
> > > >  
> > > > +/* Callback to identify and rename LTO debug sections by name.
> > > > +   Returns 1 if NAME is a LTO debug section, 0 if not.  */
> > > > +
> > > > +static int
> > > > +handle_lto_debug_sections (const char **name)
> > > > +{
> > > > +  /* ???  So we can't use .gnu.lto_ prefixed sections as the assembler
> > > > +     complains about bogus section flags.  Which means we need to 
> > > > arrange
> > > > +     for that to be fixed or .gnu.debuglto_ marked as SHF_EXCLUDE (to 
> > > > make
> > > > +     fat lto object tooling work for the fat part).  */
> > > > +  /* ???  For now this handles both .gnu.lto_ and .gnu.debuglto_ 
> > > > prefixed
> > > > +     sections.  */
> > > > +  /* Copy LTO debug sections and rename them to their non-LTO name.  */
> > > > +  if (strncmp (*name, ".gnu.debuglto_", sizeof (".gnu.debuglto_") - 1) 
> > > > == 0)
> > > > +    {
> > > > +      *name = *name + sizeof (".gnu.debuglto_") - 1;
> > > > +      return 1;
> > > > +    }
> > > > +  else if (strncmp (*name, ".gnu.lto_.debug_", sizeof 
> > > > (".gnu.lto_.debug_") -1) == 0)
> > > > +    {
> > > > +      *name = *name + sizeof (".gnu.lto_") - 1;
> > > > +      return 1;
> > > > +    }
> > > > +  return 0;
> > > > +}
> > > > +
> > > > +/* Copy LTO debug sections.  */
> > > > +
> > > > +const char *
> > > > +simple_object_copy_lto_debug_sections (simple_object_read *sobj,
> > > > +                                      const char *dest, int *err)
> > > > +{
> > > > +  const char *errmsg;
> > > > +  simple_object_write *dest_sobj;
> > > > +  simple_object_attributes *attrs;
> > > > +  int outfd;
> > > > +
> > > > +  if (! sobj->functions->copy_lto_debug_sections)
> > > > +    {
> > > > +      *err = EINVAL;
> > > > +      return "simple_object_copy_lto_debug_sections not implemented";
> > > > +    }
> > > > +
> > > > +  attrs = simple_object_fetch_attributes (sobj, &errmsg, err);
> > > > +  if (! attrs)
> > > > +    return errmsg;
> > > > +  dest_sobj = simple_object_start_write (attrs, NULL, &errmsg, err);
> > > > +  simple_object_release_attributes (attrs);
> > > > +  if (! dest_sobj)
> > > > +    return errmsg;
> > > > +
> > > > +  errmsg = sobj->functions->copy_lto_debug_sections (sobj, dest_sobj,
> > > > +                                                    
> > > > handle_lto_debug_sections,
> > > > +                                                    err);
> > > > +  if (errmsg)
> > > > +    {
> > > > +      simple_object_release_write (dest_sobj);
> > > > +      return errmsg;
> > > > +    }
> > > > +
> > > > +  outfd = creat (dest, 00777);
> > > > +  if (outfd == -1)
> > > > +    {
> > > > +      *err = errno;
> > > > +      simple_object_release_write (dest_sobj);
> > > > +      return "open failed";
> > > > +    }
> > > > +
> > > > +  errmsg = simple_object_write_to_file (dest_sobj, outfd, err);
> > > > +  close (outfd);
> > > > +  if (errmsg)
> > > > +    {
> > > > +      simple_object_release_write (dest_sobj);
> > > > +      return errmsg;
> > > > +    }
> > > > +
> > > > +  simple_object_release_write (dest_sobj);
> > > > +  return NULL;
> > > > +}
> > > > +
> > > >  /* Fetch attributes.  */
> > > >  
> > > >  simple_object_attributes *
> > > > @@ -315,7 +396,7 @@ simple_object_start_write (simple_object
> > > >      return NULL;
> > > >    ret = XNEW (simple_object_write);
> > > >    ret->functions = attrs->functions;
> > > > -  ret->segment_name = xstrdup (segment_name);
> > > > +  ret->segment_name = segment_name ? xstrdup (segment_name) : NULL;
> > > >    ret->sections = NULL;
> > > >    ret->last_section = NULL;
> > > >    ret->data = data;
> > > > Index: early-lto-debug/libiberty/simple-object-coff.c
> > > > ===================================================================
> > > > --- early-lto-debug.orig/libiberty/simple-object-coff.c 2016-10-19 
> > > > 13:19:58.012326431 +0200
> > > > +++ early-lto-debug/libiberty/simple-object-coff.c      2016-10-20 
> > > > 10:51:49.881723228 +0200
> > > > @@ -800,5 +800,6 @@ const struct simple_object_functions sim
> > > >    simple_object_coff_release_attributes,
> > > >    simple_object_coff_start_write,
> > > >    simple_object_coff_write_to_file,
> > > > -  simple_object_coff_release_write
> > > > +  simple_object_coff_release_write,
> > > > +  NULL
> > > >  };
> > > > Index: early-lto-debug/libiberty/simple-object-mach-o.c
> > > > ===================================================================
> > > > --- early-lto-debug.orig/libiberty/simple-object-mach-o.c       
> > > > 2016-10-19 13:19:58.012326431 +0200
> > > > +++ early-lto-debug/libiberty/simple-object-mach-o.c    2016-10-20 
> > > > 10:51:49.881723228 +0200
> > > > @@ -1374,5 +1374,6 @@ const struct simple_object_functions sim
> > > >    simple_object_mach_o_release_attributes,
> > > >    simple_object_mach_o_start_write,
> > > >    simple_object_mach_o_write_to_file,
> > > > -  simple_object_mach_o_release_write
> > > > +  simple_object_mach_o_release_write,
> > > > +  NULL
> > > >  };
> > > > Index: early-lto-debug/libiberty/simple-object-xcoff.c
> > > > ===================================================================
> > > > --- early-lto-debug.orig/libiberty/simple-object-xcoff.c        
> > > > 2016-10-19 13:19:58.012326431 +0200
> > > > +++ early-lto-debug/libiberty/simple-object-xcoff.c     2016-10-20 
> > > > 10:51:49.881723228 +0200
> > > > @@ -894,5 +894,6 @@ const struct simple_object_functions sim
> > > >    simple_object_xcoff_release_attributes,
> > > >    simple_object_xcoff_start_write,
> > > >    simple_object_xcoff_write_to_file,
> > > > -  simple_object_xcoff_release_write
> > > > +  simple_object_xcoff_release_write,
> > > > +  NULL
> > > >  };
> > > > 
> > > 
> > > 
> > 
> > 
> 
> 

-- 
Richard Biener <rguent...@suse.de>
SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Graham Norton, HRB 
21284 (AG Nuernberg)

Reply via email to