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.
> 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)
