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