projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ubsan: alpha-coff: signed integer overflow
[deliverable/binutils-gdb.git] / libiberty / simple-object-elf.c
CommitLineData
ffa54e5c 1/* simple-object-elf.c -- routines to manipulate ELF object files.
82704155 2 Copyright (C) 2010-2019 Free Software Foundation, Inc.
ffa54e5c
DD		 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>
db3410f8
EZ		 25/* mingw.org's MinGW doesn't have ENOTSUP. */
26#ifndef ENOTSUP
27# define ENOTSUP ENOSYS
28#endif
ffa54e5c
DD		 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
f9e6589d
DD		 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
ffa54e5c
DD		 127/* Special section index values. */
128
f8ad2513 129#define SHN_UNDEF 0 /* Undefined section */
ffa54e5c 130#define SHN_LORESERVE 0xFF00 /* Begin range of reserved indices */
f8ad2513 131#define SHN_COMMON 0xFFF2 /* Associated symbol is in common */
ffa54e5c 132#define SHN_XINDEX 0xFFFF /* Section index is held elsewhere */
e9301e76 133#define SHN_HIRESERVE 0xffff /* End of reserved indices */
ffa54e5c 134
f8ad2513 135
ffa54e5c
DD		 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
f8ad2513 194#define SHT_NULL 0 /* Section header table entry unused */
ffa54e5c 195#define SHT_PROGBITS 1 /* Program data */
f8ad2513 196#define SHT_SYMTAB 2 /* Link editing symbol table */
ffa54e5c 197#define SHT_STRTAB 3 /* A string table */
f8ad2513
NC		 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 */
e9301e76 201#define SHT_SYMTAB_SHNDX 18 /* Extended section indeces */
f8ad2513
NC		 202
203/* Values for sh_flags field. */
204
e9301e76 205#define SHF_INFO_LINK 0x00000040 /* `sh_info' contains SHT index */
2a8ae714 206#define SHF_EXECINSTR 0x00000004 /* Executable section. */
f8ad2513
NC		 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 */
2a8ae714 246#define STB_WEAK 2 /* Weak global */
f8ad2513
NC		 247
248#define STV_DEFAULT 0 /* Visibility is specified by binding type */
2a8ae714 249#define STV_HIDDEN 2 /* Can only be seen inside currect component */
ffa54e5c
DD		 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
f8ad2513
NC		 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
ffa54e5c
DD		 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 }
f211b8c0
NC		 551
552 if (eor->shstrndx == 0)
553 {
554 *errmsg = "invalid ELF shstrndx == 0";
555 *err = 0;
556 XDELETE (eor);
557 return NULL;
558 }
559
ffa54e5c
DD		 560 return (void *) eor;
561}
562
563/* Find all sections in an ELF file. */
564
565static const char *
566simple_object_elf_find_sections (simple_object_read *sobj,
567 int (*pfn) (void *, const char *,
568 off_t offset, off_t length),
569 void *data,
570 int *err)
571{
572 struct simple_object_elf_read *eor =
573 (struct simple_object_elf_read *) sobj->data;
574 const struct elf_type_functions *type_functions = eor->type_functions;
575 unsigned char ei_class = eor->ei_class;
576 size_t shdr_size;
577 unsigned int shnum;
578 unsigned char *shdrs;
579 const char *errmsg;
580 unsigned char *shstrhdr;
581 size_t name_size;
582 off_t shstroff;
583 unsigned char *names;
584 unsigned int i;
585
586 shdr_size = (ei_class == ELFCLASS32
587 ? sizeof (Elf32_External_Shdr)
588 : sizeof (Elf64_External_Shdr));
589
590 /* Read the section headers. We skip section 0, which is not a
591 useful section. */
592
593 shnum = eor->shnum;
594 shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
595
596 if (!simple_object_internal_read (sobj->descriptor,
597 sobj->offset + eor->shoff + shdr_size,
598 shdrs,
599 shdr_size * (shnum - 1),
600 &errmsg, err))
601 {
602 XDELETEVEC (shdrs);
603 return errmsg;
604 }
605
606 /* Read the section names. */
607
608 shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
609 name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
610 shstrhdr, sh_size, Elf_Addr);
611 shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
612 shstrhdr, sh_offset, Elf_Addr);
613 names = XNEWVEC (unsigned char, name_size);
614 if (!simple_object_internal_read (sobj->descriptor,
615 sobj->offset + shstroff,
616 names, name_size, &errmsg, err))
617 {
618 XDELETEVEC (names);
619 XDELETEVEC (shdrs);
620 return errmsg;
621 }
622
623 for (i = 1; i < shnum; ++i)
624 {
625 unsigned char *shdr;
626 unsigned int sh_name;
627 const char *name;
628 off_t offset;
629 off_t length;
630
631 shdr = shdrs + (i - 1) * shdr_size;
632 sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
633 shdr, sh_name, Elf_Word);
634 if (sh_name >= name_size)
635 {
636 *err = 0;
637 XDELETEVEC (names);
638 XDELETEVEC (shdrs);
639 return "ELF section name out of range";
640 }
641
642 name = (const char *) names + sh_name;
643 offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
644 shdr, sh_offset, Elf_Addr);
645 length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
646 shdr, sh_size, Elf_Addr);
647
648 if (!(*pfn) (data, name, offset, length))
649 break;
650 }
651
652 XDELETEVEC (names);
653 XDELETEVEC (shdrs);
654
655 return NULL;
656}
657
658/* Fetch the attributes for an simple_object_read. */
659
660static void *
661simple_object_elf_fetch_attributes (simple_object_read *sobj,
662 const char **errmsg ATTRIBUTE_UNUSED,
663 int *err ATTRIBUTE_UNUSED)
664{
665 struct simple_object_elf_read *eor =
666 (struct simple_object_elf_read *) sobj->data;
667 struct simple_object_elf_attributes *ret;
668
669 ret = XNEW (struct simple_object_elf_attributes);
670 ret->type_functions = eor->type_functions;
671 ret->ei_data = eor->ei_data;
672 ret->ei_class = eor->ei_class;
673 ret->ei_osabi = eor->ei_osabi;
674 ret->machine = eor->machine;
675 ret->flags = eor->flags;
676 return ret;
677}
678
679/* Release the privata data for an simple_object_read. */
680
681static void
682simple_object_elf_release_read (void *data)
683{
684 XDELETE (data);
685}
686
687/* Compare two attributes structures. */
688
689static const char *
f9e6589d 690simple_object_elf_attributes_merge (void *todata, void *fromdata, int *err)
ffa54e5c 691{
f9e6589d
DD		 692 struct simple_object_elf_attributes *to =
693 (struct simple_object_elf_attributes *) todata;
694 struct simple_object_elf_attributes *from =
695 (struct simple_object_elf_attributes *) fromdata;
696
697 if (to->ei_data != from->ei_data || to->ei_class != from->ei_class)
ffa54e5c
DD		 698 {
699 *err = 0;
700 return "ELF object format mismatch";
701 }
f9e6589d
DD		 702
703 if (to->machine != from->machine)
704 {
705 int ok;
706
707 /* EM_SPARC and EM_SPARC32PLUS are compatible and force an
708 output of EM_SPARC32PLUS. */
709 ok = 0;
710 switch (to->machine)
711 {
712 case EM_SPARC:
713 if (from->machine == EM_SPARC32PLUS)
714 {
715 to->machine = from->machine;
716 ok = 1;
717 }
718 break;
719
720 case EM_SPARC32PLUS:
721 if (from->machine == EM_SPARC)
722 ok = 1;
723 break;
724
725 default:
726 break;
727 }
728
729 if (!ok)
730 {
731 *err = 0;
732 return "ELF machine number mismatch";
733 }
734 }
735
ffa54e5c
DD		 736 return NULL;
737}
738
739/* Release the private data for an attributes structure. */
740
741static void
742simple_object_elf_release_attributes (void *data)
743{
744 XDELETE (data);
745}
746
747/* Prepare to write out a file. */
748
749static void *
750simple_object_elf_start_write (void *attributes_data,
751 const char **errmsg ATTRIBUTE_UNUSED,
752 int *err ATTRIBUTE_UNUSED)
753{
754 struct simple_object_elf_attributes *attrs =
755 (struct simple_object_elf_attributes *) attributes_data;
f8ad2513 756 struct simple_object_elf_write *ret;
ffa54e5c
DD		 757
758 /* We're just going to record the attributes, but we need to make a
759 copy because the user may delete them. */
f8ad2513
NC		 760 ret = XNEW (struct simple_object_elf_write);
761 ret->attrs = *attrs;
762 ret->shdrs = NULL;
ffa54e5c
DD		 763 return ret;
764}
765
766/* Write out an ELF ehdr. */
767
768static int
769simple_object_elf_write_ehdr (simple_object_write *sobj, int descriptor,
770 const char **errmsg, int *err)
771{
772 struct simple_object_elf_attributes *attrs =
773 (struct simple_object_elf_attributes *) sobj->data;
774 const struct elf_type_functions* fns;
775 unsigned char cl;
776 size_t ehdr_size;
777 unsigned char buf[sizeof (Elf64_External_Ehdr)];
778 simple_object_write_section *section;
779 unsigned int shnum;
b55f9678 780 unsigned int shstrndx;
ffa54e5c
DD		 781
782 fns = attrs->type_functions;
783 cl = attrs->ei_class;
784
785 shnum = 0;
786 for (section = sobj->sections; section != NULL; section = section->next)
787 ++shnum;
788 if (shnum > 0)
789 {
790 /* Add a section header for the dummy section and one for
791 .shstrtab. */
792 shnum += 2;
793 }
794
795 ehdr_size = (cl == ELFCLASS32
796 ? sizeof (Elf32_External_Ehdr)
797 : sizeof (Elf64_External_Ehdr));
798 memset (buf, 0, sizeof (Elf64_External_Ehdr));
799
800 buf[EI_MAG0] = ELFMAG0;
801 buf[EI_MAG1] = ELFMAG1;
802 buf[EI_MAG2] = ELFMAG2;
803 buf[EI_MAG3] = ELFMAG3;
804 buf[EI_CLASS] = cl;
805 buf[EI_DATA] = attrs->ei_data;
806 buf[EI_VERSION] = EV_CURRENT;
807 buf[EI_OSABI] = attrs->ei_osabi;
808
809 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_type, Elf_Half, ET_REL);
810 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_machine, Elf_Half, attrs->machine);
811 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_version, Elf_Word, EV_CURRENT);
812 /* e_entry left as zero. */
813 /* e_phoff left as zero. */
814 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shoff, Elf_Addr, ehdr_size);
815 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_flags, Elf_Word, attrs->flags);
816 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_ehsize, Elf_Half, ehdr_size);
817 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_phentsize, Elf_Half,
818 (cl == ELFCLASS32
819 ? sizeof (Elf32_External_Phdr)
820 : sizeof (Elf64_External_Phdr)));
821 /* e_phnum left as zero. */
822 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shentsize, Elf_Half,
823 (cl == ELFCLASS32
824 ? sizeof (Elf32_External_Shdr)
825 : sizeof (Elf64_External_Shdr)));
b55f9678
IB		 826 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shnum, Elf_Half,
827 shnum >= SHN_LORESERVE ? 0 : shnum);
828 if (shnum == 0)
829 shstrndx = 0;
830 else
831 {
832 shstrndx = shnum - 1;
833 if (shstrndx >= SHN_LORESERVE)
834 shstrndx = SHN_XINDEX;
835 }
836 ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shstrndx, Elf_Half, shstrndx);
ffa54e5c
DD		 837
838 return simple_object_internal_write (descriptor, 0, buf, ehdr_size,
839 errmsg, err);
840}
841
842/* Write out an ELF shdr. */
843
844static int
845simple_object_elf_write_shdr (simple_object_write *sobj, int descriptor,
846 off_t offset, unsigned int sh_name,
847 unsigned int sh_type, unsigned int sh_flags,
f8ad2513 848 off_t sh_addr,
ffa54e5c 849 unsigned int sh_offset, unsigned int sh_size,
f8ad2513
NC		 850 unsigned int sh_link, unsigned int sh_info,
851 size_t sh_addralign,
852 size_t sh_entsize,
b55f9678 853 const char **errmsg, int *err)
ffa54e5c
DD		 854{
855 struct simple_object_elf_attributes *attrs =
856 (struct simple_object_elf_attributes *) sobj->data;
857 const struct elf_type_functions* fns;
858 unsigned char cl;
859 size_t shdr_size;
860 unsigned char buf[sizeof (Elf64_External_Shdr)];
861
862 fns = attrs->type_functions;
863 cl = attrs->ei_class;
864
865 shdr_size = (cl == ELFCLASS32
866 ? sizeof (Elf32_External_Shdr)
867 : sizeof (Elf64_External_Shdr));
868 memset (buf, 0, sizeof (Elf64_External_Shdr));
869
870 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_name, Elf_Word, sh_name);
871 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_type, Elf_Word, sh_type);
872 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_flags, Elf_Addr, sh_flags);
f8ad2513 873 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addr, Elf_Addr, sh_addr);
ffa54e5c
DD		 874 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_offset, Elf_Addr, sh_offset);
875 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_size, Elf_Addr, sh_size);
b55f9678 876 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_link, Elf_Word, sh_link);
f8ad2513 877 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_info, Elf_Word, sh_info);
ffa54e5c 878 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addralign, Elf_Addr, sh_addralign);
f8ad2513 879 ELF_SET_FIELD (fns, cl, Shdr, buf, sh_entsize, Elf_Addr, sh_entsize);
ffa54e5c
DD		 880
881 return simple_object_internal_write (descriptor, offset, buf, shdr_size,
882 errmsg, err);
883}
884
885/* Write out a complete ELF file.
886 Ehdr
887 initial dummy Shdr
888 user-created Shdrs
889 .shstrtab Shdr
890 user-created section data
891 .shstrtab data */
892
893static const char *
894simple_object_elf_write_to_file (simple_object_write *sobj, int descriptor,
895 int *err)
896{
f8ad2513
NC		 897 struct simple_object_elf_write *eow =
898 (struct simple_object_elf_write *) sobj->data;
899 struct simple_object_elf_attributes *attrs = &eow->attrs;
ffa54e5c
DD		 900 unsigned char cl;
901 size_t ehdr_size;
902 size_t shdr_size;
903 const char *errmsg;
904 simple_object_write_section *section;
905 unsigned int shnum;
906 size_t shdr_offset;
907 size_t sh_offset;
b55f9678
IB		 908 unsigned int first_sh_size;
909 unsigned int first_sh_link;
ffa54e5c
DD		 910 size_t sh_name;
911 unsigned char zero;
f8ad2513 912 unsigned secnum;
ffa54e5c
DD		 913
914 if (!simple_object_elf_write_ehdr (sobj, descriptor, &errmsg, err))
915 return errmsg;
916
917 cl = attrs->ei_class;
918 if (cl == ELFCLASS32)
919 {
920 ehdr_size = sizeof (Elf32_External_Ehdr);
921 shdr_size = sizeof (Elf32_External_Shdr);
922 }
923 else
924 {
925 ehdr_size = sizeof (Elf64_External_Ehdr);
926 shdr_size = sizeof (Elf64_External_Shdr);
927 }
928
929 shnum = 0;
930 for (section = sobj->sections; section != NULL; section = section->next)
931 ++shnum;
932 if (shnum == 0)
933 return NULL;
934
935 /* Add initial dummy Shdr and .shstrtab. */
936 shnum += 2;
937
938 shdr_offset = ehdr_size;
939 sh_offset = shdr_offset + shnum * shdr_size;
940
b55f9678
IB		 941 if (shnum < SHN_LORESERVE)
942 first_sh_size = 0;
943 else
944 first_sh_size = shnum;
945 if (shnum - 1 < SHN_LORESERVE)
946 first_sh_link = 0;
947 else
948 first_sh_link = shnum - 1;
ffa54e5c 949 if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
f8ad2513
NC		 950 0, 0, 0, 0, 0, first_sh_size, first_sh_link,
951 0, 0, 0, &errmsg, err))
ffa54e5c
DD		 952 return errmsg;
953
954 shdr_offset += shdr_size;
955
956 sh_name = 1;
f8ad2513 957 secnum = 0;
ffa54e5c
DD		 958 for (section = sobj->sections; section != NULL; section = section->next)
959 {
960 size_t mask;
961 size_t new_sh_offset;
962 size_t sh_size;
963 struct simple_object_write_section_buffer *buffer;
f8ad2513
NC		 964 unsigned int sh_type = SHT_PROGBITS;
965 unsigned int sh_flags = 0;
966 off_t sh_addr = 0;
967 unsigned int sh_link = 0;
968 unsigned int sh_info = 0;
969 size_t sh_addralign = 1U << section->align;
970 size_t sh_entsize = 0;
971 if (eow->shdrs)
972 {
973 sh_type = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
974 eow->shdrs + secnum * shdr_size,
975 sh_type, Elf_Word);
976 sh_flags = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
977 eow->shdrs + secnum * shdr_size,
978 sh_flags, Elf_Addr);
979 sh_addr = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
980 eow->shdrs + secnum * shdr_size,
981 sh_addr, Elf_Addr);
982 sh_link = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
983 eow->shdrs + secnum * shdr_size,
984 sh_link, Elf_Word);
985 sh_info = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
986 eow->shdrs + secnum * shdr_size,
987 sh_info, Elf_Word);
988 sh_addralign = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
989 eow->shdrs + secnum * shdr_size,
990 sh_addralign, Elf_Addr);
991 sh_entsize = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
992 eow->shdrs + secnum * shdr_size,
993 sh_entsize, Elf_Addr);
994 secnum++;
995 }
ffa54e5c 996
f8ad2513 997 mask = sh_addralign - 1;
ffa54e5c
DD		 998 new_sh_offset = sh_offset + mask;
999 new_sh_offset &= ~ mask;
1000 while (new_sh_offset > sh_offset)
1001 {
1002 unsigned char zeroes[16];
1003 size_t write;
1004
1005 memset (zeroes, 0, sizeof zeroes);
1006 write = new_sh_offset - sh_offset;
1007 if (write > sizeof zeroes)
1008 write = sizeof zeroes;
1009 if (!simple_object_internal_write (descriptor, sh_offset, zeroes,
1010 write, &errmsg, err))
1011 return errmsg;
1012 sh_offset += write;
1013 }
1014
1015 sh_size = 0;
1016 for (buffer = section->buffers; buffer != NULL; buffer = buffer->next)
1017 {
1018 if (!simple_object_internal_write (descriptor, sh_offset + sh_size,
1019 ((const unsigned char *)
1020 buffer->buffer),
1021 buffer->size, &errmsg, err))
1022 return errmsg;
1023 sh_size += buffer->size;
1024 }
1025
1026 if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
f8ad2513
NC		 1027 sh_name, sh_type, sh_flags,
1028 sh_addr, sh_offset,
1029 sh_size, sh_link, sh_info,
1030 sh_addralign, sh_entsize,
ffa54e5c
DD		 1031 &errmsg, err))
1032 return errmsg;
1033
1034 shdr_offset += shdr_size;
1035 sh_name += strlen (section->name) + 1;
1036 sh_offset += sh_size;
1037 }
1038
1039 if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
f8ad2513
NC		 1040 sh_name, SHT_STRTAB, 0, 0, sh_offset,
1041 sh_name + strlen (".shstrtab") + 1, 0, 0,
1042 1, 0, &errmsg, err))
ffa54e5c
DD		 1043 return errmsg;
1044
1045 /* .shstrtab has a leading zero byte. */
1046 zero = 0;
1047 if (!simple_object_internal_write (descriptor, sh_offset, &zero, 1,
1048 &errmsg, err))
1049 return errmsg;
1050 ++sh_offset;
1051
1052 for (section = sobj->sections; section != NULL; section = section->next)
1053 {
1054 size_t len;
1055
1056 len = strlen (section->name) + 1;
1057 if (!simple_object_internal_write (descriptor, sh_offset,
1058 (const unsigned char *) section->name,
1059 len, &errmsg, err))
1060 return errmsg;
1061 sh_offset += len;
1062 }
1063
1064 if (!simple_object_internal_write (descriptor, sh_offset,
1065 (const unsigned char *) ".shstrtab",
1066 strlen (".shstrtab") + 1, &errmsg, err))
1067 return errmsg;
1068
1069 return NULL;
1070}
1071
1072/* Release the private data for an simple_object_write structure. */
1073
1074static void
1075simple_object_elf_release_write (void *data)
1076{
f8ad2513
NC		 1077 struct simple_object_elf_write *eow = (struct simple_object_elf_write *) data;
1078 if (eow->shdrs)
1079 XDELETE (eow->shdrs);
ffa54e5c
DD		 1080 XDELETE (data);
1081}
1082
f8ad2513
NC		 1083/* Copy all sections in an ELF file. */
1084
1085static const char *
1086simple_object_elf_copy_lto_debug_sections (simple_object_read *sobj,
1087 simple_object_write *dobj,
e9301e76 1088 char *(*pfn) (const char *),
f8ad2513
NC		 1089 int *err)
1090{
1091 struct simple_object_elf_read *eor =
1092 (struct simple_object_elf_read *) sobj->data;
1093 const struct elf_type_functions *type_functions = eor->type_functions;
1094 struct simple_object_elf_write *eow =
1095 (struct simple_object_elf_write *) dobj->data;
1096 unsigned char ei_class = eor->ei_class;
1097 size_t shdr_size;
1098 unsigned int shnum;
1099 unsigned char *shdrs;
1100 const char *errmsg;
1101 unsigned char *shstrhdr;
1102 size_t name_size;
1103 off_t shstroff;
1104 unsigned char *names;
1105 unsigned int i;
2a8ae714 1106 int changed;
f8ad2513
NC		 1107 int *pfnret;
1108 const char **pfnname;
e9301e76
NC		 1109 unsigned new_i;
1110 unsigned *sh_map;
2a8ae714 1111 unsigned first_shndx = 0;
e9301e76 1112 unsigned int *symtab_indices_shndx;
f8ad2513
NC		 1113
1114 shdr_size = (ei_class == ELFCLASS32
1115 ? sizeof (Elf32_External_Shdr)
1116 : sizeof (Elf64_External_Shdr));
1117
1118 /* Read the section headers. We skip section 0, which is not a
1119 useful section. */
1120
1121 shnum = eor->shnum;
1122 shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
1123
1124 if (!simple_object_internal_read (sobj->descriptor,
1125 sobj->offset + eor->shoff + shdr_size,
1126 shdrs,
1127 shdr_size * (shnum - 1),
1128 &errmsg, err))
1129 {
1130 XDELETEVEC (shdrs);
1131 return errmsg;
1132 }
1133
1134 /* Read the section names. */
1135
1136 shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
1137 name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1138 shstrhdr, sh_size, Elf_Addr);
1139 shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1140 shstrhdr, sh_offset, Elf_Addr);
1141 names = XNEWVEC (unsigned char, name_size);
1142 if (!simple_object_internal_read (sobj->descriptor,
1143 sobj->offset + shstroff,
1144 names, name_size, &errmsg, err))
1145 {
1146 XDELETEVEC (names);
1147 XDELETEVEC (shdrs);
1148 return errmsg;
1149 }
1150
f8ad2513
NC		 1151 pfnret = XNEWVEC (int, shnum);
1152 pfnname = XNEWVEC (const char *, shnum);
1153
e9301e76
NC		 1154 /* Map of symtab to index section. */
1155 symtab_indices_shndx = XCNEWVEC (unsigned int, shnum - 1);
1156
f8ad2513
NC		 1157 /* First perform the callbacks to know which sections to preserve and
1158 what name to use for those. */
1159 for (i = 1; i < shnum; ++i)
1160 {
1161 unsigned char *shdr;
e9301e76 1162 unsigned int sh_name, sh_type;
f8ad2513 1163 const char *name;
e9301e76 1164 char *ret;
f8ad2513
NC		 1165
1166 shdr = shdrs + (i - 1) * shdr_size;
1167 sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1168 shdr, sh_name, Elf_Word);
1169 if (sh_name >= name_size)
1170 {
1171 *err = 0;
1172 XDELETEVEC (names);
1173 XDELETEVEC (shdrs);
1174 return "ELF section name out of range";
1175 }
1176
1177 name = (const char *) names + sh_name;
1178
e9301e76
NC		 1179 ret = (*pfn) (name);
1180 pfnret[i - 1] = ret == NULL ? -1 : 0;
1181 pfnname[i - 1] = ret == NULL ? name : ret;
2a8ae714
NC		 1182 if (first_shndx == 0
1183 && pfnret[i - 1] == 0)
1184 first_shndx = i;
e9301e76
NC		 1185
1186 /* Remember the indexes of existing SHT_SYMTAB_SHNDX sections. */
1187 sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1188 shdr, sh_type, Elf_Word);
1189 if (sh_type == SHT_SYMTAB_SHNDX)
1190 {
1191 unsigned int sh_link;
1192 sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1193 shdr, sh_link, Elf_Word);
1194 symtab_indices_shndx[sh_link - 1] = i;
1195 /* Always discard the extended index sections, after
1196 copying it will not be needed. This way we don't need to
1197 update it and deal with the ordering constraints of
1198 processing the existing symtab and changing the index. */
1199 pfnret[i - 1] = -1;
1200 }
f8ad2513
NC		 1201 }
1202
1203 /* Mark sections as preserved that are required by to be preserved
1204 sections. */
26a67918 1205 do
f8ad2513 1206 {
26a67918
PA		 1207 changed = 0;
1208 for (i = 1; i < shnum; ++i)
f8ad2513 1209 {
26a67918
PA		 1210 unsigned char *shdr;
1211 unsigned int sh_type, sh_info, sh_link;
1212 off_t offset;
1213 off_t length;
1214
1215 shdr = shdrs + (i - 1) * shdr_size;
1216 sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1217 shdr, sh_type, Elf_Word);
1218 sh_info = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1219 shdr, sh_info, Elf_Word);
1220 sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1221 shdr, sh_link, Elf_Word);
1222 if (sh_type == SHT_GROUP)
f8ad2513 1223 {
26a67918
PA		 1224 /* Mark groups containing copied sections. */
1225 unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class,
1226 Shdr, shdr, sh_entsize,
1227 Elf_Addr);
1228 unsigned char *ent, *buf;
1229 int keep = 0;
1230 offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1231 shdr, sh_offset, Elf_Addr);
1232 length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1233 shdr, sh_size, Elf_Addr);
1234 buf = XNEWVEC (unsigned char, length);
1235 if (!simple_object_internal_read (sobj->descriptor,
1236 sobj->offset + offset, buf,
1237 (size_t) length, &errmsg, err))
1238 {
1239 XDELETEVEC (buf);
1240 XDELETEVEC (names);
1241 XDELETEVEC (shdrs);
1242 return errmsg;
1243 }
1244 for (ent = buf + entsize; ent < buf + length; ent += entsize)
1245 {
1246 unsigned sec = type_functions->fetch_Elf_Word (ent);
1247 if (pfnret[sec - 1] == 0)
1248 keep = 1;
1249 }
1250 if (keep)
1251 {
1252 changed |= (pfnret[sh_link - 1] == -1
1253 || pfnret[i - 1] == -1);
1254 pfnret[sh_link - 1] = 0;
1255 pfnret[i - 1] = 0;
1256 }
f8ad2513 1257 }
26a67918
PA		 1258 if (sh_type == SHT_RELA
1259 || sh_type == SHT_REL)
f8ad2513 1260 {
26a67918
PA		 1261 /* Mark relocation sections and symtab of copied sections. */
1262 if (pfnret[sh_info - 1] == 0)
1263 {
1264 changed |= (pfnret[sh_link - 1] == -1
1265 || pfnret[i - 1] == -1);
1266 pfnret[sh_link - 1] = 0;
1267 pfnret[i - 1] = 0;
1268 }
f8ad2513 1269 }
26a67918 1270 if (sh_type == SHT_SYMTAB)
f8ad2513 1271 {
26a67918
PA		 1272 /* Mark strings sections of copied symtabs. */
1273 if (pfnret[i - 1] == 0)
1274 {
1275 changed |= pfnret[sh_link - 1] == -1;
1276 pfnret[sh_link - 1] = 0;
1277 }
f8ad2513
NC		 1278 }
1279 }
f8ad2513 1280 }
26a67918 1281 while (changed);
f8ad2513 1282
e9301e76
NC		 1283 /* Compute a mapping of old -> new section numbers. */
1284 sh_map = XNEWVEC (unsigned, shnum);
1285 sh_map[0] = 0;
1286 new_i = 1;
1287 for (i = 1; i < shnum; ++i)
1288 {
1289 if (pfnret[i - 1] == -1)
1290 sh_map[i] = 0;
1291 else
1292 sh_map[i] = new_i++;
1293 }
1294 if (new_i - 1 >= SHN_LORESERVE)
1295 {
1296 *err = ENOTSUP;
1297 return "Too many copied sections";
1298 }
1299 eow->shdrs = XNEWVEC (unsigned char, shdr_size * (new_i - 1));
1300
f8ad2513 1301 /* Then perform the actual copying. */
e9301e76 1302 new_i = 0;
f8ad2513
NC		 1303 for (i = 1; i < shnum; ++i)
1304 {
1305 unsigned char *shdr;
1306 unsigned int sh_name, sh_type;
1307 const char *name;
1308 off_t offset;
1309 off_t length;
f8ad2513
NC		 1310 simple_object_write_section *dest;
1311 off_t flags;
1312 unsigned char *buf;
1313
e9301e76
NC		 1314 if (pfnret[i - 1])
1315 continue;
1316
1317 new_i++;
f8ad2513
NC		 1318 shdr = shdrs + (i - 1) * shdr_size;
1319 sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1320 shdr, sh_name, Elf_Word);
1321 if (sh_name >= name_size)
1322 {
1323 *err = 0;
1324 XDELETEVEC (names);
1325 XDELETEVEC (shdrs);
e9301e76 1326 XDELETEVEC (symtab_indices_shndx);
f8ad2513
NC		 1327 return "ELF section name out of range";
1328 }
1329
e9301e76 1330 name = pfnname[i - 1];
f8ad2513
NC		 1331 offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1332 shdr, sh_offset, Elf_Addr);
1333 length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1334 shdr, sh_size, Elf_Addr);
1335 sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1336 shdr, sh_type, Elf_Word);
1337
e9301e76
NC		 1338 dest = simple_object_write_create_section (dobj, pfnname[i - 1],
1339 0, &errmsg, err);
f8ad2513
NC		 1340 if (dest == NULL)
1341 {
1342 XDELETEVEC (names);
1343 XDELETEVEC (shdrs);
e9301e76 1344 XDELETEVEC (symtab_indices_shndx);
f8ad2513
NC		 1345 return errmsg;
1346 }
1347
1348 /* Record the SHDR of the source. */
e9301e76
NC		 1349 memcpy (eow->shdrs + (new_i - 1) * shdr_size, shdr, shdr_size);
1350 shdr = eow->shdrs + (new_i - 1) * shdr_size;
f8ad2513
NC		 1351
1352 /* Copy the data.
1353 ??? This is quite wasteful and ideally would be delayed until
1354 write_to_file (). Thus it questions the interfacing
1355 which eventually should contain destination creation plus
1356 writing. */
e9301e76
NC		 1357 buf = XNEWVEC (unsigned char, length);
1358 if (!simple_object_internal_read (sobj->descriptor,
1359 sobj->offset + offset, buf,
1360 (size_t) length, &errmsg, err))
1361 {
1362 XDELETEVEC (buf);
1363 XDELETEVEC (names);
1364 XDELETEVEC (shdrs);
1365 XDELETEVEC (symtab_indices_shndx);
1366 return errmsg;
1367 }
1368
f211b8c0
NC		 1369 /* If we are processing .symtab purge __gnu_lto_slim symbol
1370 from it and any symbols in discarded sections. */
e9301e76 1371 if (sh_type == SHT_SYMTAB)
f8ad2513 1372 {
e9301e76
NC		 1373 unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1374 shdr, sh_entsize, Elf_Addr);
1375 unsigned strtab = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1376 shdr, sh_link, Elf_Word);
1377 unsigned char *strshdr = shdrs + (strtab - 1) * shdr_size;
1378 off_t stroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1379 strshdr, sh_offset, Elf_Addr);
1380 size_t strsz = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1381 strshdr, sh_size, Elf_Addr);
1382 char *strings = XNEWVEC (char, strsz);
1383 char *gnu_lto = strings;
1384 unsigned char *ent;
1385 unsigned *shndx_table = NULL;
1386 simple_object_internal_read (sobj->descriptor,
1387 sobj->offset + stroff,
1388 (unsigned char *)strings,
1389 strsz, &errmsg, err);
f211b8c0
NC		 1390 /* Find first '\0' in strings. */
1391 gnu_lto = (char *) memchr (gnu_lto + 1, '\0',
1392 strings + strsz - gnu_lto);
e9301e76
NC		 1393 /* Read the section index table if present. */
1394 if (symtab_indices_shndx[i - 1] != 0)
f8ad2513 1395 {
e9301e76
NC		 1396 unsigned char *sidxhdr = shdrs + (strtab - 1) * shdr_size;
1397 off_t sidxoff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1398 sidxhdr, sh_offset, Elf_Addr);
1399 size_t sidxsz = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1400 sidxhdr, sh_size, Elf_Addr);
1401 shndx_table = (unsigned *)XNEWVEC (char, sidxsz);
1402 simple_object_internal_read (sobj->descriptor,
1403 sobj->offset + sidxoff,
1404 (unsigned char *)shndx_table,
1405 sidxsz, &errmsg, err);
f8ad2513 1406 }
e9301e76 1407 for (ent = buf; ent < buf + length; ent += entsize)
f8ad2513 1408 {
e9301e76
NC		 1409 unsigned st_shndx = ELF_FETCH_FIELD (type_functions, ei_class,
1410 Sym, ent,
1411 st_shndx, Elf_Half);
1412 unsigned raw_st_shndx = st_shndx;
1413 unsigned char *st_info;
1414 unsigned char *st_other;
1415 int discard = 0;
1416 if (ei_class == ELFCLASS32)
f8ad2513 1417 {
e9301e76
NC		 1418 st_info = &((Elf32_External_Sym *)ent)->st_info;
1419 st_other = &((Elf32_External_Sym *)ent)->st_other;
1420 }
1421 else
1422 {
1423 st_info = &((Elf64_External_Sym *)ent)->st_info;
1424 st_other = &((Elf64_External_Sym *)ent)->st_other;
1425 }
1426 if (st_shndx == SHN_XINDEX)
1427 st_shndx = type_functions->fetch_Elf_Word
1428 ((unsigned char *)(shndx_table + (ent - buf) / entsize));
1429 /* Eliminate all COMMONs - this includes __gnu_lto_v1
1430 and __gnu_lto_slim which otherwise cause endless
1431 LTO plugin invocation. */
1432 if (st_shndx == SHN_COMMON)
1433 discard = 1;
1434 /* We also need to remove symbols refering to sections
1435 we'll eventually remove as with fat LTO objects
1436 we otherwise get duplicate symbols at final link
1437 (with GNU ld, gold is fine and ignores symbols in
1438 sections marked as EXCLUDE). ld/20513 */
1439 else if (st_shndx != SHN_UNDEF
1440 && st_shndx < shnum
1441 && pfnret[st_shndx - 1] == -1)
1442 discard = 1;
1443
1444 if (discard)
1445 {
1446 /* Make discarded symbols undefined and unnamed
1447 in case it is local. */
1448 int bind = ELF_ST_BIND (*st_info);
1449 int other = STV_DEFAULT;
1450 if (bind == STB_LOCAL)
f8ad2513 1451 {
e9301e76
NC		 1452 /* Make discarded local symbols unnamed and
1453 defined in the first prevailing section. */
1454 ELF_SET_FIELD (type_functions, ei_class, Sym,
1455 ent, st_name, Elf_Word, 0);
1456 ELF_SET_FIELD (type_functions, ei_class, Sym,
1457 ent, st_shndx, Elf_Half,
1458 sh_map[first_shndx]);
f8ad2513
NC		 1459 }
1460 else
1461 {
e9301e76
NC		 1462 /* Make discarded global symbols hidden weak
1463 undefined and sharing the gnu_lto_ name. */
1464 bind = STB_WEAK;
1465 other = STV_HIDDEN;
f211b8c0
NC		 1466 ELF_SET_FIELD (type_functions, ei_class, Sym,
1467 ent, st_name, Elf_Word,
1468 gnu_lto - strings);
f8ad2513 1469 ELF_SET_FIELD (type_functions, ei_class, Sym,
e9301e76 1470 ent, st_shndx, Elf_Half, SHN_UNDEF);
f8ad2513 1471 }
e9301e76
NC		 1472 *st_other = other;
1473 *st_info = ELF_ST_INFO (bind, STT_NOTYPE);
1474 ELF_SET_FIELD (type_functions, ei_class, Sym,
1475 ent, st_value, Elf_Addr, 0);
1476 ELF_SET_FIELD (type_functions, ei_class, Sym,
1477 ent, st_size, Elf_Word, 0);
f8ad2513 1478 }
e9301e76
NC		 1479 else if (raw_st_shndx < SHN_LORESERVE
1480 || raw_st_shndx == SHN_XINDEX)
1481 /* Remap the section reference. */
1482 ELF_SET_FIELD (type_functions, ei_class, Sym,
1483 ent, st_shndx, Elf_Half, sh_map[st_shndx]);
f8ad2513 1484 }
e9301e76
NC		 1485 XDELETEVEC (strings);
1486 XDELETEVEC (shndx_table);
1487 }
1488 else if (sh_type == SHT_GROUP)
1489 {
1490 /* Remap section indices in groups and remove removed members. */
1491 unsigned char *ent, *dst;
1492 for (dst = ent = buf + 4; ent < buf + length; ent += 4)
f8ad2513 1493 {
e9301e76
NC		 1494 unsigned shndx = type_functions->fetch_Elf_Word (ent);
1495 if (pfnret[shndx - 1] == -1)
1496 ;
1497 else
1498 {
1499 type_functions->set_Elf_Word (dst, sh_map[shndx]);
1500 dst += 4;
1501 }
f8ad2513 1502 }
e9301e76
NC		 1503 /* Adjust the length. */
1504 length = dst - buf;
f8ad2513 1505 }
e9301e76
NC		 1506
1507 errmsg = simple_object_write_add_data (dobj, dest,
1508 buf, length, 1, err);
1509 XDELETEVEC (buf);
1510 if (errmsg)
f8ad2513 1511 {
e9301e76
NC		 1512 XDELETEVEC (names);
1513 XDELETEVEC (shdrs);
1514 XDELETEVEC (symtab_indices_shndx);
1515 return errmsg;
f8ad2513
NC		 1516 }
1517
1518 flags = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1519 shdr, sh_flags, Elf_Addr);
e9301e76
NC		 1520 /* Remap the section references. */
1521 {
1522 unsigned int sh_info, sh_link;
1523 if (flags & SHF_INFO_LINK || sh_type == SHT_REL || sh_type == SHT_RELA)
1524 {
1525 sh_info = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1526 shdr, sh_info, Elf_Word);
1527 if (sh_info < SHN_LORESERVE
1528 || sh_info > SHN_HIRESERVE)
1529 sh_info = sh_map[sh_info];
1530 ELF_SET_FIELD (type_functions, ei_class, Shdr,
1531 shdr, sh_info, Elf_Word, sh_info);
1532 }
1533 sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
1534 shdr, sh_link, Elf_Word);
1535 if (sh_link < SHN_LORESERVE
1536 || sh_link > SHN_HIRESERVE)
1537 sh_link = sh_map[sh_link];
1538 ELF_SET_FIELD (type_functions, ei_class, Shdr,
1539 shdr, sh_link, Elf_Word, sh_link);
1540 }
1541 /* The debugobj doesn't contain any code, thus no trampolines.
1542 Even when the original object needs trampolines, debugobj
1543 doesn't. */
1544 if (strcmp (name, ".note.GNU-stack") == 0)
1545 flags &= ~SHF_EXECINSTR;
1546 /* Clear SHF_EXCLUDE on to be preserved sections. */
1547 flags &= ~SHF_EXCLUDE;
f8ad2513
NC		 1548 ELF_SET_FIELD (type_functions, ei_class, Shdr,
1549 shdr, sh_flags, Elf_Addr, flags);
1550 }
1551
1552 XDELETEVEC (names);
1553 XDELETEVEC (shdrs);
1554 XDELETEVEC (pfnret);
1555 XDELETEVEC (pfnname);
e9301e76
NC		 1556 XDELETEVEC (symtab_indices_shndx);
1557 XDELETEVEC (sh_map);
f8ad2513
NC		 1558
1559 return NULL;
1560}
1561
1562
ffa54e5c
DD		 1563/* The ELF functions. */
1564
1565const struct simple_object_functions simple_object_elf_functions =
1566{
1567 simple_object_elf_match,
1568 simple_object_elf_find_sections,
1569 simple_object_elf_fetch_attributes,
1570 simple_object_elf_release_read,
f9e6589d 1571 simple_object_elf_attributes_merge,
ffa54e5c
DD		 1572 simple_object_elf_release_attributes,
1573 simple_object_elf_start_write,
1574 simple_object_elf_write_to_file,
f8ad2513
NC		 1575 simple_object_elf_release_write,
1576 simple_object_elf_copy_lto_debug_sections
ffa54e5c 1577};
GDB Binutils - Deliverables
This page took 0.563468 seconds and 4 git commands to generate.