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)