Improve addressing of TI/TFmode
[official-gcc.git] / libiberty / simple-object-elf.c
blob14f71053150890aecc8d500ac0e8f1f493bbe71b
1 /* simple-object-elf.c -- routines to manipulate ELF object files.
2 Copyright (C) 2010-2017 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Google.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any
8 later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, 51 Franklin Street - Fifth Floor,
18 Boston, MA 02110-1301, USA. */
20 #include "config.h"
21 #include "libiberty.h"
22 #include "simple-object.h"
24 #include <errno.h>
25 #include <stddef.h>
27 #ifdef HAVE_STDLIB_H
28 #include <stdlib.h>
29 #endif
31 #ifdef HAVE_STDINT_H
32 #include <stdint.h>
33 #endif
35 #ifdef HAVE_STRING_H
36 #include <string.h>
37 #endif
39 #ifdef HAVE_INTTYPES_H
40 #include <inttypes.h>
41 #endif
43 #include "simple-object-common.h"
45 /* ELF structures and constants. */
47 /* 32-bit ELF file header. */
49 typedef struct {
50 unsigned char e_ident[16]; /* ELF "magic number" */
51 unsigned char e_type[2]; /* Identifies object file type */
52 unsigned char e_machine[2]; /* Specifies required architecture */
53 unsigned char e_version[4]; /* Identifies object file version */
54 unsigned char e_entry[4]; /* Entry point virtual address */
55 unsigned char e_phoff[4]; /* Program header table file offset */
56 unsigned char e_shoff[4]; /* Section header table file offset */
57 unsigned char e_flags[4]; /* Processor-specific flags */
58 unsigned char e_ehsize[2]; /* ELF header size in bytes */
59 unsigned char e_phentsize[2]; /* Program header table entry size */
60 unsigned char e_phnum[2]; /* Program header table entry count */
61 unsigned char e_shentsize[2]; /* Section header table entry size */
62 unsigned char e_shnum[2]; /* Section header table entry count */
63 unsigned char e_shstrndx[2]; /* Section header string table index */
64 } Elf32_External_Ehdr;
66 /* 64-bit ELF file header. */
68 typedef struct {
69 unsigned char e_ident[16]; /* ELF "magic number" */
70 unsigned char e_type[2]; /* Identifies object file type */
71 unsigned char e_machine[2]; /* Specifies required architecture */
72 unsigned char e_version[4]; /* Identifies object file version */
73 unsigned char e_entry[8]; /* Entry point virtual address */
74 unsigned char e_phoff[8]; /* Program header table file offset */
75 unsigned char e_shoff[8]; /* Section header table file offset */
76 unsigned char e_flags[4]; /* Processor-specific flags */
77 unsigned char e_ehsize[2]; /* ELF header size in bytes */
78 unsigned char e_phentsize[2]; /* Program header table entry size */
79 unsigned char e_phnum[2]; /* Program header table entry count */
80 unsigned char e_shentsize[2]; /* Section header table entry size */
81 unsigned char e_shnum[2]; /* Section header table entry count */
82 unsigned char e_shstrndx[2]; /* Section header string table index */
83 } Elf64_External_Ehdr;
85 /* Indexes and values in e_ident field of Ehdr. */
87 #define EI_MAG0 0 /* File identification byte 0 index */
88 #define ELFMAG0 0x7F /* Magic number byte 0 */
90 #define EI_MAG1 1 /* File identification byte 1 index */
91 #define ELFMAG1 'E' /* Magic number byte 1 */
93 #define EI_MAG2 2 /* File identification byte 2 index */
94 #define ELFMAG2 'L' /* Magic number byte 2 */
96 #define EI_MAG3 3 /* File identification byte 3 index */
97 #define ELFMAG3 'F' /* Magic number byte 3 */
99 #define EI_CLASS 4 /* File class */
100 #define ELFCLASSNONE 0 /* Invalid class */
101 #define ELFCLASS32 1 /* 32-bit objects */
102 #define ELFCLASS64 2 /* 64-bit objects */
104 #define EI_DATA 5 /* Data encoding */
105 #define ELFDATANONE 0 /* Invalid data encoding */
106 #define ELFDATA2LSB 1 /* 2's complement, little endian */
107 #define ELFDATA2MSB 2 /* 2's complement, big endian */
109 #define EI_VERSION 6 /* File version */
110 #define EV_CURRENT 1 /* Current version */
112 #define EI_OSABI 7 /* Operating System/ABI indication */
114 /* Values for e_type field of Ehdr. */
116 #define ET_REL 1 /* Relocatable file */
118 /* Values for e_machine field of Ehdr. */
120 #define EM_SPARC 2 /* SUN SPARC */
121 #define EM_SPARC32PLUS 18 /* Sun's "v8plus" */
123 /* Special section index values. */
125 #define SHN_UNDEF 0 /* Undefined section */
126 #define SHN_LORESERVE 0xFF00 /* Begin range of reserved indices */
127 #define SHN_COMMON 0xFFF2 /* Associated symbol is in common */
128 #define SHN_XINDEX 0xFFFF /* Section index is held elsewhere */
131 /* 32-bit ELF program header. */
133 typedef struct {
134 unsigned char p_type[4]; /* Identifies program segment type */
135 unsigned char p_offset[4]; /* Segment file offset */
136 unsigned char p_vaddr[4]; /* Segment virtual address */
137 unsigned char p_paddr[4]; /* Segment physical address */
138 unsigned char p_filesz[4]; /* Segment size in file */
139 unsigned char p_memsz[4]; /* Segment size in memory */
140 unsigned char p_flags[4]; /* Segment flags */
141 unsigned char p_align[4]; /* Segment alignment, file & memory */
142 } Elf32_External_Phdr;
144 /* 64-bit ELF program header. */
146 typedef struct {
147 unsigned char p_type[4]; /* Identifies program segment type */
148 unsigned char p_flags[4]; /* Segment flags */
149 unsigned char p_offset[8]; /* Segment file offset */
150 unsigned char p_vaddr[8]; /* Segment virtual address */
151 unsigned char p_paddr[8]; /* Segment physical address */
152 unsigned char p_filesz[8]; /* Segment size in file */
153 unsigned char p_memsz[8]; /* Segment size in memory */
154 unsigned char p_align[8]; /* Segment alignment, file & memory */
155 } Elf64_External_Phdr;
157 /* 32-bit ELF section header */
159 typedef struct {
160 unsigned char sh_name[4]; /* Section name, index in string tbl */
161 unsigned char sh_type[4]; /* Type of section */
162 unsigned char sh_flags[4]; /* Miscellaneous section attributes */
163 unsigned char sh_addr[4]; /* Section virtual addr at execution */
164 unsigned char sh_offset[4]; /* Section file offset */
165 unsigned char sh_size[4]; /* Size of section in bytes */
166 unsigned char sh_link[4]; /* Index of another section */
167 unsigned char sh_info[4]; /* Additional section information */
168 unsigned char sh_addralign[4]; /* Section alignment */
169 unsigned char sh_entsize[4]; /* Entry size if section holds table */
170 } Elf32_External_Shdr;
172 /* 64-bit ELF section header. */
174 typedef struct {
175 unsigned char sh_name[4]; /* Section name, index in string tbl */
176 unsigned char sh_type[4]; /* Type of section */
177 unsigned char sh_flags[8]; /* Miscellaneous section attributes */
178 unsigned char sh_addr[8]; /* Section virtual addr at execution */
179 unsigned char sh_offset[8]; /* Section file offset */
180 unsigned char sh_size[8]; /* Size of section in bytes */
181 unsigned char sh_link[4]; /* Index of another section */
182 unsigned char sh_info[4]; /* Additional section information */
183 unsigned char sh_addralign[8]; /* Section alignment */
184 unsigned char sh_entsize[8]; /* Entry size if section holds table */
185 } Elf64_External_Shdr;
187 /* Values for sh_type field. */
189 #define SHT_NULL 0 /* Section header table entry unused */
190 #define SHT_PROGBITS 1 /* Program data */
191 #define SHT_SYMTAB 2 /* Link editing symbol table */
192 #define SHT_STRTAB 3 /* A string table */
193 #define SHT_RELA 4 /* Relocation entries with addends */
194 #define SHT_REL 9 /* Relocation entries, no addends */
195 #define SHT_GROUP 17 /* Section contains a section group */
197 /* Values for sh_flags field. */
199 #define SHF_EXECINSTR 0x00000004 /* Executable section. */
200 #define SHF_EXCLUDE 0x80000000 /* Link editor is to exclude this
201 section from executable and
202 shared library that it builds
203 when those objects are not to be
204 further relocated. */
205 /* Symbol table entry. */
207 typedef struct
209 unsigned char st_name[4]; /* Symbol name (string tbl index) */
210 unsigned char st_value[4]; /* Symbol value */
211 unsigned char st_size[4]; /* Symbol size */
212 unsigned char st_info; /* Symbol type and binding */
213 unsigned char st_other; /* Symbol visibility */
214 unsigned char st_shndx[2]; /* Section index */
215 } Elf32_External_Sym;
217 typedef struct
219 unsigned char st_name[4]; /* Symbol name (string tbl index) */
220 unsigned char st_info; /* Symbol type and binding */
221 unsigned char st_other; /* Symbol visibility */
222 unsigned char st_shndx[2]; /* Section index */
223 unsigned char st_value[8]; /* Symbol value */
224 unsigned char st_size[8]; /* Symbol size */
225 } Elf64_External_Sym;
227 #define ELF_ST_BIND(val) (((unsigned char) (val)) >> 4)
228 #define ELF_ST_TYPE(val) ((val) & 0xf)
229 #define ELF_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
231 #define STT_NOTYPE 0 /* Symbol type is unspecified */
232 #define STT_OBJECT 1 /* Symbol is a data object */
233 #define STT_FUNC 2 /* Symbol is a code object */
234 #define STT_TLS 6 /* Thread local data object */
235 #define STT_GNU_IFUNC 10 /* Symbol is an indirect code object */
237 #define STB_LOCAL 0 /* Local symbol */
238 #define STB_GLOBAL 1 /* Global symbol */
239 #define STB_WEAK 2 /* Weak global */
241 #define STV_DEFAULT 0 /* Visibility is specified by binding type */
242 #define STV_HIDDEN 2 /* Can only be seen inside currect component */
244 /* Functions to fetch and store different ELF types, depending on the
245 endianness and size. */
247 struct elf_type_functions
249 unsigned short (*fetch_Elf_Half) (const unsigned char *);
250 unsigned int (*fetch_Elf_Word) (const unsigned char *);
251 ulong_type (*fetch_Elf_Addr) (const unsigned char *);
252 void (*set_Elf_Half) (unsigned char *, unsigned short);
253 void (*set_Elf_Word) (unsigned char *, unsigned int);
254 void (*set_Elf_Addr) (unsigned char *, ulong_type);
257 static const struct elf_type_functions elf_big_32_functions =
259 simple_object_fetch_big_16,
260 simple_object_fetch_big_32,
261 simple_object_fetch_big_32_ulong,
262 simple_object_set_big_16,
263 simple_object_set_big_32,
264 simple_object_set_big_32_ulong
267 static const struct elf_type_functions elf_little_32_functions =
269 simple_object_fetch_little_16,
270 simple_object_fetch_little_32,
271 simple_object_fetch_little_32_ulong,
272 simple_object_set_little_16,
273 simple_object_set_little_32,
274 simple_object_set_little_32_ulong
277 #ifdef UNSIGNED_64BIT_TYPE
279 static const struct elf_type_functions elf_big_64_functions =
281 simple_object_fetch_big_16,
282 simple_object_fetch_big_32,
283 simple_object_fetch_big_64,
284 simple_object_set_big_16,
285 simple_object_set_big_32,
286 simple_object_set_big_64
289 static const struct elf_type_functions elf_little_64_functions =
291 simple_object_fetch_little_16,
292 simple_object_fetch_little_32,
293 simple_object_fetch_little_64,
294 simple_object_set_little_16,
295 simple_object_set_little_32,
296 simple_object_set_little_64
299 #endif
301 /* Hideous macro to fetch the value of a field from an external ELF
302 struct of some sort. TYPEFUNCS is the set of type functions.
303 BUFFER points to the external data. STRUCTTYPE is the appropriate
304 struct type. FIELD is a field within the struct. TYPE is the type
305 of the field in the struct: Elf_Half, Elf_Word, or Elf_Addr. */
307 #define ELF_FETCH_STRUCT_FIELD(TYPEFUNCS, STRUCTTYPE, FIELD, BUFFER, TYPE) \
308 ((TYPEFUNCS)->fetch_ ## TYPE ((BUFFER) + offsetof (STRUCTTYPE, FIELD)))
310 /* Even more hideous macro to fetch the value of FIELD from BUFFER.
311 SIZE is 32 or 64. STRUCTTYPE is the name of the struct from
312 elf/external.h: Ehdr, Shdr, etc. FIELD is the name of a field in
313 the struct. TYPE is the type of the field in the struct: Elf_Half,
314 Elf_Word, or Elf_Addr. */
316 #define ELF_FETCH_SIZED_FIELD(TYPEFUNCS, SIZE, STRUCTTYPE, BUFFER, \
317 FIELD, TYPE) \
318 ELF_FETCH_STRUCT_FIELD (TYPEFUNCS, \
319 Elf ## SIZE ## _External_ ## STRUCTTYPE, \
320 FIELD, BUFFER, TYPE)
322 /* Like ELF_FETCH_SIZED_FIELD but taking an ELFCLASS value. */
324 #define ELF_FETCH_FIELD(TYPEFUNCS, CLASS, STRUCTTYPE, BUFFER, \
325 FIELD, TYPE) \
326 ((CLASS) == ELFCLASS32 \
327 ? ELF_FETCH_SIZED_FIELD (TYPEFUNCS, 32, STRUCTTYPE, BUFFER, FIELD, \
328 TYPE) \
329 : ELF_FETCH_SIZED_FIELD (TYPEFUNCS, 64, STRUCTTYPE, BUFFER, FIELD, \
330 TYPE))
332 /* Hideous macro to set the value of a field in an external ELF
333 structure to VAL. TYPEFUNCS is the set of type functions. BUFFER
334 points to the external data. STRUCTTYPE is the appropriate
335 structure type. FIELD is a field within the struct. TYPE is the
336 type of the field in the struct: Elf_Half, Elf_Word, or
337 Elf_Addr. */
339 #define ELF_SET_STRUCT_FIELD(TYPEFUNCS, STRUCTTYPE, FIELD, BUFFER, TYPE, VAL) \
340 (TYPEFUNCS)->set_ ## TYPE ((BUFFER) + offsetof (STRUCTTYPE, FIELD), (VAL))
342 /* Even more hideous macro to set the value of FIELD in BUFFER to VAL.
343 SIZE is 32 or 64. STRUCTTYPE is the name of the struct from
344 elf/external.h: Ehdr, Shdr, etc. FIELD is the name of a field in
345 the struct. TYPE is the type of the field in the struct: Elf_Half,
346 Elf_Word, or Elf_Addr. */
348 #define ELF_SET_SIZED_FIELD(TYPEFUNCS, SIZE, STRUCTTYPE, BUFFER, FIELD, \
349 TYPE, VAL) \
350 ELF_SET_STRUCT_FIELD (TYPEFUNCS, \
351 Elf ## SIZE ## _External_ ## STRUCTTYPE, \
352 FIELD, BUFFER, TYPE, VAL)
354 /* Like ELF_SET_SIZED_FIELD but taking an ELFCLASS value. */
356 #define ELF_SET_FIELD(TYPEFUNCS, CLASS, STRUCTTYPE, BUFFER, FIELD, \
357 TYPE, VAL) \
358 ((CLASS) == ELFCLASS32 \
359 ? ELF_SET_SIZED_FIELD (TYPEFUNCS, 32, STRUCTTYPE, BUFFER, FIELD, \
360 TYPE, VAL) \
361 : ELF_SET_SIZED_FIELD (TYPEFUNCS, 64, STRUCTTYPE, BUFFER, FIELD, \
362 TYPE, VAL))
364 /* Private data for an simple_object_read. */
366 struct simple_object_elf_read
368 /* Type functions. */
369 const struct elf_type_functions* type_functions;
370 /* Elf data. */
371 unsigned char ei_data;
372 /* Elf class. */
373 unsigned char ei_class;
374 /* ELF OS ABI. */
375 unsigned char ei_osabi;
376 /* Elf machine number. */
377 unsigned short machine;
378 /* Processor specific flags. */
379 unsigned int flags;
380 /* File offset of section headers. */
381 ulong_type shoff;
382 /* Number of sections. */
383 unsigned int shnum;
384 /* Index of string table section header. */
385 unsigned int shstrndx;
388 /* Private data for an simple_object_attributes. */
390 struct simple_object_elf_attributes
392 /* Type functions. */
393 const struct elf_type_functions* type_functions;
394 /* Elf data. */
395 unsigned char ei_data;
396 /* Elf class. */
397 unsigned char ei_class;
398 /* ELF OS ABI. */
399 unsigned char ei_osabi;
400 /* Elf machine number. */
401 unsigned short machine;
402 /* Processor specific flags. */
403 unsigned int flags;
406 /* Private data for an simple_object_write. */
408 struct simple_object_elf_write
410 struct simple_object_elf_attributes attrs;
411 unsigned char *shdrs;
414 /* See if we have an ELF file. */
416 static void *
417 simple_object_elf_match (unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN],
418 int descriptor, off_t offset,
419 const char *segment_name ATTRIBUTE_UNUSED,
420 const char **errmsg, int *err)
422 unsigned char ei_data;
423 unsigned char ei_class;
424 const struct elf_type_functions *type_functions;
425 unsigned char ehdr[sizeof (Elf64_External_Ehdr)];
426 struct simple_object_elf_read *eor;
428 if (header[EI_MAG0] != ELFMAG0
429 || header[EI_MAG1] != ELFMAG1
430 || header[EI_MAG2] != ELFMAG2
431 || header[EI_MAG3] != ELFMAG3
432 || header[EI_VERSION] != EV_CURRENT)
434 *errmsg = NULL;
435 *err = 0;
436 return NULL;
439 ei_data = header[EI_DATA];
440 if (ei_data != ELFDATA2LSB && ei_data != ELFDATA2MSB)
442 *errmsg = "unknown ELF endianness";
443 *err = 0;
444 return NULL;
447 ei_class = header[EI_CLASS];
448 switch (ei_class)
450 case ELFCLASS32:
451 type_functions = (ei_data == ELFDATA2LSB
452 ? &elf_little_32_functions
453 : &elf_big_32_functions);
454 break;
456 case ELFCLASS64:
457 #ifndef UNSIGNED_64BIT_TYPE
458 *errmsg = "64-bit ELF objects not supported";
459 *err = 0;
460 return NULL;
461 #else
462 type_functions = (ei_data == ELFDATA2LSB
463 ? &elf_little_64_functions
464 : &elf_big_64_functions);
465 break;
466 #endif
468 default:
469 *errmsg = "unrecognized ELF size";
470 *err = 0;
471 return NULL;
474 if (!simple_object_internal_read (descriptor, offset, ehdr, sizeof ehdr,
475 errmsg, err))
476 return NULL;
478 eor = XNEW (struct simple_object_elf_read);
479 eor->type_functions = type_functions;
480 eor->ei_data = ei_data;
481 eor->ei_class = ei_class;
482 eor->ei_osabi = header[EI_OSABI];
483 eor->machine = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
484 e_machine, Elf_Half);
485 eor->flags = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
486 e_flags, Elf_Word);
487 eor->shoff = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
488 e_shoff, Elf_Addr);
489 eor->shnum = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
490 e_shnum, Elf_Half);
491 eor->shstrndx = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
492 e_shstrndx, Elf_Half);
494 if ((eor->shnum == 0 || eor->shstrndx == SHN_XINDEX)
495 && eor->shoff != 0)
497 unsigned char shdr[sizeof (Elf64_External_Shdr)];
499 /* Object file has more than 0xffff sections. */
501 if (!simple_object_internal_read (descriptor, offset + eor->shoff, shdr,
502 (ei_class == ELFCLASS32
503 ? sizeof (Elf32_External_Shdr)
504 : sizeof (Elf64_External_Shdr)),
505 errmsg, err))
507 XDELETE (eor);
508 return NULL;
511 if (eor->shnum == 0)
512 eor->shnum = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
513 shdr, sh_size, Elf_Addr);
515 if (eor->shstrndx == SHN_XINDEX)
517 eor->shstrndx = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
518 shdr, sh_link, Elf_Word);
520 /* Versions of the GNU binutils between 2.12 and 2.18 did
521 not handle objects with more than SHN_LORESERVE sections
522 correctly. All large section indexes were offset by
523 0x100. There is more information at
524 http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
525 Fortunately these object files are easy to detect, as the
526 GNU binutils always put the section header string table
527 near the end of the list of sections. Thus if the
528 section header string table index is larger than the
529 number of sections, then we know we have to subtract
530 0x100 to get the real section index. */
531 if (eor->shstrndx >= eor->shnum
532 && eor->shstrndx >= SHN_LORESERVE + 0x100)
533 eor->shstrndx -= 0x100;
537 if (eor->shstrndx >= eor->shnum)
539 *errmsg = "invalid ELF shstrndx >= shnum";
540 *err = 0;
541 XDELETE (eor);
542 return NULL;
545 return (void *) eor;
548 /* Find all sections in an ELF file. */
550 static const char *
551 simple_object_elf_find_sections (simple_object_read *sobj,
552 int (*pfn) (void *, const char *,
553 off_t offset, off_t length),
554 void *data,
555 int *err)
557 struct simple_object_elf_read *eor =
558 (struct simple_object_elf_read *) sobj->data;
559 const struct elf_type_functions *type_functions = eor->type_functions;
560 unsigned char ei_class = eor->ei_class;
561 size_t shdr_size;
562 unsigned int shnum;
563 unsigned char *shdrs;
564 const char *errmsg;
565 unsigned char *shstrhdr;
566 size_t name_size;
567 off_t shstroff;
568 unsigned char *names;
569 unsigned int i;
571 shdr_size = (ei_class == ELFCLASS32
572 ? sizeof (Elf32_External_Shdr)
573 : sizeof (Elf64_External_Shdr));
575 /* Read the section headers. We skip section 0, which is not a
576 useful section. */
578 shnum = eor->shnum;
579 shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
581 if (!simple_object_internal_read (sobj->descriptor,
582 sobj->offset + eor->shoff + shdr_size,
583 shdrs,
584 shdr_size * (shnum - 1),
585 &errmsg, err))
587 XDELETEVEC (shdrs);
588 return errmsg;
591 /* Read the section names. */
593 shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
594 name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
595 shstrhdr, sh_size, Elf_Addr);
596 shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
597 shstrhdr, sh_offset, Elf_Addr);
598 names = XNEWVEC (unsigned char, name_size);
599 if (!simple_object_internal_read (sobj->descriptor,
600 sobj->offset + shstroff,
601 names, name_size, &errmsg, err))
603 XDELETEVEC (names);
604 XDELETEVEC (shdrs);
605 return errmsg;
608 for (i = 1; i < shnum; ++i)
610 unsigned char *shdr;
611 unsigned int sh_name;
612 const char *name;
613 off_t offset;
614 off_t length;
616 shdr = shdrs + (i - 1) * shdr_size;
617 sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
618 shdr, sh_name, Elf_Word);
619 if (sh_name >= name_size)
621 *err = 0;
622 XDELETEVEC (names);
623 XDELETEVEC (shdrs);
624 return "ELF section name out of range";
627 name = (const char *) names + sh_name;
628 offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
629 shdr, sh_offset, Elf_Addr);
630 length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
631 shdr, sh_size, Elf_Addr);
633 if (!(*pfn) (data, name, offset, length))
634 break;
637 XDELETEVEC (names);
638 XDELETEVEC (shdrs);
640 return NULL;
643 /* Fetch the attributes for an simple_object_read. */
645 static void *
646 simple_object_elf_fetch_attributes (simple_object_read *sobj,
647 const char **errmsg ATTRIBUTE_UNUSED,
648 int *err ATTRIBUTE_UNUSED)
650 struct simple_object_elf_read *eor =
651 (struct simple_object_elf_read *) sobj->data;
652 struct simple_object_elf_attributes *ret;
654 ret = XNEW (struct simple_object_elf_attributes);
655 ret->type_functions = eor->type_functions;
656 ret->ei_data = eor->ei_data;
657 ret->ei_class = eor->ei_class;
658 ret->ei_osabi = eor->ei_osabi;
659 ret->machine = eor->machine;
660 ret->flags = eor->flags;
661 return ret;
664 /* Release the privata data for an simple_object_read. */
666 static void
667 simple_object_elf_release_read (void *data)
669 XDELETE (data);
672 /* Compare two attributes structures. */
674 static const char *
675 simple_object_elf_attributes_merge (void *todata, void *fromdata, int *err)
677 struct simple_object_elf_attributes *to =
678 (struct simple_object_elf_attributes *) todata;
679 struct simple_object_elf_attributes *from =
680 (struct simple_object_elf_attributes *) fromdata;
682 if (to->ei_data != from->ei_data || to->ei_class != from->ei_class)
684 *err = 0;
685 return "ELF object format mismatch";
688 if (to->machine != from->machine)
690 int ok;
692 /* EM_SPARC and EM_SPARC32PLUS are compatible and force an
693 output of EM_SPARC32PLUS. */
694 ok = 0;
695 switch (to->machine)
697 case EM_SPARC:
698 if (from->machine == EM_SPARC32PLUS)
700 to->machine = from->machine;
701 ok = 1;
703 break;
705 case EM_SPARC32PLUS:
706 if (from->machine == EM_SPARC)
707 ok = 1;
708 break;
710 default:
711 break;
714 if (!ok)
716 *err = 0;
717 return "ELF machine number mismatch";
721 return NULL;
724 /* Release the private data for an attributes structure. */
726 static void
727 simple_object_elf_release_attributes (void *data)
729 XDELETE (data);
732 /* Prepare to write out a file. */
734 static void *
735 simple_object_elf_start_write (void *attributes_data,
736 const char **errmsg ATTRIBUTE_UNUSED,
737 int *err ATTRIBUTE_UNUSED)
739 struct simple_object_elf_attributes *attrs =
740 (struct simple_object_elf_attributes *) attributes_data;
741 struct simple_object_elf_write *ret;
743 /* We're just going to record the attributes, but we need to make a
744 copy because the user may delete them. */
745 ret = XNEW (struct simple_object_elf_write);
746 ret->attrs = *attrs;
747 ret->shdrs = NULL;
748 return ret;
751 /* Write out an ELF ehdr. */
753 static int
754 simple_object_elf_write_ehdr (simple_object_write *sobj, int descriptor,
755 const char **errmsg, int *err)
757 struct simple_object_elf_attributes *attrs =
758 (struct simple_object_elf_attributes *) sobj->data;
759 const struct elf_type_functions* fns;
760 unsigned char cl;
761 size_t ehdr_size;
762 unsigned char buf[sizeof (Elf64_External_Ehdr)];
763 simple_object_write_section *section;
764 unsigned int shnum;
765 unsigned int shstrndx;
767 fns = attrs->type_functions;
768 cl = attrs->ei_class;
770 shnum = 0;
771 for (section = sobj->sections; section != NULL; section = section->next)
772 ++shnum;
773 if (shnum > 0)
775 /* Add a section header for the dummy section and one for
776 .shstrtab. */
777 shnum += 2;
780 ehdr_size = (cl == ELFCLASS32
781 ? sizeof (Elf32_External_Ehdr)
782 : sizeof (Elf64_External_Ehdr));
783 memset (buf, 0, sizeof (Elf64_External_Ehdr));
785 buf[EI_MAG0] = ELFMAG0;
786 buf[EI_MAG1] = ELFMAG1;
787 buf[EI_MAG2] = ELFMAG2;
788 buf[EI_MAG3] = ELFMAG3;
789 buf[EI_CLASS] = cl;
790 buf[EI_DATA] = attrs->ei_data;
791 buf[EI_VERSION] = EV_CURRENT;
792 buf[EI_OSABI] = attrs->ei_osabi;
794 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_type, Elf_Half, ET_REL);
795 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_machine, Elf_Half, attrs->machine);
796 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_version, Elf_Word, EV_CURRENT);
797 /* e_entry left as zero. */
798 /* e_phoff left as zero. */
799 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shoff, Elf_Addr, ehdr_size);
800 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_flags, Elf_Word, attrs->flags);
801 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_ehsize, Elf_Half, ehdr_size);
802 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_phentsize, Elf_Half,
803 (cl == ELFCLASS32
804 ? sizeof (Elf32_External_Phdr)
805 : sizeof (Elf64_External_Phdr)));
806 /* e_phnum left as zero. */
807 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shentsize, Elf_Half,
808 (cl == ELFCLASS32
809 ? sizeof (Elf32_External_Shdr)
810 : sizeof (Elf64_External_Shdr)));
811 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shnum, Elf_Half,
812 shnum >= SHN_LORESERVE ? 0 : shnum);
813 if (shnum == 0)
814 shstrndx = 0;
815 else
817 shstrndx = shnum - 1;
818 if (shstrndx >= SHN_LORESERVE)
819 shstrndx = SHN_XINDEX;
821 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shstrndx, Elf_Half, shstrndx);
823 return simple_object_internal_write (descriptor, 0, buf, ehdr_size,
824 errmsg, err);
827 /* Write out an ELF shdr. */
829 static int
830 simple_object_elf_write_shdr (simple_object_write *sobj, int descriptor,
831 off_t offset, unsigned int sh_name,
832 unsigned int sh_type, unsigned int sh_flags,
833 off_t sh_addr,
834 unsigned int sh_offset, unsigned int sh_size,
835 unsigned int sh_link, unsigned int sh_info,
836 size_t sh_addralign,
837 size_t sh_entsize,
838 const char **errmsg, int *err)
840 struct simple_object_elf_attributes *attrs =
841 (struct simple_object_elf_attributes *) sobj->data;
842 const struct elf_type_functions* fns;
843 unsigned char cl;
844 size_t shdr_size;
845 unsigned char buf[sizeof (Elf64_External_Shdr)];
847 fns = attrs->type_functions;
848 cl = attrs->ei_class;
850 shdr_size = (cl == ELFCLASS32
851 ? sizeof (Elf32_External_Shdr)
852 : sizeof (Elf64_External_Shdr));
853 memset (buf, 0, sizeof (Elf64_External_Shdr));
855 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_name, Elf_Word, sh_name);
856 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_type, Elf_Word, sh_type);
857 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_flags, Elf_Addr, sh_flags);
858 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addr, Elf_Addr, sh_addr);
859 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_offset, Elf_Addr, sh_offset);
860 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_size, Elf_Addr, sh_size);
861 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_link, Elf_Word, sh_link);
862 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_info, Elf_Word, sh_info);
863 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addralign, Elf_Addr, sh_addralign);
864 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_entsize, Elf_Addr, sh_entsize);
866 return simple_object_internal_write (descriptor, offset, buf, shdr_size,
867 errmsg, err);
870 /* Write out a complete ELF file.
871 Ehdr
872 initial dummy Shdr
873 user-created Shdrs
874 .shstrtab Shdr
875 user-created section data
876 .shstrtab data */
878 static const char *
879 simple_object_elf_write_to_file (simple_object_write *sobj, int descriptor,
880 int *err)
882 struct simple_object_elf_write *eow =
883 (struct simple_object_elf_write *) sobj->data;
884 struct simple_object_elf_attributes *attrs = &eow->attrs;
885 unsigned char cl;
886 size_t ehdr_size;
887 size_t shdr_size;
888 const char *errmsg;
889 simple_object_write_section *section;
890 unsigned int shnum;
891 size_t shdr_offset;
892 size_t sh_offset;
893 unsigned int first_sh_size;
894 unsigned int first_sh_link;
895 size_t sh_name;
896 unsigned char zero;
897 unsigned secnum;
899 if (!simple_object_elf_write_ehdr (sobj, descriptor, &errmsg, err))
900 return errmsg;
902 cl = attrs->ei_class;
903 if (cl == ELFCLASS32)
905 ehdr_size = sizeof (Elf32_External_Ehdr);
906 shdr_size = sizeof (Elf32_External_Shdr);
908 else
910 ehdr_size = sizeof (Elf64_External_Ehdr);
911 shdr_size = sizeof (Elf64_External_Shdr);
914 shnum = 0;
915 for (section = sobj->sections; section != NULL; section = section->next)
916 ++shnum;
917 if (shnum == 0)
918 return NULL;
920 /* Add initial dummy Shdr and .shstrtab. */
921 shnum += 2;
923 shdr_offset = ehdr_size;
924 sh_offset = shdr_offset + shnum * shdr_size;
926 if (shnum < SHN_LORESERVE)
927 first_sh_size = 0;
928 else
929 first_sh_size = shnum;
930 if (shnum - 1 < SHN_LORESERVE)
931 first_sh_link = 0;
932 else
933 first_sh_link = shnum - 1;
934 if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
935 0, 0, 0, 0, 0, first_sh_size, first_sh_link,
936 0, 0, 0, &errmsg, err))
937 return errmsg;
939 shdr_offset += shdr_size;
941 sh_name = 1;
942 secnum = 0;
943 for (section = sobj->sections; section != NULL; section = section->next)
945 size_t mask;
946 size_t new_sh_offset;
947 size_t sh_size;
948 struct simple_object_write_section_buffer *buffer;
949 unsigned int sh_type = SHT_PROGBITS;
950 unsigned int sh_flags = 0;
951 off_t sh_addr = 0;
952 unsigned int sh_link = 0;
953 unsigned int sh_info = 0;
954 size_t sh_addralign = 1U << section->align;
955 size_t sh_entsize = 0;
956 if (eow->shdrs)
958 sh_type = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
959 eow->shdrs + secnum * shdr_size,
960 sh_type, Elf_Word);
961 sh_flags = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
962 eow->shdrs + secnum * shdr_size,
963 sh_flags, Elf_Addr);
964 sh_addr = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
965 eow->shdrs + secnum * shdr_size,
966 sh_addr, Elf_Addr);
967 sh_link = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
968 eow->shdrs + secnum * shdr_size,
969 sh_link, Elf_Word);
970 sh_info = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
971 eow->shdrs + secnum * shdr_size,
972 sh_info, Elf_Word);
973 sh_addralign = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
974 eow->shdrs + secnum * shdr_size,
975 sh_addralign, Elf_Addr);
976 sh_entsize = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
977 eow->shdrs + secnum * shdr_size,
978 sh_entsize, Elf_Addr);
979 secnum++;
982 mask = sh_addralign - 1;
983 new_sh_offset = sh_offset + mask;
984 new_sh_offset &= ~ mask;
985 while (new_sh_offset > sh_offset)
987 unsigned char zeroes[16];
988 size_t write;
990 memset (zeroes, 0, sizeof zeroes);
991 write = new_sh_offset - sh_offset;
992 if (write > sizeof zeroes)
993 write = sizeof zeroes;
994 if (!simple_object_internal_write (descriptor, sh_offset, zeroes,
995 write, &errmsg, err))
996 return errmsg;
997 sh_offset += write;
1000 sh_size = 0;
1001 for (buffer = section->buffers; buffer != NULL; buffer = buffer->next)
1003 if (!simple_object_internal_write (descriptor, sh_offset + sh_size,
1004 ((const unsigned char *)
1005 buffer->buffer),
1006 buffer->size, &errmsg, err))
1007 return errmsg;
1008 sh_size += buffer->size;
1011 if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
1012 sh_name, sh_type, sh_flags,
1013 sh_addr, sh_offset,
1014 sh_size, sh_link, sh_info,
1015 sh_addralign, sh_entsize,
1016 &errmsg, err))
1017 return errmsg;
1019 shdr_offset += shdr_size;
1020 sh_name += strlen (section->name) + 1;
1021 sh_offset += sh_size;
1024 if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
1025 sh_name, SHT_STRTAB, 0, 0, sh_offset,
1026 sh_name + strlen (".shstrtab") + 1, 0, 0,
1027 1, 0, &errmsg, err))
1028 return errmsg;
1030 /* .shstrtab has a leading zero byte. */
1031 zero = 0;
1032 if (!simple_object_internal_write (descriptor, sh_offset, &zero, 1,
1033 &errmsg, err))
1034 return errmsg;
1035 ++sh_offset;
1037 for (section = sobj->sections; section != NULL; section = section->next)
1039 size_t len;
1041 len = strlen (section->name) + 1;
1042 if (!simple_object_internal_write (descriptor, sh_offset,
1043 (const unsigned char *) section->name,
1044 len, &errmsg, err))
1045 return errmsg;
1046 sh_offset += len;
1049 if (!simple_object_internal_write (descriptor, sh_offset,
1050 (const unsigned char *) ".shstrtab",
1051 strlen (".shstrtab") + 1, &errmsg, err))
1052 return errmsg;
1054 return NULL;
1057 /* Release the private data for an simple_object_write structure. */
1059 static void
1060 simple_object_elf_release_write (void *data)
1062 struct simple_object_elf_write *eow = (struct simple_object_elf_write *) data;
1063 if (eow->shdrs)
1064 XDELETE (eow->shdrs);
1065 XDELETE (data);
1068 /* Copy all sections in an ELF file. */
1070 static const char *
1071 simple_object_elf_copy_lto_debug_sections (simple_object_read *sobj,
1072 simple_object_write *dobj,
1073 int (*pfn) (const char **),
1074 int *err)
1076 struct simple_object_elf_read *eor =
1077 (struct simple_object_elf_read *) sobj->data;
1078 const struct elf_type_functions *type_functions = eor->type_functions;
1079 struct simple_object_elf_write *eow =
1080 (struct simple_object_elf_write *) dobj->data;
1081 unsigned char ei_class = eor->ei_class;
1082 size_t shdr_size;
1083 unsigned int shnum;
1084 unsigned char *shdrs;
1085 const char *errmsg;
1086 unsigned char *shstrhdr;
1087 size_t name_size;
1088 off_t shstroff;
1089 unsigned char *names;
1090 unsigned int i;
1091 int changed;
1092 int *pfnret;
1093 const char **pfnname;
1095 shdr_size = (ei_class == ELFCLASS32
1096 ? sizeof (Elf32_External_Shdr)
1097 : sizeof (Elf64_External_Shdr));
1099 /* Read the section headers. We skip section 0, which is not a
1100 useful section. */
1102 shnum = eor->shnum;
1103 shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
1105 if (!simple_object_internal_read (sobj->descriptor,
1106 sobj->offset + eor->shoff + shdr_size,
1107 shdrs,
1108 shdr_size * (shnum - 1),
1109 &errmsg, err))
1111 XDELETEVEC (shdrs);
1112 return errmsg;
1115 /* Read the section names. */
1117 shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
1118 name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1119 shstrhdr, sh_size, Elf_Addr);
1120 shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1121 shstrhdr, sh_offset, Elf_Addr);
1122 names = XNEWVEC (unsigned char, name_size);
1123 if (!simple_object_internal_read (sobj->descriptor,
1124 sobj->offset + shstroff,
1125 names, name_size, &errmsg, err))
1127 XDELETEVEC (names);
1128 XDELETEVEC (shdrs);
1129 return errmsg;
1132 eow->shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
1133 pfnret = XNEWVEC (int, shnum);
1134 pfnname = XNEWVEC (const char *, shnum);
1136 /* First perform the callbacks to know which sections to preserve and
1137 what name to use for those. */
1138 for (i = 1; i < shnum; ++i)
1140 unsigned char *shdr;
1141 unsigned int sh_name;
1142 const char *name;
1143 int ret;
1145 shdr = shdrs + (i - 1) * shdr_size;
1146 sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1147 shdr, sh_name, Elf_Word);
1148 if (sh_name >= name_size)
1150 *err = 0;
1151 XDELETEVEC (names);
1152 XDELETEVEC (shdrs);
1153 return "ELF section name out of range";
1156 name = (const char *) names + sh_name;
1158 ret = (*pfn) (&name);
1159 pfnret[i - 1] = ret == 1 ? 0 : -1;
1160 pfnname[i - 1] = name;
1163 /* Mark sections as preserved that are required by to be preserved
1164 sections. */
1167 changed = 0;
1168 for (i = 1; i < shnum; ++i)
1170 unsigned char *shdr;
1171 unsigned int sh_type, sh_info, sh_link;
1172 off_t offset;
1173 off_t length;
1175 shdr = shdrs + (i - 1) * shdr_size;
1176 sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1177 shdr, sh_type, Elf_Word);
1178 sh_info = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1179 shdr, sh_info, Elf_Word);
1180 sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1181 shdr, sh_link, Elf_Word);
1182 if (sh_type == SHT_GROUP)
1184 /* Mark groups containing copied sections. */
1185 unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class,
1186 Shdr, shdr, sh_entsize,
1187 Elf_Addr);
1188 unsigned char *ent, *buf;
1189 int keep = 0;
1190 offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1191 shdr, sh_offset, Elf_Addr);
1192 length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1193 shdr, sh_size, Elf_Addr);
1194 buf = XNEWVEC (unsigned char, length);
1195 if (!simple_object_internal_read (sobj->descriptor,
1196 sobj->offset + offset, buf,
1197 (size_t) length, &errmsg, err))
1199 XDELETEVEC (buf);
1200 XDELETEVEC (names);
1201 XDELETEVEC (shdrs);
1202 return errmsg;
1204 for (ent = buf + entsize; ent < buf + length; ent += entsize)
1206 unsigned sec = type_functions->fetch_Elf_Word (ent);
1207 if (pfnret[sec - 1] == 0)
1208 keep = 1;
1210 if (keep)
1212 changed |= (pfnret[sh_link - 1] == -1
1213 || pfnret[i - 1] == -1);
1214 pfnret[sh_link - 1] = 0;
1215 pfnret[i - 1] = 0;
1218 if (sh_type == SHT_RELA
1219 || sh_type == SHT_REL)
1221 /* Mark relocation sections and symtab of copied sections. */
1222 if (pfnret[sh_info - 1] == 0)
1224 changed |= (pfnret[sh_link - 1] == -1
1225 || pfnret[i - 1] == -1);
1226 pfnret[sh_link - 1] = 0;
1227 pfnret[i - 1] = 0;
1230 if (sh_type == SHT_SYMTAB)
1232 /* Mark strings sections of copied symtabs. */
1233 if (pfnret[i - 1] == 0)
1235 changed |= pfnret[sh_link - 1] == -1;
1236 pfnret[sh_link - 1] = 0;
1241 while (changed);
1243 /* Then perform the actual copying. */
1244 for (i = 1; i < shnum; ++i)
1246 unsigned char *shdr;
1247 unsigned int sh_name, sh_type;
1248 const char *name;
1249 off_t offset;
1250 off_t length;
1251 int ret;
1252 simple_object_write_section *dest;
1253 off_t flags;
1254 unsigned char *buf;
1256 shdr = shdrs + (i - 1) * shdr_size;
1257 sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1258 shdr, sh_name, Elf_Word);
1259 if (sh_name >= name_size)
1261 *err = 0;
1262 XDELETEVEC (names);
1263 XDELETEVEC (shdrs);
1264 return "ELF section name out of range";
1267 name = (const char *) names + sh_name;
1268 offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1269 shdr, sh_offset, Elf_Addr);
1270 length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1271 shdr, sh_size, Elf_Addr);
1272 sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1273 shdr, sh_type, Elf_Word);
1275 ret = pfnret[i - 1];
1276 name = ret == 0 ? pfnname[i - 1] : "";
1278 dest = simple_object_write_create_section (dobj, name, 0, &errmsg, err);
1279 if (dest == NULL)
1281 XDELETEVEC (names);
1282 XDELETEVEC (shdrs);
1283 return errmsg;
1286 /* Record the SHDR of the source. */
1287 memcpy (eow->shdrs + (i - 1) * shdr_size, shdr, shdr_size);
1288 shdr = eow->shdrs + (i - 1) * shdr_size;
1290 /* Copy the data.
1291 ??? This is quite wasteful and ideally would be delayed until
1292 write_to_file (). Thus it questions the interfacing
1293 which eventually should contain destination creation plus
1294 writing. */
1295 /* Keep empty sections for sections we should discard. This avoids
1296 the need to rewrite section indices in symtab and relocation
1297 sections. */
1298 if (ret == 0)
1300 buf = XNEWVEC (unsigned char, length);
1301 if (!simple_object_internal_read (sobj->descriptor,
1302 sobj->offset + offset, buf,
1303 (size_t) length, &errmsg, err))
1305 XDELETEVEC (buf);
1306 XDELETEVEC (names);
1307 XDELETEVEC (shdrs);
1308 return errmsg;
1311 /* If we are processing .symtab purge __gnu_lto_v1 and
1312 __gnu_lto_slim symbols from it. */
1313 if (sh_type == SHT_SYMTAB)
1315 unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1316 shdr, sh_entsize, Elf_Addr);
1317 unsigned strtab = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1318 shdr, sh_link, Elf_Word);
1319 unsigned char *strshdr = shdrs + (strtab - 1) * shdr_size;
1320 off_t stroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1321 strshdr, sh_offset, Elf_Addr);
1322 size_t strsz = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1323 strshdr, sh_size, Elf_Addr);
1324 char *strings = XNEWVEC (char, strsz);
1325 unsigned char *ent;
1326 simple_object_internal_read (sobj->descriptor,
1327 sobj->offset + stroff,
1328 (unsigned char *)strings,
1329 strsz, &errmsg, err);
1330 for (ent = buf; ent < buf + length; ent += entsize)
1332 unsigned st_shndx = ELF_FETCH_FIELD (type_functions, ei_class,
1333 Sym, ent,
1334 st_shndx, Elf_Half);
1335 unsigned char *st_info;
1336 unsigned char *st_other;
1337 int discard = 0;
1338 if (ei_class == ELFCLASS32)
1340 st_info = &((Elf32_External_Sym *)ent)->st_info;
1341 st_other = &((Elf32_External_Sym *)ent)->st_other;
1343 else
1345 st_info = &((Elf64_External_Sym *)ent)->st_info;
1346 st_other = &((Elf64_External_Sym *)ent)->st_other;
1348 /* Eliminate all COMMONs - this includes __gnu_lto_v1
1349 and __gnu_lto_slim which otherwise cause endless
1350 LTO plugin invocation. */
1351 if (st_shndx == SHN_COMMON)
1352 discard = 1;
1353 /* We also need to remove symbols refering to sections
1354 we'll eventually remove as with fat LTO objects
1355 we otherwise get duplicate symbols at final link
1356 (with GNU ld, gold is fine and ignores symbols in
1357 sections marked as EXCLUDE). ld/20513 */
1358 else if (st_shndx != SHN_UNDEF
1359 && st_shndx < shnum
1360 && pfnret[st_shndx - 1] == -1)
1361 discard = 1;
1363 if (discard)
1365 /* Make discarded symbols undefined and unnamed
1366 in case it is local. */
1367 int bind = ELF_ST_BIND (*st_info);
1368 int other = STV_DEFAULT;
1369 size_t st_name;
1371 if (bind == STB_LOCAL)
1372 ELF_SET_FIELD (type_functions, ei_class, Sym,
1373 ent, st_name, Elf_Word, 0);
1374 else
1376 bind = STB_WEAK;
1377 st_name = ELF_FETCH_FIELD (type_functions, ei_class,
1378 Sym, ent, st_name,
1379 Elf_Word);
1380 if (st_name < strsz)
1382 char *p = strings + st_name;
1383 if (p[0] == '_'
1384 && p[1] == '_'
1385 && strncmp (p + (p[2] == '_'),
1386 "__gnu_lto_", 10) == 0)
1387 other = STV_HIDDEN;
1390 *st_other = other;
1391 *st_info = ELF_ST_INFO (bind, STT_NOTYPE);
1392 ELF_SET_FIELD (type_functions, ei_class, Sym,
1393 ent, st_value, Elf_Addr, 0);
1394 ELF_SET_FIELD (type_functions, ei_class, Sym,
1395 ent, st_size, Elf_Word, 0);
1396 ELF_SET_FIELD (type_functions, ei_class, Sym,
1397 ent, st_shndx, Elf_Half, SHN_UNDEF);
1400 XDELETEVEC (strings);
1403 errmsg = simple_object_write_add_data (dobj, dest,
1404 buf, length, 1, err);
1405 XDELETEVEC (buf);
1406 if (errmsg)
1408 XDELETEVEC (names);
1409 XDELETEVEC (shdrs);
1410 return errmsg;
1413 else
1415 /* For deleted sections mark the section header table entry as
1416 unused. That allows the link editor to remove it in a partial
1417 link. */
1418 ELF_SET_FIELD (type_functions, ei_class, Shdr,
1419 shdr, sh_type, Elf_Word, SHT_NULL);
1422 flags = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1423 shdr, sh_flags, Elf_Addr);
1424 if (ret == 0)
1426 /* The debugobj doesn't contain any code, thus no trampolines.
1427 Even when the original object needs trampolines, debugobj
1428 doesn't. */
1429 if (strcmp (name, ".note.GNU-stack") == 0)
1430 flags &= ~SHF_EXECINSTR;
1431 flags &= ~SHF_EXCLUDE;
1433 else if (ret == -1)
1434 flags = SHF_EXCLUDE;
1435 ELF_SET_FIELD (type_functions, ei_class, Shdr,
1436 shdr, sh_flags, Elf_Addr, flags);
1439 XDELETEVEC (names);
1440 XDELETEVEC (shdrs);
1441 XDELETEVEC (pfnret);
1442 XDELETEVEC (pfnname);
1444 return NULL;
1448 /* The ELF functions. */
1450 const struct simple_object_functions simple_object_elf_functions =
1452 simple_object_elf_match,
1453 simple_object_elf_find_sections,
1454 simple_object_elf_fetch_attributes,
1455 simple_object_elf_release_read,
1456 simple_object_elf_attributes_merge,
1457 simple_object_elf_release_attributes,
1458 simple_object_elf_start_write,
1459 simple_object_elf_write_to_file,
1460 simple_object_elf_release_write,
1461 simple_object_elf_copy_lto_debug_sections