libiberty/simple-object-elf.c

   1 /* simple-object-elf.c -- routines to manipulate ELF object files.
   2    Copyright (C) 2010-2017 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_LORESERVE   0xFF00          /* Begin range of reserved indices */
 126 #define SHN_XINDEX      0xFFFF          /* Section index is held elsewhere */
 127
 128 /* 32-bit ELF program header.  */
 129
 130 typedef struct {
 131   unsigned char p_type[4];              /* Identifies program segment type */
 132   unsigned char p_offset[4];            /* Segment file offset */
 133   unsigned char p_vaddr[4];             /* Segment virtual address */
 134   unsigned char p_paddr[4];             /* Segment physical address */
 135   unsigned char p_filesz[4];            /* Segment size in file */
 136   unsigned char p_memsz[4];             /* Segment size in memory */
 137   unsigned char p_flags[4];             /* Segment flags */
 138   unsigned char p_align[4];             /* Segment alignment, file & memory */
 139 } Elf32_External_Phdr;
 140
 141 /* 64-bit ELF program header.  */
 142
 143 typedef struct {
 144   unsigned char p_type[4];              /* Identifies program segment type */
 145   unsigned char p_flags[4];             /* Segment flags */
 146   unsigned char p_offset[8];            /* Segment file offset */
 147   unsigned char p_vaddr[8];             /* Segment virtual address */
 148   unsigned char p_paddr[8];             /* Segment physical address */
 149   unsigned char p_filesz[8];            /* Segment size in file */
 150   unsigned char p_memsz[8];             /* Segment size in memory */
 151   unsigned char p_align[8];             /* Segment alignment, file & memory */
 152 } Elf64_External_Phdr;
 153
 154 /* 32-bit ELF section header */
 155
 156 typedef struct {
 157   unsigned char sh_name[4];             /* Section name, index in string tbl */
 158   unsigned char sh_type[4];             /* Type of section */
 159   unsigned char sh_flags[4];            /* Miscellaneous section attributes */
 160   unsigned char sh_addr[4];             /* Section virtual addr at execution */
 161   unsigned char sh_offset[4];           /* Section file offset */
 162   unsigned char sh_size[4];             /* Size of section in bytes */
 163   unsigned char sh_link[4];             /* Index of another section */
 164   unsigned char sh_info[4];             /* Additional section information */
 165   unsigned char sh_addralign[4];        /* Section alignment */
 166   unsigned char sh_entsize[4];          /* Entry size if section holds table */
 167 } Elf32_External_Shdr;
 168
 169 /* 64-bit ELF section header.  */
 170
 171 typedef struct {
 172   unsigned char sh_name[4];             /* Section name, index in string tbl */
 173   unsigned char sh_type[4];             /* Type of section */
 174   unsigned char sh_flags[8];            /* Miscellaneous section attributes */
 175   unsigned char sh_addr[8];             /* Section virtual addr at execution */
 176   unsigned char sh_offset[8];           /* Section file offset */
 177   unsigned char sh_size[8];             /* Size of section in bytes */
 178   unsigned char sh_link[4];             /* Index of another section */
 179   unsigned char sh_info[4];             /* Additional section information */
 180   unsigned char sh_addralign[8];        /* Section alignment */
 181   unsigned char sh_entsize[8];          /* Entry size if section holds table */
 182 } Elf64_External_Shdr;
 183
 184 /* Values for sh_type field.  */
 185
 186 #define SHT_PROGBITS    1               /* Program data */
 187 #define SHT_STRTAB      3               /* A string table */
 188
 189 /* Functions to fetch and store different ELF types, depending on the
 190    endianness and size.  */
 191
 192 struct elf_type_functions
 193 {
 194   unsigned short (*fetch_Elf_Half) (const unsigned char *);
 195   unsigned int (*fetch_Elf_Word) (const unsigned char *);
 196   ulong_type (*fetch_Elf_Addr) (const unsigned char *);
 197   void (*set_Elf_Half) (unsigned char *, unsigned short);
 198   void (*set_Elf_Word) (unsigned char *, unsigned int);
 199   void (*set_Elf_Addr) (unsigned char *, ulong_type);
 200 };
 201
 202 static const struct elf_type_functions elf_big_32_functions =
 203 {
 204   simple_object_fetch_big_16,
 205   simple_object_fetch_big_32,
 206   simple_object_fetch_big_32_ulong,
 207   simple_object_set_big_16,
 208   simple_object_set_big_32,
 209   simple_object_set_big_32_ulong
 210 };
 211
 212 static const struct elf_type_functions elf_little_32_functions =
 213 {
 214   simple_object_fetch_little_16,
 215   simple_object_fetch_little_32,
 216   simple_object_fetch_little_32_ulong,
 217   simple_object_set_little_16,
 218   simple_object_set_little_32,
 219   simple_object_set_little_32_ulong
 220 };
 221
 222 #ifdef UNSIGNED_64BIT_TYPE
 223
 224 static const struct elf_type_functions elf_big_64_functions =
 225 {
 226   simple_object_fetch_big_16,
 227   simple_object_fetch_big_32,
 228   simple_object_fetch_big_64,
 229   simple_object_set_big_16,
 230   simple_object_set_big_32,
 231   simple_object_set_big_64
 232 };
 233
 234 static const struct elf_type_functions elf_little_64_functions =
 235 {
 236   simple_object_fetch_little_16,
 237   simple_object_fetch_little_32,
 238   simple_object_fetch_little_64,
 239   simple_object_set_little_16,
 240   simple_object_set_little_32,
 241   simple_object_set_little_64
 242 };
 243
 244 #endif
 245
 246 /* Hideous macro to fetch the value of a field from an external ELF
 247    struct of some sort.  TYPEFUNCS is the set of type functions.
 248    BUFFER points to the external data.  STRUCTTYPE is the appropriate
 249    struct type.  FIELD is a field within the struct.  TYPE is the type
 250    of the field in the struct: Elf_Half, Elf_Word, or Elf_Addr.  */
 251
 252 #define ELF_FETCH_STRUCT_FIELD(TYPEFUNCS, STRUCTTYPE, FIELD, BUFFER, TYPE) \
 253   ((TYPEFUNCS)->fetch_ ## TYPE ((BUFFER) + offsetof (STRUCTTYPE, FIELD)))
 254
 255 /* Even more hideous macro to fetch the value of FIELD from BUFFER.
 256    SIZE is 32 or 64.  STRUCTTYPE is the name of the struct from
 257    elf/external.h: Ehdr, Shdr, etc.  FIELD is the name of a field in
 258    the struct.  TYPE is the type of the field in the struct: Elf_Half,
 259    Elf_Word, or Elf_Addr.  */
 260
 261 #define ELF_FETCH_SIZED_FIELD(TYPEFUNCS, SIZE, STRUCTTYPE, BUFFER,      \
 262                               FIELD, TYPE)                              \
 263   ELF_FETCH_STRUCT_FIELD (TYPEFUNCS,                                    \
 264                           Elf ## SIZE ## _External_ ## STRUCTTYPE,      \
 265                           FIELD, BUFFER, TYPE)
 266
 267 /* Like ELF_FETCH_SIZED_FIELD but taking an ELFCLASS value.  */
 268
 269 #define ELF_FETCH_FIELD(TYPEFUNCS, CLASS, STRUCTTYPE, BUFFER,           \
 270                         FIELD, TYPE)                                    \
 271   ((CLASS) == ELFCLASS32                                                \
 272     ? ELF_FETCH_SIZED_FIELD (TYPEFUNCS, 32, STRUCTTYPE, BUFFER, FIELD,  \
 273                              TYPE)                                      \
 274     : ELF_FETCH_SIZED_FIELD (TYPEFUNCS, 64, STRUCTTYPE, BUFFER, FIELD,  \
 275                              TYPE))
 276
 277 /* Hideous macro to set the value of a field in an external ELF
 278    structure to VAL.  TYPEFUNCS is the set of type functions.  BUFFER
 279    points to the external data.  STRUCTTYPE is the appropriate
 280    structure type.  FIELD is a field within the struct.  TYPE is the
 281    type of the field in the struct: Elf_Half, Elf_Word, or
 282    Elf_Addr.  */
 283
 284 #define ELF_SET_STRUCT_FIELD(TYPEFUNCS, STRUCTTYPE, FIELD, BUFFER, TYPE, VAL) \
 285   (TYPEFUNCS)->set_ ## TYPE ((BUFFER) + offsetof (STRUCTTYPE, FIELD), (VAL))
 286
 287 /* Even more hideous macro to set the value of FIELD in BUFFER to VAL.
 288    SIZE is 32 or 64.  STRUCTTYPE is the name of the struct from
 289    elf/external.h: Ehdr, Shdr, etc.  FIELD is the name of a field in
 290    the struct.  TYPE is the type of the field in the struct: Elf_Half,
 291    Elf_Word, or Elf_Addr.  */
 292
 293 #define ELF_SET_SIZED_FIELD(TYPEFUNCS, SIZE, STRUCTTYPE, BUFFER, FIELD, \
 294                             TYPE, VAL)                                  \
 295   ELF_SET_STRUCT_FIELD (TYPEFUNCS,                                      \
 296                         Elf ## SIZE ## _External_ ## STRUCTTYPE,        \
 297                         FIELD, BUFFER, TYPE, VAL)
 298
 299 /* Like ELF_SET_SIZED_FIELD but taking an ELFCLASS value.  */
 300
 301 #define ELF_SET_FIELD(TYPEFUNCS, CLASS, STRUCTTYPE, BUFFER, FIELD,      \
 302                       TYPE, VAL)                                        \
 303   ((CLASS) == ELFCLASS32                                                \
 304     ? ELF_SET_SIZED_FIELD (TYPEFUNCS, 32, STRUCTTYPE, BUFFER, FIELD,    \
 305                            TYPE, VAL)                                   \
 306     : ELF_SET_SIZED_FIELD (TYPEFUNCS, 64, STRUCTTYPE, BUFFER, FIELD,    \
 307                            TYPE, VAL))
 308
 309 /* Private data for an simple_object_read.  */
 310
 311 struct simple_object_elf_read
 312 {
 313   /* Type functions.  */
 314   const struct elf_type_functions* type_functions;
 315   /* Elf data.  */
 316   unsigned char ei_data;
 317   /* Elf class.  */
 318   unsigned char ei_class;
 319   /* ELF OS ABI.  */
 320   unsigned char ei_osabi;
 321   /* Elf machine number.  */
 322   unsigned short machine;
 323   /* Processor specific flags.  */
 324   unsigned int flags;
 325   /* File offset of section headers.  */
 326   ulong_type shoff;
 327   /* Number of sections.  */
 328   unsigned int shnum;
 329   /* Index of string table section header.  */
 330   unsigned int shstrndx;
 331 };
 332
 333 /* Private data for an simple_object_attributes.  */
 334
 335 struct simple_object_elf_attributes
 336 {
 337   /* Type functions.  */
 338   const struct elf_type_functions* type_functions;
 339   /* Elf data.  */
 340   unsigned char ei_data;
 341   /* Elf class.  */
 342   unsigned char ei_class;
 343   /* ELF OS ABI.  */
 344   unsigned char ei_osabi;
 345   /* Elf machine number.  */
 346   unsigned short machine;
 347   /* Processor specific flags.  */
 348   unsigned int flags;
 349 };
 350
 351 /* See if we have an ELF file.  */
 352
 353 static void *
 354 simple_object_elf_match (unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN],
 355                          int descriptor, off_t offset,
 356                          const char *segment_name ATTRIBUTE_UNUSED,
 357                          const char **errmsg, int *err)
 358 {
 359   unsigned char ei_data;
 360   unsigned char ei_class;
 361   const struct elf_type_functions *type_functions;
 362   unsigned char ehdr[sizeof (Elf64_External_Ehdr)];
 363   struct simple_object_elf_read *eor;
 364
 365   if (header[EI_MAG0] != ELFMAG0
 366       || header[EI_MAG1] != ELFMAG1
 367       || header[EI_MAG2] != ELFMAG2
 368       || header[EI_MAG3] != ELFMAG3
 369       || header[EI_VERSION] != EV_CURRENT)
 370     {
 371       *errmsg = NULL;
 372       *err = 0;
 373       return NULL;
 374     }
 375
 376   ei_data = header[EI_DATA];
 377   if (ei_data != ELFDATA2LSB && ei_data != ELFDATA2MSB)
 378     {
 379       *errmsg = "unknown ELF endianness";
 380       *err = 0;
 381       return NULL;
 382     }
 383
 384   ei_class = header[EI_CLASS];
 385   switch (ei_class)
 386     {
 387     case ELFCLASS32:
 388       type_functions = (ei_data == ELFDATA2LSB
 389                         ? &elf_little_32_functions
 390                         : &elf_big_32_functions);
 391       break;
 392
 393     case ELFCLASS64:
 394 #ifndef UNSIGNED_64BIT_TYPE
 395       *errmsg = "64-bit ELF objects not supported";
 396       *err = 0;
 397       return NULL;
 398 #else
 399       type_functions = (ei_data == ELFDATA2LSB
 400                         ? &elf_little_64_functions
 401                         : &elf_big_64_functions);
 402       break;
 403 #endif
 404
 405     default:
 406       *errmsg = "unrecognized ELF size";
 407       *err = 0;
 408       return NULL;
 409     }
 410
 411   if (!simple_object_internal_read (descriptor, offset, ehdr, sizeof ehdr,
 412                                     errmsg, err))
 413     return NULL;
 414
 415   eor = XNEW (struct simple_object_elf_read);
 416   eor->type_functions = type_functions;
 417   eor->ei_data = ei_data;
 418   eor->ei_class = ei_class;
 419   eor->ei_osabi = header[EI_OSABI];
 420   eor->machine = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
 421                                   e_machine, Elf_Half);
 422   eor->flags = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
 423                                 e_flags, Elf_Word);
 424   eor->shoff = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
 425                                 e_shoff, Elf_Addr);
 426   eor->shnum = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
 427                                 e_shnum, Elf_Half);
 428   eor->shstrndx = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
 429                                    e_shstrndx, Elf_Half);
 430
 431   if ((eor->shnum == 0 || eor->shstrndx == SHN_XINDEX)
 432       && eor->shoff != 0)
 433     {
 434       unsigned char shdr[sizeof (Elf64_External_Shdr)];
 435
 436       /* Object file has more than 0xffff sections.  */
 437
 438       if (!simple_object_internal_read (descriptor, offset + eor->shoff, shdr,
 439                                         (ei_class == ELFCLASS32
 440                                          ? sizeof (Elf32_External_Shdr)
 441                                          : sizeof (Elf64_External_Shdr)),
 442                                         errmsg, err))
 443         {
 444           XDELETE (eor);
 445           return NULL;
 446         }
 447
 448       if (eor->shnum == 0)
 449         eor->shnum = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
 450                                       shdr, sh_size, Elf_Addr);
 451
 452       if (eor->shstrndx == SHN_XINDEX)
 453         {
 454           eor->shstrndx = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
 455                                            shdr, sh_link, Elf_Word);
 456
 457           /* Versions of the GNU binutils between 2.12 and 2.18 did
 458              not handle objects with more than SHN_LORESERVE sections
 459              correctly.  All large section indexes were offset by
 460              0x100.  There is more information at
 461              http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
 462              Fortunately these object files are easy to detect, as the
 463              GNU binutils always put the section header string table
 464              near the end of the list of sections.  Thus if the
 465              section header string table index is larger than the
 466              number of sections, then we know we have to subtract
 467              0x100 to get the real section index.  */
 468           if (eor->shstrndx >= eor->shnum
 469               && eor->shstrndx >= SHN_LORESERVE + 0x100)
 470             eor->shstrndx -= 0x100;
 471         }
 472     }
 473
 474   if (eor->shstrndx >= eor->shnum)
 475     {
 476       *errmsg = "invalid ELF shstrndx >= shnum";
 477       *err = 0;
 478       XDELETE (eor);
 479       return NULL;
 480     }
 481
 482   return (void *) eor;
 483 }
 484
 485 /* Find all sections in an ELF file.  */
 486
 487 static const char *
 488 simple_object_elf_find_sections (simple_object_read *sobj,
 489                                  int (*pfn) (void *, const char *,
 490                                              off_t offset, off_t length),
 491                                  void *data,
 492                                  int *err)
 493 {
 494   struct simple_object_elf_read *eor =
 495     (struct simple_object_elf_read *) sobj->data;
 496   const struct elf_type_functions *type_functions = eor->type_functions;
 497   unsigned char ei_class = eor->ei_class;
 498   size_t shdr_size;
 499   unsigned int shnum;
 500   unsigned char *shdrs;
 501   const char *errmsg;
 502   unsigned char *shstrhdr;
 503   size_t name_size;
 504   off_t shstroff;
 505   unsigned char *names;
 506   unsigned int i;
 507
 508   shdr_size = (ei_class == ELFCLASS32
 509                ? sizeof (Elf32_External_Shdr)
 510                : sizeof (Elf64_External_Shdr));
 511
 512   /* Read the section headers.  We skip section 0, which is not a
 513      useful section.  */
 514
 515   shnum = eor->shnum;
 516   shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
 517
 518   if (!simple_object_internal_read (sobj->descriptor,
 519                                     sobj->offset + eor->shoff + shdr_size,
 520                                     shdrs,
 521                                     shdr_size * (shnum - 1),
 522                                     &errmsg, err))
 523     {
 524       XDELETEVEC (shdrs);
 525       return errmsg;
 526     }
 527
 528   /* Read the section names.  */
 529
 530   shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
 531   name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
 532                                shstrhdr, sh_size, Elf_Addr);
 533   shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
 534                               shstrhdr, sh_offset, Elf_Addr);
 535   names = XNEWVEC (unsigned char, name_size);
 536   if (!simple_object_internal_read (sobj->descriptor,
 537                                     sobj->offset + shstroff,
 538                                     names, name_size, &errmsg, err))
 539     {
 540       XDELETEVEC (names);
 541       XDELETEVEC (shdrs);
 542       return errmsg;
 543     }
 544
 545   for (i = 1; i < shnum; ++i)
 546     {
 547       unsigned char *shdr;
 548       unsigned int sh_name;
 549       const char *name;
 550       off_t offset;
 551       off_t length;
 552
 553       shdr = shdrs + (i - 1) * shdr_size;
 554       sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
 555                                  shdr, sh_name, Elf_Word);
 556       if (sh_name >= name_size)
 557         {
 558           *err = 0;
 559           XDELETEVEC (names);
 560           XDELETEVEC (shdrs);
 561           return "ELF section name out of range";
 562         }
 563
 564       name = (const char *) names + sh_name;
 565       offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
 566                                 shdr, sh_offset, Elf_Addr);
 567       length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
 568                                 shdr, sh_size, Elf_Addr);
 569
 570       if (!(*pfn) (data, name, offset, length))
 571         break;
 572     }
 573
 574   XDELETEVEC (names);
 575   XDELETEVEC (shdrs);
 576
 577   return NULL;
 578 }
 579
 580 /* Fetch the attributes for an simple_object_read.  */
 581
 582 static void *
 583 simple_object_elf_fetch_attributes (simple_object_read *sobj,
 584                                     const char **errmsg ATTRIBUTE_UNUSED,
 585                                     int *err ATTRIBUTE_UNUSED)
 586 {
 587   struct simple_object_elf_read *eor =
 588     (struct simple_object_elf_read *) sobj->data;
 589   struct simple_object_elf_attributes *ret;
 590
 591   ret = XNEW (struct simple_object_elf_attributes);
 592   ret->type_functions = eor->type_functions;
 593   ret->ei_data = eor->ei_data;
 594   ret->ei_class = eor->ei_class;
 595   ret->ei_osabi = eor->ei_osabi;
 596   ret->machine = eor->machine;
 597   ret->flags = eor->flags;
 598   return ret;
 599 }
 600
 601 /* Release the privata data for an simple_object_read.  */
 602
 603 static void
 604 simple_object_elf_release_read (void *data)
 605 {
 606   XDELETE (data);
 607 }
 608
 609 /* Compare two attributes structures.  */
 610
 611 static const char *
 612 simple_object_elf_attributes_merge (void *todata, void *fromdata, int *err)
 613 {
 614   struct simple_object_elf_attributes *to =
 615     (struct simple_object_elf_attributes *) todata;
 616   struct simple_object_elf_attributes *from =
 617     (struct simple_object_elf_attributes *) fromdata;
 618
 619   if (to->ei_data != from->ei_data || to->ei_class != from->ei_class)
 620     {
 621       *err = 0;
 622       return "ELF object format mismatch";
 623     }
 624
 625   if (to->machine != from->machine)
 626     {
 627       int ok;
 628
 629       /* EM_SPARC and EM_SPARC32PLUS are compatible and force an
 630          output of EM_SPARC32PLUS.  */
 631       ok = 0;
 632       switch (to->machine)
 633         {
 634         case EM_SPARC:
 635           if (from->machine == EM_SPARC32PLUS)
 636             {
 637               to->machine = from->machine;
 638               ok = 1;
 639             }
 640           break;
 641
 642         case EM_SPARC32PLUS:
 643           if (from->machine == EM_SPARC)
 644             ok = 1;
 645           break;
 646
 647         default:
 648           break;
 649         }
 650
 651       if (!ok)
 652         {
 653           *err = 0;
 654           return "ELF machine number mismatch";
 655         }
 656     }
 657
 658   return NULL;
 659 }
 660
 661 /* Release the private data for an attributes structure.  */
 662
 663 static void
 664 simple_object_elf_release_attributes (void *data)
 665 {
 666   XDELETE (data);
 667 }
 668
 669 /* Prepare to write out a file.  */
 670
 671 static void *
 672 simple_object_elf_start_write (void *attributes_data,
 673                                const char **errmsg ATTRIBUTE_UNUSED,
 674                                int *err ATTRIBUTE_UNUSED)
 675 {
 676   struct simple_object_elf_attributes *attrs =
 677     (struct simple_object_elf_attributes *) attributes_data;
 678   struct simple_object_elf_attributes *ret;
 679
 680   /* We're just going to record the attributes, but we need to make a
 681      copy because the user may delete them.  */
 682   ret = XNEW (struct simple_object_elf_attributes);
 683   *ret = *attrs;
 684   return ret;
 685 }
 686
 687 /* Write out an ELF ehdr.  */
 688
 689 static int
 690 simple_object_elf_write_ehdr (simple_object_write *sobj, int descriptor,
 691                               const char **errmsg, int *err)
 692 {
 693   struct simple_object_elf_attributes *attrs =
 694     (struct simple_object_elf_attributes *) sobj->data;
 695   const struct elf_type_functions* fns;
 696   unsigned char cl;
 697   size_t ehdr_size;
 698   unsigned char buf[sizeof (Elf64_External_Ehdr)];
 699   simple_object_write_section *section;
 700   unsigned int shnum;
 701   unsigned int shstrndx;
 702
 703   fns = attrs->type_functions;
 704   cl = attrs->ei_class;
 705
 706   shnum = 0;
 707   for (section = sobj->sections; section != NULL; section = section->next)
 708     ++shnum;
 709   if (shnum > 0)
 710     {
 711       /* Add a section header for the dummy section and one for
 712          .shstrtab.  */
 713       shnum += 2;
 714     }
 715
 716   ehdr_size = (cl == ELFCLASS32
 717                ? sizeof (Elf32_External_Ehdr)
 718                : sizeof (Elf64_External_Ehdr));
 719   memset (buf, 0, sizeof (Elf64_External_Ehdr));
 720
 721   buf[EI_MAG0] = ELFMAG0;
 722   buf[EI_MAG1] = ELFMAG1;
 723   buf[EI_MAG2] = ELFMAG2;
 724   buf[EI_MAG3] = ELFMAG3;
 725   buf[EI_CLASS] = cl;
 726   buf[EI_DATA] = attrs->ei_data;
 727   buf[EI_VERSION] = EV_CURRENT;
 728   buf[EI_OSABI] = attrs->ei_osabi;
 729
 730   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_type, Elf_Half, ET_REL);
 731   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_machine, Elf_Half, attrs->machine);
 732   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_version, Elf_Word, EV_CURRENT);
 733   /* e_entry left as zero.  */
 734   /* e_phoff left as zero.  */
 735   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shoff, Elf_Addr, ehdr_size);
 736   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_flags, Elf_Word, attrs->flags);
 737   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_ehsize, Elf_Half, ehdr_size);
 738   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_phentsize, Elf_Half,
 739                  (cl == ELFCLASS32
 740                   ? sizeof (Elf32_External_Phdr)
 741                   : sizeof (Elf64_External_Phdr)));
 742   /* e_phnum left as zero.  */
 743   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shentsize, Elf_Half,
 744                  (cl == ELFCLASS32
 745                   ? sizeof (Elf32_External_Shdr)
 746                   : sizeof (Elf64_External_Shdr)));
 747   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shnum, Elf_Half,
 748                  shnum >= SHN_LORESERVE ? 0 : shnum);
 749   if (shnum == 0)
 750     shstrndx = 0;
 751   else
 752     {
 753       shstrndx = shnum - 1;
 754       if (shstrndx >= SHN_LORESERVE)
 755         shstrndx = SHN_XINDEX;
 756     }
 757   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shstrndx, Elf_Half, shstrndx);
 758
 759   return simple_object_internal_write (descriptor, 0, buf, ehdr_size,
 760                                        errmsg, err);
 761 }
 762
 763 /* Write out an ELF shdr.  */
 764
 765 static int
 766 simple_object_elf_write_shdr (simple_object_write *sobj, int descriptor,
 767                               off_t offset, unsigned int sh_name,
 768                               unsigned int sh_type, unsigned int sh_flags,
 769                               unsigned int sh_offset, unsigned int sh_size,
 770                               unsigned int sh_link, unsigned int sh_addralign,
 771                               const char **errmsg, int *err)
 772 {
 773   struct simple_object_elf_attributes *attrs =
 774     (struct simple_object_elf_attributes *) sobj->data;
 775   const struct elf_type_functions* fns;
 776   unsigned char cl;
 777   size_t shdr_size;
 778   unsigned char buf[sizeof (Elf64_External_Shdr)];
 779
 780   fns = attrs->type_functions;
 781   cl = attrs->ei_class;
 782
 783   shdr_size = (cl == ELFCLASS32
 784                ? sizeof (Elf32_External_Shdr)
 785                : sizeof (Elf64_External_Shdr));
 786   memset (buf, 0, sizeof (Elf64_External_Shdr));
 787
 788   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_name, Elf_Word, sh_name);
 789   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_type, Elf_Word, sh_type);
 790   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_flags, Elf_Addr, sh_flags);
 791   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_offset, Elf_Addr, sh_offset);
 792   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_size, Elf_Addr, sh_size);
 793   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_link, Elf_Word, sh_link);
 794   /* sh_info left as zero.  */
 795   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addralign, Elf_Addr, sh_addralign);
 796   /* sh_entsize left as zero.  */
 797
 798   return simple_object_internal_write (descriptor, offset, buf, shdr_size,
 799                                        errmsg, err);
 800 }
 801
 802 /* Write out a complete ELF file.
 803    Ehdr
 804    initial dummy Shdr
 805    user-created Shdrs
 806    .shstrtab Shdr
 807    user-created section data
 808    .shstrtab data  */
 809
 810 static const char *
 811 simple_object_elf_write_to_file (simple_object_write *sobj, int descriptor,
 812                                  int *err)
 813 {
 814   struct simple_object_elf_attributes *attrs =
 815     (struct simple_object_elf_attributes *) sobj->data;
 816   unsigned char cl;
 817   size_t ehdr_size;
 818   size_t shdr_size;
 819   const char *errmsg;
 820   simple_object_write_section *section;
 821   unsigned int shnum;
 822   size_t shdr_offset;
 823   size_t sh_offset;
 824   unsigned int first_sh_size;
 825   unsigned int first_sh_link;
 826   size_t sh_name;
 827   unsigned char zero;
 828
 829   if (!simple_object_elf_write_ehdr (sobj, descriptor, &errmsg, err))
 830     return errmsg;
 831
 832   cl = attrs->ei_class;
 833   if (cl == ELFCLASS32)
 834     {
 835       ehdr_size = sizeof (Elf32_External_Ehdr);
 836       shdr_size = sizeof (Elf32_External_Shdr);
 837     }
 838   else
 839     {
 840       ehdr_size = sizeof (Elf64_External_Ehdr);
 841       shdr_size = sizeof (Elf64_External_Shdr);
 842     }
 843
 844   shnum = 0;
 845   for (section = sobj->sections; section != NULL; section = section->next)
 846     ++shnum;
 847   if (shnum == 0)
 848     return NULL;
 849
 850   /* Add initial dummy Shdr and .shstrtab.  */
 851   shnum += 2;
 852
 853   shdr_offset = ehdr_size;
 854   sh_offset = shdr_offset + shnum * shdr_size;
 855
 856   if (shnum < SHN_LORESERVE)
 857     first_sh_size = 0;
 858   else
 859     first_sh_size = shnum;
 860   if (shnum - 1 < SHN_LORESERVE)
 861     first_sh_link = 0;
 862   else
 863     first_sh_link = shnum - 1;
 864   if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
 865                                      0, 0, 0, 0, first_sh_size, first_sh_link,
 866                                      0, &errmsg, err))
 867     return errmsg;
 868
 869   shdr_offset += shdr_size;
 870
 871   sh_name = 1;
 872   for (section = sobj->sections; section != NULL; section = section->next)
 873     {
 874       size_t mask;
 875       size_t new_sh_offset;
 876       size_t sh_size;
 877       struct simple_object_write_section_buffer *buffer;
 878
 879       mask = (1U << section->align) - 1;
 880       new_sh_offset = sh_offset + mask;
 881       new_sh_offset &= ~ mask;
 882       while (new_sh_offset > sh_offset)
 883         {
 884           unsigned char zeroes[16];
 885           size_t write;
 886
 887           memset (zeroes, 0, sizeof zeroes);
 888           write = new_sh_offset - sh_offset;
 889           if (write > sizeof zeroes)
 890             write = sizeof zeroes;
 891           if (!simple_object_internal_write (descriptor, sh_offset, zeroes,
 892                                              write, &errmsg, err))
 893             return errmsg;
 894           sh_offset += write;
 895         }
 896
 897       sh_size = 0;
 898       for (buffer = section->buffers; buffer != NULL; buffer = buffer->next)
 899         {
 900           if (!simple_object_internal_write (descriptor, sh_offset + sh_size,
 901                                              ((const unsigned char *)
 902                                               buffer->buffer),
 903                                              buffer->size, &errmsg, err))
 904             return errmsg;
 905           sh_size += buffer->size;
 906         }
 907
 908       if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
 909                                          sh_name, SHT_PROGBITS, 0, sh_offset,
 910                                          sh_size, 0, 1U << section->align,
 911                                          &errmsg, err))
 912         return errmsg;
 913
 914       shdr_offset += shdr_size;
 915       sh_name += strlen (section->name) + 1;
 916       sh_offset += sh_size;
 917     }
 918
 919   if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
 920                                      sh_name, SHT_STRTAB, 0, sh_offset,
 921                                      sh_name + strlen (".shstrtab") + 1, 0,
 922                                      1, &errmsg, err))
 923     return errmsg;
 924
 925   /* .shstrtab has a leading zero byte.  */
 926   zero = 0;
 927   if (!simple_object_internal_write (descriptor, sh_offset, &zero, 1,
 928                                      &errmsg, err))
 929     return errmsg;
 930   ++sh_offset;
 931
 932   for (section = sobj->sections; section != NULL; section = section->next)
 933     {
 934       size_t len;
 935
 936       len = strlen (section->name) + 1;
 937       if (!simple_object_internal_write (descriptor, sh_offset,
 938                                          (const unsigned char *) section->name,
 939                                          len, &errmsg, err))
 940         return errmsg;
 941       sh_offset += len;
 942     }
 943
 944   if (!simple_object_internal_write (descriptor, sh_offset,
 945                                      (const unsigned char *) ".shstrtab",
 946                                      strlen (".shstrtab") + 1, &errmsg, err))
 947     return errmsg;
 948
 949   return NULL;
 950 }
 951
 952 /* Release the private data for an simple_object_write structure.  */
 953
 954 static void
 955 simple_object_elf_release_write (void *data)
 956 {
 957   XDELETE (data);
 958 }
 959
 960 /* The ELF functions.  */
 961
 962 const struct simple_object_functions simple_object_elf_functions =
 963 {
 964   simple_object_elf_match,
 965   simple_object_elf_find_sections,
 966   simple_object_elf_fetch_attributes,
 967   simple_object_elf_release_read,
 968   simple_object_elf_attributes_merge,
 969   simple_object_elf_release_attributes,
 970   simple_object_elf_start_write,
 971   simple_object_elf_write_to_file,
 972   simple_object_elf_release_write
 973 };