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 }; 954