libiberty/simple-object-elf.c

   1 /* simple-object-elf.c -- routines to manipulate ELF object files.
   2    Copyright 2010 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
 702   fns = attrs->type_functions;
 703   cl = attrs->ei_class;
 704
 705   shnum = 0;
 706   for (section = sobj->sections; section != NULL; section = section->next)
 707     ++shnum;
 708   if (shnum > 0)
 709     {
 710       /* Add a section header for the dummy section and one for
 711          .shstrtab.  */
 712       shnum += 2;
 713     }
 714
 715   ehdr_size = (cl == ELFCLASS32
 716                ? sizeof (Elf32_External_Ehdr)
 717                : sizeof (Elf64_External_Ehdr));
 718   memset (buf, 0, sizeof (Elf64_External_Ehdr));
 719
 720   buf[EI_MAG0] = ELFMAG0;
 721   buf[EI_MAG1] = ELFMAG1;
 722   buf[EI_MAG2] = ELFMAG2;
 723   buf[EI_MAG3] = ELFMAG3;
 724   buf[EI_CLASS] = cl;
 725   buf[EI_DATA] = attrs->ei_data;
 726   buf[EI_VERSION] = EV_CURRENT;
 727   buf[EI_OSABI] = attrs->ei_osabi;
 728
 729   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_type, Elf_Half, ET_REL);
 730   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_machine, Elf_Half, attrs->machine);
 731   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_version, Elf_Word, EV_CURRENT);
 732   /* e_entry left as zero.  */
 733   /* e_phoff left as zero.  */
 734   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shoff, Elf_Addr, ehdr_size);
 735   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_flags, Elf_Word, attrs->flags);
 736   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_ehsize, Elf_Half, ehdr_size);
 737   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_phentsize, Elf_Half,
 738                  (cl == ELFCLASS32
 739                   ? sizeof (Elf32_External_Phdr)
 740                   : sizeof (Elf64_External_Phdr)));
 741   /* e_phnum left as zero.  */
 742   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shentsize, Elf_Half,
 743                  (cl == ELFCLASS32
 744                   ? sizeof (Elf32_External_Shdr)
 745                   : sizeof (Elf64_External_Shdr)));
 746   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shnum, Elf_Half, shnum);
 747   ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shstrndx, Elf_Half,
 748                  shnum == 0 ? 0 : shnum - 1);
 749
 750   return simple_object_internal_write (descriptor, 0, buf, ehdr_size,
 751                                        errmsg, err);
 752 }
 753
 754 /* Write out an ELF shdr.  */
 755
 756 static int
 757 simple_object_elf_write_shdr (simple_object_write *sobj, int descriptor,
 758                               off_t offset, unsigned int sh_name,
 759                               unsigned int sh_type, unsigned int sh_flags,
 760                               unsigned int sh_offset, unsigned int sh_size,
 761                               unsigned int sh_addralign, const char **errmsg,
 762                               int *err)
 763 {
 764   struct simple_object_elf_attributes *attrs =
 765     (struct simple_object_elf_attributes *) sobj->data;
 766   const struct elf_type_functions* fns;
 767   unsigned char cl;
 768   size_t shdr_size;
 769   unsigned char buf[sizeof (Elf64_External_Shdr)];
 770
 771   fns = attrs->type_functions;
 772   cl = attrs->ei_class;
 773
 774   shdr_size = (cl == ELFCLASS32
 775                ? sizeof (Elf32_External_Shdr)
 776                : sizeof (Elf64_External_Shdr));
 777   memset (buf, 0, sizeof (Elf64_External_Shdr));
 778
 779   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_name, Elf_Word, sh_name);
 780   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_type, Elf_Word, sh_type);
 781   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_flags, Elf_Addr, sh_flags);
 782   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_offset, Elf_Addr, sh_offset);
 783   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_size, Elf_Addr, sh_size);
 784   /* sh_link left as zero.  */
 785   /* sh_info left as zero.  */
 786   ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addralign, Elf_Addr, sh_addralign);
 787   /* sh_entsize left as zero.  */
 788
 789   return simple_object_internal_write (descriptor, offset, buf, shdr_size,
 790                                        errmsg, err);
 791 }
 792
 793 /* Write out a complete ELF file.
 794    Ehdr
 795    initial dummy Shdr
 796    user-created Shdrs
 797    .shstrtab Shdr
 798    user-created section data
 799    .shstrtab data  */
 800
 801 static const char *
 802 simple_object_elf_write_to_file (simple_object_write *sobj, int descriptor,
 803                                  int *err)
 804 {
 805   struct simple_object_elf_attributes *attrs =
 806     (struct simple_object_elf_attributes *) sobj->data;
 807   unsigned char cl;
 808   size_t ehdr_size;
 809   size_t shdr_size;
 810   const char *errmsg;
 811   simple_object_write_section *section;
 812   unsigned int shnum;
 813   size_t shdr_offset;
 814   size_t sh_offset;
 815   size_t sh_name;
 816   unsigned char zero;
 817
 818   if (!simple_object_elf_write_ehdr (sobj, descriptor, &errmsg, err))
 819     return errmsg;
 820
 821   cl = attrs->ei_class;
 822   if (cl == ELFCLASS32)
 823     {
 824       ehdr_size = sizeof (Elf32_External_Ehdr);
 825       shdr_size = sizeof (Elf32_External_Shdr);
 826     }
 827   else
 828     {
 829       ehdr_size = sizeof (Elf64_External_Ehdr);
 830       shdr_size = sizeof (Elf64_External_Shdr);
 831     }
 832
 833   shnum = 0;
 834   for (section = sobj->sections; section != NULL; section = section->next)
 835     ++shnum;
 836   if (shnum == 0)
 837     return NULL;
 838
 839   /* Add initial dummy Shdr and .shstrtab.  */
 840   shnum += 2;
 841
 842   shdr_offset = ehdr_size;
 843   sh_offset = shdr_offset + shnum * shdr_size;
 844
 845   if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
 846                                      0, 0, 0, 0, 0, 0, &errmsg, err))
 847     return errmsg;
 848
 849   shdr_offset += shdr_size;
 850
 851   sh_name = 1;
 852   for (section = sobj->sections; section != NULL; section = section->next)
 853     {
 854       size_t mask;
 855       size_t new_sh_offset;
 856       size_t sh_size;
 857       struct simple_object_write_section_buffer *buffer;
 858
 859       mask = (1U << section->align) - 1;
 860       new_sh_offset = sh_offset + mask;
 861       new_sh_offset &= ~ mask;
 862       while (new_sh_offset > sh_offset)
 863         {
 864           unsigned char zeroes[16];
 865           size_t write;
 866
 867           memset (zeroes, 0, sizeof zeroes);
 868           write = new_sh_offset - sh_offset;
 869           if (write > sizeof zeroes)
 870             write = sizeof zeroes;
 871           if (!simple_object_internal_write (descriptor, sh_offset, zeroes,
 872                                              write, &errmsg, err))
 873             return errmsg;
 874           sh_offset += write;
 875         }
 876
 877       sh_size = 0;
 878       for (buffer = section->buffers; buffer != NULL; buffer = buffer->next)
 879         {
 880           if (!simple_object_internal_write (descriptor, sh_offset + sh_size,
 881                                              ((const unsigned char *)
 882                                               buffer->buffer),
 883                                              buffer->size, &errmsg, err))
 884             return errmsg;
 885           sh_size += buffer->size;
 886         }
 887
 888       if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
 889                                          sh_name, SHT_PROGBITS, 0, sh_offset,
 890                                          sh_size, 1U << section->align,
 891                                          &errmsg, err))
 892         return errmsg;
 893
 894       shdr_offset += shdr_size;
 895       sh_name += strlen (section->name) + 1;
 896       sh_offset += sh_size;
 897     }
 898
 899   if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
 900                                      sh_name, SHT_STRTAB, 0, sh_offset,
 901                                      sh_name + strlen (".shstrtab") + 1,
 902                                      1, &errmsg, err))
 903     return errmsg;
 904
 905   /* .shstrtab has a leading zero byte.  */
 906   zero = 0;
 907   if (!simple_object_internal_write (descriptor, sh_offset, &zero, 1,
 908                                      &errmsg, err))
 909     return errmsg;
 910   ++sh_offset;
 911
 912   for (section = sobj->sections; section != NULL; section = section->next)
 913     {
 914       size_t len;
 915
 916       len = strlen (section->name) + 1;
 917       if (!simple_object_internal_write (descriptor, sh_offset,
 918                                          (const unsigned char *) section->name,
 919                                          len, &errmsg, err))
 920         return errmsg;
 921       sh_offset += len;
 922     }
 923
 924   if (!simple_object_internal_write (descriptor, sh_offset,
 925                                      (const unsigned char *) ".shstrtab",
 926                                      strlen (".shstrtab") + 1, &errmsg, err))
 927     return errmsg;
 928
 929   return NULL;
 930 }
 931
 932 /* Release the private data for an simple_object_write structure.  */
 933
 934 static void
 935 simple_object_elf_release_write (void *data)
 936 {
 937   XDELETE (data);
 938 }
 939
 940 /* The ELF functions.  */
 941
 942 const struct simple_object_functions simple_object_elf_functions =
 943 {
 944   simple_object_elf_match,
 945   simple_object_elf_find_sections,
 946   simple_object_elf_fetch_attributes,
 947   simple_object_elf_release_read,
 948   simple_object_elf_attributes_merge,
 949   simple_object_elf_release_attributes,
 950   simple_object_elf_start_write,
 951   simple_object_elf_write_to_file,
 952   simple_object_elf_release_write
 953 };