1 /* elfedit.c -- Update the ELF header of an ELF format file 2 Copyright 2010, 2011, 2012 3 Free Software Foundation, Inc. 4 5 This file is part of GNU Binutils. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 20 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include <assert.h> 24 25 #if __GNUC__ >= 2 26 /* Define BFD64 here, even if our default architecture is 32 bit ELF 27 as this will allow us to read in and parse 64bit and 32bit ELF files. 28 Only do this if we believe that the compiler can support a 64 bit 29 data type. For now we only rely on GCC being able to do this. */ 30 #define BFD64 31 #endif 32 33 #include "bfd.h" 34 #include "elfcomm.h" 35 #include "bucomm.h" 36 37 #include "elf/common.h" 38 #include "elf/external.h" 39 #include "elf/internal.h" 40 41 #include "getopt.h" 42 #include "libiberty.h" 43 #include "safe-ctype.h" 44 #include "filenames.h" 45 46 char * program_name = "elfedit"; 47 static long archive_file_offset; 48 static unsigned long archive_file_size; 49 static Elf_Internal_Ehdr elf_header; 50 static Elf32_External_Ehdr ehdr32; 51 static Elf64_External_Ehdr ehdr64; 52 static int input_elf_machine = -1; 53 static int output_elf_machine = -1; 54 static int input_elf_type = -1; 55 static int output_elf_type = -1; 56 static int input_elf_osabi = -1; 57 static int output_elf_osabi = -1; 58 static int input_elf_class = -1; 59 60 static int 61 update_elf_header (const char *file_name, FILE *file) 62 { 63 int class, machine, type, status, osabi; 64 65 if (elf_header.e_ident[EI_MAG0] != ELFMAG0 66 || elf_header.e_ident[EI_MAG1] != ELFMAG1 67 || elf_header.e_ident[EI_MAG2] != ELFMAG2 68 || elf_header.e_ident[EI_MAG3] != ELFMAG3) 69 { 70 error 71 (_("%s: Not an ELF file - wrong magic bytes at the start\n"), 72 file_name); 73 return 0; 74 } 75 76 if (elf_header.e_ident[EI_VERSION] != EV_CURRENT) 77 { 78 error 79 (_("%s: Unsupported EI_VERSION: %d is not %d\n"), 80 file_name, elf_header.e_ident[EI_VERSION], 81 EV_CURRENT); 82 return 0; 83 } 84 85 /* Return if e_machine is the same as output_elf_machine. */ 86 if (output_elf_machine == elf_header.e_machine) 87 return 1; 88 89 class = elf_header.e_ident[EI_CLASS]; 90 91 /* Skip if class doesn't match. */ 92 if (input_elf_class != -1 && class != input_elf_class) 93 { 94 error 95 (_("%s: Unmatched EI_CLASS: %d is not %d\n"), 96 file_name, class, input_elf_class); 97 return 0; 98 } 99 100 machine = elf_header.e_machine; 101 102 /* Skip if e_machine doesn't match. */ 103 if (input_elf_machine != -1 && machine != input_elf_machine) 104 { 105 error 106 (_("%s: Unmatched e_machine: %d is not %d\n"), 107 file_name, machine, input_elf_machine); 108 return 0; 109 } 110 111 type = elf_header.e_type; 112 113 /* Skip if e_type doesn't match. */ 114 if (input_elf_type != -1 && type != input_elf_type) 115 { 116 error 117 (_("%s: Unmatched e_type: %d is not %d\n"), 118 file_name, type, input_elf_type); 119 return 0; 120 } 121 122 osabi = elf_header.e_ident[EI_OSABI]; 123 124 /* Skip if OSABI doesn't match. */ 125 if (input_elf_osabi != -1 && osabi != input_elf_osabi) 126 { 127 error 128 (_("%s: Unmatched EI_OSABI: %d is not %d\n"), 129 file_name, osabi, input_elf_osabi); 130 return 0; 131 } 132 133 /* Update e_machine, e_type and EI_OSABI. */ 134 switch (class) 135 { 136 default: 137 /* We should never get here. */ 138 abort (); 139 break; 140 case ELFCLASS32: 141 if (output_elf_machine != -1) 142 BYTE_PUT (ehdr32.e_machine, output_elf_machine); 143 if (output_elf_type != -1) 144 BYTE_PUT (ehdr32.e_type, output_elf_type); 145 if (output_elf_osabi != -1) 146 ehdr32.e_ident[EI_OSABI] = output_elf_osabi; 147 status = fwrite (&ehdr32, sizeof (ehdr32), 1, file) == 1; 148 break; 149 case ELFCLASS64: 150 if (output_elf_machine != -1) 151 BYTE_PUT (ehdr64.e_machine, output_elf_machine); 152 if (output_elf_type != -1) 153 BYTE_PUT (ehdr64.e_type, output_elf_type); 154 if (output_elf_osabi != -1) 155 ehdr64.e_ident[EI_OSABI] = output_elf_osabi; 156 status = fwrite (&ehdr64, sizeof (ehdr64), 1, file) == 1; 157 break; 158 } 159 160 if (status != 1) 161 error (_("%s: Failed to update ELF header: %s\n"), 162 file_name, strerror (errno)); 163 164 return status; 165 } 166 167 static int 168 get_file_header (FILE * file) 169 { 170 /* Read in the identity array. */ 171 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1) 172 return 0; 173 174 /* Determine how to read the rest of the header. */ 175 switch (elf_header.e_ident[EI_DATA]) 176 { 177 default: /* fall through */ 178 case ELFDATANONE: /* fall through */ 179 case ELFDATA2LSB: 180 byte_get = byte_get_little_endian; 181 byte_put = byte_put_little_endian; 182 break; 183 case ELFDATA2MSB: 184 byte_get = byte_get_big_endian; 185 byte_put = byte_put_big_endian; 186 break; 187 } 188 189 /* Read in the rest of the header. For now we only support 32 bit 190 and 64 bit ELF files. */ 191 switch (elf_header.e_ident[EI_CLASS]) 192 { 193 default: 194 error (_("Unsupported EI_CLASS: %d\n"), 195 elf_header.e_ident[EI_CLASS]); 196 return 0; 197 198 case ELFCLASS32: 199 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 200 1, file) != 1) 201 return 0; 202 203 elf_header.e_type = BYTE_GET (ehdr32.e_type); 204 elf_header.e_machine = BYTE_GET (ehdr32.e_machine); 205 elf_header.e_version = BYTE_GET (ehdr32.e_version); 206 elf_header.e_entry = BYTE_GET (ehdr32.e_entry); 207 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff); 208 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff); 209 elf_header.e_flags = BYTE_GET (ehdr32.e_flags); 210 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize); 211 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize); 212 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum); 213 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize); 214 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum); 215 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx); 216 217 memcpy (&ehdr32, &elf_header, EI_NIDENT); 218 break; 219 220 case ELFCLASS64: 221 /* If we have been compiled with sizeof (bfd_vma) == 4, then 222 we will not be able to cope with the 64bit data found in 223 64 ELF files. Detect this now and abort before we start 224 overwriting things. */ 225 if (sizeof (bfd_vma) < 8) 226 { 227 error (_("This executable has been built without support for a\n\ 228 64 bit data type and so it cannot process 64 bit ELF files.\n")); 229 return 0; 230 } 231 232 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 233 1, file) != 1) 234 return 0; 235 236 elf_header.e_type = BYTE_GET (ehdr64.e_type); 237 elf_header.e_machine = BYTE_GET (ehdr64.e_machine); 238 elf_header.e_version = BYTE_GET (ehdr64.e_version); 239 elf_header.e_entry = BYTE_GET (ehdr64.e_entry); 240 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff); 241 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff); 242 elf_header.e_flags = BYTE_GET (ehdr64.e_flags); 243 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize); 244 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize); 245 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum); 246 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize); 247 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum); 248 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx); 249 250 memcpy (&ehdr64, &elf_header, EI_NIDENT); 251 break; 252 } 253 return 1; 254 } 255 256 /* Process one ELF object file according to the command line options. 257 This file may actually be stored in an archive. The file is 258 positioned at the start of the ELF object. */ 259 260 static int 261 process_object (const char *file_name, FILE *file) 262 { 263 /* Rememeber where we are. */ 264 long offset = ftell (file); 265 266 if (! get_file_header (file)) 267 { 268 error (_("%s: Failed to read ELF header\n"), file_name); 269 return 1; 270 } 271 272 /* Go to the position of the ELF header. */ 273 if (fseek (file, offset, SEEK_SET) != 0) 274 { 275 error (_("%s: Failed to seek to ELF header\n"), file_name); 276 } 277 278 if (! update_elf_header (file_name, file)) 279 return 1; 280 281 return 0; 282 } 283 284 /* Process an ELF archive. 285 On entry the file is positioned just after the ARMAG string. */ 286 287 static int 288 process_archive (const char * file_name, FILE * file, 289 bfd_boolean is_thin_archive) 290 { 291 struct archive_info arch; 292 struct archive_info nested_arch; 293 size_t got; 294 int ret; 295 296 /* The ARCH structure is used to hold information about this archive. */ 297 arch.file_name = NULL; 298 arch.file = NULL; 299 arch.index_array = NULL; 300 arch.sym_table = NULL; 301 arch.longnames = NULL; 302 303 /* The NESTED_ARCH structure is used as a single-item cache of information 304 about a nested archive (when members of a thin archive reside within 305 another regular archive file). */ 306 nested_arch.file_name = NULL; 307 nested_arch.file = NULL; 308 nested_arch.index_array = NULL; 309 nested_arch.sym_table = NULL; 310 nested_arch.longnames = NULL; 311 312 if (setup_archive (&arch, file_name, file, is_thin_archive, FALSE) != 0) 313 { 314 ret = 1; 315 goto out; 316 } 317 318 ret = 0; 319 320 while (1) 321 { 322 char * name; 323 size_t namelen; 324 char * qualified_name; 325 326 /* Read the next archive header. */ 327 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0) 328 { 329 error (_("%s: failed to seek to next archive header\n"), 330 file_name); 331 return 1; 332 } 333 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file); 334 if (got != sizeof arch.arhdr) 335 { 336 if (got == 0) 337 break; 338 error (_("%s: failed to read archive header\n"), 339 file_name); 340 ret = 1; 341 break; 342 } 343 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0) 344 { 345 error (_("%s: did not find a valid archive header\n"), 346 arch.file_name); 347 ret = 1; 348 break; 349 } 350 351 arch.next_arhdr_offset += sizeof arch.arhdr; 352 353 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10); 354 if (archive_file_size & 01) 355 ++archive_file_size; 356 357 name = get_archive_member_name (&arch, &nested_arch); 358 if (name == NULL) 359 { 360 error (_("%s: bad archive file name\n"), file_name); 361 ret = 1; 362 break; 363 } 364 namelen = strlen (name); 365 366 qualified_name = make_qualified_name (&arch, &nested_arch, name); 367 if (qualified_name == NULL) 368 { 369 error (_("%s: bad archive file name\n"), file_name); 370 ret = 1; 371 break; 372 } 373 374 if (is_thin_archive && arch.nested_member_origin == 0) 375 { 376 /* This is a proxy for an external member of a thin archive. */ 377 FILE *member_file; 378 char *member_file_name = adjust_relative_path (file_name, 379 name, namelen); 380 if (member_file_name == NULL) 381 { 382 ret = 1; 383 break; 384 } 385 386 member_file = fopen (member_file_name, "r+b"); 387 if (member_file == NULL) 388 { 389 error (_("Input file '%s' is not readable\n"), 390 member_file_name); 391 free (member_file_name); 392 ret = 1; 393 break; 394 } 395 396 archive_file_offset = arch.nested_member_origin; 397 398 ret |= process_object (qualified_name, member_file); 399 400 fclose (member_file); 401 free (member_file_name); 402 } 403 else if (is_thin_archive) 404 { 405 /* This is a proxy for a member of a nested archive. */ 406 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr; 407 408 /* The nested archive file will have been opened and setup by 409 get_archive_member_name. */ 410 if (fseek (nested_arch.file, archive_file_offset, 411 SEEK_SET) != 0) 412 { 413 error (_("%s: failed to seek to archive member\n"), 414 nested_arch.file_name); 415 ret = 1; 416 break; 417 } 418 419 ret |= process_object (qualified_name, nested_arch.file); 420 } 421 else 422 { 423 archive_file_offset = arch.next_arhdr_offset; 424 arch.next_arhdr_offset += archive_file_size; 425 426 ret |= process_object (qualified_name, file); 427 } 428 429 free (qualified_name); 430 } 431 432 out: 433 if (nested_arch.file != NULL) 434 fclose (nested_arch.file); 435 release_archive (&nested_arch); 436 release_archive (&arch); 437 438 return ret; 439 } 440 441 static int 442 check_file (const char *file_name, struct stat *statbuf_p) 443 { 444 struct stat statbuf; 445 446 if (statbuf_p == NULL) 447 statbuf_p = &statbuf; 448 449 if (stat (file_name, statbuf_p) < 0) 450 { 451 if (errno == ENOENT) 452 error (_("'%s': No such file\n"), file_name); 453 else 454 error (_("Could not locate '%s'. System error message: %s\n"), 455 file_name, strerror (errno)); 456 return 1; 457 } 458 459 if (! S_ISREG (statbuf_p->st_mode)) 460 { 461 error (_("'%s' is not an ordinary file\n"), file_name); 462 return 1; 463 } 464 465 return 0; 466 } 467 468 static int 469 process_file (const char *file_name) 470 { 471 FILE * file; 472 char armag[SARMAG]; 473 int ret; 474 475 if (check_file (file_name, NULL)) 476 return 1; 477 478 file = fopen (file_name, "r+b"); 479 if (file == NULL) 480 { 481 error (_("Input file '%s' is not readable\n"), file_name); 482 return 1; 483 } 484 485 if (fread (armag, SARMAG, 1, file) != 1) 486 { 487 error (_("%s: Failed to read file's magic number\n"), 488 file_name); 489 fclose (file); 490 return 1; 491 } 492 493 if (memcmp (armag, ARMAG, SARMAG) == 0) 494 ret = process_archive (file_name, file, FALSE); 495 else if (memcmp (armag, ARMAGT, SARMAG) == 0) 496 ret = process_archive (file_name, file, TRUE); 497 else 498 { 499 rewind (file); 500 archive_file_size = archive_file_offset = 0; 501 ret = process_object (file_name, file); 502 } 503 504 fclose (file); 505 506 return ret; 507 } 508 509 static const struct 510 { 511 int osabi; 512 const char *name; 513 } 514 osabis[] = 515 { 516 { ELFOSABI_NONE, "none" }, 517 { ELFOSABI_HPUX, "HPUX" }, 518 { ELFOSABI_NETBSD, "NetBSD" }, 519 { ELFOSABI_GNU, "GNU" }, 520 { ELFOSABI_GNU, "Linux" }, 521 { ELFOSABI_SOLARIS, "Solaris" }, 522 { ELFOSABI_AIX, "AIX" }, 523 { ELFOSABI_IRIX, "Irix" }, 524 { ELFOSABI_FREEBSD, "FreeBSD" }, 525 { ELFOSABI_TRU64, "TRU64" }, 526 { ELFOSABI_MODESTO, "Modesto" }, 527 { ELFOSABI_OPENBSD, "OpenBSD" }, 528 { ELFOSABI_OPENVMS, "OpenVMS" }, 529 { ELFOSABI_NSK, "NSK" }, 530 { ELFOSABI_AROS, "AROS" }, 531 { ELFOSABI_FENIXOS, "FenixOS" } 532 }; 533 534 /* Return ELFOSABI_XXX for an OSABI string, OSABI. */ 535 536 static int 537 elf_osabi (const char *osabi) 538 { 539 unsigned int i; 540 541 for (i = 0; i < ARRAY_SIZE (osabis); i++) 542 if (strcasecmp (osabi, osabis[i].name) == 0) 543 return osabis[i].osabi; 544 545 error (_("Unknown OSABI: %s\n"), osabi); 546 547 return -1; 548 } 549 550 /* Return EM_XXX for a machine string, MACH. */ 551 552 static int 553 elf_machine (const char *mach) 554 { 555 if (strcasecmp (mach, "l1om") == 0) 556 return EM_L1OM; 557 if (strcasecmp (mach, "k1om") == 0) 558 return EM_K1OM; 559 if (strcasecmp (mach, "x86_64") == 0) 560 return EM_X86_64; 561 if (strcasecmp (mach, "x86-64") == 0) 562 return EM_X86_64; 563 if (strcasecmp (mach, "none") == 0) 564 return EM_NONE; 565 566 error (_("Unknown machine type: %s\n"), mach); 567 568 return -1; 569 } 570 571 /* Return ELF class for a machine type, MACH. */ 572 573 static int 574 elf_class (int mach) 575 { 576 switch (mach) 577 { 578 case EM_L1OM: 579 case EM_K1OM: 580 case EM_X86_64: 581 return ELFCLASS64; 582 case EM_NONE: 583 return ELFCLASSNONE; 584 default: 585 error (_("Unknown machine type: %d\n"), mach); 586 return -1; 587 } 588 } 589 590 /* Return ET_XXX for a type string, TYPE. */ 591 592 static int 593 elf_type (const char *type) 594 { 595 if (strcasecmp (type, "rel") == 0) 596 return ET_REL; 597 if (strcasecmp (type, "exec") == 0) 598 return ET_EXEC; 599 if (strcasecmp (type, "dyn") == 0) 600 return ET_DYN; 601 if (strcasecmp (type, "none") == 0) 602 return ET_NONE; 603 604 error (_("Unknown type: %s\n"), type); 605 606 return -1; 607 } 608 609 enum command_line_switch 610 { 611 OPTION_INPUT_MACH = 150, 612 OPTION_OUTPUT_MACH, 613 OPTION_INPUT_TYPE, 614 OPTION_OUTPUT_TYPE, 615 OPTION_INPUT_OSABI, 616 OPTION_OUTPUT_OSABI 617 }; 618 619 static struct option options[] = 620 { 621 {"input-mach", required_argument, 0, OPTION_INPUT_MACH}, 622 {"output-mach", required_argument, 0, OPTION_OUTPUT_MACH}, 623 {"input-type", required_argument, 0, OPTION_INPUT_TYPE}, 624 {"output-type", required_argument, 0, OPTION_OUTPUT_TYPE}, 625 {"input-osabi", required_argument, 0, OPTION_INPUT_OSABI}, 626 {"output-osabi", required_argument, 0, OPTION_OUTPUT_OSABI}, 627 {"version", no_argument, 0, 'v'}, 628 {"help", no_argument, 0, 'h'}, 629 {0, no_argument, 0, 0} 630 }; 631 632 static void 633 usage (FILE *stream, int exit_status) 634 { 635 fprintf (stream, _("Usage: %s <option(s)> elffile(s)\n"), 636 program_name); 637 fprintf (stream, _(" Update the ELF header of ELF files\n")); 638 fprintf (stream, _(" The options are:\n")); 639 fprintf (stream, _("\ 640 --input-mach <machine> Set input machine type to <machine>\n\ 641 --output-mach <machine> Set output machine type to <machine>\n\ 642 --input-type <type> Set input file type to <type>\n\ 643 --output-type <type> Set output file type to <type>\n\ 644 --input-osabi <osabi> Set input OSABI to <osabi>\n\ 645 --output-osabi <osabi> Set output OSABI to <osabi>\n\ 646 -h --help Display this information\n\ 647 -v --version Display the version number of %s\n\ 648 "), 649 program_name); 650 if (REPORT_BUGS_TO[0] && exit_status == 0) 651 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO); 652 exit (exit_status); 653 } 654 655 int 656 main (int argc, char ** argv) 657 { 658 int c, status; 659 660 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) 661 setlocale (LC_MESSAGES, ""); 662 #endif 663 #if defined (HAVE_SETLOCALE) 664 setlocale (LC_CTYPE, ""); 665 #endif 666 bindtextdomain (PACKAGE, LOCALEDIR); 667 textdomain (PACKAGE); 668 669 expandargv (&argc, &argv); 670 671 while ((c = getopt_long (argc, argv, "hv", 672 options, (int *) 0)) != EOF) 673 { 674 switch (c) 675 { 676 case OPTION_INPUT_MACH: 677 input_elf_machine = elf_machine (optarg); 678 if (input_elf_machine < 0) 679 return 1; 680 input_elf_class = elf_class (input_elf_machine); 681 if (input_elf_class < 0) 682 return 1; 683 break; 684 685 case OPTION_OUTPUT_MACH: 686 output_elf_machine = elf_machine (optarg); 687 if (output_elf_machine < 0) 688 return 1; 689 break; 690 691 case OPTION_INPUT_TYPE: 692 input_elf_type = elf_type (optarg); 693 if (input_elf_type < 0) 694 return 1; 695 break; 696 697 case OPTION_OUTPUT_TYPE: 698 output_elf_type = elf_type (optarg); 699 if (output_elf_type < 0) 700 return 1; 701 break; 702 703 case OPTION_INPUT_OSABI: 704 input_elf_osabi = elf_osabi (optarg); 705 if (input_elf_osabi < 0) 706 return 1; 707 break; 708 709 case OPTION_OUTPUT_OSABI: 710 output_elf_osabi = elf_osabi (optarg); 711 if (output_elf_osabi < 0) 712 return 1; 713 break; 714 715 case 'h': 716 usage (stdout, 0); 717 718 case 'v': 719 print_version (program_name); 720 break; 721 722 default: 723 usage (stderr, 1); 724 } 725 } 726 727 if (optind == argc 728 || (output_elf_machine == -1 729 && output_elf_type == -1 730 && output_elf_osabi == -1)) 731 usage (stderr, 1); 732 733 status = 0; 734 while (optind < argc) 735 status |= process_file (argv[optind++]); 736 737 return status; 738 } 739