This implements (for ELF sofar) the Early LTO debug information copier.
To remind people what this is about with Early LTO Debug the compile-stage
emits the DWARF DIEs as they are at dwarf2out_early_finish into the
object files that also contain the LTO IL. On ELF they end up in
sections prefixed by .gnu.debuglto_ but otherwise with the usual
DWARF debug section names and flags. They can appear alongside regular
DWARF debug sections for the fat part of the object (if compiled with
-flto -ffat-lto-objects - the default on targets where linker plugin
support is not available).
Simple C hello world compiled with -g -flto -ffat-lto-objects:
Section Headers:
[Nr] Name Type Address Off Size ES
Flg Lk Inf Al
[ 0] NULL 0000000000000000 000000 000000 00
0 0 0
[ 1] .text PROGBITS 0000000000000000 000040 0000c6 00
AX 0 0 1
[ 2] .data PROGBITS 0000000000000000 000106 000000 00
WA 0 0 1
[ 3] .bss NOBITS 0000000000000000 000106 000000 00
WA 0 0 1
[ 4] .gnu.debuglto_.debug_info PROGBITS 0000000000000000 000106
000099 00 E 0 0 1
[ 5] .rela.gnu.debuglto_.debug_info RELA 0000000000000000
0011b0 0000c0 18 I 27 4 8
[ 6] .gnu.debuglto_.debug_abbrev PROGBITS 0000000000000000 00019f
000088 00 E 0 0 1
[ 7] .gnu.debuglto_.debug_str PROGBITS 0000000000000000 000227
0000bf 01 MSE 0 0 1
[ 8] .gnu.lto_.inline.34f47533603cde40 PROGBITS 0000000000000000
0002e6 00002b 00 E 0 0 1
[ 9] .gnu.lto_main.34f47533603cde40 PROGBITS 0000000000000000
000311 0004db 00 E 0 0 1
[10] .gnu.lto_.symbol_nodes.34f47533603cde40 PROGBITS
0000000000000000 0007ec 00004c 00 E 0 0 1
[11] .gnu.lto_.refs.34f47533603cde40 PROGBITS 0000000000000000
000838 00000f 00 E 0 0 1
[12] .gnu.lto_.decls.34f47533603cde40 PROGBITS 0000000000000000
000847 00039d 00 E 0 0 1
[13] .gnu.lto_.symtab.34f47533603cde40 PROGBITS 0000000000000000
000be4 000014 00 E 0 0 1
[14] .gnu.lto_.opts PROGBITS 0000000000000000 000bf8 0000b5 00
E 0 0 1
[15] .debug_info PROGBITS 0000000000000000 000cad 0000e1 00
0 0 1
[16] .rela.debug_info RELA 0000000000000000 001270 000120 18
I 27 15 8
[17] .debug_abbrev PROGBITS 0000000000000000 000d8e 0000a1 00
0 0 1
[18] .debug_aranges PROGBITS 0000000000000000 000e2f 000030 00
0 0 1
[19] .rela.debug_aranges RELA 0000000000000000 001390 000030
18 I 27 18 8
[20] .debug_line PROGBITS 0000000000000000 000e5f 00004f 00
0 0 1
[21] .rela.debug_line RELA 0000000000000000 0013c0 000018 18
I 27 20 8
[22] .comment PROGBITS 0000000000000000 000eae 000042 01
MS 0 0 1
[23] .note.GNU-stack PROGBITS 0000000000000000 000ef0 000000 00
0 0 1
[24] .eh_frame PROGBITS 0000000000000000 000ef0 000040 00
A 0 0 8
[25] .rela.eh_frame RELA 0000000000000000 0013d8 000018 18
I 27 24 8
[26] .shstrtab STRTAB 0000000000000000 0013f0 0001b9 00
0 0 1
[27] .symtab SYMTAB 0000000000000000 000f30 000258 18
28 22 8
[28] .strtab STRTAB 0000000000000000 001188 000025 00
0 0 1
Symbol table '.symtab' contains 25 entries:
Num: Value Size Type Bind Vis Ndx Name
...
22: 0000000000000000 0 NOTYPE WEAK HIDDEN 4 gt.c.675919dd
23: 0000000000000000 198 FUNC GLOBAL DEFAULT 1 main
24: 0000000000000001 1 OBJECT GLOBAL DEFAULT COM __gnu_lto_v1
important parts to notice is that there are .gnu.debuglto_ sections
with relocations and with symbols we have to preserve.
The task of the simple-object worker is to copy the .gnu.debuglto_
sections to a new object, stripping the section name mangling
(and removing the Exclude flag). The result of the operation to the
above sections is
Section Headers:
[Nr] Name Type Address Off Size ES
Flg Lk Inf Al
[ 0] NULL 0000000000000000 000000 000000 00
0 0 0
[ 1] NULL 0000000000000000 0007c0 000000 00
E 0 0 1
[ 2] NULL 0000000000000000 0007c0 000000 00
E 0 0 1
[ 3] NULL 0000000000000000 0007c0 000000 00
E 0 0 1
[ 4] .debug_info PROGBITS 0000000000000000 0007c0 000099 00
0 0 1
[ 5] .rela.gnu.debuglto_.debug_info RELA 0000000000000000
000860 0000c0 18 I 27 4 8
[ 6] .debug_abbrev PROGBITS 0000000000000000 000920 000088 00
0 0 1
[ 7] .debug_str PROGBITS 0000000000000000 0009a8 0000bf 01
MS 0 0 1
[ 8] NULL 0000000000000000 000a67 000000 00
E 0 0 1
[ 9] NULL 0000000000000000 000a67 000000 00
E 0 0 1
[10] NULL 0000000000000000 000a67 000000 00
E 0 0 1
[11] NULL 0000000000000000 000a67 000000 00
E 0 0 1
[12] NULL 0000000000000000 000a67 000000 00
E 0 0 1
[13] NULL 0000000000000000 000a67 000000 00
E 0 0 1
[14] NULL 0000000000000000 000a67 000000 00
E 0 0 1
[15] NULL 0000000000000000 000a67 000000 00
E 0 0 1
[16] NULL 0000000000000000 000a68 000000 18
E 27 15 8
[17] NULL 0000000000000000 000a68 000000 00
E 0 0 1
[18] NULL 0000000000000000 000a68 000000 00
E 0 0 1
[19] NULL 0000000000000000 000a68 000000 18
E 27 18 8
[20] NULL 0000000000000000 000a68 000000 00
E 0 0 1
[21] NULL 0000000000000000 000a68 000000 18
E 27 20 8
[22] NULL 0000000000000000 000a68 000000 01
E 0 0 1
[23] NULL 0000000000000000 000a68 000000 00
E 0 0 1
[24] NULL 0000000000000000 000a68 000000 00
E 0 0 8
[25] NULL 0000000000000000 000a68 000000 18
E 27 24 8
[26] NULL 0000000000000000 000a68 000000 00
E 0 0 1
[27] .symtab SYMTAB 0000000000000000 000a68 000258 18
28 22 8
[28] .strtab STRTAB 0000000000000000 000cc0 000025 00
0 0 1
[29] .shstrtab STRTAB 0000000000000000 000ce5 000075 00
0 0 1
Symbol table '.symtab' contains 25 entries:
Num: Value Size Type Bind Vis Ndx Name
...
22: 0000000000000000 0 NOTYPE WEAK HIDDEN 4 gt.c.675919dd
23: 0000000000000000 0 OBJECT GLOBAL DEFAULT 1
24: 0000000000000000 0 OBJECT GLOBAL DEFAULT COM
you can see some of the tricks I pulled off to avoid re-writing
the relocation section entries... (keep section and symbol indices
unchanged).
The above result is later fed to a partial link (linking all input TUs
early debug objects to a single one) so the unused sections and symbols
go away before the final link (not that this matters I guess). The
object gets linked with the output from the LTRANS compile stage
which provides "late" DWARF referencing the early DWARF via the
above symbol.
The simple-object interface to this is quite simple:
/* 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);
and a simple_object_write is constructed by common simple-object code
(so you know the destination is empty and it's written from only
the target provided data). The ELF implementation still has
remanents of a more generic approach (copy/rename selected sections),
completely folding the writing side into the hook would for example
avoid keeping the sections data live in memory. It might also
ease a darwin implementation if we manage to require only a full
segment transfer, say from __GNU_DWARF_LTO to __DWARF.
I'm posting it in the current form to seek feedback on whether it's
fine to add such special stuff to simple-object and if there are
any suggestions on how to improve the interface (the change suggested
above would make the hook have the same signature as the simple-object
API and the common implementation would only dispatch to the hook).
Bootstrapped and tested on x86_64-unknown-linux-gnu (with the
early-LTO debug patch).
Thanks,
Richard.
2016-09-20 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-09-20
14:16:53.789716379 +0200
--- early-lto-debug/include/simple-object.h 2016-09-20 14:24:14.710861059
+0200
*************** simple_object_write_to_file (simple_obje
*** 197,202 ****
--- 197,210 ----
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-09-20
14:16:53.789716379 +0200
--- early-lto-debug/libiberty/simple-object-common.h 2016-09-20
14:24:14.714861105 +0200
*************** struct simple_object_functions
*** 141,146 ****
--- 141,152 ----
/* 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-09-20
14:16:53.789716379 +0200
--- early-lto-debug/libiberty/simple-object-elf.c 2016-09-20
14:38:52.553108743 +0200
*************** typedef struct {
*** 183,190 ****
--- 183,237 ----
/* 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. */
*************** struct simple_object_elf_attributes
*** 348,353 ****
--- 395,408 ----
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 *
*************** simple_object_elf_start_write (void *att
*** 675,686 ****
{
struct simple_object_elf_attributes *attrs =
(struct simple_object_elf_attributes *) attributes_data;
! struct simple_object_elf_attributes *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;
return ret;
}
--- 730,742 ----
{
struct simple_object_elf_attributes *attrs =
(struct simple_object_elf_attributes *) attributes_data;
! 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_write);
! ret->attrs = *attrs;
! ret->shdrs = NULL;
return ret;
}
*************** static int
*** 766,773 ****
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,
unsigned int sh_offset, unsigned int sh_size,
! unsigned int sh_link, unsigned int sh_addralign,
const char **errmsg, int *err)
{
struct simple_object_elf_attributes *attrs =
--- 822,832 ----
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_info,
! unsigned int sh_addralign,
! unsigned int sh_entsize,
const char **errmsg, int *err)
{
struct simple_object_elf_attributes *attrs =
*************** simple_object_elf_write_shdr (simple_obj
*** 788,799 ****
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_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_addralign, Elf_Addr, sh_addralign);
! /* sh_entsize left as zero. */
return simple_object_internal_write (descriptor, offset, buf, shdr_size,
errmsg, err);
--- 847,859 ----
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);
! 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);
! 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);
*************** static const char *
*** 811,818 ****
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;
unsigned char cl;
size_t ehdr_size;
size_t shdr_size;
--- 871,879 ----
simple_object_elf_write_to_file (simple_object_write *sobj, int descriptor,
int *err)
{
! 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;
*************** simple_object_elf_write_to_file (simple_
*** 825,830 ****
--- 886,892 ----
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;
*************** simple_object_elf_write_to_file (simple_
*** 862,882 ****
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))
return errmsg;
shdr_offset += shdr_size;
sh_name = 1;
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;
! mask = (1U << section->align) - 1;
new_sh_offset = sh_offset + mask;
new_sh_offset &= ~ mask;
while (new_sh_offset > sh_offset)
--- 924,977 ----
else
first_sh_link = shnum - 1;
if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
! 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 = sh_addralign - 1;
new_sh_offset = sh_offset + mask;
new_sh_offset &= ~ mask;
while (new_sh_offset > sh_offset)
*************** simple_object_elf_write_to_file (simple_
*** 906,913 ****
}
if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
! sh_name, SHT_PROGBITS, 0, sh_offset,
! sh_size, 0, 1U << section->align,
&errmsg, err))
return errmsg;
--- 1001,1010 ----
}
if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
! sh_name, sh_type, sh_flags,
! sh_addr, sh_offset,
! sh_size, sh_link, sh_info,
! sh_addralign, sh_entsize,
&errmsg, err))
return errmsg;
*************** simple_object_elf_write_to_file (simple_
*** 917,925 ****
}
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))
return errmsg;
/* .shstrtab has a leading zero byte. */
--- 1014,1022 ----
}
if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
! 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. */
*************** simple_object_elf_write_to_file (simple_
*** 954,962 ****
--- 1051,1413 ----
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 =
*************** const struct simple_object_functions sim
*** 969,973 ****
simple_object_elf_release_attributes,
simple_object_elf_start_write,
simple_object_elf_write_to_file,
! simple_object_elf_release_write
};
--- 1420,1425 ----
simple_object_elf_release_attributes,
simple_object_elf_start_write,
simple_object_elf_write_to_file,
! 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-09-20
14:16:53.789716379 +0200
--- early-lto-debug/libiberty/simple-object.c 2016-09-20 14:36:20.271331053
+0200
*************** Boston, MA 02110-1301, USA. */
*** 22,27 ****
--- 22,28 ----
#include "simple-object.h"
#include <errno.h>
+ #include <fcntl.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
*************** simple_object_find_section (simple_objec
*** 249,254 ****
--- 250,334 ----
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;
+ }
+
+ return NULL;
+ }
+
/* Fetch attributes. */
simple_object_attributes *
*************** simple_object_start_write (simple_object
*** 315,321 ****
return NULL;
ret = XNEW (simple_object_write);
ret->functions = attrs->functions;
! ret->segment_name = xstrdup (segment_name);
ret->sections = NULL;
ret->last_section = NULL;
ret->data = data;
--- 395,401 ----
return NULL;
ret = XNEW (simple_object_write);
ret->functions = attrs->functions;
! 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-09-20
14:16:53.789716379 +0200
--- early-lto-debug/libiberty/simple-object-coff.c 2016-09-20
14:24:14.734861339 +0200
*************** const struct simple_object_functions sim
*** 800,804 ****
simple_object_coff_release_attributes,
simple_object_coff_start_write,
simple_object_coff_write_to_file,
! simple_object_coff_release_write
};
--- 800,805 ----
simple_object_coff_release_attributes,
simple_object_coff_start_write,
simple_object_coff_write_to_file,
! 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-09-20
14:16:53.789716379 +0200
--- early-lto-debug/libiberty/simple-object-mach-o.c 2016-09-20
14:24:14.734861339 +0200
*************** const struct simple_object_functions sim
*** 1374,1378 ****
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
};
--- 1374,1379 ----
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,
! NULL
};
Index: early-lto-debug/libiberty/simple-object-xcoff.c
===================================================================
*** early-lto-debug.orig/libiberty/simple-object-xcoff.c 2016-09-20
14:16:53.789716379 +0200
--- early-lto-debug/libiberty/simple-object-xcoff.c 2016-09-20
14:24:14.734861339 +0200
*************** const struct simple_object_functions sim
*** 894,898 ****
simple_object_xcoff_release_attributes,
simple_object_xcoff_start_write,
simple_object_xcoff_write_to_file,
! simple_object_xcoff_release_write
};
--- 894,899 ----
simple_object_xcoff_release_attributes,
simple_object_xcoff_start_write,
simple_object_xcoff_write_to_file,
! simple_object_xcoff_release_write,
! NULL
};
