Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.21 / binutils / readelf.c
1 /* readelf.c -- display contents of an ELF format file
2    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3    2008, 2009, 2010, 2011
4    Free Software Foundation, Inc.
5
6    Originally developed by Eric Youngdale <eric@andante.jic.com>
7    Modifications by Nick Clifton <nickc@redhat.com>
8
9    This file is part of GNU Binutils.
10
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program; if not, write to the Free Software
23    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24    02110-1301, USA.  */
25 \f
26 /* The difference between readelf and objdump:
27
28   Both programs are capable of displaying the contents of ELF format files,
29   so why does the binutils project have two file dumpers ?
30
31   The reason is that objdump sees an ELF file through a BFD filter of the
32   world; if BFD has a bug where, say, it disagrees about a machine constant
33   in e_flags, then the odds are good that it will remain internally
34   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
35   GAS sees it the BFD way.  There was need for a tool to go find out what
36   the file actually says.
37
38   This is why the readelf program does not link against the BFD library - it
39   exists as an independent program to help verify the correct working of BFD.
40
41   There is also the case that readelf can provide more information about an
42   ELF file than is provided by objdump.  In particular it can display DWARF
43   debugging information which (at the moment) objdump cannot.  */
44 \f
45 #include "config.h"
46 #include "sysdep.h"
47 #include <assert.h>
48 #include <sys/stat.h>
49 #include <time.h>
50 #ifdef HAVE_ZLIB_H
51 #include <zlib.h>
52 #endif
53
54 #if __GNUC__ >= 2
55 /* Define BFD64 here, even if our default architecture is 32 bit ELF
56    as this will allow us to read in and parse 64bit and 32bit ELF files.
57    Only do this if we believe that the compiler can support a 64 bit
58    data type.  For now we only rely on GCC being able to do this.  */
59 #define BFD64
60 #endif
61
62 #include "bfd.h"
63 #include "bucomm.h"
64 #include "elfcomm.h"
65 #include "dwarf.h"
66
67 #include "elf/common.h"
68 #include "elf/external.h"
69 #include "elf/internal.h"
70
71
72 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
73    we can obtain the H8 reloc numbers.  We need these for the
74    get_reloc_size() function.  We include h8.h again after defining
75    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
76
77 #include "elf/h8.h"
78 #undef _ELF_H8_H
79
80 /* Undo the effects of #including reloc-macros.h.  */
81
82 #undef START_RELOC_NUMBERS
83 #undef RELOC_NUMBER
84 #undef FAKE_RELOC
85 #undef EMPTY_RELOC
86 #undef END_RELOC_NUMBERS
87 #undef _RELOC_MACROS_H
88
89 /* The following headers use the elf/reloc-macros.h file to
90    automatically generate relocation recognition functions
91    such as elf_mips_reloc_type()  */
92
93 #define RELOC_MACROS_GEN_FUNC
94
95 #include "elf/alpha.h"
96 #include "elf/arc.h"
97 #include "elf/arm.h"
98 #include "elf/avr.h"
99 #include "elf/bfin.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
102 #include "elf/crx.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
105 #include "elf/dlx.h"
106 #include "elf/fr30.h"
107 #include "elf/frv.h"
108 #include "elf/h8.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
123 #include "elf/mep.h"
124 #include "elf/microblaze.h"
125 #include "elf/mips.h"
126 #include "elf/mmix.h"
127 #include "elf/mn10200.h"
128 #include "elf/mn10300.h"
129 #include "elf/moxie.h"
130 #include "elf/mt.h"
131 #include "elf/msp430.h"
132 #include "elf/or32.h"
133 #include "elf/pj.h"
134 #include "elf/ppc.h"
135 #include "elf/ppc64.h"
136 #include "elf/rx.h"
137 #include "elf/s390.h"
138 #include "elf/score.h"
139 #include "elf/sh.h"
140 #include "elf/sparc.h"
141 #include "elf/spu.h"
142 #include "elf/tic6x.h"
143 #include "elf/v850.h"
144 #include "elf/vax.h"
145 #include "elf/x86-64.h"
146 #include "elf/xc16x.h"
147 #include "elf/xstormy16.h"
148 #include "elf/xtensa.h"
149
150 #include "getopt.h"
151 #include "libiberty.h"
152 #include "safe-ctype.h"
153 #include "filenames.h"
154
155 char * program_name = "readelf";
156 static long archive_file_offset;
157 static unsigned long archive_file_size;
158 static unsigned long dynamic_addr;
159 static bfd_size_type dynamic_size;
160 static unsigned int dynamic_nent;
161 static char * dynamic_strings;
162 static unsigned long dynamic_strings_length;
163 static char * string_table;
164 static unsigned long string_table_length;
165 static unsigned long num_dynamic_syms;
166 static Elf_Internal_Sym * dynamic_symbols;
167 static Elf_Internal_Syminfo * dynamic_syminfo;
168 static unsigned long dynamic_syminfo_offset;
169 static unsigned int dynamic_syminfo_nent;
170 static char program_interpreter[PATH_MAX];
171 static bfd_vma dynamic_info[DT_ENCODING];
172 static bfd_vma dynamic_info_DT_GNU_HASH;
173 static bfd_vma version_info[16];
174 static Elf_Internal_Ehdr elf_header;
175 static Elf_Internal_Shdr * section_headers;
176 static Elf_Internal_Phdr * program_headers;
177 static Elf_Internal_Dyn *  dynamic_section;
178 static Elf_Internal_Shdr * symtab_shndx_hdr;
179 static int show_name;
180 static int do_dynamic;
181 static int do_syms;
182 static int do_dyn_syms;
183 static int do_reloc;
184 static int do_sections;
185 static int do_section_groups;
186 static int do_section_details;
187 static int do_segments;
188 static int do_unwind;
189 static int do_using_dynamic;
190 static int do_header;
191 static int do_dump;
192 static int do_version;
193 static int do_histogram;
194 static int do_debugging;
195 static int do_arch;
196 static int do_notes;
197 static int do_archive_index;
198 static int is_32bit_elf;
199
200 struct group_list
201 {
202   struct group_list * next;
203   unsigned int section_index;
204 };
205
206 struct group
207 {
208   struct group_list * root;
209   unsigned int group_index;
210 };
211
212 static size_t group_count;
213 static struct group * section_groups;
214 static struct group ** section_headers_groups;
215
216
217 /* Flag bits indicating particular types of dump.  */
218 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
219 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
220 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
221 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
222 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
223
224 typedef unsigned char dump_type;
225
226 /* A linked list of the section names for which dumps were requested.  */
227 struct dump_list_entry
228 {
229   char * name;
230   dump_type type;
231   struct dump_list_entry * next;
232 };
233 static struct dump_list_entry * dump_sects_byname;
234
235 /* A dynamic array of flags indicating for which sections a dump
236    has been requested via command line switches.  */
237 static dump_type *   cmdline_dump_sects = NULL;
238 static unsigned int  num_cmdline_dump_sects = 0;
239
240 /* A dynamic array of flags indicating for which sections a dump of
241    some kind has been requested.  It is reset on a per-object file
242    basis and then initialised from the cmdline_dump_sects array,
243    the results of interpreting the -w switch, and the
244    dump_sects_byname list.  */
245 static dump_type *   dump_sects = NULL;
246 static unsigned int  num_dump_sects = 0;
247
248
249 /* How to print a vma value.  */
250 typedef enum print_mode
251 {
252   HEX,
253   DEC,
254   DEC_5,
255   UNSIGNED,
256   PREFIX_HEX,
257   FULL_HEX,
258   LONG_HEX
259 }
260 print_mode;
261
262 #define UNKNOWN -1
263
264 #define SECTION_NAME(X)                                         \
265   ((X) == NULL ? _("<none>")                                    \
266    : string_table == NULL ? _("<no-name>")                      \
267    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
268   : string_table + (X)->sh_name))
269
270 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
271
272 #define GET_ELF_SYMBOLS(file, section)                  \
273   (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
274    : get_64bit_elf_symbols (file, section))
275
276 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
277 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
278    already been called and verified that the string exists.  */
279 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
280
281 #define REMOVE_ARCH_BITS(ADDR) do {             \
282     if (elf_header.e_machine == EM_ARM)         \
283       (ADDR) &= ~1;                             \
284   } while (0)
285 \f
286 static void *
287 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
288           const char * reason)
289 {
290   void * mvar;
291
292   if (size == 0 || nmemb == 0)
293     return NULL;
294
295   if (fseek (file, archive_file_offset + offset, SEEK_SET))
296     {
297       error (_("Unable to seek to 0x%lx for %s\n"),
298              (unsigned long) archive_file_offset + offset, reason);
299       return NULL;
300     }
301
302   mvar = var;
303   if (mvar == NULL)
304     {
305       /* Check for overflow.  */
306       if (nmemb < (~(size_t) 0 - 1) / size)
307         /* + 1 so that we can '\0' terminate invalid string table sections.  */
308         mvar = malloc (size * nmemb + 1);
309
310       if (mvar == NULL)
311         {
312           error (_("Out of memory allocating 0x%lx bytes for %s\n"),
313                  (unsigned long)(size * nmemb), reason);
314           return NULL;
315         }
316
317       ((char *) mvar)[size * nmemb] = '\0';
318     }
319
320   if (fread (mvar, size, nmemb, file) != nmemb)
321     {
322       error (_("Unable to read in 0x%lx bytes of %s\n"),
323              (unsigned long)(size * nmemb), reason);
324       if (mvar != var)
325         free (mvar);
326       return NULL;
327     }
328
329   return mvar;
330 }
331
332 /* Print a VMA value.  */
333
334 static int
335 print_vma (bfd_vma vma, print_mode mode)
336 {
337   int nc = 0;
338
339   switch (mode)
340     {
341     case FULL_HEX:
342       nc = printf ("0x");
343       /* Drop through.  */
344
345     case LONG_HEX:
346 #ifdef BFD64
347       if (is_32bit_elf)
348         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
349 #endif
350       printf_vma (vma);
351       return nc + 16;
352
353     case DEC_5:
354       if (vma <= 99999)
355         return printf ("%5" BFD_VMA_FMT "d", vma);
356       /* Drop through.  */
357
358     case PREFIX_HEX:
359       nc = printf ("0x");
360       /* Drop through.  */
361
362     case HEX:
363       return nc + printf ("%" BFD_VMA_FMT "x", vma);
364
365     case DEC:
366       return printf ("%" BFD_VMA_FMT "d", vma);
367
368     case UNSIGNED:
369       return printf ("%" BFD_VMA_FMT "u", vma);
370     }
371   return 0;
372 }
373
374 /* Display a symbol on stdout.  Handles the display of non-printing characters.
375
376    If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
377    truncating as necessary.  If WIDTH is negative then format the string to be
378    exactly - WIDTH characters, truncating or padding as necessary.
379
380    Returns the number of emitted characters.  */
381
382 static unsigned int
383 print_symbol (int width, const char *symbol)
384 {
385   const char *c;
386   bfd_boolean extra_padding = FALSE;
387   unsigned int num_printed = 0;
388
389   if (do_wide)
390     {
391       /* Set the width to a very large value.  This simplifies the
392          code below.  */
393       width = INT_MAX;
394     }
395   else if (width < 0)
396     {
397       /* Keep the width positive.  This also helps.  */
398       width = - width;
399       extra_padding = TRUE;
400     }
401
402   while (width)
403     {
404       int len;
405
406       c = symbol;
407
408       /* Look for non-printing symbols inside the symbol's name.
409          This test is triggered in particular by the names generated
410          by the assembler for local labels.  */
411       while (ISPRINT (*c))
412         c++;
413
414       len = c - symbol;
415
416       if (len)
417         {
418           if (len > width)
419             len = width;
420
421           printf ("%.*s", len, symbol);
422
423           width -= len;
424           num_printed += len;
425         }
426
427       if (*c == 0 || width == 0)
428         break;
429
430       /* Now display the non-printing character, if
431          there is room left in which to dipslay it.  */
432       if ((unsigned char) *c < 32)
433         {
434           if (width < 2)
435             break;
436
437           printf ("^%c", *c + 0x40);
438
439           width -= 2;
440           num_printed += 2;
441         }
442       else
443         {
444           if (width < 6)
445             break;
446
447           printf ("<0x%.2x>", (unsigned char) *c);
448
449           width -= 6;
450           num_printed += 6;
451         }
452
453       symbol = c + 1;
454     }
455
456   if (extra_padding && width > 0)
457     {
458       /* Fill in the remaining spaces.  */
459       printf ("%-*s", width, " ");
460       num_printed += 2;
461     }
462
463   return num_printed;
464 }
465
466 /* Return a pointer to section NAME, or NULL if no such section exists.  */
467
468 static Elf_Internal_Shdr *
469 find_section (const char * name)
470 {
471   unsigned int i;
472
473   for (i = 0; i < elf_header.e_shnum; i++)
474     if (streq (SECTION_NAME (section_headers + i), name))
475       return section_headers + i;
476
477   return NULL;
478 }
479
480 /* Return a pointer to a section containing ADDR, or NULL if no such
481    section exists.  */
482
483 static Elf_Internal_Shdr *
484 find_section_by_address (bfd_vma addr)
485 {
486   unsigned int i;
487
488   for (i = 0; i < elf_header.e_shnum; i++)
489     {
490       Elf_Internal_Shdr *sec = section_headers + i;
491       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
492         return sec;
493     }
494
495   return NULL;
496 }
497
498 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
499    bytes read.  */
500
501 static unsigned long
502 read_uleb128 (unsigned char *data, unsigned int *length_return)
503 {
504   return read_leb128 (data, length_return, 0);
505 }
506
507 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
508    This OS has so many departures from the ELF standard that we test it at
509    many places.  */
510
511 static inline int
512 is_ia64_vms (void)
513 {
514   return elf_header.e_machine == EM_IA_64
515     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
516 }
517
518 /* Guess the relocation size commonly used by the specific machines.  */
519
520 static int
521 guess_is_rela (unsigned int e_machine)
522 {
523   switch (e_machine)
524     {
525       /* Targets that use REL relocations.  */
526     case EM_386:
527     case EM_486:
528     case EM_960:
529     case EM_ARM:
530     case EM_D10V:
531     case EM_CYGNUS_D10V:
532     case EM_DLX:
533     case EM_MIPS:
534     case EM_MIPS_RS3_LE:
535     case EM_CYGNUS_M32R:
536     case EM_OPENRISC:
537     case EM_OR32:
538     case EM_SCORE:
539       return FALSE;
540
541       /* Targets that use RELA relocations.  */
542     case EM_68K:
543     case EM_860:
544     case EM_ALPHA:
545     case EM_ALTERA_NIOS2:
546     case EM_AVR:
547     case EM_AVR_OLD:
548     case EM_BLACKFIN:
549     case EM_CR16:
550     case EM_CR16_OLD:
551     case EM_CRIS:
552     case EM_CRX:
553     case EM_D30V:
554     case EM_CYGNUS_D30V:
555     case EM_FR30:
556     case EM_CYGNUS_FR30:
557     case EM_CYGNUS_FRV:
558     case EM_H8S:
559     case EM_H8_300:
560     case EM_H8_300H:
561     case EM_IA_64:
562     case EM_IP2K:
563     case EM_IP2K_OLD:
564     case EM_IQ2000:
565     case EM_LATTICEMICO32:
566     case EM_M32C_OLD:
567     case EM_M32C:
568     case EM_M32R:
569     case EM_MCORE:
570     case EM_CYGNUS_MEP:
571     case EM_MMIX:
572     case EM_MN10200:
573     case EM_CYGNUS_MN10200:
574     case EM_MN10300:
575     case EM_CYGNUS_MN10300:
576     case EM_MOXIE:
577     case EM_MSP430:
578     case EM_MSP430_OLD:
579     case EM_MT:
580     case EM_NIOS32:
581     case EM_PPC64:
582     case EM_PPC:
583     case EM_RX:
584     case EM_S390:
585     case EM_S390_OLD:
586     case EM_SH:
587     case EM_SPARC:
588     case EM_SPARC32PLUS:
589     case EM_SPARCV9:
590     case EM_SPU:
591     case EM_TI_C6000:
592     case EM_V850:
593     case EM_CYGNUS_V850:
594     case EM_VAX:
595     case EM_X86_64:
596     case EM_L1OM:
597     case EM_XSTORMY16:
598     case EM_XTENSA:
599     case EM_XTENSA_OLD:
600     case EM_MICROBLAZE:
601     case EM_MICROBLAZE_OLD:
602       return TRUE;
603
604     case EM_68HC05:
605     case EM_68HC08:
606     case EM_68HC11:
607     case EM_68HC16:
608     case EM_FX66:
609     case EM_ME16:
610     case EM_MMA:
611     case EM_NCPU:
612     case EM_NDR1:
613     case EM_PCP:
614     case EM_ST100:
615     case EM_ST19:
616     case EM_ST7:
617     case EM_ST9PLUS:
618     case EM_STARCORE:
619     case EM_SVX:
620     case EM_TINYJ:
621     default:
622       warn (_("Don't know about relocations on this machine architecture\n"));
623       return FALSE;
624     }
625 }
626
627 static int
628 slurp_rela_relocs (FILE * file,
629                    unsigned long rel_offset,
630                    unsigned long rel_size,
631                    Elf_Internal_Rela ** relasp,
632                    unsigned long * nrelasp)
633 {
634   Elf_Internal_Rela * relas;
635   unsigned long nrelas;
636   unsigned int i;
637
638   if (is_32bit_elf)
639     {
640       Elf32_External_Rela * erelas;
641
642       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
643                                                  rel_size, _("relocs"));
644       if (!erelas)
645         return 0;
646
647       nrelas = rel_size / sizeof (Elf32_External_Rela);
648
649       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
650                                              sizeof (Elf_Internal_Rela));
651
652       if (relas == NULL)
653         {
654           free (erelas);
655           error (_("out of memory parsing relocs\n"));
656           return 0;
657         }
658
659       for (i = 0; i < nrelas; i++)
660         {
661           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
662           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
663           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
664         }
665
666       free (erelas);
667     }
668   else
669     {
670       Elf64_External_Rela * erelas;
671
672       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
673                                                  rel_size, _("relocs"));
674       if (!erelas)
675         return 0;
676
677       nrelas = rel_size / sizeof (Elf64_External_Rela);
678
679       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
680                                              sizeof (Elf_Internal_Rela));
681
682       if (relas == NULL)
683         {
684           free (erelas);
685           error (_("out of memory parsing relocs\n"));
686           return 0;
687         }
688
689       for (i = 0; i < nrelas; i++)
690         {
691           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
692           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
693           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
694
695           /* The #ifdef BFD64 below is to prevent a compile time
696              warning.  We know that if we do not have a 64 bit data
697              type that we will never execute this code anyway.  */
698 #ifdef BFD64
699           if (elf_header.e_machine == EM_MIPS
700               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
701             {
702               /* In little-endian objects, r_info isn't really a
703                  64-bit little-endian value: it has a 32-bit
704                  little-endian symbol index followed by four
705                  individual byte fields.  Reorder INFO
706                  accordingly.  */
707               bfd_vma inf = relas[i].r_info;
708               inf = (((inf & 0xffffffff) << 32)
709                       | ((inf >> 56) & 0xff)
710                       | ((inf >> 40) & 0xff00)
711                       | ((inf >> 24) & 0xff0000)
712                       | ((inf >> 8) & 0xff000000));
713               relas[i].r_info = inf;
714             }
715 #endif /* BFD64 */
716         }
717
718       free (erelas);
719     }
720   *relasp = relas;
721   *nrelasp = nrelas;
722   return 1;
723 }
724
725 static int
726 slurp_rel_relocs (FILE * file,
727                   unsigned long rel_offset,
728                   unsigned long rel_size,
729                   Elf_Internal_Rela ** relsp,
730                   unsigned long * nrelsp)
731 {
732   Elf_Internal_Rela * rels;
733   unsigned long nrels;
734   unsigned int i;
735
736   if (is_32bit_elf)
737     {
738       Elf32_External_Rel * erels;
739
740       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
741                                                rel_size, _("relocs"));
742       if (!erels)
743         return 0;
744
745       nrels = rel_size / sizeof (Elf32_External_Rel);
746
747       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
748
749       if (rels == NULL)
750         {
751           free (erels);
752           error (_("out of memory parsing relocs\n"));
753           return 0;
754         }
755
756       for (i = 0; i < nrels; i++)
757         {
758           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
759           rels[i].r_info   = BYTE_GET (erels[i].r_info);
760           rels[i].r_addend = 0;
761         }
762
763       free (erels);
764     }
765   else
766     {
767       Elf64_External_Rel * erels;
768
769       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
770                                                rel_size, _("relocs"));
771       if (!erels)
772         return 0;
773
774       nrels = rel_size / sizeof (Elf64_External_Rel);
775
776       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
777
778       if (rels == NULL)
779         {
780           free (erels);
781           error (_("out of memory parsing relocs\n"));
782           return 0;
783         }
784
785       for (i = 0; i < nrels; i++)
786         {
787           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
788           rels[i].r_info   = BYTE_GET (erels[i].r_info);
789           rels[i].r_addend = 0;
790
791           /* The #ifdef BFD64 below is to prevent a compile time
792              warning.  We know that if we do not have a 64 bit data
793              type that we will never execute this code anyway.  */
794 #ifdef BFD64
795           if (elf_header.e_machine == EM_MIPS
796               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
797             {
798               /* In little-endian objects, r_info isn't really a
799                  64-bit little-endian value: it has a 32-bit
800                  little-endian symbol index followed by four
801                  individual byte fields.  Reorder INFO
802                  accordingly.  */
803               bfd_vma inf = rels[i].r_info;
804               inf = (((inf & 0xffffffff) << 32)
805                      | ((inf >> 56) & 0xff)
806                      | ((inf >> 40) & 0xff00)
807                      | ((inf >> 24) & 0xff0000)
808                      | ((inf >> 8) & 0xff000000));
809               rels[i].r_info = inf;
810             }
811 #endif /* BFD64 */
812         }
813
814       free (erels);
815     }
816   *relsp = rels;
817   *nrelsp = nrels;
818   return 1;
819 }
820
821 /* Returns the reloc type extracted from the reloc info field.  */
822
823 static unsigned int
824 get_reloc_type (bfd_vma reloc_info)
825 {
826   if (is_32bit_elf)
827     return ELF32_R_TYPE (reloc_info);
828
829   switch (elf_header.e_machine)
830     {
831     case EM_MIPS:
832       /* Note: We assume that reloc_info has already been adjusted for us.  */
833       return ELF64_MIPS_R_TYPE (reloc_info);
834
835     case EM_SPARCV9:
836       return ELF64_R_TYPE_ID (reloc_info);
837
838     default:
839       return ELF64_R_TYPE (reloc_info);
840     }
841 }
842
843 /* Return the symbol index extracted from the reloc info field.  */
844
845 static bfd_vma
846 get_reloc_symindex (bfd_vma reloc_info)
847 {
848   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
849 }
850
851 /* Display the contents of the relocation data found at the specified
852    offset.  */
853
854 static void
855 dump_relocations (FILE * file,
856                   unsigned long rel_offset,
857                   unsigned long rel_size,
858                   Elf_Internal_Sym * symtab,
859                   unsigned long nsyms,
860                   char * strtab,
861                   unsigned long strtablen,
862                   int is_rela)
863 {
864   unsigned int i;
865   Elf_Internal_Rela * rels;
866
867   if (is_rela == UNKNOWN)
868     is_rela = guess_is_rela (elf_header.e_machine);
869
870   if (is_rela)
871     {
872       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
873         return;
874     }
875   else
876     {
877       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
878         return;
879     }
880
881   if (is_32bit_elf)
882     {
883       if (is_rela)
884         {
885           if (do_wide)
886             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
887           else
888             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
889         }
890       else
891         {
892           if (do_wide)
893             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
894           else
895             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
896         }
897     }
898   else
899     {
900       if (is_rela)
901         {
902           if (do_wide)
903             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
904           else
905             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
906         }
907       else
908         {
909           if (do_wide)
910             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
911           else
912             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
913         }
914     }
915
916   for (i = 0; i < rel_size; i++)
917     {
918       const char * rtype;
919       bfd_vma offset;
920       bfd_vma inf;
921       bfd_vma symtab_index;
922       bfd_vma type;
923
924       offset = rels[i].r_offset;
925       inf    = rels[i].r_info;
926
927       type = get_reloc_type (inf);
928       symtab_index = get_reloc_symindex  (inf);
929
930       if (is_32bit_elf)
931         {
932           printf ("%8.8lx  %8.8lx ",
933                   (unsigned long) offset & 0xffffffff,
934                   (unsigned long) inf & 0xffffffff);
935         }
936       else
937         {
938 #if BFD_HOST_64BIT_LONG
939           printf (do_wide
940                   ? "%16.16lx  %16.16lx "
941                   : "%12.12lx  %12.12lx ",
942                   offset, inf);
943 #elif BFD_HOST_64BIT_LONG_LONG
944 #ifndef __MSVCRT__
945           printf (do_wide
946                   ? "%16.16llx  %16.16llx "
947                   : "%12.12llx  %12.12llx ",
948                   offset, inf);
949 #else
950           printf (do_wide
951                   ? "%16.16I64x  %16.16I64x "
952                   : "%12.12I64x  %12.12I64x ",
953                   offset, inf);
954 #endif
955 #else
956           printf (do_wide
957                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
958                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
959                   _bfd_int64_high (offset),
960                   _bfd_int64_low (offset),
961                   _bfd_int64_high (inf),
962                   _bfd_int64_low (inf));
963 #endif
964         }
965
966       switch (elf_header.e_machine)
967         {
968         default:
969           rtype = NULL;
970           break;
971
972         case EM_M32R:
973         case EM_CYGNUS_M32R:
974           rtype = elf_m32r_reloc_type (type);
975           break;
976
977         case EM_386:
978         case EM_486:
979           rtype = elf_i386_reloc_type (type);
980           break;
981
982         case EM_68HC11:
983         case EM_68HC12:
984           rtype = elf_m68hc11_reloc_type (type);
985           break;
986
987         case EM_68K:
988           rtype = elf_m68k_reloc_type (type);
989           break;
990
991         case EM_960:
992           rtype = elf_i960_reloc_type (type);
993           break;
994
995         case EM_AVR:
996         case EM_AVR_OLD:
997           rtype = elf_avr_reloc_type (type);
998           break;
999
1000         case EM_OLD_SPARCV9:
1001         case EM_SPARC32PLUS:
1002         case EM_SPARCV9:
1003         case EM_SPARC:
1004           rtype = elf_sparc_reloc_type (type);
1005           break;
1006
1007         case EM_SPU:
1008           rtype = elf_spu_reloc_type (type);
1009           break;
1010
1011         case EM_V850:
1012         case EM_CYGNUS_V850:
1013           rtype = v850_reloc_type (type);
1014           break;
1015
1016         case EM_D10V:
1017         case EM_CYGNUS_D10V:
1018           rtype = elf_d10v_reloc_type (type);
1019           break;
1020
1021         case EM_D30V:
1022         case EM_CYGNUS_D30V:
1023           rtype = elf_d30v_reloc_type (type);
1024           break;
1025
1026         case EM_DLX:
1027           rtype = elf_dlx_reloc_type (type);
1028           break;
1029
1030         case EM_SH:
1031           rtype = elf_sh_reloc_type (type);
1032           break;
1033
1034         case EM_MN10300:
1035         case EM_CYGNUS_MN10300:
1036           rtype = elf_mn10300_reloc_type (type);
1037           break;
1038
1039         case EM_MN10200:
1040         case EM_CYGNUS_MN10200:
1041           rtype = elf_mn10200_reloc_type (type);
1042           break;
1043
1044         case EM_FR30:
1045         case EM_CYGNUS_FR30:
1046           rtype = elf_fr30_reloc_type (type);
1047           break;
1048
1049         case EM_CYGNUS_FRV:
1050           rtype = elf_frv_reloc_type (type);
1051           break;
1052
1053         case EM_MCORE:
1054           rtype = elf_mcore_reloc_type (type);
1055           break;
1056
1057         case EM_MMIX:
1058           rtype = elf_mmix_reloc_type (type);
1059           break;
1060
1061         case EM_MOXIE:
1062           rtype = elf_moxie_reloc_type (type);
1063           break;
1064
1065         case EM_MSP430:
1066         case EM_MSP430_OLD:
1067           rtype = elf_msp430_reloc_type (type);
1068           break;
1069
1070         case EM_PPC:
1071           rtype = elf_ppc_reloc_type (type);
1072           break;
1073
1074         case EM_PPC64:
1075           rtype = elf_ppc64_reloc_type (type);
1076           break;
1077
1078         case EM_MIPS:
1079         case EM_MIPS_RS3_LE:
1080           rtype = elf_mips_reloc_type (type);
1081           break;
1082
1083         case EM_ALPHA:
1084           rtype = elf_alpha_reloc_type (type);
1085           break;
1086
1087         case EM_ARM:
1088           rtype = elf_arm_reloc_type (type);
1089           break;
1090
1091         case EM_ARC:
1092           rtype = elf_arc_reloc_type (type);
1093           break;
1094
1095         case EM_PARISC:
1096           rtype = elf_hppa_reloc_type (type);
1097           break;
1098
1099         case EM_H8_300:
1100         case EM_H8_300H:
1101         case EM_H8S:
1102           rtype = elf_h8_reloc_type (type);
1103           break;
1104
1105         case EM_OPENRISC:
1106         case EM_OR32:
1107           rtype = elf_or32_reloc_type (type);
1108           break;
1109
1110         case EM_PJ:
1111         case EM_PJ_OLD:
1112           rtype = elf_pj_reloc_type (type);
1113           break;
1114         case EM_IA_64:
1115           rtype = elf_ia64_reloc_type (type);
1116           break;
1117
1118         case EM_CRIS:
1119           rtype = elf_cris_reloc_type (type);
1120           break;
1121
1122         case EM_860:
1123           rtype = elf_i860_reloc_type (type);
1124           break;
1125
1126         case EM_X86_64:
1127         case EM_L1OM:
1128           rtype = elf_x86_64_reloc_type (type);
1129           break;
1130
1131         case EM_S370:
1132           rtype = i370_reloc_type (type);
1133           break;
1134
1135         case EM_S390_OLD:
1136         case EM_S390:
1137           rtype = elf_s390_reloc_type (type);
1138           break;
1139
1140         case EM_SCORE:
1141           rtype = elf_score_reloc_type (type);
1142           break;
1143
1144         case EM_XSTORMY16:
1145           rtype = elf_xstormy16_reloc_type (type);
1146           break;
1147
1148         case EM_CRX:
1149           rtype = elf_crx_reloc_type (type);
1150           break;
1151
1152         case EM_VAX:
1153           rtype = elf_vax_reloc_type (type);
1154           break;
1155
1156         case EM_IP2K:
1157         case EM_IP2K_OLD:
1158           rtype = elf_ip2k_reloc_type (type);
1159           break;
1160
1161         case EM_IQ2000:
1162           rtype = elf_iq2000_reloc_type (type);
1163           break;
1164
1165         case EM_XTENSA_OLD:
1166         case EM_XTENSA:
1167           rtype = elf_xtensa_reloc_type (type);
1168           break;
1169
1170         case EM_LATTICEMICO32:
1171           rtype = elf_lm32_reloc_type (type);
1172           break;
1173
1174         case EM_M32C_OLD:
1175         case EM_M32C:
1176           rtype = elf_m32c_reloc_type (type);
1177           break;
1178
1179         case EM_MT:
1180           rtype = elf_mt_reloc_type (type);
1181           break;
1182
1183         case EM_BLACKFIN:
1184           rtype = elf_bfin_reloc_type (type);
1185           break;
1186
1187         case EM_CYGNUS_MEP:
1188           rtype = elf_mep_reloc_type (type);
1189           break;
1190
1191         case EM_CR16:
1192         case EM_CR16_OLD:
1193           rtype = elf_cr16_reloc_type (type);
1194           break;
1195
1196         case EM_MICROBLAZE:
1197         case EM_MICROBLAZE_OLD:
1198           rtype = elf_microblaze_reloc_type (type);
1199           break;
1200
1201         case EM_RX:
1202           rtype = elf_rx_reloc_type (type);
1203           break;
1204
1205         case EM_XC16X:
1206         case EM_C166:
1207           rtype = elf_xc16x_reloc_type (type);
1208           break;
1209
1210         case EM_TI_C6000:
1211           rtype = elf_tic6x_reloc_type (type);
1212           break;
1213         }
1214
1215       if (rtype == NULL)
1216         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1217       else
1218         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1219
1220       if (elf_header.e_machine == EM_ALPHA
1221           && rtype != NULL
1222           && streq (rtype, "R_ALPHA_LITUSE")
1223           && is_rela)
1224         {
1225           switch (rels[i].r_addend)
1226             {
1227             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1228             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1229             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1230             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1231             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1232             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1233             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1234             default: rtype = NULL;
1235             }
1236           if (rtype)
1237             printf (" (%s)", rtype);
1238           else
1239             {
1240               putchar (' ');
1241               printf (_("<unknown addend: %lx>"),
1242                       (unsigned long) rels[i].r_addend);
1243             }
1244         }
1245       else if (symtab_index)
1246         {
1247           if (symtab == NULL || symtab_index >= nsyms)
1248             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1249           else
1250             {
1251               Elf_Internal_Sym * psym;
1252
1253               psym = symtab + symtab_index;
1254
1255               printf (" ");
1256
1257               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1258                 {
1259                   const char * name;
1260                   unsigned int len;
1261                   unsigned int width = is_32bit_elf ? 8 : 14;
1262
1263                   /* Relocations against GNU_IFUNC symbols do not use the value
1264                      of the symbol as the address to relocate against.  Instead
1265                      they invoke the function named by the symbol and use its
1266                      result as the address for relocation.
1267
1268                      To indicate this to the user, do not display the value of
1269                      the symbol in the "Symbols's Value" field.  Instead show
1270                      its name followed by () as a hint that the symbol is
1271                      invoked.  */
1272
1273                   if (strtab == NULL
1274                       || psym->st_name == 0
1275                       || psym->st_name >= strtablen)
1276                     name = "??";
1277                   else
1278                     name = strtab + psym->st_name;
1279
1280                   len = print_symbol (width, name);
1281                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1282                 }
1283               else
1284                 {
1285                   print_vma (psym->st_value, LONG_HEX);
1286
1287                   printf (is_32bit_elf ? "   " : " ");
1288                 }
1289
1290               if (psym->st_name == 0)
1291                 {
1292                   const char * sec_name = "<null>";
1293                   char name_buf[40];
1294
1295                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1296                     {
1297                       if (psym->st_shndx < elf_header.e_shnum)
1298                         sec_name
1299                           = SECTION_NAME (section_headers + psym->st_shndx);
1300                       else if (psym->st_shndx == SHN_ABS)
1301                         sec_name = "ABS";
1302                       else if (psym->st_shndx == SHN_COMMON)
1303                         sec_name = "COMMON";
1304                       else if (elf_header.e_machine == EM_MIPS
1305                                && psym->st_shndx == SHN_MIPS_SCOMMON)
1306                         sec_name = "SCOMMON";
1307                       else if (elf_header.e_machine == EM_MIPS
1308                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1309                         sec_name = "SUNDEF";
1310                       else if ((elf_header.e_machine == EM_X86_64
1311                                 || elf_header.e_machine == EM_L1OM)
1312                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1313                         sec_name = "LARGE_COMMON";
1314                       else if (elf_header.e_machine == EM_IA_64
1315                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1316                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1317                         sec_name = "ANSI_COM";
1318                       else if (is_ia64_vms ()
1319                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1320                         sec_name = "VMS_SYMVEC";
1321                       else
1322                         {
1323                           sprintf (name_buf, "<section 0x%x>",
1324                                    (unsigned int) psym->st_shndx);
1325                           sec_name = name_buf;
1326                         }
1327                     }
1328                   print_symbol (22, sec_name);
1329                 }
1330               else if (strtab == NULL)
1331                 printf (_("<string table index: %3ld>"), psym->st_name);
1332               else if (psym->st_name >= strtablen)
1333                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1334               else
1335                 print_symbol (22, strtab + psym->st_name);
1336
1337               if (is_rela)
1338                 {
1339                   bfd_signed_vma off = rels[i].r_addend;
1340
1341                   if (off < 0)
1342                     printf (" - %" BFD_VMA_FMT "x", - off);
1343                   else
1344                     printf (" + %" BFD_VMA_FMT "x", off);
1345                 }
1346             }
1347         }
1348       else if (is_rela)
1349         {
1350           printf ("%*c", is_32bit_elf ?
1351                   (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1352           print_vma (rels[i].r_addend, LONG_HEX);
1353         }
1354
1355       if (elf_header.e_machine == EM_SPARCV9
1356           && rtype != NULL
1357           && streq (rtype, "R_SPARC_OLO10"))
1358         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1359
1360       putchar ('\n');
1361
1362 #ifdef BFD64
1363       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1364         {
1365           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1366           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1367           const char * rtype2 = elf_mips_reloc_type (type2);
1368           const char * rtype3 = elf_mips_reloc_type (type3);
1369
1370           printf ("                    Type2: ");
1371
1372           if (rtype2 == NULL)
1373             printf (_("unrecognized: %-7lx"),
1374                     (unsigned long) type2 & 0xffffffff);
1375           else
1376             printf ("%-17.17s", rtype2);
1377
1378           printf ("\n                    Type3: ");
1379
1380           if (rtype3 == NULL)
1381             printf (_("unrecognized: %-7lx"),
1382                     (unsigned long) type3 & 0xffffffff);
1383           else
1384             printf ("%-17.17s", rtype3);
1385
1386           putchar ('\n');
1387         }
1388 #endif /* BFD64 */
1389     }
1390
1391   free (rels);
1392 }
1393
1394 static const char *
1395 get_mips_dynamic_type (unsigned long type)
1396 {
1397   switch (type)
1398     {
1399     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1400     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1401     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1402     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1403     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1404     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1405     case DT_MIPS_MSYM: return "MIPS_MSYM";
1406     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1407     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1408     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1409     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1410     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1411     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1412     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1413     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1414     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1415     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1416     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1417     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1418     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1419     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1420     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1421     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1422     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1423     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1424     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1425     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1426     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1427     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1428     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1429     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1430     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1431     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1432     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1433     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1434     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1435     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1436     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1437     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1438     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1439     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1440     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1441     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1442     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1443     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1444     default:
1445       return NULL;
1446     }
1447 }
1448
1449 static const char *
1450 get_sparc64_dynamic_type (unsigned long type)
1451 {
1452   switch (type)
1453     {
1454     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1455     default:
1456       return NULL;
1457     }
1458 }
1459
1460 static const char *
1461 get_ppc_dynamic_type (unsigned long type)
1462 {
1463   switch (type)
1464     {
1465     case DT_PPC_GOT:    return "PPC_GOT";
1466     case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1467     default:
1468       return NULL;
1469     }
1470 }
1471
1472 static const char *
1473 get_ppc64_dynamic_type (unsigned long type)
1474 {
1475   switch (type)
1476     {
1477     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1478     case DT_PPC64_OPD:    return "PPC64_OPD";
1479     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1480     case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1481     default:
1482       return NULL;
1483     }
1484 }
1485
1486 static const char *
1487 get_parisc_dynamic_type (unsigned long type)
1488 {
1489   switch (type)
1490     {
1491     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1492     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1493     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1494     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1495     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1496     case DT_HP_PREINIT:         return "HP_PREINIT";
1497     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1498     case DT_HP_NEEDED:          return "HP_NEEDED";
1499     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1500     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1501     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1502     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1503     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1504     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1505     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1506     case DT_HP_FILTERED:        return "HP_FILTERED";
1507     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1508     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1509     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1510     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1511     case DT_PLT:                return "PLT";
1512     case DT_PLT_SIZE:           return "PLT_SIZE";
1513     case DT_DLT:                return "DLT";
1514     case DT_DLT_SIZE:           return "DLT_SIZE";
1515     default:
1516       return NULL;
1517     }
1518 }
1519
1520 static const char *
1521 get_ia64_dynamic_type (unsigned long type)
1522 {
1523   switch (type)
1524     {
1525     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1526     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1527     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1528     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1529     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1530     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1531     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1532     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1533     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1534     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1535     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1536     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1537     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1538     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1539     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1540     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1541     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1542     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1543     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1544     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1545     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1546     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1547     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1548     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1549     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1550     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1551     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1552     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1553     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1554     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1555     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1556     default:
1557       return NULL;
1558     }
1559 }
1560
1561 static const char *
1562 get_alpha_dynamic_type (unsigned long type)
1563 {
1564   switch (type)
1565     {
1566     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1567     default:
1568       return NULL;
1569     }
1570 }
1571
1572 static const char *
1573 get_score_dynamic_type (unsigned long type)
1574 {
1575   switch (type)
1576     {
1577     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1578     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1579     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1580     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1581     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1582     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1583     default:
1584       return NULL;
1585     }
1586 }
1587
1588 static const char *
1589 get_tic6x_dynamic_type (unsigned long type)
1590 {
1591   switch (type)
1592     {
1593     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1594     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1595     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1596     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1597     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1598     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1599     default:
1600       return NULL;
1601     }
1602 }
1603
1604 static const char *
1605 get_dynamic_type (unsigned long type)
1606 {
1607   static char buff[64];
1608
1609   switch (type)
1610     {
1611     case DT_NULL:       return "NULL";
1612     case DT_NEEDED:     return "NEEDED";
1613     case DT_PLTRELSZ:   return "PLTRELSZ";
1614     case DT_PLTGOT:     return "PLTGOT";
1615     case DT_HASH:       return "HASH";
1616     case DT_STRTAB:     return "STRTAB";
1617     case DT_SYMTAB:     return "SYMTAB";
1618     case DT_RELA:       return "RELA";
1619     case DT_RELASZ:     return "RELASZ";
1620     case DT_RELAENT:    return "RELAENT";
1621     case DT_STRSZ:      return "STRSZ";
1622     case DT_SYMENT:     return "SYMENT";
1623     case DT_INIT:       return "INIT";
1624     case DT_FINI:       return "FINI";
1625     case DT_SONAME:     return "SONAME";
1626     case DT_RPATH:      return "RPATH";
1627     case DT_SYMBOLIC:   return "SYMBOLIC";
1628     case DT_REL:        return "REL";
1629     case DT_RELSZ:      return "RELSZ";
1630     case DT_RELENT:     return "RELENT";
1631     case DT_PLTREL:     return "PLTREL";
1632     case DT_DEBUG:      return "DEBUG";
1633     case DT_TEXTREL:    return "TEXTREL";
1634     case DT_JMPREL:     return "JMPREL";
1635     case DT_BIND_NOW:   return "BIND_NOW";
1636     case DT_INIT_ARRAY: return "INIT_ARRAY";
1637     case DT_FINI_ARRAY: return "FINI_ARRAY";
1638     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1639     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1640     case DT_RUNPATH:    return "RUNPATH";
1641     case DT_FLAGS:      return "FLAGS";
1642
1643     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1644     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1645
1646     case DT_CHECKSUM:   return "CHECKSUM";
1647     case DT_PLTPADSZ:   return "PLTPADSZ";
1648     case DT_MOVEENT:    return "MOVEENT";
1649     case DT_MOVESZ:     return "MOVESZ";
1650     case DT_FEATURE:    return "FEATURE";
1651     case DT_POSFLAG_1:  return "POSFLAG_1";
1652     case DT_SYMINSZ:    return "SYMINSZ";
1653     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1654
1655     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1656     case DT_CONFIG:     return "CONFIG";
1657     case DT_DEPAUDIT:   return "DEPAUDIT";
1658     case DT_AUDIT:      return "AUDIT";
1659     case DT_PLTPAD:     return "PLTPAD";
1660     case DT_MOVETAB:    return "MOVETAB";
1661     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1662
1663     case DT_VERSYM:     return "VERSYM";
1664
1665     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1666     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1667     case DT_RELACOUNT:  return "RELACOUNT";
1668     case DT_RELCOUNT:   return "RELCOUNT";
1669     case DT_FLAGS_1:    return "FLAGS_1";
1670     case DT_VERDEF:     return "VERDEF";
1671     case DT_VERDEFNUM:  return "VERDEFNUM";
1672     case DT_VERNEED:    return "VERNEED";
1673     case DT_VERNEEDNUM: return "VERNEEDNUM";
1674
1675     case DT_AUXILIARY:  return "AUXILIARY";
1676     case DT_USED:       return "USED";
1677     case DT_FILTER:     return "FILTER";
1678
1679     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1680     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1681     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1682     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1683     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1684     case DT_GNU_HASH:   return "GNU_HASH";
1685
1686     default:
1687       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1688         {
1689           const char * result;
1690
1691           switch (elf_header.e_machine)
1692             {
1693             case EM_MIPS:
1694             case EM_MIPS_RS3_LE:
1695               result = get_mips_dynamic_type (type);
1696               break;
1697             case EM_SPARCV9:
1698               result = get_sparc64_dynamic_type (type);
1699               break;
1700             case EM_PPC:
1701               result = get_ppc_dynamic_type (type);
1702               break;
1703             case EM_PPC64:
1704               result = get_ppc64_dynamic_type (type);
1705               break;
1706             case EM_IA_64:
1707               result = get_ia64_dynamic_type (type);
1708               break;
1709             case EM_ALPHA:
1710               result = get_alpha_dynamic_type (type);
1711               break;
1712             case EM_SCORE:
1713               result = get_score_dynamic_type (type);
1714               break;
1715             case EM_TI_C6000:
1716               result = get_tic6x_dynamic_type (type);
1717               break;
1718             default:
1719               result = NULL;
1720               break;
1721             }
1722
1723           if (result != NULL)
1724             return result;
1725
1726           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1727         }
1728       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1729                || (elf_header.e_machine == EM_PARISC
1730                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1731         {
1732           const char * result;
1733
1734           switch (elf_header.e_machine)
1735             {
1736             case EM_PARISC:
1737               result = get_parisc_dynamic_type (type);
1738               break;
1739             case EM_IA_64:
1740               result = get_ia64_dynamic_type (type);
1741               break;
1742             default:
1743               result = NULL;
1744               break;
1745             }
1746
1747           if (result != NULL)
1748             return result;
1749
1750           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1751                     type);
1752         }
1753       else
1754         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1755
1756       return buff;
1757     }
1758 }
1759
1760 static char *
1761 get_file_type (unsigned e_type)
1762 {
1763   static char buff[32];
1764
1765   switch (e_type)
1766     {
1767     case ET_NONE:       return _("NONE (None)");
1768     case ET_REL:        return _("REL (Relocatable file)");
1769     case ET_EXEC:       return _("EXEC (Executable file)");
1770     case ET_DYN:        return _("DYN (Shared object file)");
1771     case ET_CORE:       return _("CORE (Core file)");
1772
1773     default:
1774       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1775         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1776       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1777         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1778       else
1779         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1780       return buff;
1781     }
1782 }
1783
1784 static char *
1785 get_machine_name (unsigned e_machine)
1786 {
1787   static char buff[64]; /* XXX */
1788
1789   switch (e_machine)
1790     {
1791     case EM_NONE:               return _("None");
1792     case EM_M32:                return "WE32100";
1793     case EM_SPARC:              return "Sparc";
1794     case EM_SPU:                return "SPU";
1795     case EM_386:                return "Intel 80386";
1796     case EM_68K:                return "MC68000";
1797     case EM_88K:                return "MC88000";
1798     case EM_486:                return "Intel 80486";
1799     case EM_860:                return "Intel 80860";
1800     case EM_MIPS:               return "MIPS R3000";
1801     case EM_S370:               return "IBM System/370";
1802     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1803     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1804     case EM_PARISC:             return "HPPA";
1805     case EM_PPC_OLD:            return "Power PC (old)";
1806     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1807     case EM_960:                return "Intel 90860";
1808     case EM_PPC:                return "PowerPC";
1809     case EM_PPC64:              return "PowerPC64";
1810     case EM_V800:               return "NEC V800";
1811     case EM_FR20:               return "Fujitsu FR20";
1812     case EM_RH32:               return "TRW RH32";
1813     case EM_MCORE:              return "MCORE";
1814     case EM_ARM:                return "ARM";
1815     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1816     case EM_SH:                 return "Renesas / SuperH SH";
1817     case EM_SPARCV9:            return "Sparc v9";
1818     case EM_TRICORE:            return "Siemens Tricore";
1819     case EM_ARC:                return "ARC";
1820     case EM_H8_300:             return "Renesas H8/300";
1821     case EM_H8_300H:            return "Renesas H8/300H";
1822     case EM_H8S:                return "Renesas H8S";
1823     case EM_H8_500:             return "Renesas H8/500";
1824     case EM_IA_64:              return "Intel IA-64";
1825     case EM_MIPS_X:             return "Stanford MIPS-X";
1826     case EM_COLDFIRE:           return "Motorola Coldfire";
1827     case EM_68HC12:             return "Motorola M68HC12";
1828     case EM_ALPHA:              return "Alpha";
1829     case EM_CYGNUS_D10V:
1830     case EM_D10V:               return "d10v";
1831     case EM_CYGNUS_D30V:
1832     case EM_D30V:               return "d30v";
1833     case EM_CYGNUS_M32R:
1834     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1835     case EM_CYGNUS_V850:
1836     case EM_V850:               return "NEC v850";
1837     case EM_CYGNUS_MN10300:
1838     case EM_MN10300:            return "mn10300";
1839     case EM_CYGNUS_MN10200:
1840     case EM_MN10200:            return "mn10200";
1841     case EM_MOXIE:              return "Moxie";
1842     case EM_CYGNUS_FR30:
1843     case EM_FR30:               return "Fujitsu FR30";
1844     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1845     case EM_PJ_OLD:
1846     case EM_PJ:                 return "picoJava";
1847     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1848     case EM_PCP:                return "Siemens PCP";
1849     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1850     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1851     case EM_STARCORE:           return "Motorola Star*Core processor";
1852     case EM_ME16:               return "Toyota ME16 processor";
1853     case EM_ST100:              return "STMicroelectronics ST100 processor";
1854     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1855     case EM_PDSP:               return "Sony DSP processor";
1856     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
1857     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
1858     case EM_FX66:               return "Siemens FX66 microcontroller";
1859     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1860     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1861     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1862     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1863     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1864     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1865     case EM_SVX:                return "Silicon Graphics SVx";
1866     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1867     case EM_VAX:                return "Digital VAX";
1868     case EM_AVR_OLD:
1869     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
1870     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
1871     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
1872     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
1873     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
1874     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
1875     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
1876     case EM_PRISM:              return "Vitesse Prism";
1877     case EM_X86_64:             return "Advanced Micro Devices X86-64";
1878     case EM_L1OM:               return "Intel L1OM";
1879     case EM_S390_OLD:
1880     case EM_S390:               return "IBM S/390";
1881     case EM_SCORE:              return "SUNPLUS S+Core";
1882     case EM_XSTORMY16:          return "Sanyo Xstormy16 CPU core";
1883     case EM_OPENRISC:
1884     case EM_OR32:               return "OpenRISC";
1885     case EM_ARC_A5:             return "ARC International ARCompact processor";
1886     case EM_CRX:                return "National Semiconductor CRX microprocessor";
1887     case EM_DLX:                return "OpenDLX";
1888     case EM_IP2K_OLD:
1889     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
1890     case EM_IQ2000:             return "Vitesse IQ2000";
1891     case EM_XTENSA_OLD:
1892     case EM_XTENSA:             return "Tensilica Xtensa Processor";
1893     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
1894     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
1895     case EM_NS32K:              return "National Semiconductor 32000 series";
1896     case EM_TPC:                return "Tenor Network TPC processor";
1897     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
1898     case EM_MAX:                return "MAX Processor";
1899     case EM_CR:                 return "National Semiconductor CompactRISC";
1900     case EM_F2MC16:             return "Fujitsu F2MC16";
1901     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
1902     case EM_LATTICEMICO32:      return "Lattice Mico32";
1903     case EM_M32C_OLD:
1904     case EM_M32C:               return "Renesas M32c";
1905     case EM_MT:                 return "Morpho Techologies MT processor";
1906     case EM_BLACKFIN:           return "Analog Devices Blackfin";
1907     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
1908     case EM_SEP:                return "Sharp embedded microprocessor";
1909     case EM_ARCA:               return "Arca RISC microprocessor";
1910     case EM_UNICORE:            return "Unicore";
1911     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
1912     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
1913     case EM_NIOS32:             return "Altera Nios";
1914     case EM_ALTERA_NIOS2:       return "Altera Nios II";
1915     case EM_C166:
1916     case EM_XC16X:              return "Infineon Technologies xc16x";
1917     case EM_M16C:               return "Renesas M16C series microprocessors";
1918     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
1919     case EM_CE:                 return "Freescale Communication Engine RISC core";
1920     case EM_TSK3000:            return "Altium TSK3000 core";
1921     case EM_RS08:               return "Freescale RS08 embedded processor";
1922     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
1923     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
1924     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
1925     case EM_SE_C17:             return "Seiko Epson C17 family";
1926     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
1927     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
1928     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
1929     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
1930     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
1931     case EM_R32C:               return "Renesas R32C series microprocessors";
1932     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
1933     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
1934     case EM_8051:               return "Intel 8051 and variants";
1935     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
1936     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
1937     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
1938     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1939     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
1940     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
1941     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
1942     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
1943     case EM_CR16:
1944     case EM_CR16_OLD:           return "National Semiconductor's CR16";
1945     case EM_MICROBLAZE:         return "Xilinx MicroBlaze";
1946     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
1947     case EM_RX:                 return "Renesas RX";
1948     case EM_METAG:              return "Imagination Technologies META processor architecture";
1949     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
1950     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
1951     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
1952     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
1953     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
1954     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
1955     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
1956     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
1957     case EM_CUDA:               return "NVIDIA CUDA architecture";
1958     default:
1959       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
1960       return buff;
1961     }
1962 }
1963
1964 static void
1965 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1966 {
1967   unsigned eabi;
1968   int unknown = 0;
1969
1970   eabi = EF_ARM_EABI_VERSION (e_flags);
1971   e_flags &= ~ EF_ARM_EABIMASK;
1972
1973   /* Handle "generic" ARM flags.  */
1974   if (e_flags & EF_ARM_RELEXEC)
1975     {
1976       strcat (buf, ", relocatable executable");
1977       e_flags &= ~ EF_ARM_RELEXEC;
1978     }
1979
1980   if (e_flags & EF_ARM_HASENTRY)
1981     {
1982       strcat (buf, ", has entry point");
1983       e_flags &= ~ EF_ARM_HASENTRY;
1984     }
1985
1986   /* Now handle EABI specific flags.  */
1987   switch (eabi)
1988     {
1989     default:
1990       strcat (buf, ", <unrecognized EABI>");
1991       if (e_flags)
1992         unknown = 1;
1993       break;
1994
1995     case EF_ARM_EABI_VER1:
1996       strcat (buf, ", Version1 EABI");
1997       while (e_flags)
1998         {
1999           unsigned flag;
2000
2001           /* Process flags one bit at a time.  */
2002           flag = e_flags & - e_flags;
2003           e_flags &= ~ flag;
2004
2005           switch (flag)
2006             {
2007             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2008               strcat (buf, ", sorted symbol tables");
2009               break;
2010
2011             default:
2012               unknown = 1;
2013               break;
2014             }
2015         }
2016       break;
2017
2018     case EF_ARM_EABI_VER2:
2019       strcat (buf, ", Version2 EABI");
2020       while (e_flags)
2021         {
2022           unsigned flag;
2023
2024           /* Process flags one bit at a time.  */
2025           flag = e_flags & - e_flags;
2026           e_flags &= ~ flag;
2027
2028           switch (flag)
2029             {
2030             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2031               strcat (buf, ", sorted symbol tables");
2032               break;
2033
2034             case EF_ARM_DYNSYMSUSESEGIDX:
2035               strcat (buf, ", dynamic symbols use segment index");
2036               break;
2037
2038             case EF_ARM_MAPSYMSFIRST:
2039               strcat (buf, ", mapping symbols precede others");
2040               break;
2041
2042             default:
2043               unknown = 1;
2044               break;
2045             }
2046         }
2047       break;
2048
2049     case EF_ARM_EABI_VER3:
2050       strcat (buf, ", Version3 EABI");
2051       break;
2052
2053     case EF_ARM_EABI_VER4:
2054       strcat (buf, ", Version4 EABI");
2055       goto eabi;
2056
2057     case EF_ARM_EABI_VER5:
2058       strcat (buf, ", Version5 EABI");
2059     eabi:
2060       while (e_flags)
2061         {
2062           unsigned flag;
2063
2064           /* Process flags one bit at a time.  */
2065           flag = e_flags & - e_flags;
2066           e_flags &= ~ flag;
2067
2068           switch (flag)
2069             {
2070             case EF_ARM_BE8:
2071               strcat (buf, ", BE8");
2072               break;
2073
2074             case EF_ARM_LE8:
2075               strcat (buf, ", LE8");
2076               break;
2077
2078             default:
2079               unknown = 1;
2080               break;
2081             }
2082         }
2083       break;
2084
2085     case EF_ARM_EABI_UNKNOWN:
2086       strcat (buf, ", GNU EABI");
2087       while (e_flags)
2088         {
2089           unsigned flag;
2090
2091           /* Process flags one bit at a time.  */
2092           flag = e_flags & - e_flags;
2093           e_flags &= ~ flag;
2094
2095           switch (flag)
2096             {
2097             case EF_ARM_INTERWORK:
2098               strcat (buf, ", interworking enabled");
2099               break;
2100
2101             case EF_ARM_APCS_26:
2102               strcat (buf, ", uses APCS/26");
2103               break;
2104
2105             case EF_ARM_APCS_FLOAT:
2106               strcat (buf, ", uses APCS/float");
2107               break;
2108
2109             case EF_ARM_PIC:
2110               strcat (buf, ", position independent");
2111               break;
2112
2113             case EF_ARM_ALIGN8:
2114               strcat (buf, ", 8 bit structure alignment");
2115               break;
2116
2117             case EF_ARM_NEW_ABI:
2118               strcat (buf, ", uses new ABI");
2119               break;
2120
2121             case EF_ARM_OLD_ABI:
2122               strcat (buf, ", uses old ABI");
2123               break;
2124
2125             case EF_ARM_SOFT_FLOAT:
2126               strcat (buf, ", software FP");
2127               break;
2128
2129             case EF_ARM_VFP_FLOAT:
2130               strcat (buf, ", VFP");
2131               break;
2132
2133             case EF_ARM_MAVERICK_FLOAT:
2134               strcat (buf, ", Maverick FP");
2135               break;
2136
2137             default:
2138               unknown = 1;
2139               break;
2140             }
2141         }
2142     }
2143
2144   if (unknown)
2145     strcat (buf,_(", <unknown>"));
2146 }
2147
2148 static char *
2149 get_machine_flags (unsigned e_flags, unsigned e_machine)
2150 {
2151   static char buf[1024];
2152
2153   buf[0] = '\0';
2154
2155   if (e_flags)
2156     {
2157       switch (e_machine)
2158         {
2159         default:
2160           break;
2161
2162         case EM_ARM:
2163           decode_ARM_machine_flags (e_flags, buf);
2164           break;
2165
2166         case EM_CYGNUS_FRV:
2167           switch (e_flags & EF_FRV_CPU_MASK)
2168             {
2169             case EF_FRV_CPU_GENERIC:
2170               break;
2171
2172             default:
2173               strcat (buf, ", fr???");
2174               break;
2175
2176             case EF_FRV_CPU_FR300:
2177               strcat (buf, ", fr300");
2178               break;
2179
2180             case EF_FRV_CPU_FR400:
2181               strcat (buf, ", fr400");
2182               break;
2183             case EF_FRV_CPU_FR405:
2184               strcat (buf, ", fr405");
2185               break;
2186
2187             case EF_FRV_CPU_FR450:
2188               strcat (buf, ", fr450");
2189               break;
2190
2191             case EF_FRV_CPU_FR500:
2192               strcat (buf, ", fr500");
2193               break;
2194             case EF_FRV_CPU_FR550:
2195               strcat (buf, ", fr550");
2196               break;
2197
2198             case EF_FRV_CPU_SIMPLE:
2199               strcat (buf, ", simple");
2200               break;
2201             case EF_FRV_CPU_TOMCAT:
2202               strcat (buf, ", tomcat");
2203               break;
2204             }
2205           break;
2206
2207         case EM_68K:
2208           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2209             strcat (buf, ", m68000");
2210           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2211             strcat (buf, ", cpu32");
2212           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2213             strcat (buf, ", fido_a");
2214           else
2215             {
2216               char const * isa = _("unknown");
2217               char const * mac = _("unknown mac");
2218               char const * additional = NULL;
2219
2220               switch (e_flags & EF_M68K_CF_ISA_MASK)
2221                 {
2222                 case EF_M68K_CF_ISA_A_NODIV:
2223                   isa = "A";
2224                   additional = ", nodiv";
2225                   break;
2226                 case EF_M68K_CF_ISA_A:
2227                   isa = "A";
2228                   break;
2229                 case EF_M68K_CF_ISA_A_PLUS:
2230                   isa = "A+";
2231                   break;
2232                 case EF_M68K_CF_ISA_B_NOUSP:
2233                   isa = "B";
2234                   additional = ", nousp";
2235                   break;
2236                 case EF_M68K_CF_ISA_B:
2237                   isa = "B";
2238                   break;
2239                 case EF_M68K_CF_ISA_C:
2240                   isa = "C";
2241                   break;
2242                 case EF_M68K_CF_ISA_C_NODIV:
2243                   isa = "C";
2244                   additional = ", nodiv";
2245                   break;
2246                 }
2247               strcat (buf, ", cf, isa ");
2248               strcat (buf, isa);
2249               if (additional)
2250                 strcat (buf, additional);
2251               if (e_flags & EF_M68K_CF_FLOAT)
2252                 strcat (buf, ", float");
2253               switch (e_flags & EF_M68K_CF_MAC_MASK)
2254                 {
2255                 case 0:
2256                   mac = NULL;
2257                   break;
2258                 case EF_M68K_CF_MAC:
2259                   mac = "mac";
2260                   break;
2261                 case EF_M68K_CF_EMAC:
2262                   mac = "emac";
2263                   break;
2264                 case EF_M68K_CF_EMAC_B:
2265                   mac = "emac_b";
2266                   break;
2267                 }
2268               if (mac)
2269                 {
2270                   strcat (buf, ", ");
2271                   strcat (buf, mac);
2272                 }
2273             }
2274           break;
2275
2276         case EM_PPC:
2277           if (e_flags & EF_PPC_EMB)
2278             strcat (buf, ", emb");
2279
2280           if (e_flags & EF_PPC_RELOCATABLE)
2281             strcat (buf, _(", relocatable"));
2282
2283           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2284             strcat (buf, _(", relocatable-lib"));
2285           break;
2286
2287         case EM_V850:
2288         case EM_CYGNUS_V850:
2289           switch (e_flags & EF_V850_ARCH)
2290             {
2291             case E_V850E2V3_ARCH:
2292               strcat (buf, ", v850e2v3");
2293               break;
2294             case E_V850E2_ARCH:
2295               strcat (buf, ", v850e2");
2296               break;
2297             case E_V850E1_ARCH:
2298               strcat (buf, ", v850e1");
2299               break;
2300             case E_V850E_ARCH:
2301               strcat (buf, ", v850e");
2302               break;
2303             case E_V850_ARCH:
2304               strcat (buf, ", v850");
2305               break;
2306             default:
2307               strcat (buf, _(", unknown v850 architecture variant"));
2308               break;
2309             }
2310           break;
2311
2312         case EM_M32R:
2313         case EM_CYGNUS_M32R:
2314           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2315             strcat (buf, ", m32r");
2316           break;
2317
2318         case EM_MIPS:
2319         case EM_MIPS_RS3_LE:
2320           if (e_flags & EF_MIPS_NOREORDER)
2321             strcat (buf, ", noreorder");
2322
2323           if (e_flags & EF_MIPS_PIC)
2324             strcat (buf, ", pic");
2325
2326           if (e_flags & EF_MIPS_CPIC)
2327             strcat (buf, ", cpic");
2328
2329           if (e_flags & EF_MIPS_UCODE)
2330             strcat (buf, ", ugen_reserved");
2331
2332           if (e_flags & EF_MIPS_ABI2)
2333             strcat (buf, ", abi2");
2334
2335           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2336             strcat (buf, ", odk first");
2337
2338           if (e_flags & EF_MIPS_32BITMODE)
2339             strcat (buf, ", 32bitmode");
2340
2341           switch ((e_flags & EF_MIPS_MACH))
2342             {
2343             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2344             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2345             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2346             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2347             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2348             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2349             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2350             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2351             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2352             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2353             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2354             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2355             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2356             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2357             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2358             case 0:
2359             /* We simply ignore the field in this case to avoid confusion:
2360                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2361                extension.  */
2362               break;
2363             default: strcat (buf, _(", unknown CPU")); break;
2364             }
2365
2366           switch ((e_flags & EF_MIPS_ABI))
2367             {
2368             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2369             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2370             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2371             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2372             case 0:
2373             /* We simply ignore the field in this case to avoid confusion:
2374                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2375                This means it is likely to be an o32 file, but not for
2376                sure.  */
2377               break;
2378             default: strcat (buf, _(", unknown ABI")); break;
2379             }
2380
2381           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2382             strcat (buf, ", mdmx");
2383
2384           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2385             strcat (buf, ", mips16");
2386
2387           switch ((e_flags & EF_MIPS_ARCH))
2388             {
2389             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2390             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2391             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2392             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2393             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2394             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2395             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2396             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2397             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2398             default: strcat (buf, _(", unknown ISA")); break;
2399             }
2400
2401           if (e_flags & EF_SH_PIC)
2402             strcat (buf, ", pic");
2403
2404           if (e_flags & EF_SH_FDPIC)
2405             strcat (buf, ", fdpic");
2406           break;
2407
2408         case EM_SH:
2409           switch ((e_flags & EF_SH_MACH_MASK))
2410             {
2411             case EF_SH1: strcat (buf, ", sh1"); break;
2412             case EF_SH2: strcat (buf, ", sh2"); break;
2413             case EF_SH3: strcat (buf, ", sh3"); break;
2414             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2415             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2416             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2417             case EF_SH3E: strcat (buf, ", sh3e"); break;
2418             case EF_SH4: strcat (buf, ", sh4"); break;
2419             case EF_SH5: strcat (buf, ", sh5"); break;
2420             case EF_SH2E: strcat (buf, ", sh2e"); break;
2421             case EF_SH4A: strcat (buf, ", sh4a"); break;
2422             case EF_SH2A: strcat (buf, ", sh2a"); break;
2423             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2424             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2425             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2426             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2427             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2428             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2429             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2430             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2431             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2432             default: strcat (buf, _(", unknown ISA")); break;
2433             }
2434
2435           break;
2436
2437         case EM_SPARCV9:
2438           if (e_flags & EF_SPARC_32PLUS)
2439             strcat (buf, ", v8+");
2440
2441           if (e_flags & EF_SPARC_SUN_US1)
2442             strcat (buf, ", ultrasparcI");
2443
2444           if (e_flags & EF_SPARC_SUN_US3)
2445             strcat (buf, ", ultrasparcIII");
2446
2447           if (e_flags & EF_SPARC_HAL_R1)
2448             strcat (buf, ", halr1");
2449
2450           if (e_flags & EF_SPARC_LEDATA)
2451             strcat (buf, ", ledata");
2452
2453           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2454             strcat (buf, ", tso");
2455
2456           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2457             strcat (buf, ", pso");
2458
2459           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2460             strcat (buf, ", rmo");
2461           break;
2462
2463         case EM_PARISC:
2464           switch (e_flags & EF_PARISC_ARCH)
2465             {
2466             case EFA_PARISC_1_0:
2467               strcpy (buf, ", PA-RISC 1.0");
2468               break;
2469             case EFA_PARISC_1_1:
2470               strcpy (buf, ", PA-RISC 1.1");
2471               break;
2472             case EFA_PARISC_2_0:
2473               strcpy (buf, ", PA-RISC 2.0");
2474               break;
2475             default:
2476               break;
2477             }
2478           if (e_flags & EF_PARISC_TRAPNIL)
2479             strcat (buf, ", trapnil");
2480           if (e_flags & EF_PARISC_EXT)
2481             strcat (buf, ", ext");
2482           if (e_flags & EF_PARISC_LSB)
2483             strcat (buf, ", lsb");
2484           if (e_flags & EF_PARISC_WIDE)
2485             strcat (buf, ", wide");
2486           if (e_flags & EF_PARISC_NO_KABP)
2487             strcat (buf, ", no kabp");
2488           if (e_flags & EF_PARISC_LAZYSWAP)
2489             strcat (buf, ", lazyswap");
2490           break;
2491
2492         case EM_PJ:
2493         case EM_PJ_OLD:
2494           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2495             strcat (buf, ", new calling convention");
2496
2497           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2498             strcat (buf, ", gnu calling convention");
2499           break;
2500
2501         case EM_IA_64:
2502           if ((e_flags & EF_IA_64_ABI64))
2503             strcat (buf, ", 64-bit");
2504           else
2505             strcat (buf, ", 32-bit");
2506           if ((e_flags & EF_IA_64_REDUCEDFP))
2507             strcat (buf, ", reduced fp model");
2508           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2509             strcat (buf, ", no function descriptors, constant gp");
2510           else if ((e_flags & EF_IA_64_CONS_GP))
2511             strcat (buf, ", constant gp");
2512           if ((e_flags & EF_IA_64_ABSOLUTE))
2513             strcat (buf, ", absolute");
2514           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2515             {
2516               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2517                 strcat (buf, ", vms_linkages");
2518               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2519                 {
2520                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2521                   break;
2522                 case EF_IA_64_VMS_COMCOD_WARNING:
2523                   strcat (buf, ", warning");
2524                   break;
2525                 case EF_IA_64_VMS_COMCOD_ERROR:
2526                   strcat (buf, ", error");
2527                   break;
2528                 case EF_IA_64_VMS_COMCOD_ABORT:
2529                   strcat (buf, ", abort");
2530                   break;
2531                 default:
2532                   abort ();
2533                 }
2534             }
2535           break;
2536
2537         case EM_VAX:
2538           if ((e_flags & EF_VAX_NONPIC))
2539             strcat (buf, ", non-PIC");
2540           if ((e_flags & EF_VAX_DFLOAT))
2541             strcat (buf, ", D-Float");
2542           if ((e_flags & EF_VAX_GFLOAT))
2543             strcat (buf, ", G-Float");
2544           break;
2545
2546         case EM_RX:
2547           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2548             strcat (buf, ", 64-bit doubles");
2549           if (e_flags & E_FLAG_RX_DSP)
2550             strcat (buf, ", dsp");
2551
2552         case EM_S390:
2553           if (e_flags & EF_S390_HIGH_GPRS)
2554             strcat (buf, ", highgprs");
2555
2556         case EM_TI_C6000:
2557           if ((e_flags & EF_C6000_REL))
2558             strcat (buf, ", relocatable module");
2559         }
2560     }
2561
2562   return buf;
2563 }
2564
2565 static const char *
2566 get_osabi_name (unsigned int osabi)
2567 {
2568   static char buff[32];
2569
2570   switch (osabi)
2571     {
2572     case ELFOSABI_NONE:         return "UNIX - System V";
2573     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
2574     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
2575     case ELFOSABI_LINUX:        return "UNIX - Linux";
2576     case ELFOSABI_HURD:         return "GNU/Hurd";
2577     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
2578     case ELFOSABI_AIX:          return "UNIX - AIX";
2579     case ELFOSABI_IRIX:         return "UNIX - IRIX";
2580     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
2581     case ELFOSABI_TRU64:        return "UNIX - TRU64";
2582     case ELFOSABI_MODESTO:      return "Novell - Modesto";
2583     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
2584     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
2585     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
2586     case ELFOSABI_AROS:         return "AROS";
2587     case ELFOSABI_FENIXOS:      return "FenixOS";
2588     default:
2589       if (osabi >= 64)
2590         switch (elf_header.e_machine)
2591           {
2592           case EM_ARM:
2593             switch (osabi)
2594               {
2595               case ELFOSABI_ARM:        return "ARM";
2596               default:
2597                 break;
2598               }
2599             break;
2600
2601           case EM_MSP430:
2602           case EM_MSP430_OLD:
2603             switch (osabi)
2604               {
2605               case ELFOSABI_STANDALONE: return _("Standalone App");
2606               default:
2607                 break;
2608               }
2609             break;
2610
2611           case EM_TI_C6000:
2612             switch (osabi)
2613               {
2614               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
2615               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
2616               default:
2617                 break;
2618               }
2619             break;
2620
2621           default:
2622             break;
2623           }
2624       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2625       return buff;
2626     }
2627 }
2628
2629 static const char *
2630 get_arm_segment_type (unsigned long type)
2631 {
2632   switch (type)
2633     {
2634     case PT_ARM_EXIDX:
2635       return "EXIDX";
2636     default:
2637       break;
2638     }
2639
2640   return NULL;
2641 }
2642
2643 static const char *
2644 get_mips_segment_type (unsigned long type)
2645 {
2646   switch (type)
2647     {
2648     case PT_MIPS_REGINFO:
2649       return "REGINFO";
2650     case PT_MIPS_RTPROC:
2651       return "RTPROC";
2652     case PT_MIPS_OPTIONS:
2653       return "OPTIONS";
2654     default:
2655       break;
2656     }
2657
2658   return NULL;
2659 }
2660
2661 static const char *
2662 get_parisc_segment_type (unsigned long type)
2663 {
2664   switch (type)
2665     {
2666     case PT_HP_TLS:             return "HP_TLS";
2667     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
2668     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
2669     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
2670     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
2671     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
2672     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
2673     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
2674     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
2675     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
2676     case PT_HP_PARALLEL:        return "HP_PARALLEL";
2677     case PT_HP_FASTBIND:        return "HP_FASTBIND";
2678     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
2679     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
2680     case PT_HP_STACK:           return "HP_STACK";
2681     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
2682     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
2683     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
2684     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
2685     default:
2686       break;
2687     }
2688
2689   return NULL;
2690 }
2691
2692 static const char *
2693 get_ia64_segment_type (unsigned long type)
2694 {
2695   switch (type)
2696     {
2697     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
2698     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
2699     case PT_HP_TLS:             return "HP_TLS";
2700     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
2701     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
2702     case PT_IA_64_HP_STACK:     return "HP_STACK";
2703     default:
2704       break;
2705     }
2706
2707   return NULL;
2708 }
2709
2710 static const char *
2711 get_tic6x_segment_type (unsigned long type)
2712 {
2713   switch (type)
2714     {
2715     case PT_C6000_PHATTR:       return "C6000_PHATTR";
2716     default:
2717       break;
2718     }
2719
2720   return NULL;
2721 }
2722
2723 static const char *
2724 get_segment_type (unsigned long p_type)
2725 {
2726   static char buff[32];
2727
2728   switch (p_type)
2729     {
2730     case PT_NULL:       return "NULL";
2731     case PT_LOAD:       return "LOAD";
2732     case PT_DYNAMIC:    return "DYNAMIC";
2733     case PT_INTERP:     return "INTERP";
2734     case PT_NOTE:       return "NOTE";
2735     case PT_SHLIB:      return "SHLIB";
2736     case PT_PHDR:       return "PHDR";
2737     case PT_TLS:        return "TLS";
2738
2739     case PT_GNU_EH_FRAME:
2740                         return "GNU_EH_FRAME";
2741     case PT_GNU_STACK:  return "GNU_STACK";
2742     case PT_GNU_RELRO:  return "GNU_RELRO";
2743
2744     default:
2745       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2746         {
2747           const char * result;
2748
2749           switch (elf_header.e_machine)
2750             {
2751             case EM_ARM:
2752               result = get_arm_segment_type (p_type);
2753               break;
2754             case EM_MIPS:
2755             case EM_MIPS_RS3_LE:
2756               result = get_mips_segment_type (p_type);
2757               break;
2758             case EM_PARISC:
2759               result = get_parisc_segment_type (p_type);
2760               break;
2761             case EM_IA_64:
2762               result = get_ia64_segment_type (p_type);
2763               break;
2764             case EM_TI_C6000:
2765               result = get_tic6x_segment_type (p_type);
2766               break;
2767             default:
2768               result = NULL;
2769               break;
2770             }
2771
2772           if (result != NULL)
2773             return result;
2774
2775           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2776         }
2777       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2778         {
2779           const char * result;
2780
2781           switch (elf_header.e_machine)
2782             {
2783             case EM_PARISC:
2784               result = get_parisc_segment_type (p_type);
2785               break;
2786             case EM_IA_64:
2787               result = get_ia64_segment_type (p_type);
2788               break;
2789             default:
2790               result = NULL;
2791               break;
2792             }
2793
2794           if (result != NULL)
2795             return result;
2796
2797           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2798         }
2799       else
2800         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2801
2802       return buff;
2803     }
2804 }
2805
2806 static const char *
2807 get_mips_section_type_name (unsigned int sh_type)
2808 {
2809   switch (sh_type)
2810     {
2811     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
2812     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
2813     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
2814     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
2815     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
2816     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
2817     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
2818     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
2819     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
2820     case SHT_MIPS_RELD:          return "MIPS_RELD";
2821     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
2822     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
2823     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
2824     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
2825     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
2826     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
2827     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
2828     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
2829     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
2830     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
2831     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
2832     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
2833     case SHT_MIPS_LINE:          return "MIPS_LINE";
2834     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
2835     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
2836     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
2837     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
2838     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
2839     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
2840     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
2841     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
2842     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
2843     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
2844     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
2845     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
2846     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
2847     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
2848     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
2849     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2850     default:
2851       break;
2852     }
2853   return NULL;
2854 }
2855
2856 static const char *
2857 get_parisc_section_type_name (unsigned int sh_type)
2858 {
2859   switch (sh_type)
2860     {
2861     case SHT_PARISC_EXT:        return "PARISC_EXT";
2862     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
2863     case SHT_PARISC_DOC:        return "PARISC_DOC";
2864     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
2865     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
2866     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
2867     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
2868     default:
2869       break;
2870     }
2871   return NULL;
2872 }
2873
2874 static const char *
2875 get_ia64_section_type_name (unsigned int sh_type)
2876 {
2877   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
2878   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2879     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2880
2881   switch (sh_type)
2882     {
2883     case SHT_IA_64_EXT:                return "IA_64_EXT";
2884     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
2885     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
2886     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
2887     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2888     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
2889     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
2890     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
2891     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
2892     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
2893     default:
2894       break;
2895     }
2896   return NULL;
2897 }
2898
2899 static const char *
2900 get_x86_64_section_type_name (unsigned int sh_type)
2901 {
2902   switch (sh_type)
2903     {
2904     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
2905     default:
2906       break;
2907     }
2908   return NULL;
2909 }
2910
2911 static const char *
2912 get_arm_section_type_name (unsigned int sh_type)
2913 {
2914   switch (sh_type)
2915     {
2916     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
2917     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
2918     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
2919     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
2920     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
2921     default:
2922       break;
2923     }
2924   return NULL;
2925 }
2926
2927 static const char *
2928 get_tic6x_section_type_name (unsigned int sh_type)
2929 {
2930   switch (sh_type)
2931     {
2932     case SHT_C6000_UNWIND:
2933       return "C6000_UNWIND";
2934     case SHT_C6000_PREEMPTMAP:
2935       return "C6000_PREEMPTMAP";
2936     case SHT_C6000_ATTRIBUTES:
2937       return "C6000_ATTRIBUTES";
2938     case SHT_TI_ICODE:
2939       return "TI_ICODE";
2940     case SHT_TI_XREF:
2941       return "TI_XREF";
2942     case SHT_TI_HANDLER:
2943       return "TI_HANDLER";
2944     case SHT_TI_INITINFO:
2945       return "TI_INITINFO";
2946     case SHT_TI_PHATTRS:
2947       return "TI_PHATTRS";
2948     default:
2949       break;
2950     }
2951   return NULL;
2952 }
2953
2954 static const char *
2955 get_section_type_name (unsigned int sh_type)
2956 {
2957   static char buff[32];
2958
2959   switch (sh_type)
2960     {
2961     case SHT_NULL:              return "NULL";
2962     case SHT_PROGBITS:          return "PROGBITS";
2963     case SHT_SYMTAB:            return "SYMTAB";
2964     case SHT_STRTAB:            return "STRTAB";
2965     case SHT_RELA:              return "RELA";
2966     case SHT_HASH:              return "HASH";
2967     case SHT_DYNAMIC:           return "DYNAMIC";
2968     case SHT_NOTE:              return "NOTE";
2969     case SHT_NOBITS:            return "NOBITS";
2970     case SHT_REL:               return "REL";
2971     case SHT_SHLIB:             return "SHLIB";
2972     case SHT_DYNSYM:            return "DYNSYM";
2973     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
2974     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
2975     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
2976     case SHT_GNU_HASH:          return "GNU_HASH";
2977     case SHT_GROUP:             return "GROUP";
2978     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
2979     case SHT_GNU_verdef:        return "VERDEF";
2980     case SHT_GNU_verneed:       return "VERNEED";
2981     case SHT_GNU_versym:        return "VERSYM";
2982     case 0x6ffffff0:            return "VERSYM";
2983     case 0x6ffffffc:            return "VERDEF";
2984     case 0x7ffffffd:            return "AUXILIARY";
2985     case 0x7fffffff:            return "FILTER";
2986     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
2987
2988     default:
2989       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2990         {
2991           const char * result;
2992
2993           switch (elf_header.e_machine)
2994             {
2995             case EM_MIPS:
2996             case EM_MIPS_RS3_LE:
2997               result = get_mips_section_type_name (sh_type);
2998               break;
2999             case EM_PARISC:
3000               result = get_parisc_section_type_name (sh_type);
3001               break;
3002             case EM_IA_64:
3003               result = get_ia64_section_type_name (sh_type);
3004               break;
3005             case EM_X86_64:
3006             case EM_L1OM:
3007               result = get_x86_64_section_type_name (sh_type);
3008               break;
3009             case EM_ARM:
3010               result = get_arm_section_type_name (sh_type);
3011               break;
3012             case EM_TI_C6000:
3013               result = get_tic6x_section_type_name (sh_type);
3014               break;
3015             default:
3016               result = NULL;
3017               break;
3018             }
3019
3020           if (result != NULL)
3021             return result;
3022
3023           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3024         }
3025       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3026         {
3027           const char * result;
3028
3029           switch (elf_header.e_machine)
3030             {
3031             case EM_IA_64:
3032               result = get_ia64_section_type_name (sh_type);
3033               break;
3034             default:
3035               result = NULL;
3036               break;
3037             }
3038
3039           if (result != NULL)
3040             return result;
3041
3042           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3043         }
3044       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3045         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3046       else
3047         snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
3048
3049       return buff;
3050     }
3051 }
3052
3053 #define OPTION_DEBUG_DUMP       512
3054 #define OPTION_DYN_SYMS         513
3055
3056 static struct option options[] =
3057 {
3058   {"all",              no_argument, 0, 'a'},
3059   {"file-header",      no_argument, 0, 'h'},
3060   {"program-headers",  no_argument, 0, 'l'},
3061   {"headers",          no_argument, 0, 'e'},
3062   {"histogram",        no_argument, 0, 'I'},
3063   {"segments",         no_argument, 0, 'l'},
3064   {"sections",         no_argument, 0, 'S'},
3065   {"section-headers",  no_argument, 0, 'S'},
3066   {"section-groups",   no_argument, 0, 'g'},
3067   {"section-details",  no_argument, 0, 't'},
3068   {"full-section-name",no_argument, 0, 'N'},
3069   {"symbols",          no_argument, 0, 's'},
3070   {"syms",             no_argument, 0, 's'},
3071   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3072   {"relocs",           no_argument, 0, 'r'},
3073   {"notes",            no_argument, 0, 'n'},
3074   {"dynamic",          no_argument, 0, 'd'},
3075   {"arch-specific",    no_argument, 0, 'A'},
3076   {"version-info",     no_argument, 0, 'V'},
3077   {"use-dynamic",      no_argument, 0, 'D'},
3078   {"unwind",           no_argument, 0, 'u'},
3079   {"archive-index",    no_argument, 0, 'c'},
3080   {"hex-dump",         required_argument, 0, 'x'},
3081   {"relocated-dump",   required_argument, 0, 'R'},
3082   {"string-dump",      required_argument, 0, 'p'},
3083 #ifdef SUPPORT_DISASSEMBLY
3084   {"instruction-dump", required_argument, 0, 'i'},
3085 #endif
3086   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3087
3088   {"version",          no_argument, 0, 'v'},
3089   {"wide",             no_argument, 0, 'W'},
3090   {"help",             no_argument, 0, 'H'},
3091   {0,                  no_argument, 0, 0}
3092 };
3093
3094 static void
3095 usage (FILE * stream)
3096 {
3097   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3098   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3099   fprintf (stream, _(" Options are:\n\
3100   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3101   -h --file-header       Display the ELF file header\n\
3102   -l --program-headers   Display the program headers\n\
3103      --segments          An alias for --program-headers\n\
3104   -S --section-headers   Display the sections' header\n\
3105      --sections          An alias for --section-headers\n\
3106   -g --section-groups    Display the section groups\n\
3107   -t --section-details   Display the section details\n\
3108   -e --headers           Equivalent to: -h -l -S\n\
3109   -s --syms              Display the symbol table\n\
3110      --symbols           An alias for --syms\n\
3111   --dyn-syms             Display the dynamic symbol table\n\
3112   -n --notes             Display the core notes (if present)\n\
3113   -r --relocs            Display the relocations (if present)\n\
3114   -u --unwind            Display the unwind info (if present)\n\
3115   -d --dynamic           Display the dynamic section (if present)\n\
3116   -V --version-info      Display the version sections (if present)\n\
3117   -A --arch-specific     Display architecture specific information (if any).\n\
3118   -c --archive-index     Display the symbol/file index in an archive\n\
3119   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3120   -x --hex-dump=<number|name>\n\
3121                          Dump the contents of section <number|name> as bytes\n\
3122   -p --string-dump=<number|name>\n\
3123                          Dump the contents of section <number|name> as strings\n\
3124   -R --relocated-dump=<number|name>\n\
3125                          Dump the contents of section <number|name> as relocated bytes\n\
3126   -w[lLiaprmfFsoRt] or\n\
3127   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3128                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3129                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
3130                          Display the contents of DWARF2 debug sections\n"));
3131 #ifdef SUPPORT_DISASSEMBLY
3132   fprintf (stream, _("\
3133   -i --instruction-dump=<number|name>\n\
3134                          Disassemble the contents of section <number|name>\n"));
3135 #endif
3136   fprintf (stream, _("\
3137   -I --histogram         Display histogram of bucket list lengths\n\
3138   -W --wide              Allow output width to exceed 80 characters\n\
3139   @<file>                Read options from <file>\n\
3140   -H --help              Display this information\n\
3141   -v --version           Display the version number of readelf\n"));
3142
3143   if (REPORT_BUGS_TO[0] && stream == stdout)
3144     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3145
3146   exit (stream == stdout ? 0 : 1);
3147 }
3148
3149 /* Record the fact that the user wants the contents of section number
3150    SECTION to be displayed using the method(s) encoded as flags bits
3151    in TYPE.  Note, TYPE can be zero if we are creating the array for
3152    the first time.  */
3153
3154 static void
3155 request_dump_bynumber (unsigned int section, dump_type type)
3156 {
3157   if (section >= num_dump_sects)
3158     {
3159       dump_type * new_dump_sects;
3160
3161       new_dump_sects = (dump_type *) calloc (section + 1,
3162                                              sizeof (* dump_sects));
3163
3164       if (new_dump_sects == NULL)
3165         error (_("Out of memory allocating dump request table.\n"));
3166       else
3167         {
3168           /* Copy current flag settings.  */
3169           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3170
3171           free (dump_sects);
3172
3173           dump_sects = new_dump_sects;
3174           num_dump_sects = section + 1;
3175         }
3176     }
3177
3178   if (dump_sects)
3179     dump_sects[section] |= type;
3180
3181   return;
3182 }
3183
3184 /* Request a dump by section name.  */
3185
3186 static void
3187 request_dump_byname (const char * section, dump_type type)
3188 {
3189   struct dump_list_entry * new_request;
3190
3191   new_request = (struct dump_list_entry *)
3192       malloc (sizeof (struct dump_list_entry));
3193   if (!new_request)
3194     error (_("Out of memory allocating dump request table.\n"));
3195
3196   new_request->name = strdup (section);
3197   if (!new_request->name)
3198     error (_("Out of memory allocating dump request table.\n"));
3199
3200   new_request->type = type;
3201
3202   new_request->next = dump_sects_byname;
3203   dump_sects_byname = new_request;
3204 }
3205
3206 static inline void
3207 request_dump (dump_type type)
3208 {
3209   int section;
3210   char * cp;
3211
3212   do_dump++;
3213   section = strtoul (optarg, & cp, 0);
3214
3215   if (! *cp && section >= 0)
3216     request_dump_bynumber (section, type);
3217   else
3218     request_dump_byname (optarg, type);
3219 }
3220
3221
3222 static void
3223 parse_args (int argc, char ** argv)
3224 {
3225   int c;
3226
3227   if (argc < 2)
3228     usage (stderr);
3229
3230   while ((c = getopt_long
3231           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3232     {
3233       switch (c)
3234         {
3235         case 0:
3236           /* Long options.  */
3237           break;
3238         case 'H':
3239           usage (stdout);
3240           break;
3241
3242         case 'a':
3243           do_syms++;
3244           do_reloc++;
3245           do_unwind++;
3246           do_dynamic++;
3247           do_header++;
3248           do_sections++;
3249           do_section_groups++;
3250           do_segments++;
3251           do_version++;
3252           do_histogram++;
3253           do_arch++;
3254           do_notes++;
3255           break;
3256         case 'g':
3257           do_section_groups++;
3258           break;
3259         case 't':
3260         case 'N':
3261           do_sections++;
3262           do_section_details++;
3263           break;
3264         case 'e':
3265           do_header++;
3266           do_sections++;
3267           do_segments++;
3268           break;
3269         case 'A':
3270           do_arch++;
3271           break;
3272         case 'D':
3273           do_using_dynamic++;
3274           break;
3275         case 'r':
3276           do_reloc++;
3277           break;
3278         case 'u':
3279           do_unwind++;
3280           break;
3281         case 'h':
3282           do_header++;
3283           break;
3284         case 'l':
3285           do_segments++;
3286           break;
3287         case 's':
3288           do_syms++;
3289           break;
3290         case 'S':
3291           do_sections++;
3292           break;
3293         case 'd':
3294           do_dynamic++;
3295           break;
3296         case 'I':
3297           do_histogram++;
3298           break;
3299         case 'n':
3300           do_notes++;
3301           break;
3302         case 'c':
3303           do_archive_index++;
3304           break;
3305         case 'x':
3306           request_dump (HEX_DUMP);
3307           break;
3308         case 'p':
3309           request_dump (STRING_DUMP);
3310           break;
3311         case 'R':
3312           request_dump (RELOC_DUMP);
3313           break;
3314         case 'w':
3315           do_dump++;
3316           if (optarg == 0)
3317             {
3318               do_debugging = 1;
3319               dwarf_select_sections_all ();
3320             }
3321           else
3322             {
3323               do_debugging = 0;
3324               dwarf_select_sections_by_letters (optarg);
3325             }
3326           break;
3327         case OPTION_DEBUG_DUMP:
3328           do_dump++;
3329           if (optarg == 0)
3330             do_debugging = 1;
3331           else
3332             {
3333               do_debugging = 0;
3334               dwarf_select_sections_by_names (optarg);
3335             }
3336           break;
3337         case OPTION_DYN_SYMS:
3338           do_dyn_syms++;
3339           break;
3340 #ifdef SUPPORT_DISASSEMBLY
3341         case 'i':
3342           request_dump (DISASS_DUMP);
3343           break;
3344 #endif
3345         case 'v':
3346           print_version (program_name);
3347           break;
3348         case 'V':
3349           do_version++;
3350           break;
3351         case 'W':
3352           do_wide++;
3353           break;
3354         default:
3355           /* xgettext:c-format */
3356           error (_("Invalid option '-%c'\n"), c);
3357           /* Drop through.  */
3358         case '?':
3359           usage (stderr);
3360         }
3361     }
3362
3363   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3364       && !do_segments && !do_header && !do_dump && !do_version
3365       && !do_histogram && !do_debugging && !do_arch && !do_notes
3366       && !do_section_groups && !do_archive_index
3367       && !do_dyn_syms)
3368     usage (stderr);
3369   else if (argc < 3)
3370     {
3371       warn (_("Nothing to do.\n"));
3372       usage (stderr);
3373     }
3374 }
3375
3376 static const char *
3377 get_elf_class (unsigned int elf_class)
3378 {
3379   static char buff[32];
3380
3381   switch (elf_class)
3382     {
3383     case ELFCLASSNONE: return _("none");
3384     case ELFCLASS32:   return "ELF32";
3385     case ELFCLASS64:   return "ELF64";
3386     default:
3387       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3388       return buff;
3389     }
3390 }
3391
3392 static const char *
3393 get_data_encoding (unsigned int encoding)
3394 {
3395   static char buff[32];
3396
3397   switch (encoding)
3398     {
3399     case ELFDATANONE: return _("none");
3400     case ELFDATA2LSB: return _("2's complement, little endian");
3401     case ELFDATA2MSB: return _("2's complement, big endian");
3402     default:
3403       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3404       return buff;
3405     }
3406 }
3407
3408 /* Decode the data held in 'elf_header'.  */
3409
3410 static int
3411 process_file_header (void)
3412 {
3413   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3414       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3415       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3416       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3417     {
3418       error
3419         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3420       return 0;
3421     }
3422
3423   init_dwarf_regnames (elf_header.e_machine);
3424
3425   if (do_header)
3426     {
3427       int i;
3428
3429       printf (_("ELF Header:\n"));
3430       printf (_("  Magic:   "));
3431       for (i = 0; i < EI_NIDENT; i++)
3432         printf ("%2.2x ", elf_header.e_ident[i]);
3433       printf ("\n");
3434       printf (_("  Class:                             %s\n"),
3435               get_elf_class (elf_header.e_ident[EI_CLASS]));
3436       printf (_("  Data:                              %s\n"),
3437               get_data_encoding (elf_header.e_ident[EI_DATA]));
3438       printf (_("  Version:                           %d %s\n"),
3439               elf_header.e_ident[EI_VERSION],
3440               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3441                ? "(current)"
3442                : (elf_header.e_ident[EI_VERSION] != EV_NONE
3443                   ? _("<unknown: %lx>")
3444                   : "")));
3445       printf (_("  OS/ABI:                            %s\n"),
3446               get_osabi_name (elf_header.e_ident[EI_OSABI]));
3447       printf (_("  ABI Version:                       %d\n"),
3448               elf_header.e_ident[EI_ABIVERSION]);
3449       printf (_("  Type:                              %s\n"),
3450               get_file_type (elf_header.e_type));
3451       printf (_("  Machine:                           %s\n"),
3452               get_machine_name (elf_header.e_machine));
3453       printf (_("  Version:                           0x%lx\n"),
3454               (unsigned long) elf_header.e_version);
3455
3456       printf (_("  Entry point address:               "));
3457       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3458       printf (_("\n  Start of program headers:          "));
3459       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3460       printf (_(" (bytes into file)\n  Start of section headers:          "));
3461       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3462       printf (_(" (bytes into file)\n"));
3463
3464       printf (_("  Flags:                             0x%lx%s\n"),
3465               (unsigned long) elf_header.e_flags,
3466               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3467       printf (_("  Size of this header:               %ld (bytes)\n"),
3468               (long) elf_header.e_ehsize);
3469       printf (_("  Size of program headers:           %ld (bytes)\n"),
3470               (long) elf_header.e_phentsize);
3471       printf (_("  Number of program headers:         %ld"),
3472               (long) elf_header.e_phnum);
3473       if (section_headers != NULL
3474           && elf_header.e_phnum == PN_XNUM
3475           && section_headers[0].sh_info != 0)
3476         printf (" (%ld)", (long) section_headers[0].sh_info);
3477       putc ('\n', stdout);
3478       printf (_("  Size of section headers:           %ld (bytes)\n"),
3479               (long) elf_header.e_shentsize);
3480       printf (_("  Number of section headers:         %ld"),
3481               (long) elf_header.e_shnum);
3482       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3483         printf (" (%ld)", (long) section_headers[0].sh_size);
3484       putc ('\n', stdout);
3485       printf (_("  Section header string table index: %ld"),
3486               (long) elf_header.e_shstrndx);
3487       if (section_headers != NULL
3488           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3489         printf (" (%u)", section_headers[0].sh_link);
3490       else if (elf_header.e_shstrndx != SHN_UNDEF
3491                && elf_header.e_shstrndx >= elf_header.e_shnum)
3492         printf (_(" <corrupt: out of range>"));
3493       putc ('\n', stdout);
3494     }
3495
3496   if (section_headers != NULL)
3497     {
3498       if (elf_header.e_phnum == PN_XNUM
3499           && section_headers[0].sh_info != 0)
3500         elf_header.e_phnum = section_headers[0].sh_info;
3501       if (elf_header.e_shnum == SHN_UNDEF)
3502         elf_header.e_shnum = section_headers[0].sh_size;
3503       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3504         elf_header.e_shstrndx = section_headers[0].sh_link;
3505       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3506         elf_header.e_shstrndx = SHN_UNDEF;
3507       free (section_headers);
3508       section_headers = NULL;
3509     }
3510
3511   return 1;
3512 }
3513
3514
3515 static int
3516 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3517 {
3518   Elf32_External_Phdr * phdrs;
3519   Elf32_External_Phdr * external;
3520   Elf_Internal_Phdr *   internal;
3521   unsigned int i;
3522
3523   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3524                                             elf_header.e_phentsize,
3525                                             elf_header.e_phnum,
3526                                             _("program headers"));
3527   if (!phdrs)
3528     return 0;
3529
3530   for (i = 0, internal = pheaders, external = phdrs;
3531        i < elf_header.e_phnum;
3532        i++, internal++, external++)
3533     {
3534       internal->p_type   = BYTE_GET (external->p_type);
3535       internal->p_offset = BYTE_GET (external->p_offset);
3536       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3537       internal->p_paddr  = BYTE_GET (external->p_paddr);
3538       internal->p_filesz = BYTE_GET (external->p_filesz);
3539       internal->p_memsz  = BYTE_GET (external->p_memsz);
3540       internal->p_flags  = BYTE_GET (external->p_flags);
3541       internal->p_align  = BYTE_GET (external->p_align);
3542     }
3543
3544   free (phdrs);
3545
3546   return 1;
3547 }
3548
3549 static int
3550 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3551 {
3552   Elf64_External_Phdr * phdrs;
3553   Elf64_External_Phdr * external;
3554   Elf_Internal_Phdr *   internal;
3555   unsigned int i;
3556
3557   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3558                                             elf_header.e_phentsize,
3559                                             elf_header.e_phnum,
3560                                             _("program headers"));
3561   if (!phdrs)
3562     return 0;
3563
3564   for (i = 0, internal = pheaders, external = phdrs;
3565        i < elf_header.e_phnum;
3566        i++, internal++, external++)
3567     {
3568       internal->p_type   = BYTE_GET (external->p_type);
3569       internal->p_flags  = BYTE_GET (external->p_flags);
3570       internal->p_offset = BYTE_GET (external->p_offset);
3571       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3572       internal->p_paddr  = BYTE_GET (external->p_paddr);
3573       internal->p_filesz = BYTE_GET (external->p_filesz);
3574       internal->p_memsz  = BYTE_GET (external->p_memsz);
3575       internal->p_align  = BYTE_GET (external->p_align);
3576     }
3577
3578   free (phdrs);
3579
3580   return 1;
3581 }
3582
3583 /* Returns 1 if the program headers were read into `program_headers'.  */
3584
3585 static int
3586 get_program_headers (FILE * file)
3587 {
3588   Elf_Internal_Phdr * phdrs;
3589
3590   /* Check cache of prior read.  */
3591   if (program_headers != NULL)
3592     return 1;
3593
3594   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3595                                          sizeof (Elf_Internal_Phdr));
3596
3597   if (phdrs == NULL)
3598     {
3599       error (_("Out of memory\n"));
3600       return 0;
3601     }
3602
3603   if (is_32bit_elf
3604       ? get_32bit_program_headers (file, phdrs)
3605       : get_64bit_program_headers (file, phdrs))
3606     {
3607       program_headers = phdrs;
3608       return 1;
3609     }
3610
3611   free (phdrs);
3612   return 0;
3613 }
3614
3615 /* Returns 1 if the program headers were loaded.  */
3616
3617 static int
3618 process_program_headers (FILE * file)
3619 {
3620   Elf_Internal_Phdr * segment;
3621   unsigned int i;
3622
3623   if (elf_header.e_phnum == 0)
3624     {
3625       if (do_segments)
3626         printf (_("\nThere are no program headers in this file.\n"));
3627       return 0;
3628     }
3629
3630   if (do_segments && !do_header)
3631     {
3632       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3633       printf (_("Entry point "));
3634       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3635       printf (_("\nThere are %d program headers, starting at offset "),
3636               elf_header.e_phnum);
3637       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3638       printf ("\n");
3639     }
3640
3641   if (! get_program_headers (file))
3642       return 0;
3643
3644   if (do_segments)
3645     {
3646       if (elf_header.e_phnum > 1)
3647         printf (_("\nProgram Headers:\n"));
3648       else
3649         printf (_("\nProgram Headers:\n"));
3650
3651       if (is_32bit_elf)
3652         printf
3653           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
3654       else if (do_wide)
3655         printf
3656           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
3657       else
3658         {
3659           printf
3660             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
3661           printf
3662             (_("                 FileSiz            MemSiz              Flags  Align\n"));
3663         }
3664     }
3665
3666   dynamic_addr = 0;
3667   dynamic_size = 0;
3668
3669   for (i = 0, segment = program_headers;
3670        i < elf_header.e_phnum;
3671        i++, segment++)
3672     {
3673       if (do_segments)
3674         {
3675           printf ("  %-14.14s ", get_segment_type (segment->p_type));
3676
3677           if (is_32bit_elf)
3678             {
3679               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3680               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3681               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3682               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3683               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3684               printf ("%c%c%c ",
3685                       (segment->p_flags & PF_R ? 'R' : ' '),
3686                       (segment->p_flags & PF_W ? 'W' : ' '),
3687                       (segment->p_flags & PF_X ? 'E' : ' '));
3688               printf ("%#lx", (unsigned long) segment->p_align);
3689             }
3690           else if (do_wide)
3691             {
3692               if ((unsigned long) segment->p_offset == segment->p_offset)
3693                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3694               else
3695                 {
3696                   print_vma (segment->p_offset, FULL_HEX);
3697                   putchar (' ');
3698                 }
3699
3700               print_vma (segment->p_vaddr, FULL_HEX);
3701               putchar (' ');
3702               print_vma (segment->p_paddr, FULL_HEX);
3703               putchar (' ');
3704
3705               if ((unsigned long) segment->p_filesz == segment->p_filesz)
3706                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3707               else
3708                 {
3709                   print_vma (segment->p_filesz, FULL_HEX);
3710                   putchar (' ');
3711                 }
3712
3713               if ((unsigned long) segment->p_memsz == segment->p_memsz)
3714                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3715               else
3716                 {
3717                   print_vma (segment->p_offset, FULL_HEX);
3718                 }
3719
3720               printf (" %c%c%c ",
3721                       (segment->p_flags & PF_R ? 'R' : ' '),
3722                       (segment->p_flags & PF_W ? 'W' : ' '),
3723                       (segment->p_flags & PF_X ? 'E' : ' '));
3724
3725               if ((unsigned long) segment->p_align == segment->p_align)
3726                 printf ("%#lx", (unsigned long) segment->p_align);
3727               else
3728                 {
3729                   print_vma (segment->p_align, PREFIX_HEX);
3730                 }
3731             }
3732           else
3733             {
3734               print_vma (segment->p_offset, FULL_HEX);
3735               putchar (' ');
3736               print_vma (segment->p_vaddr, FULL_HEX);
3737               putchar (' ');
3738               print_vma (segment->p_paddr, FULL_HEX);
3739               printf ("\n                 ");
3740               print_vma (segment->p_filesz, FULL_HEX);
3741               putchar (' ');
3742               print_vma (segment->p_memsz, FULL_HEX);
3743               printf ("  %c%c%c    ",
3744                       (segment->p_flags & PF_R ? 'R' : ' '),
3745                       (segment->p_flags & PF_W ? 'W' : ' '),
3746                       (segment->p_flags & PF_X ? 'E' : ' '));
3747               print_vma (segment->p_align, HEX);
3748             }
3749         }
3750
3751       switch (segment->p_type)
3752         {
3753         case PT_DYNAMIC:
3754           if (dynamic_addr)
3755             error (_("more than one dynamic segment\n"));
3756
3757           /* By default, assume that the .dynamic section is the first
3758              section in the DYNAMIC segment.  */
3759           dynamic_addr = segment->p_offset;
3760           dynamic_size = segment->p_filesz;
3761
3762           /* Try to locate the .dynamic section. If there is
3763              a section header table, we can easily locate it.  */
3764           if (section_headers != NULL)
3765             {
3766               Elf_Internal_Shdr * sec;
3767
3768               sec = find_section (".dynamic");
3769               if (sec == NULL || sec->sh_size == 0)
3770                 {
3771                   /* A corresponding .dynamic section is expected, but on
3772                      IA-64/OpenVMS it is OK for it to be missing.  */
3773                   if (!is_ia64_vms ())
3774                     error (_("no .dynamic section in the dynamic segment\n"));
3775                   break;
3776                 }
3777
3778               if (sec->sh_type == SHT_NOBITS)
3779                 {
3780                   dynamic_size = 0;
3781                   break;
3782                 }
3783
3784               dynamic_addr = sec->sh_offset;
3785               dynamic_size = sec->sh_size;
3786
3787               if (dynamic_addr < segment->p_offset
3788                   || dynamic_addr > segment->p_offset + segment->p_filesz)
3789                 warn (_("the .dynamic section is not contained"
3790                         " within the dynamic segment\n"));
3791               else if (dynamic_addr > segment->p_offset)
3792                 warn (_("the .dynamic section is not the first section"
3793                         " in the dynamic segment.\n"));
3794             }
3795           break;
3796
3797         case PT_INTERP:
3798           if (fseek (file, archive_file_offset + (long) segment->p_offset,
3799                      SEEK_SET))
3800             error (_("Unable to find program interpreter name\n"));
3801           else
3802             {
3803               char fmt [32];
3804               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3805
3806               if (ret >= (int) sizeof (fmt) || ret < 0)
3807                 error (_("Internal error: failed to create format string to display program interpreter\n"));
3808
3809               program_interpreter[0] = 0;
3810               if (fscanf (file, fmt, program_interpreter) <= 0)
3811                 error (_("Unable to read program interpreter name\n"));
3812
3813               if (do_segments)
3814                 printf (_("\n      [Requesting program interpreter: %s]"),
3815                     program_interpreter);
3816             }
3817           break;
3818         }
3819
3820       if (do_segments)
3821         putc ('\n', stdout);
3822     }
3823
3824   if (do_segments && section_headers != NULL && string_table != NULL)
3825     {
3826       printf (_("\n Section to Segment mapping:\n"));
3827       printf (_("  Segment Sections...\n"));
3828
3829       for (i = 0; i < elf_header.e_phnum; i++)
3830         {
3831           unsigned int j;
3832           Elf_Internal_Shdr * section;
3833
3834           segment = program_headers + i;
3835           section = section_headers + 1;
3836
3837           printf ("   %2.2d     ", i);
3838
3839           for (j = 1; j < elf_header.e_shnum; j++, section++)
3840             {
3841               if (!ELF_TBSS_SPECIAL (section, segment)
3842                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
3843                 printf ("%s ", SECTION_NAME (section));
3844             }
3845
3846           putc ('\n',stdout);
3847         }
3848     }
3849
3850   return 1;
3851 }
3852
3853
3854 /* Find the file offset corresponding to VMA by using the program headers.  */
3855
3856 static long
3857 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3858 {
3859   Elf_Internal_Phdr * seg;
3860
3861   if (! get_program_headers (file))
3862     {
3863       warn (_("Cannot interpret virtual addresses without program headers.\n"));
3864       return (long) vma;
3865     }
3866
3867   for (seg = program_headers;
3868        seg < program_headers + elf_header.e_phnum;
3869        ++seg)
3870     {
3871       if (seg->p_type != PT_LOAD)
3872         continue;
3873
3874       if (vma >= (seg->p_vaddr & -seg->p_align)
3875           && vma + size <= seg->p_vaddr + seg->p_filesz)
3876         return vma - seg->p_vaddr + seg->p_offset;
3877     }
3878
3879   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3880         (unsigned long) vma);
3881   return (long) vma;
3882 }
3883
3884
3885 static int
3886 get_32bit_section_headers (FILE * file, unsigned int num)
3887 {
3888   Elf32_External_Shdr * shdrs;
3889   Elf_Internal_Shdr *   internal;
3890   unsigned int i;
3891
3892   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3893                                             elf_header.e_shentsize, num,
3894                                             _("section headers"));
3895   if (!shdrs)
3896     return 0;
3897
3898   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3899                                                    sizeof (Elf_Internal_Shdr));
3900
3901   if (section_headers == NULL)
3902     {
3903       error (_("Out of memory\n"));
3904       return 0;
3905     }
3906
3907   for (i = 0, internal = section_headers;
3908        i < num;
3909        i++, internal++)
3910     {
3911       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3912       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3913       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3914       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3915       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3916       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3917       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3918       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3919       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3920       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3921     }
3922
3923   free (shdrs);
3924
3925   return 1;
3926 }
3927
3928 static int
3929 get_64bit_section_headers (FILE * file, unsigned int num)
3930 {
3931   Elf64_External_Shdr * shdrs;
3932   Elf_Internal_Shdr *   internal;
3933   unsigned int i;
3934
3935   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3936                                             elf_header.e_shentsize, num,
3937                                             _("section headers"));
3938   if (!shdrs)
3939     return 0;
3940
3941   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3942                                                    sizeof (Elf_Internal_Shdr));
3943
3944   if (section_headers == NULL)
3945     {
3946       error (_("Out of memory\n"));
3947       return 0;
3948     }
3949
3950   for (i = 0, internal = section_headers;
3951        i < num;
3952        i++, internal++)
3953     {
3954       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3955       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3956       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3957       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3958       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3959       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3960       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3961       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3962       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3963       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3964     }
3965
3966   free (shdrs);
3967
3968   return 1;
3969 }
3970
3971 static Elf_Internal_Sym *
3972 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
3973 {
3974   unsigned long number;
3975   Elf32_External_Sym * esyms = NULL;
3976   Elf_External_Sym_Shndx * shndx;
3977   Elf_Internal_Sym * isyms = NULL;
3978   Elf_Internal_Sym * psym;
3979   unsigned int j;
3980
3981   /* Run some sanity checks first.  */
3982   if (section->sh_entsize == 0)
3983     {
3984       error (_("sh_entsize is zero\n"));
3985       return NULL;
3986     }
3987
3988   number = section->sh_size / section->sh_entsize;
3989
3990   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
3991     {
3992       error (_("Invalid sh_entsize\n"));
3993       return NULL;
3994     }
3995
3996   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
3997                                            section->sh_size, _("symbols"));
3998   if (esyms == NULL)
3999     return NULL;
4000
4001   shndx = NULL;
4002   if (symtab_shndx_hdr != NULL
4003       && (symtab_shndx_hdr->sh_link
4004           == (unsigned long) (section - section_headers)))
4005     {
4006       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4007                                                    symtab_shndx_hdr->sh_offset,
4008                                                    1, symtab_shndx_hdr->sh_size,
4009                                                    _("symtab shndx"));