contrib/gcc-8.0/libiberty/simple-object-elf.c

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