]> git.ipfire.org Git - thirdparty/gcc.git/blame - libiberty/simple-object-elf.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Use -flto instead of -flto=N in DWARF producer string.
[thirdparty/gcc.git] / libiberty / simple-object-elf.c
CommitLineData
1cfabf34 1/* simple-object-elf.c -- routines to manipulate ELF object files.
a5544970 2 Copyright (C) 2010-2019 Free Software Foundation, Inc.
1cfabf34
ILT		 3 Written by Ian Lance Taylor, Google.
4
5This program is free software; you can redistribute it and/or modify it
6under the terms of the GNU General Public License as published by the
7Free Software Foundation; either version 2, or (at your option) any
8later version.
9
10This program is distributed in the hope that it will be useful,
11but WITHOUT ANY WARRANTY; without even the implied warranty of
12MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13GNU General Public License for more details.
14
15You should have received a copy of the GNU General Public License
16along with this program; if not, write to the Free Software
17Foundation, 51 Franklin Street - Fifth Floor,
18Boston, MA 02110-1301, USA. */
19
20#include "config.h"
21#include "libiberty.h"
22#include "simple-object.h"
23
24#include <errno.h>
30ae6662
EZ		 25/* mingw.org's MinGW doesn't have ENOTSUP. */
26#ifndef ENOTSUP
27# define ENOTSUP ENOSYS
28#endif
1cfabf34
ILT		 29#include <stddef.h>
30
31#ifdef HAVE_STDLIB_H
32#include <stdlib.h>
33#endif
34
35#ifdef HAVE_STDINT_H
36#include <stdint.h>
37#endif
38
39#ifdef HAVE_STRING_H
40#include <string.h>
41#endif
42
43#ifdef HAVE_INTTYPES_H
44#include <inttypes.h>
45#endif
46
47#include "simple-object-common.h"
48
49/* ELF structures and constants. */
50
51/* 32-bit ELF file header. */
52
53typedef struct {
54 unsigned char e_ident[16]; /* ELF "magic number" */
55 unsigned char e_type[2]; /* Identifies object file type */
56 unsigned char e_machine[2]; /* Specifies required architecture */
57 unsigned char e_version[4]; /* Identifies object file version */
58 unsigned char e_entry[4]; /* Entry point virtual address */
59 unsigned char e_phoff[4]; /* Program header table file offset */
60 unsigned char e_shoff[4]; /* Section header table file offset */
61 unsigned char e_flags[4]; /* Processor-specific flags */
62 unsigned char e_ehsize[2]; /* ELF header size in bytes */
63 unsigned char e_phentsize[2]; /* Program header table entry size */
64 unsigned char e_phnum[2]; /* Program header table entry count */
65 unsigned char e_shentsize[2]; /* Section header table entry size */
66 unsigned char e_shnum[2]; /* Section header table entry count */
67 unsigned char e_shstrndx[2]; /* Section header string table index */
68} Elf32_External_Ehdr;
69
70/* 64-bit ELF file header. */
71
72typedef struct {
73 unsigned char e_ident[16]; /* ELF "magic number" */
74 unsigned char e_type[2]; /* Identifies object file type */
75 unsigned char e_machine[2]; /* Specifies required architecture */
76 unsigned char e_version[4]; /* Identifies object file version */
77 unsigned char e_entry[8]; /* Entry point virtual address */
78 unsigned char e_phoff[8]; /* Program header table file offset */
79 unsigned char e_shoff[8]; /* Section header table file offset */
80 unsigned char e_flags[4]; /* Processor-specific flags */
81 unsigned char e_ehsize[2]; /* ELF header size in bytes */
82 unsigned char e_phentsize[2]; /* Program header table entry size */
83 unsigned char e_phnum[2]; /* Program header table entry count */
84 unsigned char e_shentsize[2]; /* Section header table entry size */
85 unsigned char e_shnum[2]; /* Section header table entry count */
86 unsigned char e_shstrndx[2]; /* Section header string table index */
87} Elf64_External_Ehdr;
88
89/* Indexes and values in e_ident field of Ehdr. */
90
91#define EI_MAG0 0 /* File identification byte 0 index */
92#define ELFMAG0 0x7F /* Magic number byte 0 */
93
94#define EI_MAG1 1 /* File identification byte 1 index */
95#define ELFMAG1 'E' /* Magic number byte 1 */
96
97#define EI_MAG2 2 /* File identification byte 2 index */
98#define ELFMAG2 'L' /* Magic number byte 2 */
99
100#define EI_MAG3 3 /* File identification byte 3 index */
101#define ELFMAG3 'F' /* Magic number byte 3 */
102
103#define EI_CLASS 4 /* File class */
104#define ELFCLASSNONE 0 /* Invalid class */
105#define ELFCLASS32 1 /* 32-bit objects */
106#define ELFCLASS64 2 /* 64-bit objects */
107
108#define EI_DATA 5 /* Data encoding */
109#define ELFDATANONE 0 /* Invalid data encoding */
110#define ELFDATA2LSB 1 /* 2's complement, little endian */
111#define ELFDATA2MSB 2 /* 2's complement, big endian */
112
113#define EI_VERSION 6 /* File version */
114#define EV_CURRENT 1 /* Current version */
115
116#define EI_OSABI 7 /* Operating System/ABI indication */
117
118/* Values for e_type field of Ehdr. */
119
120#define ET_REL 1 /* Relocatable file */
121
d82f74d3
ILT		 122/* Values for e_machine field of Ehdr. */
123
124#define EM_SPARC 2 /* SUN SPARC */
125#define EM_SPARC32PLUS 18 /* Sun's "v8plus" */
126
1cfabf34
ILT		 127/* Special section index values. */
128
1ea85365 129#define SHN_UNDEF 0 /* Undefined section */
1cfabf34 130#define SHN_LORESERVE 0xFF00 /* Begin range of reserved indices */
1ea85365 131#define SHN_COMMON 0xFFF2 /* Associated symbol is in common */
1cfabf34 132#define SHN_XINDEX 0xFFFF /* Section index is held elsewhere */
bf6f2cc7 133#define SHN_HIRESERVE 0xffff /* End of reserved indices */
1cfabf34 134
1ea85365 135
1cfabf34
ILT		 136/* 32-bit ELF program header. */
137
138typedef struct {
139 unsigned char p_type[4]; /* Identifies program segment type */
140 unsigned char p_offset[4]; /* Segment file offset */
141 unsigned char p_vaddr[4]; /* Segment virtual address */
142 unsigned char p_paddr[4]; /* Segment physical address */
143 unsigned char p_filesz[4]; /* Segment size in file */
144 unsigned char p_memsz[4]; /* Segment size in memory */
145 unsigned char p_flags[4]; /* Segment flags */
146 unsigned char p_align[4]; /* Segment alignment, file & memory */
147} Elf32_External_Phdr;
148
149/* 64-bit ELF program header. */
150
151typedef struct {
152 unsigned char p_type[4]; /* Identifies program segment type */
153 unsigned char p_flags[4]; /* Segment flags */
154 unsigned char p_offset[8]; /* Segment file offset */
155 unsigned char p_vaddr[8]; /* Segment virtual address */
156 unsigned char p_paddr[8]; /* Segment physical address */
157 unsigned char p_filesz[8]; /* Segment size in file */
158 unsigned char p_memsz[8]; /* Segment size in memory */
159 unsigned char p_align[8]; /* Segment alignment, file & memory */
160} Elf64_External_Phdr;
161
162/* 32-bit ELF section header */
163
164typedef struct {
165 unsigned char sh_name[4]; /* Section name, index in string tbl */
166 unsigned char sh_type[4]; /* Type of section */
167 unsigned char sh_flags[4]; /* Miscellaneous section attributes */
168 unsigned char sh_addr[4]; /* Section virtual addr at execution */
169 unsigned char sh_offset[4]; /* Section file offset */
170 unsigned char sh_size[4]; /* Size of section in bytes */
171 unsigned char sh_link[4]; /* Index of another section */
172 unsigned char sh_info[4]; /* Additional section information */
173 unsigned char sh_addralign[4]; /* Section alignment */
174 unsigned char sh_entsize[4]; /* Entry size if section holds table */
175} Elf32_External_Shdr;
176
177/* 64-bit ELF section header. */
178
179typedef struct {
180 unsigned char sh_name[4]; /* Section name, index in string tbl */
181 unsigned char sh_type[4]; /* Type of section */
182 unsigned char sh_flags[8]; /* Miscellaneous section attributes */
183 unsigned char sh_addr[8]; /* Section virtual addr at execution */
184 unsigned char sh_offset[8]; /* Section file offset */
185 unsigned char sh_size[8]; /* Size of section in bytes */
186 unsigned char sh_link[4]; /* Index of another section */
187 unsigned char sh_info[4]; /* Additional section information */
188 unsigned char sh_addralign[8]; /* Section alignment */
189 unsigned char sh_entsize[8]; /* Entry size if section holds table */
190} Elf64_External_Shdr;
191
192/* Values for sh_type field. */
193
1ea85365 194#define SHT_NULL 0 /* Section header table entry unused */
1cfabf34 195#define SHT_PROGBITS 1 /* Program data */
1ea85365 196#define SHT_SYMTAB 2 /* Link editing symbol table */
1cfabf34 197#define SHT_STRTAB 3 /* A string table */
1ea85365
RB		 198#define SHT_RELA 4 /* Relocation entries with addends */
199#define SHT_REL 9 /* Relocation entries, no addends */
200#define SHT_GROUP 17 /* Section contains a section group */
bf6f2cc7 201#define SHT_SYMTAB_SHNDX 18 /* Extended section indeces */
1ea85365
RB		 202
203/* Values for sh_flags field. */
204
bf6f2cc7 205#define SHF_INFO_LINK 0x00000040 /* `sh_info' contains SHT index */
f8049c44 206#define SHF_EXECINSTR 0x00000004 /* Executable section. */
1ea85365
RB		 207#define SHF_EXCLUDE 0x80000000 /* Link editor is to exclude this
208 section from executable and
209 shared library that it builds
210 when those objects are not to be
211 further relocated. */
212/* Symbol table entry. */
213
214typedef struct
215{
216 unsigned char st_name[4]; /* Symbol name (string tbl index) */
217 unsigned char st_value[4]; /* Symbol value */
218 unsigned char st_size[4]; /* Symbol size */
219 unsigned char st_info; /* Symbol type and binding */
220 unsigned char st_other; /* Symbol visibility */
221 unsigned char st_shndx[2]; /* Section index */
222} Elf32_External_Sym;
223
224typedef struct
225{
226 unsigned char st_name[4]; /* Symbol name (string tbl index) */
227 unsigned char st_info; /* Symbol type and binding */
228 unsigned char st_other; /* Symbol visibility */
229 unsigned char st_shndx[2]; /* Section index */
230 unsigned char st_value[8]; /* Symbol value */
231 unsigned char st_size[8]; /* Symbol size */
232} Elf64_External_Sym;
233
234#define ELF_ST_BIND(val) (((unsigned char) (val)) >> 4)
235#define ELF_ST_TYPE(val) ((val) & 0xf)
236#define ELF_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
237
238#define STT_NOTYPE 0 /* Symbol type is unspecified */
239#define STT_OBJECT 1 /* Symbol is a data object */
240#define STT_FUNC 2 /* Symbol is a code object */
241#define STT_TLS 6 /* Thread local data object */
242#define STT_GNU_IFUNC 10 /* Symbol is an indirect code object */
243
244#define STB_LOCAL 0 /* Local symbol */
245#define STB_GLOBAL 1 /* Global symbol */
ebd208bf 246#define STB_WEAK 2 /* Weak global */
1ea85365
RB		 247
248#define STV_DEFAULT 0 /* Visibility is specified by binding type */
ebd208bf 249#define STV_HIDDEN 2 /* Can only be seen inside currect component */
1cfabf34
ILT		 250
251/* Functions to fetch and store different ELF types, depending on the
252 endianness and size. */
253
254struct elf_type_functions
255{
256 unsigned short (*fetch_Elf_Half) (const unsigned char *);
257 unsigned int (*fetch_Elf_Word) (const unsigned char *);
258 ulong_type (*fetch_Elf_Addr) (const unsigned char *);
259 void (*set_Elf_Half) (unsigned char *, unsigned short);
260 void (*set_Elf_Word) (unsigned char *, unsigned int);
261 void (*set_Elf_Addr) (unsigned char *, ulong_type);
262};
263
264static const struct elf_type_functions elf_big_32_functions =
265{
266 simple_object_fetch_big_16,
267 simple_object_fetch_big_32,
268 simple_object_fetch_big_32_ulong,
269 simple_object_set_big_16,
270 simple_object_set_big_32,
271 simple_object_set_big_32_ulong
272};
273
274static const struct elf_type_functions elf_little_32_functions =
275{
276 simple_object_fetch_little_16,
277 simple_object_fetch_little_32,
278 simple_object_fetch_little_32_ulong,
279 simple_object_set_little_16,
280 simple_object_set_little_32,
281 simple_object_set_little_32_ulong
282};
283
284#ifdef UNSIGNED_64BIT_TYPE
285
286static const struct elf_type_functions elf_big_64_functions =
287{
288 simple_object_fetch_big_16,
289 simple_object_fetch_big_32,
290 simple_object_fetch_big_64,
291 simple_object_set_big_16,
292 simple_object_set_big_32,
293 simple_object_set_big_64
294};
295
296static const struct elf_type_functions elf_little_64_functions =
297{
298 simple_object_fetch_little_16,
299 simple_object_fetch_little_32,
300 simple_object_fetch_little_64,
301 simple_object_set_little_16,
302 simple_object_set_little_32,
303 simple_object_set_little_64
304};
305
306#endif
307
308/* Hideous macro to fetch the value of a field from an external ELF
309 struct of some sort. TYPEFUNCS is the set of type functions.
310 BUFFER points to the external data. STRUCTTYPE is the appropriate
311 struct type. FIELD is a field within the struct. TYPE is the type
312 of the field in the struct: Elf_Half, Elf_Word, or Elf_Addr. */
313
314#define ELF_FETCH_STRUCT_FIELD(TYPEFUNCS, STRUCTTYPE, FIELD, BUFFER, TYPE) \
315 ((TYPEFUNCS)->fetch_ ## TYPE ((BUFFER) + offsetof (STRUCTTYPE, FIELD)))
316
317/* Even more hideous macro to fetch the value of FIELD from BUFFER.
318 SIZE is 32 or 64. STRUCTTYPE is the name of the struct from
319 elf/external.h: Ehdr, Shdr, etc. FIELD is the name of a field in
320 the struct. TYPE is the type of the field in the struct: Elf_Half,
321 Elf_Word, or Elf_Addr. */
322
323#define ELF_FETCH_SIZED_FIELD(TYPEFUNCS, SIZE, STRUCTTYPE, BUFFER, \
324 FIELD, TYPE) \
325 ELF_FETCH_STRUCT_FIELD (TYPEFUNCS, \
326 Elf ## SIZE ## _External_ ## STRUCTTYPE, \
327 FIELD, BUFFER, TYPE)
328
329/* Like ELF_FETCH_SIZED_FIELD but taking an ELFCLASS value. */
330
331#define ELF_FETCH_FIELD(TYPEFUNCS, CLASS, STRUCTTYPE, BUFFER, \
332 FIELD, TYPE) \
333 ((CLASS) == ELFCLASS32 \
334 ? ELF_FETCH_SIZED_FIELD (TYPEFUNCS, 32, STRUCTTYPE, BUFFER, FIELD, \
335 TYPE) \
336 : ELF_FETCH_SIZED_FIELD (TYPEFUNCS, 64, STRUCTTYPE, BUFFER, FIELD, \
337 TYPE))
338
339/* Hideous macro to set the value of a field in an external ELF
340 structure to VAL. TYPEFUNCS is the set of type functions. BUFFER
341 points to the external data. STRUCTTYPE is the appropriate
342 structure type. FIELD is a field within the struct. TYPE is the
343 type of the field in the struct: Elf_Half, Elf_Word, or
344 Elf_Addr. */
345
346#define ELF_SET_STRUCT_FIELD(TYPEFUNCS, STRUCTTYPE, FIELD, BUFFER, TYPE, VAL) \
347 (TYPEFUNCS)->set_ ## TYPE ((BUFFER) + offsetof (STRUCTTYPE, FIELD), (VAL))
348
349/* Even more hideous macro to set the value of FIELD in BUFFER to VAL.
350 SIZE is 32 or 64. STRUCTTYPE is the name of the struct from
351 elf/external.h: Ehdr, Shdr, etc. FIELD is the name of a field in
352 the struct. TYPE is the type of the field in the struct: Elf_Half,
353 Elf_Word, or Elf_Addr. */
354
355#define ELF_SET_SIZED_FIELD(TYPEFUNCS, SIZE, STRUCTTYPE, BUFFER, FIELD, \
356 TYPE, VAL) \
357 ELF_SET_STRUCT_FIELD (TYPEFUNCS, \
358 Elf ## SIZE ## _External_ ## STRUCTTYPE, \
359 FIELD, BUFFER, TYPE, VAL)
360
361/* Like ELF_SET_SIZED_FIELD but taking an ELFCLASS value. */
362
363#define ELF_SET_FIELD(TYPEFUNCS, CLASS, STRUCTTYPE, BUFFER, FIELD, \
364 TYPE, VAL) \
365 ((CLASS) == ELFCLASS32 \
366 ? ELF_SET_SIZED_FIELD (TYPEFUNCS, 32, STRUCTTYPE, BUFFER, FIELD, \
367 TYPE, VAL) \
368 : ELF_SET_SIZED_FIELD (TYPEFUNCS, 64, STRUCTTYPE, BUFFER, FIELD, \
369 TYPE, VAL))
370
371/* Private data for an simple_object_read. */
372
373struct simple_object_elf_read
374{
375 /* Type functions. */
376 const struct elf_type_functions* type_functions;
377 /* Elf data. */
378 unsigned char ei_data;
379 /* Elf class. */
380 unsigned char ei_class;
381 /* ELF OS ABI. */
382 unsigned char ei_osabi;
383 /* Elf machine number. */
384 unsigned short machine;
385 /* Processor specific flags. */
386 unsigned int flags;
387 /* File offset of section headers. */
388 ulong_type shoff;
389 /* Number of sections. */
390 unsigned int shnum;
391 /* Index of string table section header. */
392 unsigned int shstrndx;
393};
394
395/* Private data for an simple_object_attributes. */
396
397struct simple_object_elf_attributes
398{
399 /* Type functions. */
400 const struct elf_type_functions* type_functions;
401 /* Elf data. */
402 unsigned char ei_data;
403 /* Elf class. */
404 unsigned char ei_class;
405 /* ELF OS ABI. */
406 unsigned char ei_osabi;
407 /* Elf machine number. */
408 unsigned short machine;
409 /* Processor specific flags. */
410 unsigned int flags;
411};
412
1ea85365
RB		 413/* Private data for an simple_object_write. */
414
415struct simple_object_elf_write
416{
417 struct simple_object_elf_attributes attrs;
418 unsigned char *shdrs;
419};
420
1cfabf34
ILT		 421/* See if we have an ELF file. */
422
423static void *
424simple_object_elf_match (unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN],
425 int descriptor, off_t offset,
426 const char *segment_name ATTRIBUTE_UNUSED,
427 const char **errmsg, int *err)
428{
429 unsigned char ei_data;
430 unsigned char ei_class;
431 const struct elf_type_functions *type_functions;
432 unsigned char ehdr[sizeof (Elf64_External_Ehdr)];
433 struct simple_object_elf_read *eor;
434
435 if (header[EI_MAG0] != ELFMAG0
436 || header[EI_MAG1] != ELFMAG1
437 || header[EI_MAG2] != ELFMAG2
438 || header[EI_MAG3] != ELFMAG3
439 || header[EI_VERSION] != EV_CURRENT)
440 {
441 *errmsg = NULL;
442 *err = 0;
443 return NULL;
444 }
445
446 ei_data = header[EI_DATA];
447 if (ei_data != ELFDATA2LSB && ei_data != ELFDATA2MSB)
448 {
449 *errmsg = "unknown ELF endianness";
450 *err = 0;
451 return NULL;
452 }
453
454 ei_class = header[EI_CLASS];
455 switch (ei_class)
456 {
457 case ELFCLASS32:
458 type_functions = (ei_data == ELFDATA2LSB
459 ? &elf_little_32_functions
460 : &elf_big_32_functions);
461 break;
462
463 case ELFCLASS64:
464#ifndef UNSIGNED_64BIT_TYPE
465 *errmsg = "64-bit ELF objects not supported";
466 *err = 0;
467 return NULL;
468#else
469 type_functions = (ei_data == ELFDATA2LSB
470 ? &elf_little_64_functions
471 : &elf_big_64_functions);
472 break;
473#endif
474
475 default:
476 *errmsg = "unrecognized ELF size";
477 *err = 0;
478 return NULL;
479 }
480
481 if (!simple_object_internal_read (descriptor, offset, ehdr, sizeof ehdr,
482 errmsg, err))
483 return NULL;
484
485 eor = XNEW (struct simple_object_elf_read);
486 eor->type_functions = type_functions;
487 eor->ei_data = ei_data;
488 eor->ei_class = ei_class;
489 eor->ei_osabi = header[EI_OSABI];
490 eor->machine = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
491 e_machine, Elf_Half);
492 eor->flags = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
493 e_flags, Elf_Word);
494 eor->shoff = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
495 e_shoff, Elf_Addr);
496 eor->shnum = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
497 e_shnum, Elf_Half);
498 eor->shstrndx = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
499 e_shstrndx, Elf_Half);
500
501 if ((eor->shnum == 0 || eor->shstrndx == SHN_XINDEX)
502 && eor->shoff != 0)
503 {
504 unsigned char shdr[sizeof (Elf64_External_Shdr)];
505
506 /* Object file has more than 0xffff sections. */
507
508 if (!simple_object_internal_read (descriptor, offset + eor->shoff, shdr,
509 (ei_class == ELFCLASS32
510 ? sizeof (Elf32_External_Shdr)
511 : sizeof (Elf64_External_Shdr)),
512 errmsg, err))
513 {
514 XDELETE (eor);
515 return NULL;
516 }
517
518 if (eor->shnum == 0)
519 eor->shnum = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
520 shdr, sh_size, Elf_Addr);
521
522 if (eor->shstrndx == SHN_XINDEX)
523 {
524 eor->shstrndx = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
525 shdr, sh_link, Elf_Word);
526
527 /* Versions of the GNU binutils between 2.12 and 2.18 did
528 not handle objects with more than SHN_LORESERVE sections
529 correctly. All large section indexes were offset by
530 0x100. There is more information at
531 http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
532 Fortunately these object files are easy to detect, as the
533 GNU binutils always put the section header string table
534 near the end of the list of sections. Thus if the
535 section header string table index is larger than the
536 number of sections, then we know we have to subtract
537 0x100 to get the real section index. */
538 if (eor->shstrndx >= eor->shnum
539 && eor->shstrndx >= SHN_LORESERVE + 0x100)
540 eor->shstrndx -= 0x100;
541 }
542 }
543
544 if (eor->shstrndx >= eor->shnum)
545 {
546 *errmsg = "invalid ELF shstrndx >= shnum";
547 *err = 0;
548 XDELETE (eor);
549 return NULL;
550 }
551
552 return (void *) eor;
553}
554
555/* Find all sections in an ELF file. */
556
557static const char *
558simple_object_elf_find_sections (simple_object_read *sobj,
559 int (*pfn) (void *, const char *,
560 off_t offset, off_t length),
561 void *data,
562 int *err)
563{
564 struct simple_object_elf_read *eor =
565 (struct simple_object_elf_read *) sobj->data;
566 const struct elf_type_functions *type_functions = eor->type_functions;
567 unsigned char ei_class = eor->ei_class;
568 size_t shdr_size;
569 unsigned int shnum;
570 unsigned char *shdrs;
571 const char *errmsg;
572 unsigned char *shstrhdr;
573 size_t name_size;
574 off_t shstroff;
575 unsigned char *names;
576 unsigned int i;
577
578 shdr_size = (ei_class == ELFCLASS32
579 ? sizeof (Elf32_External_Shdr)
580 : sizeof (Elf64_External_Shdr));
581
582 /* Read the section headers. We skip section 0, which is not a
583 useful section. */
584
585 shnum = eor->shnum;
586 shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
587
588 if (!simple_object_internal_read (sobj->descriptor,
589 sobj->offset + eor->shoff + shdr_size,
590 shdrs,
591 shdr_size * (shnum - 1),
592 &errmsg, err))
593 {
594 XDELETEVEC (shdrs);
595 return errmsg;
596 }
597
598 /* Read the section names. */
599
600 shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
601 name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
602 shstrhdr, sh_size, Elf_Addr);
603 shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
604 shstrhdr, sh_offset, Elf_Addr);
605 names = XNEWVEC (unsigned char, name_size);
606 if (!simple_object_internal_read (sobj->descriptor,
607 sobj->offset + shstroff,
608 names, name_size, &errmsg, err))
609 {
610 XDELETEVEC (names);
611 XDELETEVEC (shdrs);
612 return errmsg;
613 }
614
615 for (i = 1; i < shnum; ++i)
616 {
617 unsigned char *shdr;
618 unsigned int sh_name;
619 const char *name;
620 off_t offset;
621 off_t length;
622
623 shdr = shdrs + (i - 1) * shdr_size;
624 sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
625 shdr, sh_name, Elf_Word);
626 if (sh_name >= name_size)
627 {
628 *err = 0;
629 XDELETEVEC (names);
630 XDELETEVEC (shdrs);
631 return "ELF section name out of range";
632 }
633
634 name = (const char *) names + sh_name;
635 offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
636 shdr, sh_offset, Elf_Addr);
637 length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
638 shdr, sh_size, Elf_Addr);
639
640 if (!(*pfn) (data, name, offset, length))
641 break;
642 }
643
644 XDELETEVEC (names);
645 XDELETEVEC (shdrs);
646
647 return NULL;
648}
649
650/* Fetch the attributes for an simple_object_read. */
651
652static void *
653simple_object_elf_fetch_attributes (simple_object_read *sobj,
654 const char **errmsg ATTRIBUTE_UNUSED,
655 int *err ATTRIBUTE_UNUSED)
656{
657 struct simple_object_elf_read *eor =
658 (struct simple_object_elf_read *) sobj->data;
659 struct simple_object_elf_attributes *ret;
660
661 ret = XNEW (struct simple_object_elf_attributes);
662 ret->type_functions = eor->type_functions;
663 ret->ei_data = eor->ei_data;
664 ret->ei_class = eor->ei_class;
665 ret->ei_osabi = eor->ei_osabi;
666 ret->machine = eor->machine;
667 ret->flags = eor->flags;
668 return ret;
669}
670
671/* Release the privata data for an simple_object_read. */
672
673static void
674simple_object_elf_release_read (void *data)
675{
676 XDELETE (data);
677}
678
679/* Compare two attributes structures. */
680
681static const char *
d82f74d3 682simple_object_elf_attributes_merge (void *todata, void *fromdata, int *err)
1cfabf34 683{
d82f74d3
ILT		 684 struct simple_object_elf_attributes *to =
685 (struct simple_object_elf_attributes *) todata;
686 struct simple_object_elf_attributes *from =
687 (struct simple_object_elf_attributes *) fromdata;
688
689 if (to->ei_data != from->ei_data || to->ei_class != from->ei_class)
1cfabf34
ILT		 690 {
691 *err = 0;
692 return "ELF object format mismatch";
693 }
d82f74d3
ILT		 694
695 if (to->machine != from->machine)
696 {
697 int ok;
698
699 /* EM_SPARC and EM_SPARC32PLUS are compatible and force an
700 output of EM_SPARC32PLUS. */
701 ok = 0;
702 switch (to->machine)
703 {
704 case EM_SPARC:
705 if (from->machine == EM_SPARC32PLUS)
706 {
707 to->machine = from->machine;
708 ok = 1;
709 }
710 break;
711
712 case EM_SPARC32PLUS:
713 if (from->machine == EM_SPARC)
714 ok = 1;
715 break;
716
717 default:
718 break;
719 }
720
721 if (!ok)
722 {
723 *err = 0;
724 return "ELF machine number mismatch";
725 }
726 }
727
1cfabf34
ILT		 728 return NULL;
729}
730
731/* Release the private data for an attributes structure. */
732
733static void
734simple_object_elf_release_attributes (void *data)
735{
736 XDELETE (data);
737}
738
739/* Prepare to write out a file. */
740
741static void *
742simple_object_elf_start_write (void *attributes_data,
743 const char **errmsg ATTRIBUTE_UNUSED,
744 int *err ATTRIBUTE_UNUSED)
745{
746 struct simple_object_elf_attributes *attrs =
747 (struct simple_object_elf_attributes *) attributes_data;
1ea85365 748 struct simple_object_elf_write *ret;
1cfabf34
ILT		 749
750 /* We're just going to record the attributes, but we need to make a
751 copy because the user may delete them. */
1ea85365
RB		 752 ret = XNEW (struct simple_object_elf_write);
753 ret->attrs = *attrs;
754 ret->shdrs = NULL;
1cfabf34
ILT		 755 return ret;
756}
757
758/* Write out an ELF ehdr. */
759
760static int
761simple_object_elf_write_ehdr (simple_object_write *sobj, int descriptor,
762 const char **errmsg, int *err)
763{
764 struct simple_object_elf_attributes *attrs =
765 (struct simple_object_elf_attributes *) sobj->data;
766 const struct elf_type_functions* fns;
767 unsigned char cl;
768 size_t ehdr_size;
769 unsigned char buf[sizeof (Elf64_External_Ehdr)];
770 simple_object_write_section *section;
771 unsigned int shnum;
0f1fbc83 772 unsigned int shstrndx;
1cfabf34
ILT		 773
774 fns = attrs->type_functions;
775 cl = attrs->ei_class;
776
777 shnum = 0;
778 for (section = sobj->sections; section != NULL; section = section->next)
779 ++shnum;
780 if (shnum > 0)
781 {
782 /* Add a section header for the dummy section and one for
783 .shstrtab. */
784 shnum += 2;
785 }
786
787 ehdr_size = (cl == ELFCLASS32
788 ? sizeof (Elf32_External_Ehdr)
789 : sizeof (Elf64_External_Ehdr));
790 memset (buf, 0, sizeof (Elf64_External_Ehdr));
791
792 buf[EI_MAG0] = ELFMAG0;
793 buf[EI_MAG1] = ELFMAG1;
794 buf[EI_MAG2] = ELFMAG2;
795 buf[EI_MAG3] = ELFMAG3;
796 buf[EI_CLASS] = cl;
797 buf[EI_DATA] = attrs->ei_data;
798 buf[EI_VERSION] = EV_CURRENT;
799 buf[EI_OSABI] = attrs->ei_osabi;
800
801 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_type, Elf_Half, ET_REL);
802 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_machine, Elf_Half, attrs->machine);
803 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_version, Elf_Word, EV_CURRENT);
804 /* e_entry left as zero. */
805 /* e_phoff left as zero. */
806 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shoff, Elf_Addr, ehdr_size);
807 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_flags, Elf_Word, attrs->flags);
808 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_ehsize, Elf_Half, ehdr_size);
809 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_phentsize, Elf_Half,
810 (cl == ELFCLASS32
811 ? sizeof (Elf32_External_Phdr)
812 : sizeof (Elf64_External_Phdr)));
813 /* e_phnum left as zero. */
814 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shentsize, Elf_Half,
815 (cl == ELFCLASS32
816 ? sizeof (Elf32_External_Shdr)
817 : sizeof (Elf64_External_Shdr)));
0f1fbc83
ILT		 818 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shnum, Elf_Half,
819 shnum >= SHN_LORESERVE ? 0 : shnum);
820 if (shnum == 0)
821 shstrndx = 0;
822 else
823 {
824 shstrndx = shnum - 1;
825 if (shstrndx >= SHN_LORESERVE)
826 shstrndx = SHN_XINDEX;
827 }
828 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shstrndx, Elf_Half, shstrndx);
1cfabf34
ILT		 829
830 return simple_object_internal_write (descriptor, 0, buf, ehdr_size,
831 errmsg, err);
832}
833
834/* Write out an ELF shdr. */
835
836static int
837simple_object_elf_write_shdr (simple_object_write *sobj, int descriptor,
838 off_t offset, unsigned int sh_name,
839 unsigned int sh_type, unsigned int sh_flags,
1ea85365 840 off_t sh_addr,
1cfabf34 841 unsigned int sh_offset, unsigned int sh_size,
1ea85365 842 unsigned int sh_link, unsigned int sh_info,
d4c550fd
RB		 843 size_t sh_addralign,
844 size_t sh_entsize,
0f1fbc83 845 const char **errmsg, int *err)
1cfabf34
ILT		 846{
847 struct simple_object_elf_attributes *attrs =
848 (struct simple_object_elf_attributes *) sobj->data;
849 const struct elf_type_functions* fns;
850 unsigned char cl;
851 size_t shdr_size;
852 unsigned char buf[sizeof (Elf64_External_Shdr)];
853
854 fns = attrs->type_functions;
855 cl = attrs->ei_class;
856
857 shdr_size = (cl == ELFCLASS32
858 ? sizeof (Elf32_External_Shdr)
859 : sizeof (Elf64_External_Shdr));
860 memset (buf, 0, sizeof (Elf64_External_Shdr));
861
862 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_name, Elf_Word, sh_name);
863 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_type, Elf_Word, sh_type);
864 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_flags, Elf_Addr, sh_flags);
1ea85365 865 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addr, Elf_Addr, sh_addr);
1cfabf34
ILT		 866 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_offset, Elf_Addr, sh_offset);
867 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_size, Elf_Addr, sh_size);
0f1fbc83 868 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_link, Elf_Word, sh_link);
1ea85365 869 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_info, Elf_Word, sh_info);
1cfabf34 870 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addralign, Elf_Addr, sh_addralign);
d4c550fd 871 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_entsize, Elf_Addr, sh_entsize);
1cfabf34
ILT		 872
873 return simple_object_internal_write (descriptor, offset, buf, shdr_size,
874 errmsg, err);
875}
876
877/* Write out a complete ELF file.
878 Ehdr
879 initial dummy Shdr
880 user-created Shdrs
881 .shstrtab Shdr
882 user-created section data
883 .shstrtab data */
884
885static const char *
886simple_object_elf_write_to_file (simple_object_write *sobj, int descriptor,
887 int *err)
888{
1ea85365
RB		 889 struct simple_object_elf_write *eow =
890 (struct simple_object_elf_write *) sobj->data;
891 struct simple_object_elf_attributes *attrs = &eow->attrs;
1cfabf34
ILT		 892 unsigned char cl;
893 size_t ehdr_size;
894 size_t shdr_size;
895 const char *errmsg;
896 simple_object_write_section *section;
897 unsigned int shnum;
898 size_t shdr_offset;
899 size_t sh_offset;
0f1fbc83
ILT		 900 unsigned int first_sh_size;
901 unsigned int first_sh_link;
1cfabf34
ILT		 902 size_t sh_name;
903 unsigned char zero;
1ea85365 904 unsigned secnum;
1cfabf34
ILT		 905
906 if (!simple_object_elf_write_ehdr (sobj, descriptor, &errmsg, err))
907 return errmsg;
908
909 cl = attrs->ei_class;
910 if (cl == ELFCLASS32)
911 {
912 ehdr_size = sizeof (Elf32_External_Ehdr);
913 shdr_size = sizeof (Elf32_External_Shdr);
914 }
915 else
916 {
917 ehdr_size = sizeof (Elf64_External_Ehdr);
918 shdr_size = sizeof (Elf64_External_Shdr);
919 }
920
921 shnum = 0;
922 for (section = sobj->sections; section != NULL; section = section->next)
923 ++shnum;
924 if (shnum == 0)
925 return NULL;
926
927 /* Add initial dummy Shdr and .shstrtab. */
928 shnum += 2;
929
930 shdr_offset = ehdr_size;
931 sh_offset = shdr_offset + shnum * shdr_size;
932
0f1fbc83
ILT		 933 if (shnum < SHN_LORESERVE)
934 first_sh_size = 0;
935 else
936 first_sh_size = shnum;
937 if (shnum - 1 < SHN_LORESERVE)
938 first_sh_link = 0;
939 else
940 first_sh_link = shnum - 1;
1cfabf34 941 if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
1ea85365
RB		 942 0, 0, 0, 0, 0, first_sh_size, first_sh_link,
943 0, 0, 0, &errmsg, err))
1cfabf34
ILT		 944 return errmsg;
945
946 shdr_offset += shdr_size;
947
948 sh_name = 1;
1ea85365 949 secnum = 0;
1cfabf34
ILT		 950 for (section = sobj->sections; section != NULL; section = section->next)
951 {
952 size_t mask;
953 size_t new_sh_offset;
954 size_t sh_size;
955 struct simple_object_write_section_buffer *buffer;
1ea85365
RB		 956 unsigned int sh_type = SHT_PROGBITS;
957 unsigned int sh_flags = 0;
958 off_t sh_addr = 0;
959 unsigned int sh_link = 0;
960 unsigned int sh_info = 0;
d4c550fd
RB		 961 size_t sh_addralign = 1U << section->align;
962 size_t sh_entsize = 0;
1ea85365
RB		 963 if (eow->shdrs)
964 {
965 sh_type = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
966 eow->shdrs + secnum * shdr_size,
967 sh_type, Elf_Word);
968 sh_flags = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
969 eow->shdrs + secnum * shdr_size,
970 sh_flags, Elf_Addr);
971 sh_addr = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
972 eow->shdrs + secnum * shdr_size,
973 sh_addr, Elf_Addr);
974 sh_link = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
975 eow->shdrs + secnum * shdr_size,
976 sh_link, Elf_Word);
977 sh_info = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
978 eow->shdrs + secnum * shdr_size,
979 sh_info, Elf_Word);
980 sh_addralign = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
981 eow->shdrs + secnum * shdr_size,
982 sh_addralign, Elf_Addr);
983 sh_entsize = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
984 eow->shdrs + secnum * shdr_size,
d4c550fd 985 sh_entsize, Elf_Addr);
1ea85365
RB		 986 secnum++;
987 }
1cfabf34 988
1ea85365 989 mask = sh_addralign - 1;
1cfabf34
ILT		 990 new_sh_offset = sh_offset + mask;
991 new_sh_offset &= ~ mask;
992 while (new_sh_offset > sh_offset)
993 {
994 unsigned char zeroes[16];
995 size_t write;
996
997 memset (zeroes, 0, sizeof zeroes);
998 write = new_sh_offset - sh_offset;
999 if (write > sizeof zeroes)
1000 write = sizeof zeroes;
1001 if (!simple_object_internal_write (descriptor, sh_offset, zeroes,
1002 write, &errmsg, err))
1003 return errmsg;
1004 sh_offset += write;
1005 }
1006
1007 sh_size = 0;
1008 for (buffer = section->buffers; buffer != NULL; buffer = buffer->next)
1009 {
1010 if (!simple_object_internal_write (descriptor, sh_offset + sh_size,
1011 ((const unsigned char *)
1012 buffer->buffer),
1013 buffer->size, &errmsg, err))
1014 return errmsg;
1015 sh_size += buffer->size;
1016 }
1017
1018 if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
1ea85365
RB		 1019 sh_name, sh_type, sh_flags,
1020 sh_addr, sh_offset,
1021 sh_size, sh_link, sh_info,
1022 sh_addralign, sh_entsize,
1cfabf34
ILT		 1023 &errmsg, err))
1024 return errmsg;
1025
1026 shdr_offset += shdr_size;
1027 sh_name += strlen (section->name) + 1;
1028 sh_offset += sh_size;
1029 }
1030
1031 if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
1ea85365
RB		 1032 sh_name, SHT_STRTAB, 0, 0, sh_offset,
1033 sh_name + strlen (".shstrtab") + 1, 0, 0,
1034 1, 0, &errmsg, err))
1cfabf34
ILT		 1035 return errmsg;
1036
1037 /* .shstrtab has a leading zero byte. */
1038 zero = 0;
1039 if (!simple_object_internal_write (descriptor, sh_offset, &zero, 1,
1040 &errmsg, err))
1041 return errmsg;
1042 ++sh_offset;
1043
1044 for (section = sobj->sections; section != NULL; section = section->next)
1045 {
1046 size_t len;
1047
1048 len = strlen (section->name) + 1;
1049 if (!simple_object_internal_write (descriptor, sh_offset,
1050 (const unsigned char *) section->name,
1051 len, &errmsg, err))
1052 return errmsg;
1053 sh_offset += len;
1054 }
1055
1056 if (!simple_object_internal_write (descriptor, sh_offset,
1057 (const unsigned char *) ".shstrtab",
1058 strlen (".shstrtab") + 1, &errmsg, err))
1059 return errmsg;
1060
1061 return NULL;
1062}
1063
1064/* Release the private data for an simple_object_write structure. */
1065
1066static void
1067simple_object_elf_release_write (void *data)
1068{
1ea85365
RB		 1069 struct simple_object_elf_write *eow = (struct simple_object_elf_write *) data;
1070 if (eow->shdrs)
1071 XDELETE (eow->shdrs);
1cfabf34
ILT		 1072 XDELETE (data);
1073}
1074
1ea85365
RB		 1075/* Copy all sections in an ELF file. */
1076
1077static const char *
1078simple_object_elf_copy_lto_debug_sections (simple_object_read *sobj,
1079 simple_object_write *dobj,
bf6f2cc7 1080 char *(*pfn) (const char *),
1ea85365
RB		 1081 int *err)
1082{
1083 struct simple_object_elf_read *eor =
1084 (struct simple_object_elf_read *) sobj->data;
1085 const struct elf_type_functions *type_functions = eor->type_functions;
1086 struct simple_object_elf_write *eow =
1087 (struct simple_object_elf_write *) dobj->data;
1088 unsigned char ei_class = eor->ei_class;
1089 size_t shdr_size;
1090 unsigned int shnum;
1091 unsigned char *shdrs;
1092 const char *errmsg;
1093 unsigned char *shstrhdr;
1094 size_t name_size;
1095 off_t shstroff;
1096 unsigned char *names;
1097 unsigned int i;
160826fe 1098 int changed;
1ea85365
RB		 1099 int *pfnret;
1100 const char **pfnname;
bf6f2cc7
RB		 1101 unsigned new_i;
1102 unsigned *sh_map;
c1177db4 1103 unsigned first_shndx = 0;
bf6f2cc7 1104 unsigned int *symtab_indices_shndx;
1ea85365
RB		 1105
1106 shdr_size = (ei_class == ELFCLASS32
1107 ? sizeof (Elf32_External_Shdr)
1108 : sizeof (Elf64_External_Shdr));
1109
1110 /* Read the section headers. We skip section 0, which is not a
1111 useful section. */
1112
1113 shnum = eor->shnum;
1114 shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
1115
1116 if (!simple_object_internal_read (sobj->descriptor,
1117 sobj->offset + eor->shoff + shdr_size,
1118 shdrs,
1119 shdr_size * (shnum - 1),
1120 &errmsg, err))
1121 {
1122 XDELETEVEC (shdrs);
1123 return errmsg;
1124 }
1125
1126 /* Read the section names. */
1127
1128 shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
1129 name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1130 shstrhdr, sh_size, Elf_Addr);
1131 shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1132 shstrhdr, sh_offset, Elf_Addr);
1133 names = XNEWVEC (unsigned char, name_size);
1134 if (!simple_object_internal_read (sobj->descriptor,
1135 sobj->offset + shstroff,
1136 names, name_size, &errmsg, err))
1137 {
1138 XDELETEVEC (names);
1139 XDELETEVEC (shdrs);
1140 return errmsg;
1141 }
1142
1ea85365
RB		 1143 pfnret = XNEWVEC (int, shnum);
1144 pfnname = XNEWVEC (const char *, shnum);
1145
bf6f2cc7
RB		 1146 /* Map of symtab to index section. */
1147 symtab_indices_shndx = XCNEWVEC (unsigned int, shnum - 1);
1148
1ea85365
RB		 1149 /* First perform the callbacks to know which sections to preserve and
1150 what name to use for those. */
1151 for (i = 1; i < shnum; ++i)
1152 {
1153 unsigned char *shdr;
bf6f2cc7 1154 unsigned int sh_name, sh_type;
1ea85365 1155 const char *name;
bf6f2cc7 1156 char *ret;
1ea85365
RB		 1157
1158 shdr = shdrs + (i - 1) * shdr_size;
1159 sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1160 shdr, sh_name, Elf_Word);
1161 if (sh_name >= name_size)
1162 {
1163 *err = 0;
1164 XDELETEVEC (names);
1165 XDELETEVEC (shdrs);
1166 return "ELF section name out of range";
1167 }
1168
1169 name = (const char *) names + sh_name;
1170
bf6f2cc7
RB		 1171 ret = (*pfn) (name);
1172 pfnret[i - 1] = ret == NULL ? -1 : 0;
1173 pfnname[i - 1] = ret == NULL ? name : ret;
c1177db4
RB		 1174 if (first_shndx == 0
1175 && pfnret[i - 1] == 0)
1176 first_shndx = i;
bf6f2cc7
RB		 1177
1178 /* Remember the indexes of existing SHT_SYMTAB_SHNDX sections. */
1179 sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1180 shdr, sh_type, Elf_Word);
1181 if (sh_type == SHT_SYMTAB_SHNDX)
1182 {
1183 unsigned int sh_link;
1184 sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1185 shdr, sh_link, Elf_Word);
1186 symtab_indices_shndx[sh_link - 1] = i;
1187 /* Always discard the extended index sections, after
1188 copying it will not be needed. This way we don't need to
1189 update it and deal with the ordering constraints of
1190 processing the existing symtab and changing the index. */
1191 pfnret[i - 1] = -1;
1192 }
1ea85365
RB		 1193 }
1194
1195 /* Mark sections as preserved that are required by to be preserved
1196 sections. */
dc4b8c68 1197 do
1ea85365 1198 {
dc4b8c68
RB		 1199 changed = 0;
1200 for (i = 1; i < shnum; ++i)
1ea85365 1201 {
dc4b8c68
RB		 1202 unsigned char *shdr;
1203 unsigned int sh_type, sh_info, sh_link;
1204 off_t offset;
1205 off_t length;
1206
1207 shdr = shdrs + (i - 1) * shdr_size;
1208 sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1209 shdr, sh_type, Elf_Word);
1210 sh_info = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1211 shdr, sh_info, Elf_Word);
1212 sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1213 shdr, sh_link, Elf_Word);
1214 if (sh_type == SHT_GROUP)
1ea85365 1215 {
dc4b8c68
RB		 1216 /* Mark groups containing copied sections. */
1217 unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class,
1218 Shdr, shdr, sh_entsize,
1219 Elf_Addr);
1220 unsigned char *ent, *buf;
1221 int keep = 0;
1222 offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1223 shdr, sh_offset, Elf_Addr);
1224 length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1225 shdr, sh_size, Elf_Addr);
1226 buf = XNEWVEC (unsigned char, length);
1227 if (!simple_object_internal_read (sobj->descriptor,
1228 sobj->offset + offset, buf,
1229 (size_t) length, &errmsg, err))
1230 {
1231 XDELETEVEC (buf);
1232 XDELETEVEC (names);
1233 XDELETEVEC (shdrs);
1234 return errmsg;
1235 }
1236 for (ent = buf + entsize; ent < buf + length; ent += entsize)
1237 {
1238 unsigned sec = type_functions->fetch_Elf_Word (ent);
1239 if (pfnret[sec - 1] == 0)
1240 keep = 1;
1241 }
1242 if (keep)
1243 {
1244 changed |= (pfnret[sh_link - 1] == -1
1245 || pfnret[i - 1] == -1);
1246 pfnret[sh_link - 1] = 0;
1247 pfnret[i - 1] = 0;
1248 }
1ea85365 1249 }
dc4b8c68
RB		 1250 if (sh_type == SHT_RELA
1251 || sh_type == SHT_REL)
1ea85365 1252 {
dc4b8c68
RB		 1253 /* Mark relocation sections and symtab of copied sections. */
1254 if (pfnret[sh_info - 1] == 0)
1255 {
1256 changed |= (pfnret[sh_link - 1] == -1
1257 || pfnret[i - 1] == -1);
1258 pfnret[sh_link - 1] = 0;
1259 pfnret[i - 1] = 0;
1260 }
1ea85365 1261 }
dc4b8c68 1262 if (sh_type == SHT_SYMTAB)
1ea85365 1263 {
dc4b8c68
RB		 1264 /* Mark strings sections of copied symtabs. */
1265 if (pfnret[i - 1] == 0)
1266 {
1267 changed |= pfnret[sh_link - 1] == -1;
1268 pfnret[sh_link - 1] = 0;
1269 }
1ea85365
RB		 1270 }
1271 }
1ea85365 1272 }
dc4b8c68 1273 while (changed);
1ea85365 1274
bf6f2cc7
RB		 1275 /* Compute a mapping of old -> new section numbers. */
1276 sh_map = XNEWVEC (unsigned, shnum);
1277 sh_map[0] = 0;
1278 new_i = 1;
1279 for (i = 1; i < shnum; ++i)
1280 {
1281 if (pfnret[i - 1] == -1)
1282 sh_map[i] = 0;
1283 else
1284 sh_map[i] = new_i++;
1285 }
1286 if (new_i - 1 >= SHN_LORESERVE)
1287 {
1288 *err = ENOTSUP;
1289 return "Too many copied sections";
1290 }
1291 eow->shdrs = XNEWVEC (unsigned char, shdr_size * (new_i - 1));
1292
1ea85365 1293 /* Then perform the actual copying. */
bf6f2cc7 1294 new_i = 0;
1ea85365
RB		 1295 for (i = 1; i < shnum; ++i)
1296 {
1297 unsigned char *shdr;
1298 unsigned int sh_name, sh_type;
1299 const char *name;
1300 off_t offset;
1301 off_t length;
1ea85365
RB		 1302 simple_object_write_section *dest;
1303 off_t flags;
1304 unsigned char *buf;
1305
bf6f2cc7
RB		 1306 if (pfnret[i - 1])
1307 continue;
1308
1309 new_i++;
1ea85365
RB		 1310 shdr = shdrs + (i - 1) * shdr_size;
1311 sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1312 shdr, sh_name, Elf_Word);
1313 if (sh_name >= name_size)
1314 {
1315 *err = 0;
1316 XDELETEVEC (names);
1317 XDELETEVEC (shdrs);
bf6f2cc7 1318 XDELETEVEC (symtab_indices_shndx);
1ea85365
RB		 1319 return "ELF section name out of range";
1320 }
1321
bf6f2cc7 1322 name = pfnname[i - 1];
1ea85365
RB		 1323 offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1324 shdr, sh_offset, Elf_Addr);
1325 length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1326 shdr, sh_size, Elf_Addr);
1327 sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1328 shdr, sh_type, Elf_Word);
1329
bf6f2cc7
RB		 1330 dest = simple_object_write_create_section (dobj, pfnname[i - 1],
1331 0, &errmsg, err);
1ea85365
RB		 1332 if (dest == NULL)
1333 {
1334 XDELETEVEC (names);
1335 XDELETEVEC (shdrs);
bf6f2cc7 1336 XDELETEVEC (symtab_indices_shndx);
1ea85365
RB		 1337 return errmsg;
1338 }
1339
1340 /* Record the SHDR of the source. */
bf6f2cc7
RB		 1341 memcpy (eow->shdrs + (new_i - 1) * shdr_size, shdr, shdr_size);
1342 shdr = eow->shdrs + (new_i - 1) * shdr_size;
1ea85365
RB		 1343
1344 /* Copy the data.
1345 ??? This is quite wasteful and ideally would be delayed until
1346 write_to_file (). Thus it questions the interfacing
1347 which eventually should contain destination creation plus
1348 writing. */
bf6f2cc7
RB		 1349 buf = XNEWVEC (unsigned char, length);
1350 if (!simple_object_internal_read (sobj->descriptor,
1351 sobj->offset + offset, buf,
1352 (size_t) length, &errmsg, err))
1353 {
1354 XDELETEVEC (buf);
1355 XDELETEVEC (names);
1356 XDELETEVEC (shdrs);
1357 XDELETEVEC (symtab_indices_shndx);
1358 return errmsg;
1359 }
1360
a861990d
ML		 1361 /* If we are processing .symtab purge __gnu_lto_slim symbol
1362 from it and any symbols in discarded sections. */
bf6f2cc7 1363 if (sh_type == SHT_SYMTAB)
1ea85365 1364 {
bf6f2cc7
RB		 1365 unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1366 shdr, sh_entsize, Elf_Addr);
1367 unsigned strtab = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1368 shdr, sh_link, Elf_Word);
1369 unsigned char *strshdr = shdrs + (strtab - 1) * shdr_size;
1370 off_t stroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1371 strshdr, sh_offset, Elf_Addr);
1372 size_t strsz = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1373 strshdr, sh_size, Elf_Addr);
1374 char *strings = XNEWVEC (char, strsz);
1375 char *gnu_lto = strings;
1376 unsigned char *ent;
1377 unsigned *shndx_table = NULL;
1378 simple_object_internal_read (sobj->descriptor,
1379 sobj->offset + stroff,
1380 (unsigned char *)strings,
1381 strsz, &errmsg, err);
a861990d
ML		 1382 /* Find first '\0' in strings. */
1383 gnu_lto = (char *) memchr (gnu_lto, '\0',
1384 strings + strsz - gnu_lto + 1);
bf6f2cc7
RB		 1385 /* Read the section index table if present. */
1386 if (symtab_indices_shndx[i - 1] != 0)
1ea85365 1387 {
bf6f2cc7
RB		 1388 unsigned char *sidxhdr = shdrs + (strtab - 1) * shdr_size;
1389 off_t sidxoff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1390 sidxhdr, sh_offset, Elf_Addr);
1391 size_t sidxsz = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1392 sidxhdr, sh_size, Elf_Addr);
1393 shndx_table = (unsigned *)XNEWVEC (char, sidxsz);
1394 simple_object_internal_read (sobj->descriptor,
1395 sobj->offset + sidxoff,
1396 (unsigned char *)shndx_table,
1397 sidxsz, &errmsg, err);
1ea85365 1398 }
bf6f2cc7 1399 for (ent = buf; ent < buf + length; ent += entsize)
1ea85365 1400 {
bf6f2cc7
RB		 1401 unsigned st_shndx = ELF_FETCH_FIELD (type_functions, ei_class,
1402 Sym, ent,
1403 st_shndx, Elf_Half);
1404 unsigned raw_st_shndx = st_shndx;
1405 unsigned char *st_info;
1406 unsigned char *st_other;
1407 int discard = 0;
1408 if (ei_class == ELFCLASS32)
1ea85365 1409 {
bf6f2cc7
RB		 1410 st_info = &((Elf32_External_Sym *)ent)->st_info;
1411 st_other = &((Elf32_External_Sym *)ent)->st_other;
1412 }
1413 else
1414 {
1415 st_info = &((Elf64_External_Sym *)ent)->st_info;
1416 st_other = &((Elf64_External_Sym *)ent)->st_other;
1417 }
1418 if (st_shndx == SHN_XINDEX)
1419 st_shndx = type_functions->fetch_Elf_Word
1420 ((unsigned char *)(shndx_table + (ent - buf) / entsize));
1421 /* Eliminate all COMMONs - this includes __gnu_lto_v1
1422 and __gnu_lto_slim which otherwise cause endless
1423 LTO plugin invocation. */
1424 if (st_shndx == SHN_COMMON)
1425 discard = 1;
1426 /* We also need to remove symbols refering to sections
1427 we'll eventually remove as with fat LTO objects
1428 we otherwise get duplicate symbols at final link
1429 (with GNU ld, gold is fine and ignores symbols in
1430 sections marked as EXCLUDE). ld/20513 */
1431 else if (st_shndx != SHN_UNDEF
1432 && st_shndx < shnum
1433 && pfnret[st_shndx - 1] == -1)
1434 discard = 1;
1435
1436 if (discard)
1437 {
1438 /* Make discarded symbols undefined and unnamed
1439 in case it is local. */
1440 int bind = ELF_ST_BIND (*st_info);
1441 int other = STV_DEFAULT;
1442 if (bind == STB_LOCAL)
1ea85365 1443 {
bf6f2cc7
RB		 1444 /* Make discarded local symbols unnamed and
1445 defined in the first prevailing section. */
1446 ELF_SET_FIELD (type_functions, ei_class, Sym,
1447 ent, st_name, Elf_Word, 0);
1448 ELF_SET_FIELD (type_functions, ei_class, Sym,
1449 ent, st_shndx, Elf_Half,
1450 sh_map[first_shndx]);
1ea85365
RB		 1451 }
1452 else
1453 {
bf6f2cc7
RB		 1454 /* Make discarded global symbols hidden weak
1455 undefined and sharing the gnu_lto_ name. */
1456 bind = STB_WEAK;
1457 other = STV_HIDDEN;
a861990d
ML		 1458 ELF_SET_FIELD (type_functions, ei_class, Sym,
1459 ent, st_name, Elf_Word,
1460 gnu_lto - strings);
1ea85365 1461 ELF_SET_FIELD (type_functions, ei_class, Sym,
bf6f2cc7 1462 ent, st_shndx, Elf_Half, SHN_UNDEF);
1ea85365 1463 }
bf6f2cc7
RB		 1464 *st_other = other;
1465 *st_info = ELF_ST_INFO (bind, STT_NOTYPE);
1466 ELF_SET_FIELD (type_functions, ei_class, Sym,
1467 ent, st_value, Elf_Addr, 0);
1468 ELF_SET_FIELD (type_functions, ei_class, Sym,
1469 ent, st_size, Elf_Word, 0);
1ea85365 1470 }
bf6f2cc7
RB		 1471 else if (raw_st_shndx < SHN_LORESERVE
1472 || raw_st_shndx == SHN_XINDEX)
1473 /* Remap the section reference. */
1474 ELF_SET_FIELD (type_functions, ei_class, Sym,
1475 ent, st_shndx, Elf_Half, sh_map[st_shndx]);
1ea85365 1476 }
bf6f2cc7
RB		 1477 XDELETEVEC (strings);
1478 XDELETEVEC (shndx_table);
1479 }
1480 else if (sh_type == SHT_GROUP)
1481 {
1482 /* Remap section indices in groups and remove removed members. */
1483 unsigned char *ent, *dst;
1484 for (dst = ent = buf + 4; ent < buf + length; ent += 4)
1ea85365 1485 {
bf6f2cc7
RB		 1486 unsigned shndx = type_functions->fetch_Elf_Word (ent);
1487 if (pfnret[shndx - 1] == -1)
1488 ;
1489 else
1490 {
1491 type_functions->set_Elf_Word (dst, sh_map[shndx]);
1492 dst += 4;
1493 }
1ea85365 1494 }
bf6f2cc7
RB		 1495 /* Adjust the length. */
1496 length = dst - buf;
1ea85365 1497 }
bf6f2cc7
RB		 1498
1499 errmsg = simple_object_write_add_data (dobj, dest,
1500 buf, length, 1, err);
1501 XDELETEVEC (buf);
1502 if (errmsg)
1ea85365 1503 {
bf6f2cc7
RB		 1504 XDELETEVEC (names);
1505 XDELETEVEC (shdrs);
1506 XDELETEVEC (symtab_indices_shndx);
1507 return errmsg;
1ea85365
RB		 1508 }
1509
1510 flags = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1511 shdr, sh_flags, Elf_Addr);
bf6f2cc7
RB		 1512 /* Remap the section references. */
1513 {
1514 unsigned int sh_info, sh_link;
1515 if (flags & SHF_INFO_LINK || sh_type == SHT_REL || sh_type == SHT_RELA)
1516 {
1517 sh_info = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1518 shdr, sh_info, Elf_Word);
1519 if (sh_info < SHN_LORESERVE
1520 || sh_info > SHN_HIRESERVE)
1521 sh_info = sh_map[sh_info];
1522 ELF_SET_FIELD (type_functions, ei_class, Shdr,
1523 shdr, sh_info, Elf_Word, sh_info);
1524 }
1525 sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1526 shdr, sh_link, Elf_Word);
1527 if (sh_link < SHN_LORESERVE
1528 || sh_link > SHN_HIRESERVE)
1529 sh_link = sh_map[sh_link];
1530 ELF_SET_FIELD (type_functions, ei_class, Shdr,
1531 shdr, sh_link, Elf_Word, sh_link);
1532 }
1533 /* The debugobj doesn't contain any code, thus no trampolines.
1534 Even when the original object needs trampolines, debugobj
1535 doesn't. */
1536 if (strcmp (name, ".note.GNU-stack") == 0)
1537 flags &= ~SHF_EXECINSTR;
1538 /* Clear SHF_EXCLUDE on to be preserved sections. */
1539 flags &= ~SHF_EXCLUDE;
1ea85365
RB		 1540 ELF_SET_FIELD (type_functions, ei_class, Shdr,
1541 shdr, sh_flags, Elf_Addr, flags);
1542 }
1543
1544 XDELETEVEC (names);
1545 XDELETEVEC (shdrs);
1546 XDELETEVEC (pfnret);
1547 XDELETEVEC (pfnname);
bf6f2cc7
RB		 1548 XDELETEVEC (symtab_indices_shndx);
1549 XDELETEVEC (sh_map);
1ea85365
RB		 1550
1551 return NULL;
1552}
1553
1554
1cfabf34
ILT		 1555/* The ELF functions. */
1556
1557const struct simple_object_functions simple_object_elf_functions =
1558{
1559 simple_object_elf_match,
1560 simple_object_elf_find_sections,
1561 simple_object_elf_fetch_attributes,
1562 simple_object_elf_release_read,
d82f74d3 1563 simple_object_elf_attributes_merge,
1cfabf34
ILT		 1564 simple_object_elf_release_attributes,
1565 simple_object_elf_start_write,
1566 simple_object_elf_write_to_file,
1ea85365
RB		 1567 simple_object_elf_release_write,
1568 simple_object_elf_copy_lto_debug_sections
1cfabf34 1569};
Mirror of https://gcc.gnu.org/git/gcc.git