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