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