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