Don't change input_elf_XXX if they are -1
[external/binutils.git] / binutils / elfedit.c
1 /* elfedit.c -- Update the ELF header of an ELF format file
2    Copyright 2010
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 \f
22 #include "config.h"
23 #include "sysdep.h"
24 #include <assert.h>
25 #include <sys/stat.h>
26
27 #if __GNUC__ >= 2
28 /* Define BFD64 here, even if our default architecture is 32 bit ELF
29    as this will allow us to read in and parse 64bit and 32bit ELF files.
30    Only do this if we believe that the compiler can support a 64 bit
31    data type.  For now we only rely on GCC being able to do this.  */
32 #define BFD64
33 #endif
34
35 #include "bfd.h"
36 #include "bucomm.h"
37
38 #include "elf/common.h"
39 #include "elf/external.h"
40 #include "elf/internal.h"
41
42
43 #include "aout/ar.h"
44
45 #include "getopt.h"
46 #include "libiberty.h"
47 #include "safe-ctype.h"
48 #include "filenames.h"
49
50 char * program_name = "elfedit";
51 static long archive_file_offset;
52 static unsigned long archive_file_size;
53 static Elf_Internal_Ehdr elf_header;
54 static Elf32_External_Ehdr ehdr32;
55 static Elf64_External_Ehdr ehdr64;
56 static int input_elf_machine = -1;
57 static int output_elf_machine = -1;
58 static int input_elf_class = -1;
59
60 #define streq(a,b)        (strcmp ((a), (b)) == 0)
61 #define strneq(a,b,n)     (strncmp ((a), (b), (n)) == 0)
62 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
63
64 void
65 non_fatal (const char *message, ...)
66 {
67   va_list args;
68
69   va_start (args, message);
70   fprintf (stderr, _("%s: Error: "), program_name);
71   vfprintf (stderr, message, args);
72   va_end (args);
73 }
74
75 #define BYTE_GET(field)         byte_get (field, sizeof (field))
76 #define BYTE_PUT(field, val)    byte_put (field, val, sizeof (field))
77
78 static bfd_vma (*byte_get) (unsigned char *, int);
79 static void (*byte_put) (unsigned char *, bfd_vma, int);
80
81 static bfd_vma
82 byte_get_little_endian (unsigned char *field, int size)
83 {
84   switch (size)
85     {
86     case 1:
87       return *field;
88
89     case 2:
90       return  ((unsigned int) (field[0]))
91         |    (((unsigned int) (field[1])) << 8);
92
93     case 4:
94       return  ((unsigned long) (field[0]))
95         |    (((unsigned long) (field[1])) << 8)
96         |    (((unsigned long) (field[2])) << 16)
97         |    (((unsigned long) (field[3])) << 24);
98
99     case 8:
100       if (sizeof (bfd_vma) == 8)
101         return  ((bfd_vma) (field[0]))
102           |    (((bfd_vma) (field[1])) << 8)
103           |    (((bfd_vma) (field[2])) << 16)
104           |    (((bfd_vma) (field[3])) << 24)
105           |    (((bfd_vma) (field[4])) << 32)
106           |    (((bfd_vma) (field[5])) << 40)
107           |    (((bfd_vma) (field[6])) << 48)
108           |    (((bfd_vma) (field[7])) << 56);
109       else if (sizeof (bfd_vma) == 4)
110         /* We want to extract data from an 8 byte wide field and
111            place it into a 4 byte wide field.  Since this is a little
112            endian source we can just use the 4 byte extraction code.  */
113         return  ((unsigned long) (field[0]))
114           |    (((unsigned long) (field[1])) << 8)
115           |    (((unsigned long) (field[2])) << 16)
116           |    (((unsigned long) (field[3])) << 24);
117
118     default:
119       non_fatal (_("Unhandled data length: %d\n"), size);
120       abort ();
121     }
122 }
123
124 static bfd_vma
125 byte_get_big_endian (unsigned char *field, int size)
126 {
127   switch (size)
128     {
129     case 1:
130       return *field;
131
132     case 2:
133       return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
134
135     case 4:
136       return ((unsigned long) (field[3]))
137         |   (((unsigned long) (field[2])) << 8)
138         |   (((unsigned long) (field[1])) << 16)
139         |   (((unsigned long) (field[0])) << 24);
140
141     case 8:
142       if (sizeof (bfd_vma) == 8)
143         return ((bfd_vma) (field[7]))
144           |   (((bfd_vma) (field[6])) << 8)
145           |   (((bfd_vma) (field[5])) << 16)
146           |   (((bfd_vma) (field[4])) << 24)
147           |   (((bfd_vma) (field[3])) << 32)
148           |   (((bfd_vma) (field[2])) << 40)
149           |   (((bfd_vma) (field[1])) << 48)
150           |   (((bfd_vma) (field[0])) << 56);
151       else if (sizeof (bfd_vma) == 4)
152         {
153           /* Although we are extracing data from an 8 byte wide field,
154              we are returning only 4 bytes of data.  */
155           field += 4;
156           return ((unsigned long) (field[3]))
157             |   (((unsigned long) (field[2])) << 8)
158             |   (((unsigned long) (field[1])) << 16)
159             |   (((unsigned long) (field[0])) << 24);
160         }
161
162     default:
163       non_fatal (_("Unhandled data length: %d\n"), size);
164       abort ();
165     }
166 }
167
168 static void
169 byte_put_little_endian (unsigned char * field, bfd_vma value, int size)
170 {
171   switch (size)
172     {
173     case 8:
174       field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
175       field[6] = ((value >> 24) >> 24) & 0xff;
176       field[5] = ((value >> 24) >> 16) & 0xff;
177       field[4] = ((value >> 24) >> 8) & 0xff;
178       /* Fall through.  */
179     case 4:
180       field[3] = (value >> 24) & 0xff;
181       field[2] = (value >> 16) & 0xff;
182       /* Fall through.  */
183     case 2:
184       field[1] = (value >> 8) & 0xff;
185       /* Fall through.  */
186     case 1:
187       field[0] = value & 0xff;
188       break;
189
190     default:
191       non_fatal (_("Unhandled data length: %d\n"), size);
192       abort ();
193     }
194 }
195
196 static void
197 byte_put_big_endian (unsigned char * field, bfd_vma value, int size)
198 {
199   switch (size)
200     {
201     case 8:
202       field[7] = value & 0xff;
203       field[6] = (value >> 8) & 0xff;
204       field[5] = (value >> 16) & 0xff;
205       field[4] = (value >> 24) & 0xff;
206       value >>= 16;
207       value >>= 16;
208       /* Fall through.  */
209     case 4:
210       field[3] = value & 0xff;
211       field[2] = (value >> 8) & 0xff;
212       value >>= 16;
213       /* Fall through.  */
214     case 2:
215       field[1] = value & 0xff;
216       value >>= 8;
217       /* Fall through.  */
218     case 1:
219       field[0] = value & 0xff;
220       break;
221
222     default:
223       non_fatal (_("Unhandled data length: %d\n"), size);
224       abort ();
225     }
226 }
227
228 static int
229 update_elf_header (const char *file_name, FILE *file)
230 {
231   int class, machine, status;
232
233   if (elf_header.e_ident[EI_MAG0] != ELFMAG0
234       || elf_header.e_ident[EI_MAG1] != ELFMAG1
235       || elf_header.e_ident[EI_MAG2] != ELFMAG2
236       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
237     {
238       non_fatal
239         (_("%s: Not an ELF file - wrong magic bytes at the start\n"),
240          file_name);
241       return 0;
242     }
243
244   if (elf_header.e_ident[EI_VERSION] != EV_CURRENT)
245     {
246       non_fatal
247         (_("%s: Unsupported EI_VERSION: %d is not %d\n"),
248          file_name, elf_header.e_ident[EI_VERSION],
249          EV_CURRENT);
250       return 0;
251     }
252
253   /* Return if e_machine is the same as output_elf_machine.  */
254   if (output_elf_machine == elf_header.e_machine)
255     return 1;
256
257   class = elf_header.e_ident[EI_CLASS];
258
259   /* Skip if class doesn't match. */
260   if (input_elf_class != -1 && class != input_elf_class)
261     {
262       non_fatal
263         (_("%s: Unmatched EI_CLASS: %d is not %d\n"),
264          file_name, class, input_elf_class);
265       return 0;
266     }
267
268   machine = elf_header.e_machine;
269
270   /* Skip if e_machine doesn't match. */
271   if (input_elf_machine != -1 && machine != input_elf_machine)
272     {
273       non_fatal
274         (_("%s: Unmatched e_machine: %d is not %d\n"),
275          file_name, machine, input_elf_machine);
276       return 0;
277     }
278
279   /* Update e_machine.  */
280   switch (class)
281     {
282     default:
283       /* We should never get here.  */
284       abort ();
285       break;
286     case ELFCLASS32:
287       BYTE_PUT (ehdr32.e_machine, output_elf_machine);
288       status = fwrite (&ehdr32, sizeof (ehdr32), 1, file) == 1;
289       break;
290     case ELFCLASS64:
291       BYTE_PUT (ehdr64.e_machine, output_elf_machine);
292       status = fwrite (&ehdr64, sizeof (ehdr64), 1, file) == 1;
293       break;
294     }
295
296   if (status != 1)
297     non_fatal (_("%s: Failed to update ELF header: %s\n"),
298                file_name, strerror (errno));
299
300   return status;
301 }
302
303 static int
304 get_file_header (FILE * file)
305 {
306   /* Read in the identity array.  */
307   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
308     return 0;
309
310   /* Determine how to read the rest of the header.  */
311   switch (elf_header.e_ident[EI_DATA])
312     {
313     default: /* fall through */
314     case ELFDATANONE: /* fall through */
315     case ELFDATA2LSB:
316       byte_get = byte_get_little_endian;
317       byte_put = byte_put_little_endian;
318       break;
319     case ELFDATA2MSB:
320       byte_get = byte_get_big_endian;
321       byte_put = byte_put_big_endian;
322       break;
323     }
324
325   /* Read in the rest of the header.  For now we only support 32 bit
326      and 64 bit ELF files.  */
327   switch (elf_header.e_ident[EI_CLASS])
328     {
329     default:
330       non_fatal (_("Unsupported EI_CLASS: %d\n"),
331                  elf_header.e_ident[EI_CLASS]);
332       return 0;
333
334     case ELFCLASS32:
335       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT,
336                  1, file) != 1)
337         return 0;
338
339       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
340       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
341       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
342       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
343       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
344       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
345       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
346       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
347       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
348       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
349       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
350       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
351       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
352
353       memcpy (&ehdr32, &elf_header, EI_NIDENT);
354       break;
355
356     case ELFCLASS64:
357       /* If we have been compiled with sizeof (bfd_vma) == 4, then
358          we will not be able to cope with the 64bit data found in
359          64 ELF files.  Detect this now and abort before we start
360          overwriting things.  */
361       if (sizeof (bfd_vma) < 8)
362         {
363           non_fatal (_("This executable has been built without support for a\n\
364 64 bit data type and so it cannot process 64 bit ELF files.\n"));
365           return 0;
366         }
367
368       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT,
369                  1, file) != 1)
370         return 0;
371
372       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
373       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
374       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
375       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
376       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
377       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
378       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
379       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
380       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
381       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
382       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
383       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
384       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
385
386       memcpy (&ehdr64, &elf_header, EI_NIDENT);
387       break;
388     }
389   return 1;
390 }
391
392 /* Process one ELF object file according to the command line options.
393    This file may actually be stored in an archive.  The file is
394    positioned at the start of the ELF object.  */
395
396 static int
397 process_object (const char *file_name, FILE *file)
398 {
399   /* Rememeber where we are.  */
400   long offset = ftell (file);
401
402   if (! get_file_header (file))
403     {
404       non_fatal (_("%s: Failed to read ELF header\n"), file_name);
405       return 1;
406     }
407
408   /* Go to the position of the ELF header.  */
409   if (fseek (file, offset, SEEK_SET) != 0)
410     {
411       non_fatal (_("%s: Failed to seek to ELF header\n"), file_name);
412     }
413
414   if (! update_elf_header (file_name, file))
415     return 1;
416
417   return 0;
418 }
419
420 /* Return the path name for a proxy entry in a thin archive, adjusted relative
421    to the path name of the thin archive itself if necessary.  Always returns
422    a pointer to malloc'ed memory.  */
423
424 static char *
425 adjust_relative_path (const char *file_name, char * name, int name_len)
426 {
427   char * member_file_name;
428   const char * base_name = lbasename (file_name);
429
430   /* This is a proxy entry for a thin archive member.
431      If the extended name table contains an absolute path
432      name, or if the archive is in the current directory,
433      use the path name as given.  Otherwise, we need to
434      find the member relative to the directory where the
435      archive is located.  */
436   if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
437     {
438       member_file_name = malloc (name_len + 1);
439       if (member_file_name == NULL)
440         {
441           non_fatal (_("Out of memory\n"));
442           return NULL;
443         }
444       memcpy (member_file_name, name, name_len);
445       member_file_name[name_len] = '\0';
446     }
447   else
448     {
449       /* Concatenate the path components of the archive file name
450          to the relative path name from the extended name table.  */
451       size_t prefix_len = base_name - file_name;
452       member_file_name = malloc (prefix_len + name_len + 1);
453       if (member_file_name == NULL)
454         {
455           non_fatal (_("Out of memory\n"));
456           return NULL;
457         }
458       memcpy (member_file_name, file_name, prefix_len);
459       memcpy (member_file_name + prefix_len, name, name_len);
460       member_file_name[prefix_len + name_len] = '\0';
461     }
462   return member_file_name;
463 }
464
465 /* Structure to hold information about an archive file.  */
466
467 struct archive_info
468 {
469   char * file_name;                     /* Archive file name.  */
470   FILE * file;                          /* Open file descriptor.  */
471   unsigned long index_num;              /* Number of symbols in table.  */
472   unsigned long * index_array;          /* The array of member offsets.  */
473   char * sym_table;                     /* The symbol table.  */
474   unsigned long sym_size;               /* Size of the symbol table.  */
475   char * longnames;                     /* The long file names table.  */
476   unsigned long longnames_size;         /* Size of the long file names table.  */
477   unsigned long nested_member_origin;   /* Origin in the nested archive of the current member.  */
478   unsigned long next_arhdr_offset;      /* Offset of the next archive header.  */
479   bfd_boolean is_thin_archive;          /* TRUE if this is a thin archive.  */
480   struct ar_hdr arhdr;                  /* Current archive header.  */
481 };
482
483 /* Read the symbol table and long-name table from an archive.  */
484
485 static int
486 setup_archive (struct archive_info * arch, const char * file_name,
487                FILE * file, bfd_boolean is_thin_archive)
488 {
489   size_t got;
490   unsigned long size;
491
492   arch->file_name = strdup (file_name);
493   arch->file = file;
494   arch->index_num = 0;
495   arch->index_array = NULL;
496   arch->sym_table = NULL;
497   arch->sym_size = 0;
498   arch->longnames = NULL;
499   arch->longnames_size = 0;
500   arch->nested_member_origin = 0;
501   arch->is_thin_archive = is_thin_archive;
502   arch->next_arhdr_offset = SARMAG;
503
504   /* Read the first archive member header.  */
505   if (fseek (file, SARMAG, SEEK_SET) != 0)
506     {
507       non_fatal (_("%s: failed to seek to first archive header\n"),
508                  file_name);
509       return 1;
510     }
511   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
512   if (got != sizeof arch->arhdr)
513     {
514       if (got == 0)
515         return 0;
516
517       non_fatal (_("%s: failed to read archive header\n"), file_name);
518       return 1;
519     }
520
521   /* See if this is the archive symbol table.  */
522   if (const_strneq (arch->arhdr.ar_name, "/               ")
523       || const_strneq (arch->arhdr.ar_name, "/SYM64/         "))
524     {
525       size = strtoul (arch->arhdr.ar_size, NULL, 10);
526       size = size + (size & 1);
527
528       arch->next_arhdr_offset += sizeof arch->arhdr + size;
529
530       if (fseek (file, size, SEEK_CUR) != 0)
531         {
532           non_fatal (_("%s: failed to skip archive symbol table\n"),
533                      file_name);
534           return 1;
535         }
536
537       /* Read the next archive header.  */
538       got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
539       if (got != sizeof arch->arhdr)
540         {
541           if (got == 0)
542             return 0;
543           non_fatal (_("%s: failed to read archive header following archive index\n"),
544                      file_name);
545           return 1;
546         }
547     }
548
549   if (const_strneq (arch->arhdr.ar_name, "//              "))
550     {
551       /* This is the archive string table holding long member names.  */
552       arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
553       arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
554
555       arch->longnames = malloc (arch->longnames_size);
556       if (arch->longnames == NULL)
557         {
558           non_fatal (_("Out of memory reading long symbol names in archive\n"));
559           return 1;
560         }
561
562       if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
563         {
564           free (arch->longnames);
565           arch->longnames = NULL;
566           non_fatal (_("%s: failed to read long symbol name string table\n")
567                      , file_name);
568           return 1;
569         }
570
571       if ((arch->longnames_size & 1) != 0)
572         getc (file);
573     }
574
575   return 0;
576 }
577
578 /* Release the memory used for the archive information.  */
579
580 static void
581 release_archive (struct archive_info * arch)
582 {
583   if (arch->file_name != NULL)
584     free (arch->file_name);
585   if (arch->index_array != NULL)
586     free (arch->index_array);
587   if (arch->sym_table != NULL)
588     free (arch->sym_table);
589   if (arch->longnames != NULL)
590     free (arch->longnames);
591 }
592
593 /* Open and setup a nested archive, if not already open.  */
594
595 static int
596 setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
597 {
598   FILE * member_file;
599
600   /* Have we already setup this archive?  */
601   if (nested_arch->file_name != NULL
602       && streq (nested_arch->file_name, member_file_name))
603     return 0;
604
605   /* Close previous file and discard cached information.  */
606   if (nested_arch->file != NULL)
607     fclose (nested_arch->file);
608   release_archive (nested_arch);
609
610   member_file = fopen (member_file_name, "r+b");
611   if (member_file == NULL)
612     return 1;
613   return setup_archive (nested_arch, member_file_name, member_file,
614                         FALSE);
615 }
616
617 static char *
618 get_archive_member_name_at (struct archive_info *  arch,
619                             unsigned long          offset,
620                             struct archive_info *  nested_arch);
621
622 /* Get the name of an archive member from the current archive header.
623    For simple names, this will modify the ar_name field of the current
624    archive header.  For long names, it will return a pointer to the
625    longnames table.  For nested archives, it will open the nested archive
626    and get the name recursively.  NESTED_ARCH is a single-entry cache so
627    we don't keep rereading the same information from a nested archive.  */
628
629 static char *
630 get_archive_member_name (struct archive_info *  arch,
631                          struct archive_info *  nested_arch)
632 {
633   unsigned long j, k;
634
635   if (arch->arhdr.ar_name[0] == '/')
636     {
637       /* We have a long name.  */
638       char * endp;
639       char * member_file_name;
640       char * member_name;
641
642       arch->nested_member_origin = 0;
643       k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
644       if (arch->is_thin_archive && endp != NULL && * endp == ':')
645         arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
646
647       while ((j < arch->longnames_size)
648              && (arch->longnames[j] != '\n')
649              && (arch->longnames[j] != '\0'))
650         j++;
651       if (arch->longnames[j-1] == '/')
652         j--;
653       arch->longnames[j] = '\0';
654
655       if (!arch->is_thin_archive || arch->nested_member_origin == 0)
656         return arch->longnames + k;
657
658       /* This is a proxy for a member of a nested archive.
659          Find the name of the member in that archive.  */
660       member_file_name = adjust_relative_path (arch->file_name,
661                                                arch->longnames + k,
662                                                j - k);
663       if (member_file_name != NULL
664           && setup_nested_archive (nested_arch, member_file_name) == 0
665           && (member_name = get_archive_member_name_at (nested_arch,
666                                                         arch->nested_member_origin,
667                                                         NULL)) != NULL)
668         {
669           free (member_file_name);
670           return member_name;
671         }
672       free (member_file_name);
673
674       /* Last resort: just return the name of the nested archive.  */
675       return arch->longnames + k;
676     }
677
678   /* We have a normal (short) name.  */
679   j = 0;
680   while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
681     j++;
682   arch->arhdr.ar_name[j] = '\0';
683   return arch->arhdr.ar_name;
684 }
685
686 /* Get the name of an archive member at a given OFFSET within an
687    archive ARCH.  */
688
689 static char *
690 get_archive_member_name_at (struct archive_info * arch,
691                             unsigned long         offset,
692                             struct archive_info * nested_arch)
693 {
694   size_t got;
695
696   if (fseek (arch->file, offset, SEEK_SET) != 0)
697     {
698       non_fatal (_("%s: failed to seek to next file name\n"),
699                  arch->file_name);
700       return NULL;
701     }
702   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
703   if (got != sizeof arch->arhdr)
704     {
705       non_fatal (_("%s: failed to read archive header\n"),
706                  arch->file_name);
707       return NULL;
708     }
709   if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
710     {
711       non_fatal (_("%s: did not find a valid archive header\n"),
712                  arch->file_name);
713       return NULL;
714     }
715
716   return get_archive_member_name (arch, nested_arch);
717 }
718
719 /* Construct a string showing the name of the archive member, qualified
720    with the name of the containing archive file.  For thin archives, we
721    use square brackets to denote the indirection.  For nested archives,
722    we show the qualified name of the external member inside the square
723    brackets (e.g., "thin.a[normal.a(foo.o)]").  */
724
725 static char *
726 make_qualified_name (struct archive_info * arch,
727                      struct archive_info * nested_arch,
728                      char * member_name)
729 {
730   size_t len;
731   char * name;
732
733   len = strlen (arch->file_name) + strlen (member_name) + 3;
734   if (arch->is_thin_archive && arch->nested_member_origin != 0)
735     len += strlen (nested_arch->file_name) + 2;
736
737   name = malloc (len);
738   if (name == NULL)
739     {
740       non_fatal (_("Out of memory\n"));
741       return NULL;
742     }
743
744   if (arch->is_thin_archive && arch->nested_member_origin != 0)
745     snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
746   else if (arch->is_thin_archive)
747     snprintf (name, len, "%s[%s]", arch->file_name, member_name);
748   else
749     snprintf (name, len, "%s(%s)", arch->file_name, member_name);
750
751   return name;
752 }
753
754 /* Process an ELF archive.
755    On entry the file is positioned just after the ARMAG string.  */
756
757 static int
758 process_archive (const char * file_name, FILE * file,
759                  bfd_boolean is_thin_archive)
760 {
761   struct archive_info arch;
762   struct archive_info nested_arch;
763   size_t got;
764   size_t file_name_size;
765   int ret;
766
767   /* The ARCH structure is used to hold information about this archive.  */
768   arch.file_name = NULL;
769   arch.file = NULL;
770   arch.index_array = NULL;
771   arch.sym_table = NULL;
772   arch.longnames = NULL;
773
774   /* The NESTED_ARCH structure is used as a single-item cache of information
775      about a nested archive (when members of a thin archive reside within
776      another regular archive file).  */
777   nested_arch.file_name = NULL;
778   nested_arch.file = NULL;
779   nested_arch.index_array = NULL;
780   nested_arch.sym_table = NULL;
781   nested_arch.longnames = NULL;
782
783   if (setup_archive (&arch, file_name, file, is_thin_archive) != 0)
784     {
785       ret = 1;
786       goto out;
787     }
788
789   file_name_size = strlen (file_name);
790   ret = 0;
791
792   while (1)
793     {
794       char * name;
795       size_t namelen;
796       char * qualified_name;
797
798       /* Read the next archive header.  */
799       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
800         {
801           non_fatal (_("%s: failed to seek to next archive header\n"),
802                      file_name);
803           return 1;
804         }
805       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
806       if (got != sizeof arch.arhdr)
807         {
808           if (got == 0)
809             break;
810           non_fatal (_("%s: failed to read archive header\n"),
811                      file_name);
812           ret = 1;
813           break;
814         }
815       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
816         {
817           non_fatal (_("%s: did not find a valid archive header\n"),
818                      arch.file_name);
819           ret = 1;
820           break;
821         }
822
823       arch.next_arhdr_offset += sizeof arch.arhdr;
824
825       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
826       if (archive_file_size & 01)
827         ++archive_file_size;
828
829       name = get_archive_member_name (&arch, &nested_arch);
830       if (name == NULL)
831         {
832           non_fatal (_("%s: bad archive file name\n"), file_name);
833           ret = 1;
834           break;
835         }
836       namelen = strlen (name);
837
838       qualified_name = make_qualified_name (&arch, &nested_arch, name);
839       if (qualified_name == NULL)
840         {
841           non_fatal (_("%s: bad archive file name\n"), file_name);
842           ret = 1;
843           break;
844         }
845
846       if (is_thin_archive && arch.nested_member_origin == 0)
847         {
848           /* This is a proxy for an external member of a thin archive.  */
849           FILE *member_file;
850           char *member_file_name = adjust_relative_path (file_name,
851                                                          name, namelen);
852           if (member_file_name == NULL)
853             {
854               ret = 1;
855               break;
856             }
857
858           member_file = fopen (member_file_name, "r+b");
859           if (member_file == NULL)
860             {
861               non_fatal (_("Input file '%s' is not readable\n"),
862                          member_file_name);
863               free (member_file_name);
864               ret = 1;
865               break;
866             }
867
868           archive_file_offset = arch.nested_member_origin;
869
870           ret |= process_object (qualified_name, member_file);
871
872           fclose (member_file);
873           free (member_file_name);
874         }
875       else if (is_thin_archive)
876         {
877           /* This is a proxy for a member of a nested archive.  */
878           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
879
880           /* The nested archive file will have been opened and setup by
881              get_archive_member_name.  */
882           if (fseek (nested_arch.file, archive_file_offset,
883                      SEEK_SET) != 0)
884             {
885               non_fatal (_("%s: failed to seek to archive member\n"),
886                          nested_arch.file_name);
887               ret = 1;
888               break;
889             }
890
891           ret |= process_object (qualified_name, nested_arch.file);
892         }
893       else
894         {
895           archive_file_offset = arch.next_arhdr_offset;
896           arch.next_arhdr_offset += archive_file_size;
897
898           ret |= process_object (qualified_name, file);
899         }
900
901       free (qualified_name);
902     }
903
904  out:
905   if (nested_arch.file != NULL)
906     fclose (nested_arch.file);
907   release_archive (&nested_arch);
908   release_archive (&arch);
909
910   return ret;
911 }
912
913 static int
914 check_file (const char *file_name, struct stat *statbuf_p)
915 {
916   struct stat statbuf;
917
918   if (statbuf_p == NULL)
919     statbuf_p = &statbuf;
920
921   if (stat (file_name, statbuf_p) < 0)
922     {
923       if (errno == ENOENT)
924         non_fatal (_("'%s': No such file\n"), file_name);
925       else
926         non_fatal (_("Could not locate '%s'.  System error message: %s\n"),
927                    file_name, strerror (errno));
928       return 1;
929     }
930
931   if (! S_ISREG (statbuf_p->st_mode))
932     {
933       non_fatal (_("'%s' is not an ordinary file\n"), file_name);
934       return 1;
935     }
936
937   return 0;
938 }
939
940 static int
941 process_file (const char *file_name)
942 {
943   FILE * file;
944   char armag[SARMAG];
945   int ret;
946
947   if (check_file (file_name, NULL))
948     return 1;
949
950   file = fopen (file_name, "r+b");
951   if (file == NULL)
952     {
953       non_fatal (_("Input file '%s' is not readable\n"), file_name);
954       return 1;
955     }
956
957   if (fread (armag, SARMAG, 1, file) != 1)
958     {
959       non_fatal (_("%s: Failed to read file's magic number\n"),
960                  file_name);
961       fclose (file);
962       return 1;
963     }
964
965   if (memcmp (armag, ARMAG, SARMAG) == 0)
966     ret = process_archive (file_name, file, FALSE);
967   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
968     ret = process_archive (file_name, file, TRUE);
969   else
970     {
971       rewind (file);
972       archive_file_size = archive_file_offset = 0;
973       ret = process_object (file_name, file);
974     }
975
976   fclose (file);
977
978   return ret;
979 }
980
981 /* Return EM_XXX for a machine string, MACH.  */
982
983 static int
984 elf_machine (const char *mach)
985 {
986   if (strcasecmp (mach, "l1om") == 0)
987     return EM_L1OM;
988   if (strcasecmp (mach, "x86_64") == 0)
989     return EM_X86_64;
990   if (strcasecmp (mach, "x86-64") == 0)
991     return EM_X86_64;
992   if (strcasecmp (mach, "none") == 0)
993     return EM_NONE;
994
995   non_fatal (_("Unknown machine type: %s\n"), mach);
996
997   return -1;
998 }
999
1000 /* Return ELF class for a machine type, MACH.  */
1001
1002 static int
1003 elf_class (int mach)
1004 {
1005   switch (mach)
1006     {
1007     case EM_L1OM:
1008     case EM_X86_64:
1009       return ELFCLASS64;
1010     case EM_NONE:
1011       return ELFCLASSNONE;
1012     default:
1013       non_fatal (_("Unknown machine type: %d\n"), mach);
1014       return -1;
1015     }
1016 }
1017
1018 enum command_line_switch
1019   {
1020     OPTION_INPUT_MACH = 150,
1021     OPTION_OUTPUT_MACH
1022   };
1023
1024 static struct option options[] =
1025 {
1026   {"input-mach",        required_argument, 0, OPTION_INPUT_MACH},
1027   {"output-mach",       required_argument, 0, OPTION_OUTPUT_MACH},
1028   {"version",           no_argument, 0, 'v'},
1029   {"help",              no_argument, 0, 'h'},
1030   {0,                   no_argument, 0, 0}
1031 };
1032
1033 static void
1034 usage (FILE *stream, int exit_status)
1035 {
1036   fprintf (stream, _("Usage: %s [option(s)] --output-mach <machine> elffile(s)\n"),
1037            program_name);
1038   fprintf (stream, _(" Update the ELF header of ELF files\n"));
1039   fprintf (stream, _(" The options are:\n"));
1040   fprintf (stream, _("\
1041   --input-mach <machine>      Set input machine type to <machine>\n\
1042   --output-mach <machine>     Set output machine type to <machine>\n\
1043   -h --help                   Display this information\n\
1044   -v --version                Display the version number of %s\n\
1045 "),
1046            program_name);
1047   if (REPORT_BUGS_TO[0] && exit_status == 0)
1048     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
1049   exit (exit_status);
1050 }
1051
1052 int
1053 main (int argc, char ** argv)
1054 {
1055   int c, status;
1056
1057 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1058   setlocale (LC_MESSAGES, "");
1059 #endif
1060 #if defined (HAVE_SETLOCALE)
1061   setlocale (LC_CTYPE, "");
1062 #endif
1063   bindtextdomain (PACKAGE, LOCALEDIR);
1064   textdomain (PACKAGE);
1065
1066   expandargv (&argc, &argv);
1067
1068   while ((c = getopt_long (argc, argv, "hv",
1069                            options, (int *) 0)) != EOF)
1070     {
1071       switch (c)
1072         {
1073         case OPTION_INPUT_MACH:
1074           input_elf_machine = elf_machine (optarg);
1075           if (input_elf_machine < 0)
1076             return 1;
1077           input_elf_class = elf_class (input_elf_machine);
1078           if (input_elf_class < 0)
1079             return 1;
1080           break;
1081
1082         case OPTION_OUTPUT_MACH:
1083           output_elf_machine = elf_machine (optarg);
1084           if (output_elf_machine < 0)
1085             return 1;
1086           break;
1087
1088         case 'h':
1089           usage (stdout, 0);
1090
1091         case 'v':
1092           print_version (program_name);
1093           break;
1094
1095         default:
1096           usage (stderr, 1);
1097         }
1098     }
1099
1100   if (optind == argc || output_elf_machine == -1)
1101     usage (stderr, 1);
1102
1103   status = 0;
1104   while (optind < argc)
1105     status |= process_file (argv[optind++]);
1106
1107   return status;
1108 }