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