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