1 /* elfedit.c -- Update the ELF header of an ELF format file 2 Copyright (C) 2010-2022 Free Software Foundation, Inc. 3 4 This file is part of GNU Binutils. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 19 02110-1301, USA. */ 20 21 #include "config.h" 22 #include "sysdep.h" 23 #include "libiberty.h" 24 #include <assert.h> 25 26 #if __GNUC__ >= 2 27 /* Define BFD64 here, even if our default architecture is 32 bit ELF 28 as this will allow us to read in and parse 64bit and 32bit ELF files. 29 Only do this if we believe that the compiler can support a 64 bit 30 data type. For now we only rely on GCC being able to do this. */ 31 #define BFD64 32 #endif 33 34 #include "bfd.h" 35 #include "elfcomm.h" 36 #include "bucomm.h" 37 38 #include "elf/common.h" 39 #include "elf/external.h" 40 #include "elf/internal.h" 41 42 #include "getopt.h" 43 #include "libiberty.h" 44 #include "safe-ctype.h" 45 #include "filenames.h" 46 47 char * program_name = "elfedit"; 48 static long archive_file_offset; 49 static unsigned long archive_file_size; 50 static Elf_Internal_Ehdr elf_header; 51 static Elf32_External_Ehdr ehdr32; 52 static Elf64_External_Ehdr ehdr64; 53 static int input_elf_machine = -1; 54 static int output_elf_machine = -1; 55 static int input_elf_type = -1; 56 static int output_elf_type = -1; 57 static int input_elf_osabi = -1; 58 static int output_elf_osabi = -1; 59 static int input_elf_abiversion = -1; 60 static int output_elf_abiversion = -1; 61 enum elfclass 62 { 63 ELF_CLASS_UNKNOWN = -1, 64 ELF_CLASS_NONE = ELFCLASSNONE, 65 ELF_CLASS_32 = ELFCLASS32, 66 ELF_CLASS_64 = ELFCLASS64, 67 ELF_CLASS_BOTH 68 }; 69 static enum elfclass input_elf_class = ELF_CLASS_UNKNOWN; 70 static enum elfclass output_elf_class = ELF_CLASS_BOTH; 71 72 #ifdef HAVE_MMAP 73 #include <sys/mman.h> 74 75 static unsigned int enable_x86_features; 76 static unsigned int disable_x86_features; 77 78 static int 79 update_gnu_property (const char *file_name, FILE *file) 80 { 81 char *map; 82 Elf_Internal_Phdr *phdrs; 83 struct stat st_buf; 84 unsigned int i; 85 int ret; 86 87 if (!enable_x86_features && !disable_x86_features) 88 return 0; 89 90 if (elf_header.e_machine != EM_386 91 && elf_header.e_machine != EM_X86_64) 92 { 93 error (_("%s: Not an i386 nor x86-64 ELF file\n"), file_name); 94 return 0; 95 } 96 97 if (fstat (fileno (file), &st_buf) < 0) 98 { 99 error (_("%s: stat () failed\n"), file_name); 100 return 1; 101 } 102 103 map = mmap (NULL, st_buf.st_size, PROT_READ | PROT_WRITE, 104 MAP_SHARED, fileno (file), 0); 105 if (map == MAP_FAILED) 106 { 107 error (_("%s: mmap () failed\n"), file_name); 108 return 0; 109 } 110 111 phdrs = xmalloc (elf_header.e_phnum * sizeof (*phdrs)); 112 113 if (elf_header.e_ident[EI_CLASS] == ELFCLASS32) 114 { 115 Elf32_External_Phdr *phdrs32 116 = (Elf32_External_Phdr *) (map + elf_header.e_phoff); 117 for (i = 0; i < elf_header.e_phnum; i++) 118 { 119 phdrs[i].p_type = BYTE_GET (phdrs32[i].p_type); 120 phdrs[i].p_offset = BYTE_GET (phdrs32[i].p_offset); 121 phdrs[i].p_vaddr = BYTE_GET (phdrs32[i].p_vaddr); 122 phdrs[i].p_paddr = BYTE_GET (phdrs32[i].p_paddr); 123 phdrs[i].p_filesz = BYTE_GET (phdrs32[i].p_filesz); 124 phdrs[i].p_memsz = BYTE_GET (phdrs32[i].p_memsz); 125 phdrs[i].p_flags = BYTE_GET (phdrs32[i].p_flags); 126 phdrs[i].p_align = BYTE_GET (phdrs32[i].p_align); 127 } 128 } 129 else 130 { 131 Elf64_External_Phdr *phdrs64 132 = (Elf64_External_Phdr *) (map + elf_header.e_phoff); 133 for (i = 0; i < elf_header.e_phnum; i++) 134 { 135 phdrs[i].p_type = BYTE_GET (phdrs64[i].p_type); 136 phdrs[i].p_offset = BYTE_GET (phdrs64[i].p_offset); 137 phdrs[i].p_vaddr = BYTE_GET (phdrs64[i].p_vaddr); 138 phdrs[i].p_paddr = BYTE_GET (phdrs64[i].p_paddr); 139 phdrs[i].p_filesz = BYTE_GET (phdrs64[i].p_filesz); 140 phdrs[i].p_memsz = BYTE_GET (phdrs64[i].p_memsz); 141 phdrs[i].p_flags = BYTE_GET (phdrs64[i].p_flags); 142 phdrs[i].p_align = BYTE_GET (phdrs64[i].p_align); 143 } 144 } 145 146 ret = 0; 147 for (i = 0; i < elf_header.e_phnum; i++) 148 if (phdrs[i].p_type == PT_NOTE) 149 { 150 size_t offset = phdrs[i].p_offset; 151 size_t size = phdrs[i].p_filesz; 152 size_t align = phdrs[i].p_align; 153 char *buf = map + offset; 154 char *p = buf; 155 156 while (p < buf + size) 157 { 158 Elf_External_Note *xnp = (Elf_External_Note *) p; 159 Elf_Internal_Note in; 160 161 if (offsetof (Elf_External_Note, name) > buf - p + size) 162 { 163 ret = 1; 164 goto out; 165 } 166 167 in.type = BYTE_GET (xnp->type); 168 in.namesz = BYTE_GET (xnp->namesz); 169 in.namedata = xnp->name; 170 if (in.namesz > buf - in.namedata + size) 171 { 172 ret = 1; 173 goto out; 174 } 175 176 in.descsz = BYTE_GET (xnp->descsz); 177 in.descdata = p + ELF_NOTE_DESC_OFFSET (in.namesz, align); 178 in.descpos = offset + (in.descdata - buf); 179 if (in.descsz != 0 180 && (in.descdata >= buf + size 181 || in.descsz > buf - in.descdata + size)) 182 { 183 ret = 1; 184 goto out; 185 } 186 187 if (in.namesz == sizeof "GNU" 188 && strcmp (in.namedata, "GNU") == 0 189 && in.type == NT_GNU_PROPERTY_TYPE_0) 190 { 191 unsigned char *ptr; 192 unsigned char *ptr_end; 193 194 if (in.descsz < 8 || (in.descsz % align) != 0) 195 { 196 ret = 1; 197 goto out; 198 } 199 200 ptr = (unsigned char *) in.descdata; 201 ptr_end = ptr + in.descsz; 202 203 do 204 { 205 unsigned int type = byte_get (ptr, 4); 206 unsigned int datasz = byte_get (ptr + 4, 4); 207 unsigned int bitmask, old_bitmask; 208 209 ptr += 8; 210 if ((ptr + datasz) > ptr_end) 211 { 212 ret = 1; 213 goto out; 214 } 215 216 if (type == GNU_PROPERTY_X86_FEATURE_1_AND) 217 { 218 if (datasz != 4) 219 { 220 ret = 1; 221 goto out; 222 } 223 224 old_bitmask = byte_get (ptr, 4); 225 bitmask = old_bitmask; 226 if (enable_x86_features) 227 bitmask |= enable_x86_features; 228 if (disable_x86_features) 229 bitmask &= ~disable_x86_features; 230 if (old_bitmask != bitmask) 231 byte_put (ptr, bitmask, 4); 232 goto out; 233 } 234 235 ptr += ELF_ALIGN_UP (datasz, align); 236 } 237 while ((ptr_end - ptr) >= 8); 238 } 239 240 p += ELF_NOTE_NEXT_OFFSET (in.namesz, in.descsz, align); 241 } 242 } 243 244 out: 245 if (ret != 0) 246 error (_("%s: Invalid PT_NOTE segment\n"), file_name); 247 248 free (phdrs); 249 munmap (map, st_buf.st_size); 250 251 return ret; 252 } 253 254 /* Set enable_x86_features and disable_x86_features for a feature 255 string, FEATURE. */ 256 257 static int 258 elf_x86_feature (const char *feature, int enable) 259 { 260 unsigned int x86_feature; 261 if (strcasecmp (feature, "ibt") == 0) 262 x86_feature = GNU_PROPERTY_X86_FEATURE_1_IBT; 263 else if (strcasecmp (feature, "shstk") == 0) 264 x86_feature = GNU_PROPERTY_X86_FEATURE_1_SHSTK; 265 else if (strcasecmp (feature, "lam_u48") == 0) 266 x86_feature = GNU_PROPERTY_X86_FEATURE_1_LAM_U48; 267 else if (strcasecmp (feature, "lam_u57") == 0) 268 x86_feature = GNU_PROPERTY_X86_FEATURE_1_LAM_U57; 269 else 270 { 271 error (_("Unknown x86 feature: %s\n"), feature); 272 return -1; 273 } 274 275 if (enable) 276 { 277 enable_x86_features |= x86_feature; 278 disable_x86_features &= ~x86_feature; 279 } 280 else 281 { 282 disable_x86_features |= x86_feature; 283 enable_x86_features &= ~x86_feature; 284 } 285 286 return 0; 287 } 288 #endif 289 290 /* Return ELF class for a machine type, MACH. */ 291 292 static enum elfclass 293 elf_class (int mach) 294 { 295 switch (mach) 296 { 297 case EM_386: 298 case EM_IAMCU: 299 return ELF_CLASS_32; 300 case EM_L1OM: 301 case EM_K1OM: 302 return ELF_CLASS_64; 303 case EM_X86_64: 304 case EM_NONE: 305 return ELF_CLASS_BOTH; 306 default: 307 return ELF_CLASS_BOTH; 308 } 309 } 310 311 static int 312 update_elf_header (const char *file_name, FILE *file) 313 { 314 int class, machine, type, status, osabi, abiversion; 315 316 if (elf_header.e_ident[EI_VERSION] != EV_CURRENT) 317 { 318 error 319 (_("%s: Unsupported EI_VERSION: %d is not %d\n"), 320 file_name, elf_header.e_ident[EI_VERSION], 321 EV_CURRENT); 322 return 0; 323 } 324 325 /* Return if e_machine is the same as output_elf_machine. */ 326 if (output_elf_machine == elf_header.e_machine) 327 return 1; 328 329 class = elf_header.e_ident[EI_CLASS]; 330 machine = elf_header.e_machine; 331 332 /* Skip if class doesn't match. */ 333 if (input_elf_class == ELF_CLASS_UNKNOWN) 334 input_elf_class = elf_class (machine); 335 336 if (input_elf_class != ELF_CLASS_BOTH 337 && (int) input_elf_class != class) 338 { 339 error 340 (_("%s: Unmatched input EI_CLASS: %d is not %d\n"), 341 file_name, class, input_elf_class); 342 return 0; 343 } 344 345 if (output_elf_class != ELF_CLASS_BOTH 346 && (int) output_elf_class != class) 347 { 348 error 349 (_("%s: Unmatched output EI_CLASS: %d is not %d\n"), 350 file_name, class, output_elf_class); 351 return 0; 352 } 353 354 /* Skip if e_machine doesn't match. */ 355 if (input_elf_machine != -1 && machine != input_elf_machine) 356 { 357 error 358 (_("%s: Unmatched e_machine: %d is not %d\n"), 359 file_name, machine, input_elf_machine); 360 return 0; 361 } 362 363 type = elf_header.e_type; 364 365 /* Skip if e_type doesn't match. */ 366 if (input_elf_type != -1 && type != input_elf_type) 367 { 368 error 369 (_("%s: Unmatched e_type: %d is not %d\n"), 370 file_name, type, input_elf_type); 371 return 0; 372 } 373 374 osabi = elf_header.e_ident[EI_OSABI]; 375 376 /* Skip if OSABI doesn't match. */ 377 if (input_elf_osabi != -1 && osabi != input_elf_osabi) 378 { 379 error 380 (_("%s: Unmatched EI_OSABI: %d is not %d\n"), 381 file_name, osabi, input_elf_osabi); 382 return 0; 383 } 384 385 abiversion = elf_header.e_ident[EI_ABIVERSION]; 386 387 /* Skip if ABIVERSION doesn't match. */ 388 if (input_elf_abiversion != -1 389 && abiversion != input_elf_abiversion) 390 { 391 error 392 (_("%s: Unmatched EI_ABIVERSION: %d is not %d\n"), 393 file_name, abiversion, input_elf_abiversion); 394 return 0; 395 } 396 397 /* Update e_machine, e_type and EI_OSABI. */ 398 switch (class) 399 { 400 default: 401 /* We should never get here. */ 402 abort (); 403 break; 404 case ELFCLASS32: 405 if (output_elf_machine != -1) 406 BYTE_PUT (ehdr32.e_machine, output_elf_machine); 407 if (output_elf_type != -1) 408 BYTE_PUT (ehdr32.e_type, output_elf_type); 409 if (output_elf_osabi != -1) 410 ehdr32.e_ident[EI_OSABI] = output_elf_osabi; 411 if (output_elf_abiversion != -1) 412 ehdr32.e_ident[EI_ABIVERSION] = output_elf_abiversion; 413 status = fwrite (&ehdr32, sizeof (ehdr32), 1, file) == 1; 414 break; 415 case ELFCLASS64: 416 if (output_elf_machine != -1) 417 BYTE_PUT (ehdr64.e_machine, output_elf_machine); 418 if (output_elf_type != -1) 419 BYTE_PUT (ehdr64.e_type, output_elf_type); 420 if (output_elf_osabi != -1) 421 ehdr64.e_ident[EI_OSABI] = output_elf_osabi; 422 if (output_elf_abiversion != -1) 423 ehdr64.e_ident[EI_ABIVERSION] = output_elf_abiversion; 424 status = fwrite (&ehdr64, sizeof (ehdr64), 1, file) == 1; 425 break; 426 } 427 428 if (status != 1) 429 error (_("%s: Failed to update ELF header: %s\n"), 430 file_name, strerror (errno)); 431 432 return status; 433 } 434 435 static int 436 get_file_header (FILE * file) 437 { 438 /* Read in the identity array. */ 439 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1) 440 return 0; 441 442 if (elf_header.e_ident[EI_MAG0] != ELFMAG0 443 || elf_header.e_ident[EI_MAG1] != ELFMAG1 444 || elf_header.e_ident[EI_MAG2] != ELFMAG2 445 || elf_header.e_ident[EI_MAG3] != ELFMAG3) 446 return 0; 447 448 /* Determine how to read the rest of the header. */ 449 switch (elf_header.e_ident[EI_DATA]) 450 { 451 default: /* fall through */ 452 case ELFDATANONE: /* fall through */ 453 case ELFDATA2LSB: 454 byte_get = byte_get_little_endian; 455 byte_put = byte_put_little_endian; 456 break; 457 case ELFDATA2MSB: 458 byte_get = byte_get_big_endian; 459 byte_put = byte_put_big_endian; 460 break; 461 } 462 463 /* Read in the rest of the header. For now we only support 32 bit 464 and 64 bit ELF files. */ 465 switch (elf_header.e_ident[EI_CLASS]) 466 { 467 default: 468 return 0; 469 470 case ELFCLASS32: 471 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 472 1, file) != 1) 473 return 0; 474 475 elf_header.e_type = BYTE_GET (ehdr32.e_type); 476 elf_header.e_machine = BYTE_GET (ehdr32.e_machine); 477 elf_header.e_version = BYTE_GET (ehdr32.e_version); 478 elf_header.e_entry = BYTE_GET (ehdr32.e_entry); 479 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff); 480 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff); 481 elf_header.e_flags = BYTE_GET (ehdr32.e_flags); 482 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize); 483 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize); 484 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum); 485 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize); 486 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum); 487 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx); 488 489 memcpy (&ehdr32, &elf_header, EI_NIDENT); 490 break; 491 492 case ELFCLASS64: 493 /* If we have been compiled with sizeof (bfd_vma) == 4, then 494 we will not be able to cope with the 64bit data found in 495 64 ELF files. Detect this now and abort before we start 496 overwriting things. */ 497 if (sizeof (bfd_vma) < 8) 498 { 499 error (_("This executable has been built without support for a\n\ 500 64 bit data type and so it cannot process 64 bit ELF files.\n")); 501 return 0; 502 } 503 504 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 505 1, file) != 1) 506 return 0; 507 508 elf_header.e_type = BYTE_GET (ehdr64.e_type); 509 elf_header.e_machine = BYTE_GET (ehdr64.e_machine); 510 elf_header.e_version = BYTE_GET (ehdr64.e_version); 511 elf_header.e_entry = BYTE_GET (ehdr64.e_entry); 512 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff); 513 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff); 514 elf_header.e_flags = BYTE_GET (ehdr64.e_flags); 515 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize); 516 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize); 517 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum); 518 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize); 519 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum); 520 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx); 521 522 memcpy (&ehdr64, &elf_header, EI_NIDENT); 523 break; 524 } 525 return 1; 526 } 527 528 /* Process one ELF object file according to the command line options. 529 This file may actually be stored in an archive. The file is 530 positioned at the start of the ELF object. */ 531 532 static int 533 process_object (const char *file_name, FILE *file) 534 { 535 /* Rememeber where we are. */ 536 long offset = ftell (file); 537 538 if (! get_file_header (file)) 539 { 540 error (_("%s: Failed to read ELF header\n"), file_name); 541 return 1; 542 } 543 544 /* Go to the position of the ELF header. */ 545 if (fseek (file, offset, SEEK_SET) != 0) 546 { 547 error (_("%s: Failed to seek to ELF header\n"), file_name); 548 } 549 550 if (! update_elf_header (file_name, file)) 551 return 1; 552 553 return 0; 554 } 555 556 /* Process an ELF archive. 557 On entry the file is positioned just after the ARMAG string. */ 558 559 static int 560 process_archive (const char * file_name, FILE * file, 561 bool is_thin_archive) 562 { 563 struct archive_info arch; 564 struct archive_info nested_arch; 565 size_t got; 566 int ret; 567 struct stat statbuf; 568 569 /* The ARCH structure is used to hold information about this archive. */ 570 arch.file_name = NULL; 571 arch.file = NULL; 572 arch.index_array = NULL; 573 arch.sym_table = NULL; 574 arch.longnames = NULL; 575 576 /* The NESTED_ARCH structure is used as a single-item cache of information 577 about a nested archive (when members of a thin archive reside within 578 another regular archive file). */ 579 nested_arch.file_name = NULL; 580 nested_arch.file = NULL; 581 nested_arch.index_array = NULL; 582 nested_arch.sym_table = NULL; 583 nested_arch.longnames = NULL; 584 585 if (fstat (fileno (file), &statbuf) < 0 586 || setup_archive (&arch, file_name, file, statbuf.st_size, 587 is_thin_archive, false) != 0) 588 { 589 ret = 1; 590 goto out; 591 } 592 593 ret = 0; 594 595 while (1) 596 { 597 char * name; 598 size_t namelen; 599 char * qualified_name; 600 601 /* Read the next archive header. */ 602 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0) 603 { 604 error (_("%s: failed to seek to next archive header\n"), 605 file_name); 606 return 1; 607 } 608 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file); 609 if (got != sizeof arch.arhdr) 610 { 611 if (got == 0) 612 break; 613 error (_("%s: failed to read archive header\n"), 614 file_name); 615 ret = 1; 616 break; 617 } 618 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0) 619 { 620 error (_("%s: did not find a valid archive header\n"), 621 arch.file_name); 622 ret = 1; 623 break; 624 } 625 626 arch.next_arhdr_offset += sizeof arch.arhdr; 627 628 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10); 629 if (archive_file_size & 01) 630 ++archive_file_size; 631 632 name = get_archive_member_name (&arch, &nested_arch); 633 if (name == NULL) 634 { 635 error (_("%s: bad archive file name\n"), file_name); 636 ret = 1; 637 break; 638 } 639 namelen = strlen (name); 640 641 qualified_name = make_qualified_name (&arch, &nested_arch, name); 642 if (qualified_name == NULL) 643 { 644 error (_("%s: bad archive file name\n"), file_name); 645 free (name); 646 ret = 1; 647 break; 648 } 649 650 if (is_thin_archive && arch.nested_member_origin == 0) 651 { 652 /* This is a proxy for an external member of a thin archive. */ 653 FILE *member_file; 654 char *member_file_name = adjust_relative_path (file_name, 655 name, namelen); 656 free (name); 657 if (member_file_name == NULL) 658 { 659 free (qualified_name); 660 ret = 1; 661 break; 662 } 663 664 member_file = fopen (member_file_name, "r+b"); 665 if (member_file == NULL) 666 { 667 error (_("Input file '%s' is not readable\n"), 668 member_file_name); 669 free (member_file_name); 670 free (qualified_name); 671 ret = 1; 672 break; 673 } 674 675 archive_file_offset = arch.nested_member_origin; 676 677 ret |= process_object (qualified_name, member_file); 678 679 fclose (member_file); 680 free (member_file_name); 681 } 682 else if (is_thin_archive) 683 { 684 free (name); 685 686 /* This is a proxy for a member of a nested archive. */ 687 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr; 688 689 /* The nested archive file will have been opened and setup by 690 get_archive_member_name. */ 691 if (fseek (nested_arch.file, archive_file_offset, 692 SEEK_SET) != 0) 693 { 694 error (_("%s: failed to seek to archive member\n"), 695 nested_arch.file_name); 696 free (qualified_name); 697 ret = 1; 698 break; 699 } 700 701 ret |= process_object (qualified_name, nested_arch.file); 702 } 703 else 704 { 705 free (name); 706 archive_file_offset = arch.next_arhdr_offset; 707 arch.next_arhdr_offset += archive_file_size; 708 709 ret |= process_object (qualified_name, file); 710 } 711 712 free (qualified_name); 713 } 714 715 out: 716 if (nested_arch.file != NULL) 717 fclose (nested_arch.file); 718 release_archive (&nested_arch); 719 release_archive (&arch); 720 721 return ret; 722 } 723 724 static int 725 check_file (const char *file_name, struct stat *statbuf_p) 726 { 727 struct stat statbuf; 728 729 if (statbuf_p == NULL) 730 statbuf_p = &statbuf; 731 732 if (stat (file_name, statbuf_p) < 0) 733 { 734 if (errno == ENOENT) 735 error (_("'%s': No such file\n"), file_name); 736 else 737 error (_("Could not locate '%s'. System error message: %s\n"), 738 file_name, strerror (errno)); 739 return 1; 740 } 741 742 #if defined (_WIN32) && !defined (__CYGWIN__) 743 else if (statbuf_p->st_size == 0) 744 { 745 /* MS-Windows 'stat' reports the null device as a regular file; 746 fix that. */ 747 int fd = open (file_name, O_RDONLY | O_BINARY); 748 if (isatty (fd)) 749 { 750 statbuf_p->st_mode &= ~S_IFREG; 751 statbuf_p->st_mode |= S_IFCHR; 752 } 753 } 754 #endif 755 756 if (! S_ISREG (statbuf_p->st_mode)) 757 { 758 error (_("'%s' is not an ordinary file\n"), file_name); 759 return 1; 760 } 761 762 return 0; 763 } 764 765 static int 766 process_file (const char *file_name) 767 { 768 FILE * file; 769 char armag[SARMAG]; 770 int ret; 771 772 if (check_file (file_name, NULL)) 773 return 1; 774 775 file = fopen (file_name, "r+b"); 776 if (file == NULL) 777 { 778 error (_("Input file '%s' is not readable\n"), file_name); 779 return 1; 780 } 781 782 if (fread (armag, SARMAG, 1, file) != 1) 783 { 784 error (_("%s: Failed to read file's magic number\n"), 785 file_name); 786 fclose (file); 787 return 1; 788 } 789 790 if (memcmp (armag, ARMAG, SARMAG) == 0) 791 ret = process_archive (file_name, file, false); 792 else if (memcmp (armag, ARMAGT, SARMAG) == 0) 793 ret = process_archive (file_name, file, true); 794 else 795 { 796 rewind (file); 797 archive_file_size = archive_file_offset = 0; 798 ret = process_object (file_name, file); 799 #ifdef HAVE_MMAP 800 if (!ret 801 && (elf_header.e_type == ET_EXEC 802 || elf_header.e_type == ET_DYN)) 803 ret = update_gnu_property (file_name, file); 804 #endif 805 } 806 807 fclose (file); 808 809 return ret; 810 } 811 812 static const struct 813 { 814 int osabi; 815 const char *name; 816 } 817 osabis[] = 818 { 819 { ELFOSABI_NONE, "none" }, 820 { ELFOSABI_HPUX, "HPUX" }, 821 { ELFOSABI_NETBSD, "NetBSD" }, 822 { ELFOSABI_GNU, "GNU" }, 823 { ELFOSABI_GNU, "Linux" }, 824 { ELFOSABI_SOLARIS, "Solaris" }, 825 { ELFOSABI_AIX, "AIX" }, 826 { ELFOSABI_IRIX, "Irix" }, 827 { ELFOSABI_FREEBSD, "FreeBSD" }, 828 { ELFOSABI_TRU64, "TRU64" }, 829 { ELFOSABI_MODESTO, "Modesto" }, 830 { ELFOSABI_OPENBSD, "OpenBSD" }, 831 { ELFOSABI_OPENVMS, "OpenVMS" }, 832 { ELFOSABI_NSK, "NSK" }, 833 { ELFOSABI_AROS, "AROS" }, 834 { ELFOSABI_FENIXOS, "FenixOS" } 835 }; 836 837 /* Return ELFOSABI_XXX for an OSABI string, OSABI. */ 838 839 static int 840 elf_osabi (const char *osabi) 841 { 842 unsigned int i; 843 844 for (i = 0; i < ARRAY_SIZE (osabis); i++) 845 if (strcasecmp (osabi, osabis[i].name) == 0) 846 return osabis[i].osabi; 847 848 error (_("Unknown OSABI: %s\n"), osabi); 849 850 return -1; 851 } 852 853 /* Return EM_XXX for a machine string, MACH. */ 854 855 static int 856 elf_machine (const char *mach) 857 { 858 if (strcasecmp (mach, "i386") == 0) 859 return EM_386; 860 if (strcasecmp (mach, "iamcu") == 0) 861 return EM_IAMCU; 862 if (strcasecmp (mach, "l1om") == 0) 863 return EM_L1OM; 864 if (strcasecmp (mach, "k1om") == 0) 865 return EM_K1OM; 866 if (strcasecmp (mach, "x86_64") == 0) 867 return EM_X86_64; 868 if (strcasecmp (mach, "x86-64") == 0) 869 return EM_X86_64; 870 if (strcasecmp (mach, "none") == 0) 871 return EM_NONE; 872 873 error (_("Unknown machine type: %s\n"), mach); 874 875 return -1; 876 } 877 878 /* Return ET_XXX for a type string, TYPE. */ 879 880 static int 881 elf_type (const char *type) 882 { 883 if (strcasecmp (type, "rel") == 0) 884 return ET_REL; 885 if (strcasecmp (type, "exec") == 0) 886 return ET_EXEC; 887 if (strcasecmp (type, "dyn") == 0) 888 return ET_DYN; 889 if (strcasecmp (type, "none") == 0) 890 return ET_NONE; 891 892 error (_("Unknown type: %s\n"), type); 893 894 return -1; 895 } 896 897 enum command_line_switch 898 { 899 OPTION_INPUT_MACH = 150, 900 OPTION_OUTPUT_MACH, 901 OPTION_INPUT_TYPE, 902 OPTION_OUTPUT_TYPE, 903 OPTION_INPUT_OSABI, 904 OPTION_OUTPUT_OSABI, 905 OPTION_INPUT_ABIVERSION, 906 OPTION_OUTPUT_ABIVERSION, 907 #ifdef HAVE_MMAP 908 OPTION_ENABLE_X86_FEATURE, 909 OPTION_DISABLE_X86_FEATURE, 910 #endif 911 }; 912 913 static struct option options[] = 914 { 915 {"input-mach", required_argument, 0, OPTION_INPUT_MACH}, 916 {"output-mach", required_argument, 0, OPTION_OUTPUT_MACH}, 917 {"input-type", required_argument, 0, OPTION_INPUT_TYPE}, 918 {"output-type", required_argument, 0, OPTION_OUTPUT_TYPE}, 919 {"input-osabi", required_argument, 0, OPTION_INPUT_OSABI}, 920 {"output-osabi", required_argument, 0, OPTION_OUTPUT_OSABI}, 921 {"input-abiversion", required_argument, 0, OPTION_INPUT_ABIVERSION}, 922 {"output-abiversion", required_argument, 0, OPTION_OUTPUT_ABIVERSION}, 923 #ifdef HAVE_MMAP 924 {"enable-x86-feature", 925 required_argument, 0, OPTION_ENABLE_X86_FEATURE}, 926 {"disable-x86-feature", 927 required_argument, 0, OPTION_DISABLE_X86_FEATURE}, 928 #endif 929 {"version", no_argument, 0, 'v'}, 930 {"help", no_argument, 0, 'h'}, 931 {0, no_argument, 0, 0} 932 }; 933 934 ATTRIBUTE_NORETURN static void 935 usage (FILE *stream, int exit_status) 936 { 937 unsigned int i; 938 char *osabi = concat (osabis[0].name, NULL); 939 940 for (i = 1; i < ARRAY_SIZE (osabis); i++) 941 osabi = reconcat (osabi, osabi, "|", osabis[i].name, NULL); 942 943 fprintf (stream, _("Usage: %s <option(s)> elffile(s)\n"), 944 program_name); 945 fprintf (stream, _(" Update the ELF header of ELF files\n")); 946 fprintf (stream, _(" The options are:\n")); 947 fprintf (stream, _("\ 948 --input-mach [none|i386|iamcu|l1om|k1om|x86_64]\n\ 949 Set input machine type\n\ 950 --output-mach [none|i386|iamcu|l1om|k1om|x86_64]\n\ 951 Set output machine type\n\ 952 --input-type [none|rel|exec|dyn]\n\ 953 Set input file type\n\ 954 --output-type [none|rel|exec|dyn]\n\ 955 Set output file type\n\ 956 --input-osabi [%s]\n\ 957 Set input OSABI\n\ 958 --output-osabi [%s]\n\ 959 Set output OSABI\n\ 960 --input-abiversion [0-255] Set input ABIVERSION\n\ 961 --output-abiversion [0-255] Set output ABIVERSION\n"), 962 osabi, osabi); 963 #ifdef HAVE_MMAP 964 fprintf (stream, _("\ 965 --enable-x86-feature [ibt|shstk|lam_u48|lam_u57]\n\ 966 Enable x86 feature\n\ 967 --disable-x86-feature [ibt|shstk|lam_u48|lam_u57]\n\ 968 Disable x86 feature\n")); 969 #endif 970 fprintf (stream, _("\ 971 -h --help Display this information\n\ 972 -v --version Display the version number of %s\n\ 973 "), 974 program_name); 975 if (REPORT_BUGS_TO[0] && exit_status == 0) 976 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO); 977 free (osabi); 978 exit (exit_status); 979 } 980 981 int 982 main (int argc, char ** argv) 983 { 984 int c, status; 985 char *end; 986 987 #ifdef HAVE_LC_MESSAGES 988 setlocale (LC_MESSAGES, ""); 989 #endif 990 setlocale (LC_CTYPE, ""); 991 bindtextdomain (PACKAGE, LOCALEDIR); 992 textdomain (PACKAGE); 993 994 expandargv (&argc, &argv); 995 996 while ((c = getopt_long (argc, argv, "hv", 997 options, (int *) 0)) != EOF) 998 { 999 switch (c) 1000 { 1001 case OPTION_INPUT_MACH: 1002 input_elf_machine = elf_machine (optarg); 1003 if (input_elf_machine < 0) 1004 return 1; 1005 input_elf_class = elf_class (input_elf_machine); 1006 if (input_elf_class == ELF_CLASS_UNKNOWN) 1007 return 1; 1008 break; 1009 1010 case OPTION_OUTPUT_MACH: 1011 output_elf_machine = elf_machine (optarg); 1012 if (output_elf_machine < 0) 1013 return 1; 1014 output_elf_class = elf_class (output_elf_machine); 1015 if (output_elf_class == ELF_CLASS_UNKNOWN) 1016 return 1; 1017 break; 1018 1019 case OPTION_INPUT_TYPE: 1020 input_elf_type = elf_type (optarg); 1021 if (input_elf_type < 0) 1022 return 1; 1023 break; 1024 1025 case OPTION_OUTPUT_TYPE: 1026 output_elf_type = elf_type (optarg); 1027 if (output_elf_type < 0) 1028 return 1; 1029 break; 1030 1031 case OPTION_INPUT_OSABI: 1032 input_elf_osabi = elf_osabi (optarg); 1033 if (input_elf_osabi < 0) 1034 return 1; 1035 break; 1036 1037 case OPTION_OUTPUT_OSABI: 1038 output_elf_osabi = elf_osabi (optarg); 1039 if (output_elf_osabi < 0) 1040 return 1; 1041 break; 1042 1043 case OPTION_INPUT_ABIVERSION: 1044 input_elf_abiversion = strtoul (optarg, &end, 0); 1045 if (*end != '\0' 1046 || input_elf_abiversion < 0 1047 || input_elf_abiversion > 255) 1048 { 1049 error (_("Invalid ABIVERSION: %s\n"), optarg); 1050 return 1; 1051 } 1052 break; 1053 1054 case OPTION_OUTPUT_ABIVERSION: 1055 output_elf_abiversion = strtoul (optarg, &end, 0); 1056 if (*end != '\0' 1057 || output_elf_abiversion < 0 1058 || output_elf_abiversion > 255) 1059 { 1060 error (_("Invalid ABIVERSION: %s\n"), optarg); 1061 return 1; 1062 } 1063 break; 1064 1065 #ifdef HAVE_MMAP 1066 case OPTION_ENABLE_X86_FEATURE: 1067 if (elf_x86_feature (optarg, 1) < 0) 1068 return 1; 1069 break; 1070 1071 case OPTION_DISABLE_X86_FEATURE: 1072 if (elf_x86_feature (optarg, 0) < 0) 1073 return 1; 1074 break; 1075 #endif 1076 1077 case 'h': 1078 usage (stdout, 0); 1079 1080 case 'v': 1081 print_version (program_name); 1082 break; 1083 1084 default: 1085 usage (stderr, 1); 1086 } 1087 } 1088 1089 if (optind == argc 1090 || (output_elf_machine == -1 1091 #ifdef HAVE_MMAP 1092 && ! enable_x86_features 1093 && ! disable_x86_features 1094 #endif 1095 && output_elf_type == -1 1096 && output_elf_osabi == -1 1097 && output_elf_abiversion == -1)) 1098 usage (stderr, 1); 1099 1100 status = 0; 1101 while (optind < argc) 1102 status |= process_file (argv[optind++]); 1103 1104 return status; 1105 } 1106