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