Correct fscanf char field count
[platform/upstream/binutils.git] / binutils / readelf.c
1 /* readelf.c -- display contents of an ELF format file
2    Copyright (C) 1998-2014 Free Software Foundation, Inc.
3
4    Originally developed by Eric Youngdale <eric@andante.jic.com>
5    Modifications by Nick Clifton <nickc@redhat.com>
6
7    This file is part of GNU Binutils.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22    02110-1301, USA.  */
23 \f
24 /* The difference between readelf and objdump:
25
26   Both programs are capable of displaying the contents of ELF format files,
27   so why does the binutils project have two file dumpers ?
28
29   The reason is that objdump sees an ELF file through a BFD filter of the
30   world; if BFD has a bug where, say, it disagrees about a machine constant
31   in e_flags, then the odds are good that it will remain internally
32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
33   GAS sees it the BFD way.  There was need for a tool to go find out what
34   the file actually says.
35
36   This is why the readelf program does not link against the BFD library - it
37   exists as an independent program to help verify the correct working of BFD.
38
39   There is also the case that readelf can provide more information about an
40   ELF file than is provided by objdump.  In particular it can display DWARF
41   debugging information which (at the moment) objdump cannot.  */
42 \f
43 #include "sysdep.h"
44 #include <assert.h>
45 #include <time.h>
46 #ifdef HAVE_ZLIB_H
47 #include <zlib.h>
48 #endif
49 #ifdef HAVE_WCHAR_H
50 #include <wchar.h>
51 #endif
52
53 #if __GNUC__ >= 2
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55    as this will allow us to read in and parse 64bit and 32bit ELF files.
56    Only do this if we believe that the compiler can support a 64 bit
57    data type.  For now we only rely on GCC being able to do this.  */
58 #define BFD64
59 #endif
60
61 #include "bfd.h"
62 #include "bucomm.h"
63 #include "elfcomm.h"
64 #include "dwarf.h"
65
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
69
70
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72    we can obtain the H8 reloc numbers.  We need these for the
73    get_reloc_size() function.  We include h8.h again after defining
74    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
75
76 #include "elf/h8.h"
77 #undef _ELF_H8_H
78
79 /* Undo the effects of #including reloc-macros.h.  */
80
81 #undef START_RELOC_NUMBERS
82 #undef RELOC_NUMBER
83 #undef FAKE_RELOC
84 #undef EMPTY_RELOC
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
87
88 /* The following headers use the elf/reloc-macros.h file to
89    automatically generate relocation recognition functions
90    such as elf_mips_reloc_type()  */
91
92 #define RELOC_MACROS_GEN_FUNC
93
94 #include "elf/aarch64.h"
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/epiphany.h"
107 #include "elf/fr30.h"
108 #include "elf/frv.h"
109 #include "elf/h8.h"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/mcore.h"
124 #include "elf/mep.h"
125 #include "elf/metag.h"
126 #include "elf/microblaze.h"
127 #include "elf/mips.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
132 #include "elf/mt.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
137 #include "elf/pj.h"
138 #include "elf/ppc.h"
139 #include "elf/ppc64.h"
140 #include "elf/rl78.h"
141 #include "elf/rx.h"
142 #include "elf/s390.h"
143 #include "elf/score.h"
144 #include "elf/sh.h"
145 #include "elf/sparc.h"
146 #include "elf/spu.h"
147 #include "elf/tic6x.h"
148 #include "elf/tilegx.h"
149 #include "elf/tilepro.h"
150 #include "elf/v850.h"
151 #include "elf/vax.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
157
158 #include "getopt.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
162
163 #ifndef offsetof
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165 #endif
166
167 char * program_name = "readelf";
168 static long archive_file_offset;
169 static unsigned long archive_file_size;
170 static unsigned long dynamic_addr;
171 static bfd_size_type dynamic_size;
172 static unsigned int dynamic_nent;
173 static char * dynamic_strings;
174 static unsigned long dynamic_strings_length;
175 static char * string_table;
176 static unsigned long string_table_length;
177 static unsigned long num_dynamic_syms;
178 static Elf_Internal_Sym * dynamic_symbols;
179 static Elf_Internal_Syminfo * dynamic_syminfo;
180 static unsigned long dynamic_syminfo_offset;
181 static unsigned int dynamic_syminfo_nent;
182 static char program_interpreter[PATH_MAX];
183 static bfd_vma dynamic_info[DT_ENCODING];
184 static bfd_vma dynamic_info_DT_GNU_HASH;
185 static bfd_vma version_info[16];
186 static Elf_Internal_Ehdr elf_header;
187 static Elf_Internal_Shdr * section_headers;
188 static Elf_Internal_Phdr * program_headers;
189 static Elf_Internal_Dyn *  dynamic_section;
190 static Elf_Internal_Shdr * symtab_shndx_hdr;
191 static int show_name;
192 static int do_dynamic;
193 static int do_syms;
194 static int do_dyn_syms;
195 static int do_reloc;
196 static int do_sections;
197 static int do_section_groups;
198 static int do_section_details;
199 static int do_segments;
200 static int do_unwind;
201 static int do_using_dynamic;
202 static int do_header;
203 static int do_dump;
204 static int do_version;
205 static int do_histogram;
206 static int do_debugging;
207 static int do_arch;
208 static int do_notes;
209 static int do_archive_index;
210 static int is_32bit_elf;
211
212 struct group_list
213 {
214   struct group_list * next;
215   unsigned int section_index;
216 };
217
218 struct group
219 {
220   struct group_list * root;
221   unsigned int group_index;
222 };
223
224 static size_t group_count;
225 static struct group * section_groups;
226 static struct group ** section_headers_groups;
227
228
229 /* Flag bits indicating particular types of dump.  */
230 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
231 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
232 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
233 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
234 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
235
236 typedef unsigned char dump_type;
237
238 /* A linked list of the section names for which dumps were requested.  */
239 struct dump_list_entry
240 {
241   char * name;
242   dump_type type;
243   struct dump_list_entry * next;
244 };
245 static struct dump_list_entry * dump_sects_byname;
246
247 /* A dynamic array of flags indicating for which sections a dump
248    has been requested via command line switches.  */
249 static dump_type *   cmdline_dump_sects = NULL;
250 static unsigned int  num_cmdline_dump_sects = 0;
251
252 /* A dynamic array of flags indicating for which sections a dump of
253    some kind has been requested.  It is reset on a per-object file
254    basis and then initialised from the cmdline_dump_sects array,
255    the results of interpreting the -w switch, and the
256    dump_sects_byname list.  */
257 static dump_type *   dump_sects = NULL;
258 static unsigned int  num_dump_sects = 0;
259
260
261 /* How to print a vma value.  */
262 typedef enum print_mode
263 {
264   HEX,
265   DEC,
266   DEC_5,
267   UNSIGNED,
268   PREFIX_HEX,
269   FULL_HEX,
270   LONG_HEX
271 }
272 print_mode;
273
274 #define UNKNOWN -1
275
276 #define SECTION_NAME(X)                                         \
277   ((X) == NULL ? _("<none>")                                    \
278    : string_table == NULL ? _("<no-name>")                      \
279    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
280   : string_table + (X)->sh_name))
281
282 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
283
284 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
285   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
286    : get_64bit_elf_symbols (file, section, sym_count))
287
288 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
289 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
290    already been called and verified that the string exists.  */
291 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
292
293 #define REMOVE_ARCH_BITS(ADDR)                  \
294   do                                            \
295     {                                           \
296       if (elf_header.e_machine == EM_ARM)       \
297         (ADDR) &= ~1;                           \
298     }                                           \
299   while (0)
300 \f
301 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
302    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
303    using malloc and fill that.  In either case return the pointer to the start of
304    the retrieved data or NULL if something went wrong.  If something does go wrong
305    emit an error message using REASON as part of the context.  */
306
307 static void *
308 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
309           const char * reason)
310 {
311   void * mvar;
312
313   if (size == 0 || nmemb == 0)
314     return NULL;
315
316   if (fseek (file, archive_file_offset + offset, SEEK_SET))
317     {
318       error (_("Unable to seek to 0x%lx for %s\n"),
319              (unsigned long) archive_file_offset + offset, reason);
320       return NULL;
321     }
322
323   mvar = var;
324   if (mvar == NULL)
325     {
326       /* Check for overflow.  */
327       if (nmemb < (~(size_t) 0 - 1) / size)
328         /* + 1 so that we can '\0' terminate invalid string table sections.  */
329         mvar = malloc (size * nmemb + 1);
330
331       if (mvar == NULL)
332         {
333           error (_("Out of memory allocating 0x%lx bytes for %s\n"),
334                  (unsigned long)(size * nmemb), reason);
335           return NULL;
336         }
337
338       ((char *) mvar)[size * nmemb] = '\0';
339     }
340
341   if (fread (mvar, size, nmemb, file) != nmemb)
342     {
343       error (_("Unable to read in 0x%lx bytes of %s\n"),
344              (unsigned long)(size * nmemb), reason);
345       if (mvar != var)
346         free (mvar);
347       return NULL;
348     }
349
350   return mvar;
351 }
352
353 /* Print a VMA value.  */
354
355 static int
356 print_vma (bfd_vma vma, print_mode mode)
357 {
358   int nc = 0;
359
360   switch (mode)
361     {
362     case FULL_HEX:
363       nc = printf ("0x");
364       /* Drop through.  */
365
366     case LONG_HEX:
367 #ifdef BFD64
368       if (is_32bit_elf)
369         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
370 #endif
371       printf_vma (vma);
372       return nc + 16;
373
374     case DEC_5:
375       if (vma <= 99999)
376         return printf ("%5" BFD_VMA_FMT "d", vma);
377       /* Drop through.  */
378
379     case PREFIX_HEX:
380       nc = printf ("0x");
381       /* Drop through.  */
382
383     case HEX:
384       return nc + printf ("%" BFD_VMA_FMT "x", vma);
385
386     case DEC:
387       return printf ("%" BFD_VMA_FMT "d", vma);
388
389     case UNSIGNED:
390       return printf ("%" BFD_VMA_FMT "u", vma);
391     }
392   return 0;
393 }
394
395 /* Display a symbol on stdout.  Handles the display of control characters and
396    multibye characters (assuming the host environment supports them).
397
398    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
399
400    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
401    padding as necessary.
402
403    Returns the number of emitted characters.  */
404
405 static unsigned int
406 print_symbol (int width, const char *symbol)
407 {
408   bfd_boolean extra_padding = FALSE;
409   int num_printed = 0;
410 #ifdef HAVE_MBSTATE_T
411   mbstate_t state;
412 #endif
413   int width_remaining;
414
415   if (width < 0)
416     {
417       /* Keep the width positive.  This also helps.  */
418       width = - width;
419       extra_padding = TRUE;
420     }
421
422   if (do_wide)
423     /* Set the remaining width to a very large value.
424        This simplifies the code below.  */
425     width_remaining = INT_MAX;
426   else
427     width_remaining = width;
428
429 #ifdef HAVE_MBSTATE_T
430   /* Initialise the multibyte conversion state.  */
431   memset (& state, 0, sizeof (state));
432 #endif
433
434   while (width_remaining)
435     {
436       size_t  n;
437       const char c = *symbol++;
438
439       if (c == 0)
440         break;
441
442       /* Do not print control characters directly as they can affect terminal
443          settings.  Such characters usually appear in the names generated
444          by the assembler for local labels.  */
445       if (ISCNTRL (c))
446         {
447           if (width_remaining < 2)
448             break;
449
450           printf ("^%c", c + 0x40);
451           width_remaining -= 2;
452           num_printed += 2;
453         }
454       else if (ISPRINT (c))
455         {
456           putchar (c);
457           width_remaining --;
458           num_printed ++;
459         }
460       else
461         {
462 #ifdef HAVE_MBSTATE_T
463           wchar_t w;
464 #endif
465           /* Let printf do the hard work of displaying multibyte characters.  */
466           printf ("%.1s", symbol - 1);
467           width_remaining --;
468           num_printed ++;
469
470 #ifdef HAVE_MBSTATE_T
471           /* Try to find out how many bytes made up the character that was
472              just printed.  Advance the symbol pointer past the bytes that
473              were displayed.  */
474           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
475 #else
476           n = 1;
477 #endif
478           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
479             symbol += (n - 1);
480         }
481     }
482
483   if (extra_padding && num_printed < width)
484     {
485       /* Fill in the remaining spaces.  */
486       printf ("%-*s", width - num_printed, " ");
487       num_printed = width;
488     }
489
490   return num_printed;
491 }
492
493 /* Return a pointer to section NAME, or NULL if no such section exists.  */
494
495 static Elf_Internal_Shdr *
496 find_section (const char * name)
497 {
498   unsigned int i;
499
500   for (i = 0; i < elf_header.e_shnum; i++)
501     if (streq (SECTION_NAME (section_headers + i), name))
502       return section_headers + i;
503
504   return NULL;
505 }
506
507 /* Return a pointer to a section containing ADDR, or NULL if no such
508    section exists.  */
509
510 static Elf_Internal_Shdr *
511 find_section_by_address (bfd_vma addr)
512 {
513   unsigned int i;
514
515   for (i = 0; i < elf_header.e_shnum; i++)
516     {
517       Elf_Internal_Shdr *sec = section_headers + i;
518       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
519         return sec;
520     }
521
522   return NULL;
523 }
524
525 /* Return a pointer to section NAME, or NULL if no such section exists,
526    restricted to the list of sections given in SET.  */
527
528 static Elf_Internal_Shdr *
529 find_section_in_set (const char * name, unsigned int * set)
530 {
531   unsigned int i;
532
533   if (set != NULL)
534     {
535       while ((i = *set++) > 0)
536         if (streq (SECTION_NAME (section_headers + i), name))
537           return section_headers + i;
538     }
539
540   return find_section (name);
541 }
542
543 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
544    bytes read.  */
545
546 static inline unsigned long
547 read_uleb128 (unsigned char *data,
548               unsigned int *length_return,
549               const unsigned char * const end)
550 {
551   return read_leb128 (data, length_return, FALSE, end);
552 }
553
554 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
555    This OS has so many departures from the ELF standard that we test it at
556    many places.  */
557
558 static inline int
559 is_ia64_vms (void)
560 {
561   return elf_header.e_machine == EM_IA_64
562     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
563 }
564
565 /* Guess the relocation size commonly used by the specific machines.  */
566
567 static int
568 guess_is_rela (unsigned int e_machine)
569 {
570   switch (e_machine)
571     {
572       /* Targets that use REL relocations.  */
573     case EM_386:
574     case EM_486:
575     case EM_960:
576     case EM_ARM:
577     case EM_D10V:
578     case EM_CYGNUS_D10V:
579     case EM_DLX:
580     case EM_MIPS:
581     case EM_MIPS_RS3_LE:
582     case EM_CYGNUS_M32R:
583     case EM_SCORE:
584     case EM_XGATE:
585       return FALSE;
586
587       /* Targets that use RELA relocations.  */
588     case EM_68K:
589     case EM_860:
590     case EM_AARCH64:
591     case EM_ADAPTEVA_EPIPHANY:
592     case EM_ALPHA:
593     case EM_ALTERA_NIOS2:
594     case EM_AVR:
595     case EM_AVR_OLD:
596     case EM_BLACKFIN:
597     case EM_CR16:
598     case EM_CRIS:
599     case EM_CRX:
600     case EM_D30V:
601     case EM_CYGNUS_D30V:
602     case EM_FR30:
603     case EM_CYGNUS_FR30:
604     case EM_CYGNUS_FRV:
605     case EM_H8S:
606     case EM_H8_300:
607     case EM_H8_300H:
608     case EM_IA_64:
609     case EM_IP2K:
610     case EM_IP2K_OLD:
611     case EM_IQ2000:
612     case EM_LATTICEMICO32:
613     case EM_M32C_OLD:
614     case EM_M32C:
615     case EM_M32R:
616     case EM_MCORE:
617     case EM_CYGNUS_MEP:
618     case EM_METAG:
619     case EM_MMIX:
620     case EM_MN10200:
621     case EM_CYGNUS_MN10200:
622     case EM_MN10300:
623     case EM_CYGNUS_MN10300:
624     case EM_MOXIE:
625     case EM_MSP430:
626     case EM_MSP430_OLD:
627     case EM_MT:
628     case EM_NDS32:
629     case EM_NIOS32:
630     case EM_OR1K:
631     case EM_PPC64:
632     case EM_PPC:
633     case EM_RL78:
634     case EM_RX:
635     case EM_S390:
636     case EM_S390_OLD:
637     case EM_SH:
638     case EM_SPARC:
639     case EM_SPARC32PLUS:
640     case EM_SPARCV9:
641     case EM_SPU:
642     case EM_TI_C6000:
643     case EM_TILEGX:
644     case EM_TILEPRO:
645     case EM_V800:
646     case EM_V850:
647     case EM_CYGNUS_V850:
648     case EM_VAX:
649     case EM_X86_64:
650     case EM_L1OM:
651     case EM_K1OM:
652     case EM_XSTORMY16:
653     case EM_XTENSA:
654     case EM_XTENSA_OLD:
655     case EM_MICROBLAZE:
656     case EM_MICROBLAZE_OLD:
657       return TRUE;
658
659     case EM_68HC05:
660     case EM_68HC08:
661     case EM_68HC11:
662     case EM_68HC16:
663     case EM_FX66:
664     case EM_ME16:
665     case EM_MMA:
666     case EM_NCPU:
667     case EM_NDR1:
668     case EM_PCP:
669     case EM_ST100:
670     case EM_ST19:
671     case EM_ST7:
672     case EM_ST9PLUS:
673     case EM_STARCORE:
674     case EM_SVX:
675     case EM_TINYJ:
676     default:
677       warn (_("Don't know about relocations on this machine architecture\n"));
678       return FALSE;
679     }
680 }
681
682 static int
683 slurp_rela_relocs (FILE * file,
684                    unsigned long rel_offset,
685                    unsigned long rel_size,
686                    Elf_Internal_Rela ** relasp,
687                    unsigned long * nrelasp)
688 {
689   Elf_Internal_Rela * relas;
690   unsigned long nrelas;
691   unsigned int i;
692
693   if (is_32bit_elf)
694     {
695       Elf32_External_Rela * erelas;
696
697       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
698                                                  rel_size, _("32-bit relocation data"));
699       if (!erelas)
700         return 0;
701
702       nrelas = rel_size / sizeof (Elf32_External_Rela);
703
704       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
705                                              sizeof (Elf_Internal_Rela));
706
707       if (relas == NULL)
708         {
709           free (erelas);
710           error (_("out of memory parsing relocs\n"));
711           return 0;
712         }
713
714       for (i = 0; i < nrelas; i++)
715         {
716           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
717           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
718           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
719         }
720
721       free (erelas);
722     }
723   else
724     {
725       Elf64_External_Rela * erelas;
726
727       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
728                                                  rel_size, _("64-bit relocation data"));
729       if (!erelas)
730         return 0;
731
732       nrelas = rel_size / sizeof (Elf64_External_Rela);
733
734       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
735                                              sizeof (Elf_Internal_Rela));
736
737       if (relas == NULL)
738         {
739           free (erelas);
740           error (_("out of memory parsing relocs\n"));
741           return 0;
742         }
743
744       for (i = 0; i < nrelas; i++)
745         {
746           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
747           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
748           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
749
750           /* The #ifdef BFD64 below is to prevent a compile time
751              warning.  We know that if we do not have a 64 bit data
752              type that we will never execute this code anyway.  */
753 #ifdef BFD64
754           if (elf_header.e_machine == EM_MIPS
755               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
756             {
757               /* In little-endian objects, r_info isn't really a
758                  64-bit little-endian value: it has a 32-bit
759                  little-endian symbol index followed by four
760                  individual byte fields.  Reorder INFO
761                  accordingly.  */
762               bfd_vma inf = relas[i].r_info;
763               inf = (((inf & 0xffffffff) << 32)
764                       | ((inf >> 56) & 0xff)
765                       | ((inf >> 40) & 0xff00)
766                       | ((inf >> 24) & 0xff0000)
767                       | ((inf >> 8) & 0xff000000));
768               relas[i].r_info = inf;
769             }
770 #endif /* BFD64 */
771         }
772
773       free (erelas);
774     }
775   *relasp = relas;
776   *nrelasp = nrelas;
777   return 1;
778 }
779
780 static int
781 slurp_rel_relocs (FILE * file,
782                   unsigned long rel_offset,
783                   unsigned long rel_size,
784                   Elf_Internal_Rela ** relsp,
785                   unsigned long * nrelsp)
786 {
787   Elf_Internal_Rela * rels;
788   unsigned long nrels;
789   unsigned int i;
790
791   if (is_32bit_elf)
792     {
793       Elf32_External_Rel * erels;
794
795       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
796                                                rel_size, _("32-bit relocation data"));
797       if (!erels)
798         return 0;
799
800       nrels = rel_size / sizeof (Elf32_External_Rel);
801
802       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
803
804       if (rels == NULL)
805         {
806           free (erels);
807           error (_("out of memory parsing relocs\n"));
808           return 0;
809         }
810
811       for (i = 0; i < nrels; i++)
812         {
813           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
814           rels[i].r_info   = BYTE_GET (erels[i].r_info);
815           rels[i].r_addend = 0;
816         }
817
818       free (erels);
819     }
820   else
821     {
822       Elf64_External_Rel * erels;
823
824       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
825                                                rel_size, _("64-bit relocation data"));
826       if (!erels)
827         return 0;
828
829       nrels = rel_size / sizeof (Elf64_External_Rel);
830
831       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
832
833       if (rels == NULL)
834         {
835           free (erels);
836           error (_("out of memory parsing relocs\n"));
837           return 0;
838         }
839
840       for (i = 0; i < nrels; i++)
841         {
842           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
843           rels[i].r_info   = BYTE_GET (erels[i].r_info);
844           rels[i].r_addend = 0;
845
846           /* The #ifdef BFD64 below is to prevent a compile time
847              warning.  We know that if we do not have a 64 bit data
848              type that we will never execute this code anyway.  */
849 #ifdef BFD64
850           if (elf_header.e_machine == EM_MIPS
851               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
852             {
853               /* In little-endian objects, r_info isn't really a
854                  64-bit little-endian value: it has a 32-bit
855                  little-endian symbol index followed by four
856                  individual byte fields.  Reorder INFO
857                  accordingly.  */
858               bfd_vma inf = rels[i].r_info;
859               inf = (((inf & 0xffffffff) << 32)
860                      | ((inf >> 56) & 0xff)
861                      | ((inf >> 40) & 0xff00)
862                      | ((inf >> 24) & 0xff0000)
863                      | ((inf >> 8) & 0xff000000));
864               rels[i].r_info = inf;
865             }
866 #endif /* BFD64 */
867         }
868
869       free (erels);
870     }
871   *relsp = rels;
872   *nrelsp = nrels;
873   return 1;
874 }
875
876 /* Returns the reloc type extracted from the reloc info field.  */
877
878 static unsigned int
879 get_reloc_type (bfd_vma reloc_info)
880 {
881   if (is_32bit_elf)
882     return ELF32_R_TYPE (reloc_info);
883
884   switch (elf_header.e_machine)
885     {
886     case EM_MIPS:
887       /* Note: We assume that reloc_info has already been adjusted for us.  */
888       return ELF64_MIPS_R_TYPE (reloc_info);
889
890     case EM_SPARCV9:
891       return ELF64_R_TYPE_ID (reloc_info);
892
893     default:
894       return ELF64_R_TYPE (reloc_info);
895     }
896 }
897
898 /* Return the symbol index extracted from the reloc info field.  */
899
900 static bfd_vma
901 get_reloc_symindex (bfd_vma reloc_info)
902 {
903   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
904 }
905
906 static inline bfd_boolean
907 uses_msp430x_relocs (void)
908 {
909   return
910     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
911     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
912     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
913         /* TI compiler uses ELFOSABI_NONE.  */
914         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
915 }
916
917 /* Display the contents of the relocation data found at the specified
918    offset.  */
919
920 static void
921 dump_relocations (FILE * file,
922                   unsigned long rel_offset,
923                   unsigned long rel_size,
924                   Elf_Internal_Sym * symtab,
925                   unsigned long nsyms,
926                   char * strtab,
927                   unsigned long strtablen,
928                   int is_rela)
929 {
930   unsigned int i;
931   Elf_Internal_Rela * rels;
932
933   if (is_rela == UNKNOWN)
934     is_rela = guess_is_rela (elf_header.e_machine);
935
936   if (is_rela)
937     {
938       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
939         return;
940     }
941   else
942     {
943       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
944         return;
945     }
946
947   if (is_32bit_elf)
948     {
949       if (is_rela)
950         {
951           if (do_wide)
952             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
953           else
954             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
955         }
956       else
957         {
958           if (do_wide)
959             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
960           else
961             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
962         }
963     }
964   else
965     {
966       if (is_rela)
967         {
968           if (do_wide)
969             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
970           else
971             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
972         }
973       else
974         {
975           if (do_wide)
976             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
977           else
978             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
979         }
980     }
981
982   for (i = 0; i < rel_size; i++)
983     {
984       const char * rtype;
985       bfd_vma offset;
986       bfd_vma inf;
987       bfd_vma symtab_index;
988       bfd_vma type;
989
990       offset = rels[i].r_offset;
991       inf    = rels[i].r_info;
992
993       type = get_reloc_type (inf);
994       symtab_index = get_reloc_symindex  (inf);
995
996       if (is_32bit_elf)
997         {
998           printf ("%8.8lx  %8.8lx ",
999                   (unsigned long) offset & 0xffffffff,
1000                   (unsigned long) inf & 0xffffffff);
1001         }
1002       else
1003         {
1004 #if BFD_HOST_64BIT_LONG
1005           printf (do_wide
1006                   ? "%16.16lx  %16.16lx "
1007                   : "%12.12lx  %12.12lx ",
1008                   offset, inf);
1009 #elif BFD_HOST_64BIT_LONG_LONG
1010 #ifndef __MSVCRT__
1011           printf (do_wide
1012                   ? "%16.16llx  %16.16llx "
1013                   : "%12.12llx  %12.12llx ",
1014                   offset, inf);
1015 #else
1016           printf (do_wide
1017                   ? "%16.16I64x  %16.16I64x "
1018                   : "%12.12I64x  %12.12I64x ",
1019                   offset, inf);
1020 #endif
1021 #else
1022           printf (do_wide
1023                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1024                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1025                   _bfd_int64_high (offset),
1026                   _bfd_int64_low (offset),
1027                   _bfd_int64_high (inf),
1028                   _bfd_int64_low (inf));
1029 #endif
1030         }
1031
1032       switch (elf_header.e_machine)
1033         {
1034         default:
1035           rtype = NULL;
1036           break;
1037
1038         case EM_AARCH64:
1039           rtype = elf_aarch64_reloc_type (type);
1040           break;
1041
1042         case EM_M32R:
1043         case EM_CYGNUS_M32R:
1044           rtype = elf_m32r_reloc_type (type);
1045           break;
1046
1047         case EM_386:
1048         case EM_486:
1049           rtype = elf_i386_reloc_type (type);
1050           break;
1051
1052         case EM_68HC11:
1053         case EM_68HC12:
1054           rtype = elf_m68hc11_reloc_type (type);
1055           break;
1056
1057         case EM_68K:
1058           rtype = elf_m68k_reloc_type (type);
1059           break;
1060
1061         case EM_960:
1062           rtype = elf_i960_reloc_type (type);
1063           break;
1064
1065         case EM_AVR:
1066         case EM_AVR_OLD:
1067           rtype = elf_avr_reloc_type (type);
1068           break;
1069
1070         case EM_OLD_SPARCV9:
1071         case EM_SPARC32PLUS:
1072         case EM_SPARCV9:
1073         case EM_SPARC:
1074           rtype = elf_sparc_reloc_type (type);
1075           break;
1076
1077         case EM_SPU:
1078           rtype = elf_spu_reloc_type (type);
1079           break;
1080
1081         case EM_V800:
1082           rtype = v800_reloc_type (type);
1083           break;
1084         case EM_V850:
1085         case EM_CYGNUS_V850:
1086           rtype = v850_reloc_type (type);
1087           break;
1088
1089         case EM_D10V:
1090         case EM_CYGNUS_D10V:
1091           rtype = elf_d10v_reloc_type (type);
1092           break;
1093
1094         case EM_D30V:
1095         case EM_CYGNUS_D30V:
1096           rtype = elf_d30v_reloc_type (type);
1097           break;
1098
1099         case EM_DLX:
1100           rtype = elf_dlx_reloc_type (type);
1101           break;
1102
1103         case EM_SH:
1104           rtype = elf_sh_reloc_type (type);
1105           break;
1106
1107         case EM_MN10300:
1108         case EM_CYGNUS_MN10300:
1109           rtype = elf_mn10300_reloc_type (type);
1110           break;
1111
1112         case EM_MN10200:
1113         case EM_CYGNUS_MN10200:
1114           rtype = elf_mn10200_reloc_type (type);
1115           break;
1116
1117         case EM_FR30:
1118         case EM_CYGNUS_FR30:
1119           rtype = elf_fr30_reloc_type (type);
1120           break;
1121
1122         case EM_CYGNUS_FRV:
1123           rtype = elf_frv_reloc_type (type);
1124           break;
1125
1126         case EM_MCORE:
1127           rtype = elf_mcore_reloc_type (type);
1128           break;
1129
1130         case EM_MMIX:
1131           rtype = elf_mmix_reloc_type (type);
1132           break;
1133
1134         case EM_MOXIE:
1135           rtype = elf_moxie_reloc_type (type);
1136           break;
1137
1138         case EM_MSP430:
1139           if (uses_msp430x_relocs ())
1140             {
1141               rtype = elf_msp430x_reloc_type (type);
1142               break;
1143             }
1144         case EM_MSP430_OLD:
1145           rtype = elf_msp430_reloc_type (type);
1146           break;
1147
1148         case EM_NDS32:
1149           rtype = elf_nds32_reloc_type (type);
1150           break;
1151
1152         case EM_PPC:
1153           rtype = elf_ppc_reloc_type (type);
1154           break;
1155
1156         case EM_PPC64:
1157           rtype = elf_ppc64_reloc_type (type);
1158           break;
1159
1160         case EM_MIPS:
1161         case EM_MIPS_RS3_LE:
1162           rtype = elf_mips_reloc_type (type);
1163           break;
1164
1165         case EM_ALPHA:
1166           rtype = elf_alpha_reloc_type (type);
1167           break;
1168
1169         case EM_ARM:
1170           rtype = elf_arm_reloc_type (type);
1171           break;
1172
1173         case EM_ARC:
1174           rtype = elf_arc_reloc_type (type);
1175           break;
1176
1177         case EM_PARISC:
1178           rtype = elf_hppa_reloc_type (type);
1179           break;
1180
1181         case EM_H8_300:
1182         case EM_H8_300H:
1183         case EM_H8S:
1184           rtype = elf_h8_reloc_type (type);
1185           break;
1186
1187         case EM_OR1K:
1188           rtype = elf_or1k_reloc_type (type);
1189           break;
1190
1191         case EM_PJ:
1192         case EM_PJ_OLD:
1193           rtype = elf_pj_reloc_type (type);
1194           break;
1195         case EM_IA_64:
1196           rtype = elf_ia64_reloc_type (type);
1197           break;
1198
1199         case EM_CRIS:
1200           rtype = elf_cris_reloc_type (type);
1201           break;
1202
1203         case EM_860:
1204           rtype = elf_i860_reloc_type (type);
1205           break;
1206
1207         case EM_X86_64:
1208         case EM_L1OM:
1209         case EM_K1OM:
1210           rtype = elf_x86_64_reloc_type (type);
1211           break;
1212
1213         case EM_S370:
1214           rtype = i370_reloc_type (type);
1215           break;
1216
1217         case EM_S390_OLD:
1218         case EM_S390:
1219           rtype = elf_s390_reloc_type (type);
1220           break;
1221
1222         case EM_SCORE:
1223           rtype = elf_score_reloc_type (type);
1224           break;
1225
1226         case EM_XSTORMY16:
1227           rtype = elf_xstormy16_reloc_type (type);
1228           break;
1229
1230         case EM_CRX:
1231           rtype = elf_crx_reloc_type (type);
1232           break;
1233
1234         case EM_VAX:
1235           rtype = elf_vax_reloc_type (type);
1236           break;
1237
1238         case EM_ADAPTEVA_EPIPHANY:
1239           rtype = elf_epiphany_reloc_type (type);
1240           break;
1241
1242         case EM_IP2K:
1243         case EM_IP2K_OLD:
1244           rtype = elf_ip2k_reloc_type (type);
1245           break;
1246
1247         case EM_IQ2000:
1248           rtype = elf_iq2000_reloc_type (type);
1249           break;
1250
1251         case EM_XTENSA_OLD:
1252         case EM_XTENSA:
1253           rtype = elf_xtensa_reloc_type (type);
1254           break;
1255
1256         case EM_LATTICEMICO32:
1257           rtype = elf_lm32_reloc_type (type);
1258           break;
1259
1260         case EM_M32C_OLD:
1261         case EM_M32C:
1262           rtype = elf_m32c_reloc_type (type);
1263           break;
1264
1265         case EM_MT:
1266           rtype = elf_mt_reloc_type (type);
1267           break;
1268
1269         case EM_BLACKFIN:
1270           rtype = elf_bfin_reloc_type (type);
1271           break;
1272
1273         case EM_CYGNUS_MEP:
1274           rtype = elf_mep_reloc_type (type);
1275           break;
1276
1277         case EM_CR16:
1278           rtype = elf_cr16_reloc_type (type);
1279           break;
1280
1281         case EM_MICROBLAZE:
1282         case EM_MICROBLAZE_OLD:
1283           rtype = elf_microblaze_reloc_type (type);
1284           break;
1285
1286         case EM_RL78:
1287           rtype = elf_rl78_reloc_type (type);
1288           break;
1289
1290         case EM_RX:
1291           rtype = elf_rx_reloc_type (type);
1292           break;
1293
1294         case EM_METAG:
1295           rtype = elf_metag_reloc_type (type);
1296           break;
1297
1298         case EM_XC16X:
1299         case EM_C166:
1300           rtype = elf_xc16x_reloc_type (type);
1301           break;
1302
1303         case EM_TI_C6000:
1304           rtype = elf_tic6x_reloc_type (type);
1305           break;
1306
1307         case EM_TILEGX:
1308           rtype = elf_tilegx_reloc_type (type);
1309           break;
1310
1311         case EM_TILEPRO:
1312           rtype = elf_tilepro_reloc_type (type);
1313           break;
1314
1315         case EM_XGATE:
1316           rtype = elf_xgate_reloc_type (type);
1317           break;
1318
1319         case EM_ALTERA_NIOS2:
1320           rtype = elf_nios2_reloc_type (type);
1321           break;
1322         }
1323
1324       if (rtype == NULL)
1325         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1326       else
1327         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1328
1329       if (elf_header.e_machine == EM_ALPHA
1330           && rtype != NULL
1331           && streq (rtype, "R_ALPHA_LITUSE")
1332           && is_rela)
1333         {
1334           switch (rels[i].r_addend)
1335             {
1336             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1337             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1338             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1339             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1340             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1341             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1342             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1343             default: rtype = NULL;
1344             }
1345           if (rtype)
1346             printf (" (%s)", rtype);
1347           else
1348             {
1349               putchar (' ');
1350               printf (_("<unknown addend: %lx>"),
1351                       (unsigned long) rels[i].r_addend);
1352             }
1353         }
1354       else if (symtab_index)
1355         {
1356           if (symtab == NULL || symtab_index >= nsyms)
1357             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1358           else
1359             {
1360               Elf_Internal_Sym * psym;
1361
1362               psym = symtab + symtab_index;
1363
1364               printf (" ");
1365
1366               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1367                 {
1368                   const char * name;
1369                   unsigned int len;
1370                   unsigned int width = is_32bit_elf ? 8 : 14;
1371
1372                   /* Relocations against GNU_IFUNC symbols do not use the value
1373                      of the symbol as the address to relocate against.  Instead
1374                      they invoke the function named by the symbol and use its
1375                      result as the address for relocation.
1376
1377                      To indicate this to the user, do not display the value of
1378                      the symbol in the "Symbols's Value" field.  Instead show
1379                      its name followed by () as a hint that the symbol is
1380                      invoked.  */
1381
1382                   if (strtab == NULL
1383                       || psym->st_name == 0
1384                       || psym->st_name >= strtablen)
1385                     name = "??";
1386                   else
1387                     name = strtab + psym->st_name;
1388
1389                   len = print_symbol (width, name);
1390                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1391                 }
1392               else
1393                 {
1394                   print_vma (psym->st_value, LONG_HEX);
1395
1396                   printf (is_32bit_elf ? "   " : " ");
1397                 }
1398
1399               if (psym->st_name == 0)
1400                 {
1401                   const char * sec_name = "<null>";
1402                   char name_buf[40];
1403
1404                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1405                     {
1406                       if (psym->st_shndx < elf_header.e_shnum)
1407                         sec_name
1408                           = SECTION_NAME (section_headers + psym->st_shndx);
1409                       else if (psym->st_shndx == SHN_ABS)
1410                         sec_name = "ABS";
1411                       else if (psym->st_shndx == SHN_COMMON)
1412                         sec_name = "COMMON";
1413                       else if ((elf_header.e_machine == EM_MIPS
1414                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1415                                || (elf_header.e_machine == EM_TI_C6000
1416                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1417                         sec_name = "SCOMMON";
1418                       else if (elf_header.e_machine == EM_MIPS
1419                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1420                         sec_name = "SUNDEF";
1421                       else if ((elf_header.e_machine == EM_X86_64
1422                                 || elf_header.e_machine == EM_L1OM
1423                                 || elf_header.e_machine == EM_K1OM)
1424                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1425                         sec_name = "LARGE_COMMON";
1426                       else if (elf_header.e_machine == EM_IA_64
1427                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1428                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1429                         sec_name = "ANSI_COM";
1430                       else if (is_ia64_vms ()
1431                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1432                         sec_name = "VMS_SYMVEC";
1433                       else
1434                         {
1435                           sprintf (name_buf, "<section 0x%x>",
1436                                    (unsigned int) psym->st_shndx);
1437                           sec_name = name_buf;
1438                         }
1439                     }
1440                   print_symbol (22, sec_name);
1441                 }
1442               else if (strtab == NULL)
1443                 printf (_("<string table index: %3ld>"), psym->st_name);
1444               else if (psym->st_name >= strtablen)
1445                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1446               else
1447                 print_symbol (22, strtab + psym->st_name);
1448
1449               if (is_rela)
1450                 {
1451                   bfd_signed_vma off = rels[i].r_addend;
1452
1453                   if (off < 0)
1454                     printf (" - %" BFD_VMA_FMT "x", - off);
1455                   else
1456                     printf (" + %" BFD_VMA_FMT "x", off);
1457                 }
1458             }
1459         }
1460       else if (is_rela)
1461         {
1462           bfd_signed_vma off = rels[i].r_addend;
1463
1464           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1465           if (off < 0)
1466             printf ("-%" BFD_VMA_FMT "x", - off);
1467           else
1468             printf ("%" BFD_VMA_FMT "x", off);
1469         }
1470
1471       if (elf_header.e_machine == EM_SPARCV9
1472           && rtype != NULL
1473           && streq (rtype, "R_SPARC_OLO10"))
1474         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1475
1476       putchar ('\n');
1477
1478 #ifdef BFD64
1479       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1480         {
1481           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1482           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1483           const char * rtype2 = elf_mips_reloc_type (type2);
1484           const char * rtype3 = elf_mips_reloc_type (type3);
1485
1486           printf ("                    Type2: ");
1487
1488           if (rtype2 == NULL)
1489             printf (_("unrecognized: %-7lx"),
1490                     (unsigned long) type2 & 0xffffffff);
1491           else
1492             printf ("%-17.17s", rtype2);
1493
1494           printf ("\n                    Type3: ");
1495
1496           if (rtype3 == NULL)
1497             printf (_("unrecognized: %-7lx"),
1498                     (unsigned long) type3 & 0xffffffff);
1499           else
1500             printf ("%-17.17s", rtype3);
1501
1502           putchar ('\n');
1503         }
1504 #endif /* BFD64 */
1505     }
1506
1507   free (rels);
1508 }
1509
1510 static const char *
1511 get_mips_dynamic_type (unsigned long type)
1512 {
1513   switch (type)
1514     {
1515     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1516     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1517     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1518     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1519     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1520     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1521     case DT_MIPS_MSYM: return "MIPS_MSYM";
1522     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1523     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1524     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1525     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1526     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1527     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1528     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1529     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1530     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1531     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1532     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1533     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1534     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1535     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1536     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1537     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1538     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1539     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1540     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1541     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1542     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1543     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1544     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1545     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1546     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1547     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1548     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1549     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1550     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1551     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1552     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1553     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1554     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1555     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1556     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1557     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1558     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1559     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1560     default:
1561       return NULL;
1562     }
1563 }
1564
1565 static const char *
1566 get_sparc64_dynamic_type (unsigned long type)
1567 {
1568   switch (type)
1569     {
1570     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1571     default:
1572       return NULL;
1573     }
1574 }
1575
1576 static const char *
1577 get_ppc_dynamic_type (unsigned long type)
1578 {
1579   switch (type)
1580     {
1581     case DT_PPC_GOT:    return "PPC_GOT";
1582     case DT_PPC_OPT:    return "PPC_OPT";
1583     default:
1584       return NULL;
1585     }
1586 }
1587
1588 static const char *
1589 get_ppc64_dynamic_type (unsigned long type)
1590 {
1591   switch (type)
1592     {
1593     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1594     case DT_PPC64_OPD:    return "PPC64_OPD";
1595     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1596     case DT_PPC64_OPT:    return "PPC64_OPT";
1597     default:
1598       return NULL;
1599     }
1600 }
1601
1602 static const char *
1603 get_parisc_dynamic_type (unsigned long type)
1604 {
1605   switch (type)
1606     {
1607     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1608     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1609     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1610     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1611     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1612     case DT_HP_PREINIT:         return "HP_PREINIT";
1613     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1614     case DT_HP_NEEDED:          return "HP_NEEDED";
1615     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1616     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1617     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1618     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1619     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1620     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1621     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1622     case DT_HP_FILTERED:        return "HP_FILTERED";
1623     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1624     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1625     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1626     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1627     case DT_PLT:                return "PLT";
1628     case DT_PLT_SIZE:           return "PLT_SIZE";
1629     case DT_DLT:                return "DLT";
1630     case DT_DLT_SIZE:           return "DLT_SIZE";
1631     default:
1632       return NULL;
1633     }
1634 }
1635
1636 static const char *
1637 get_ia64_dynamic_type (unsigned long type)
1638 {
1639   switch (type)
1640     {
1641     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1642     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1643     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1644     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1645     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1646     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1647     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1648     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1649     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1650     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1651     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1652     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1653     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1654     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1655     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1656     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1657     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1658     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1659     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1660     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1661     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1662     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1663     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1664     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1665     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1666     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1667     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1668     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1669     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1670     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1671     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1672     default:
1673       return NULL;
1674     }
1675 }
1676
1677 static const char *
1678 get_alpha_dynamic_type (unsigned long type)
1679 {
1680   switch (type)
1681     {
1682     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1683     default:
1684       return NULL;
1685     }
1686 }
1687
1688 static const char *
1689 get_score_dynamic_type (unsigned long type)
1690 {
1691   switch (type)
1692     {
1693     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1694     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1695     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1696     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1697     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1698     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1699     default:
1700       return NULL;
1701     }
1702 }
1703
1704 static const char *
1705 get_tic6x_dynamic_type (unsigned long type)
1706 {
1707   switch (type)
1708     {
1709     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1710     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1711     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1712     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1713     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1714     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1715     default:
1716       return NULL;
1717     }
1718 }
1719
1720 static const char *
1721 get_nios2_dynamic_type (unsigned long type)
1722 {
1723   switch (type)
1724     {
1725     case DT_NIOS2_GP: return "NIOS2_GP";
1726     default:
1727       return NULL;
1728     }
1729 }
1730
1731 static const char *
1732 get_dynamic_type (unsigned long type)
1733 {
1734   static char buff[64];
1735
1736   switch (type)
1737     {
1738     case DT_NULL:       return "NULL";
1739     case DT_NEEDED:     return "NEEDED";
1740     case DT_PLTRELSZ:   return "PLTRELSZ";
1741     case DT_PLTGOT:     return "PLTGOT";
1742     case DT_HASH:       return "HASH";
1743     case DT_STRTAB:     return "STRTAB";
1744     case DT_SYMTAB:     return "SYMTAB";
1745     case DT_RELA:       return "RELA";
1746     case DT_RELASZ:     return "RELASZ";
1747     case DT_RELAENT:    return "RELAENT";
1748     case DT_STRSZ:      return "STRSZ";
1749     case DT_SYMENT:     return "SYMENT";
1750     case DT_INIT:       return "INIT";
1751     case DT_FINI:       return "FINI";
1752     case DT_SONAME:     return "SONAME";
1753     case DT_RPATH:      return "RPATH";
1754     case DT_SYMBOLIC:   return "SYMBOLIC";
1755     case DT_REL:        return "REL";
1756     case DT_RELSZ:      return "RELSZ";
1757     case DT_RELENT:     return "RELENT";
1758     case DT_PLTREL:     return "PLTREL";
1759     case DT_DEBUG:      return "DEBUG";
1760     case DT_TEXTREL:    return "TEXTREL";
1761     case DT_JMPREL:     return "JMPREL";
1762     case DT_BIND_NOW:   return "BIND_NOW";
1763     case DT_INIT_ARRAY: return "INIT_ARRAY";
1764     case DT_FINI_ARRAY: return "FINI_ARRAY";
1765     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1766     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1767     case DT_RUNPATH:    return "RUNPATH";
1768     case DT_FLAGS:      return "FLAGS";
1769
1770     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1771     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1772
1773     case DT_CHECKSUM:   return "CHECKSUM";
1774     case DT_PLTPADSZ:   return "PLTPADSZ";
1775     case DT_MOVEENT:    return "MOVEENT";
1776     case DT_MOVESZ:     return "MOVESZ";
1777     case DT_FEATURE:    return "FEATURE";
1778     case DT_POSFLAG_1:  return "POSFLAG_1";
1779     case DT_SYMINSZ:    return "SYMINSZ";
1780     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1781
1782     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1783     case DT_CONFIG:     return "CONFIG";
1784     case DT_DEPAUDIT:   return "DEPAUDIT";
1785     case DT_AUDIT:      return "AUDIT";
1786     case DT_PLTPAD:     return "PLTPAD";
1787     case DT_MOVETAB:    return "MOVETAB";
1788     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1789
1790     case DT_VERSYM:     return "VERSYM";
1791
1792     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1793     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1794     case DT_RELACOUNT:  return "RELACOUNT";
1795     case DT_RELCOUNT:   return "RELCOUNT";
1796     case DT_FLAGS_1:    return "FLAGS_1";
1797     case DT_VERDEF:     return "VERDEF";
1798     case DT_VERDEFNUM:  return "VERDEFNUM";
1799     case DT_VERNEED:    return "VERNEED";
1800     case DT_VERNEEDNUM: return "VERNEEDNUM";
1801
1802     case DT_AUXILIARY:  return "AUXILIARY";
1803     case DT_USED:       return "USED";
1804     case DT_FILTER:     return "FILTER";
1805
1806     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1807     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1808     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1809     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1810     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1811     case DT_GNU_HASH:   return "GNU_HASH";
1812
1813     default:
1814       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1815         {
1816           const char * result;
1817
1818           switch (elf_header.e_machine)
1819             {
1820             case EM_MIPS:
1821             case EM_MIPS_RS3_LE:
1822               result = get_mips_dynamic_type (type);
1823               break;
1824             case EM_SPARCV9:
1825               result = get_sparc64_dynamic_type (type);
1826               break;
1827             case EM_PPC:
1828               result = get_ppc_dynamic_type (type);
1829               break;
1830             case EM_PPC64:
1831               result = get_ppc64_dynamic_type (type);
1832               break;
1833             case EM_IA_64:
1834               result = get_ia64_dynamic_type (type);
1835               break;
1836             case EM_ALPHA:
1837               result = get_alpha_dynamic_type (type);
1838               break;
1839             case EM_SCORE:
1840               result = get_score_dynamic_type (type);
1841               break;
1842             case EM_TI_C6000:
1843               result = get_tic6x_dynamic_type (type);
1844               break;
1845             case EM_ALTERA_NIOS2:
1846               result = get_nios2_dynamic_type (type);
1847               break;
1848             default:
1849               result = NULL;
1850               break;
1851             }
1852
1853           if (result != NULL)
1854             return result;
1855
1856           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1857         }
1858       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1859                || (elf_header.e_machine == EM_PARISC
1860                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1861         {
1862           const char * result;
1863
1864           switch (elf_header.e_machine)
1865             {
1866             case EM_PARISC:
1867               result = get_parisc_dynamic_type (type);
1868               break;
1869             case EM_IA_64:
1870               result = get_ia64_dynamic_type (type);
1871               break;
1872             default:
1873               result = NULL;
1874               break;
1875             }
1876
1877           if (result != NULL)
1878             return result;
1879
1880           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1881                     type);
1882         }
1883       else
1884         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1885
1886       return buff;
1887     }
1888 }
1889
1890 static char *
1891 get_file_type (unsigned e_type)
1892 {
1893   static char buff[32];
1894
1895   switch (e_type)
1896     {
1897     case ET_NONE:       return _("NONE (None)");
1898     case ET_REL:        return _("REL (Relocatable file)");
1899     case ET_EXEC:       return _("EXEC (Executable file)");
1900     case ET_DYN:        return _("DYN (Shared object file)");
1901     case ET_CORE:       return _("CORE (Core file)");
1902
1903     default:
1904       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1905         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1906       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1907         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1908       else
1909         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1910       return buff;
1911     }
1912 }
1913
1914 static char *
1915 get_machine_name (unsigned e_machine)
1916 {
1917   static char buff[64]; /* XXX */
1918
1919   switch (e_machine)
1920     {
1921     case EM_NONE:               return _("None");
1922     case EM_AARCH64:            return "AArch64";
1923     case EM_M32:                return "WE32100";
1924     case EM_SPARC:              return "Sparc";
1925     case EM_SPU:                return "SPU";
1926     case EM_386:                return "Intel 80386";
1927     case EM_68K:                return "MC68000";
1928     case EM_88K:                return "MC88000";
1929     case EM_486:                return "Intel 80486";
1930     case EM_860:                return "Intel 80860";
1931     case EM_MIPS:               return "MIPS R3000";
1932     case EM_S370:               return "IBM System/370";
1933     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1934     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1935     case EM_PARISC:             return "HPPA";
1936     case EM_PPC_OLD:            return "Power PC (old)";
1937     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1938     case EM_960:                return "Intel 90860";
1939     case EM_PPC:                return "PowerPC";
1940     case EM_PPC64:              return "PowerPC64";
1941     case EM_FR20:               return "Fujitsu FR20";
1942     case EM_RH32:               return "TRW RH32";
1943     case EM_MCORE:              return "MCORE";
1944     case EM_ARM:                return "ARM";
1945     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1946     case EM_SH:                 return "Renesas / SuperH SH";
1947     case EM_SPARCV9:            return "Sparc v9";
1948     case EM_TRICORE:            return "Siemens Tricore";
1949     case EM_ARC:                return "ARC";
1950     case EM_H8_300:             return "Renesas H8/300";
1951     case EM_H8_300H:            return "Renesas H8/300H";
1952     case EM_H8S:                return "Renesas H8S";
1953     case EM_H8_500:             return "Renesas H8/500";
1954     case EM_IA_64:              return "Intel IA-64";
1955     case EM_MIPS_X:             return "Stanford MIPS-X";
1956     case EM_COLDFIRE:           return "Motorola Coldfire";
1957     case EM_ALPHA:              return "Alpha";
1958     case EM_CYGNUS_D10V:
1959     case EM_D10V:               return "d10v";
1960     case EM_CYGNUS_D30V:
1961     case EM_D30V:               return "d30v";
1962     case EM_CYGNUS_M32R:
1963     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1964     case EM_CYGNUS_V850:
1965     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
1966     case EM_V850:               return "Renesas V850";
1967     case EM_CYGNUS_MN10300:
1968     case EM_MN10300:            return "mn10300";
1969     case EM_CYGNUS_MN10200:
1970     case EM_MN10200:            return "mn10200";
1971     case EM_MOXIE:              return "Moxie";
1972     case EM_CYGNUS_FR30:
1973     case EM_FR30:               return "Fujitsu FR30";
1974     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1975     case EM_PJ_OLD:
1976     case EM_PJ:                 return "picoJava";
1977     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1978     case EM_PCP:                return "Siemens PCP";
1979     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1980     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1981     case EM_STARCORE:           return "Motorola Star*Core processor";
1982     case EM_ME16:               return "Toyota ME16 processor";
1983     case EM_ST100:              return "STMicroelectronics ST100 processor";
1984     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1985     case EM_PDSP:               return "Sony DSP processor";
1986     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
1987     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
1988     case EM_FX66:               return "Siemens FX66 microcontroller";
1989     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1990     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1991     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1992     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
1993     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1994     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1995     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1996     case EM_SVX:                return "Silicon Graphics SVx";
1997     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1998     case EM_VAX:                return "Digital VAX";
1999     case EM_AVR_OLD:
2000     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2001     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2002     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2003     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2004     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2005     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2006     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2007     case EM_PRISM:              return "Vitesse Prism";
2008     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2009     case EM_L1OM:               return "Intel L1OM";
2010     case EM_K1OM:               return "Intel K1OM";
2011     case EM_S390_OLD:
2012     case EM_S390:               return "IBM S/390";
2013     case EM_SCORE:              return "SUNPLUS S+Core";
2014     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2015     case EM_OR1K:               return "OpenRISC 1000";
2016     case EM_ARC_A5:             return "ARC International ARCompact processor";
2017     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2018     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2019     case EM_DLX:                return "OpenDLX";
2020     case EM_IP2K_OLD:
2021     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2022     case EM_IQ2000:             return "Vitesse IQ2000";
2023     case EM_XTENSA_OLD:
2024     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2025     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2026     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2027     case EM_NS32K:              return "National Semiconductor 32000 series";
2028     case EM_TPC:                return "Tenor Network TPC processor";
2029     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2030     case EM_MAX:                return "MAX Processor";
2031     case EM_CR:                 return "National Semiconductor CompactRISC";
2032     case EM_F2MC16:             return "Fujitsu F2MC16";
2033     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2034     case EM_LATTICEMICO32:      return "Lattice Mico32";
2035     case EM_M32C_OLD:
2036     case EM_M32C:               return "Renesas M32c";
2037     case EM_MT:                 return "Morpho Techologies MT processor";
2038     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2039     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2040     case EM_SEP:                return "Sharp embedded microprocessor";
2041     case EM_ARCA:               return "Arca RISC microprocessor";
2042     case EM_UNICORE:            return "Unicore";
2043     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2044     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2045     case EM_NIOS32:             return "Altera Nios";
2046     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2047     case EM_C166:
2048     case EM_XC16X:              return "Infineon Technologies xc16x";
2049     case EM_M16C:               return "Renesas M16C series microprocessors";
2050     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2051     case EM_CE:                 return "Freescale Communication Engine RISC core";
2052     case EM_TSK3000:            return "Altium TSK3000 core";
2053     case EM_RS08:               return "Freescale RS08 embedded processor";
2054     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2055     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2056     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2057     case EM_SE_C17:             return "Seiko Epson C17 family";
2058     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2059     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2060     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2061     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2062     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2063     case EM_R32C:               return "Renesas R32C series microprocessors";
2064     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2065     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2066     case EM_8051:               return "Intel 8051 and variants";
2067     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2068     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2069     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2070     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2071     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2072     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2073     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2074     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2075     case EM_CR16:
2076     case EM_MICROBLAZE:
2077     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2078     case EM_RL78:               return "Renesas RL78";
2079     case EM_RX:                 return "Renesas RX";
2080     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2081     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2082     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2083     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2084     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2085     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2086     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2087     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2088     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2089     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2090     case EM_CUDA:               return "NVIDIA CUDA architecture";
2091     case EM_XGATE:              return "Motorola XGATE embedded processor";
2092     default:
2093       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2094       return buff;
2095     }
2096 }
2097
2098 static void
2099 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2100 {
2101   unsigned eabi;
2102   int unknown = 0;
2103
2104   eabi = EF_ARM_EABI_VERSION (e_flags);
2105   e_flags &= ~ EF_ARM_EABIMASK;
2106
2107   /* Handle "generic" ARM flags.  */
2108   if (e_flags & EF_ARM_RELEXEC)
2109     {
2110       strcat (buf, ", relocatable executable");
2111       e_flags &= ~ EF_ARM_RELEXEC;
2112     }
2113
2114   if (e_flags & EF_ARM_HASENTRY)
2115     {
2116       strcat (buf, ", has entry point");
2117       e_flags &= ~ EF_ARM_HASENTRY;
2118     }
2119
2120   /* Now handle EABI specific flags.  */
2121   switch (eabi)
2122     {
2123     default:
2124       strcat (buf, ", <unrecognized EABI>");
2125       if (e_flags)
2126         unknown = 1;
2127       break;
2128
2129     case EF_ARM_EABI_VER1:
2130       strcat (buf, ", Version1 EABI");
2131       while (e_flags)
2132         {
2133           unsigned flag;
2134
2135           /* Process flags one bit at a time.  */
2136           flag = e_flags & - e_flags;
2137           e_flags &= ~ flag;
2138
2139           switch (flag)
2140             {
2141             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2142               strcat (buf, ", sorted symbol tables");
2143               break;
2144
2145             default:
2146               unknown = 1;
2147               break;
2148             }
2149         }
2150       break;
2151
2152     case EF_ARM_EABI_VER2:
2153       strcat (buf, ", Version2 EABI");
2154       while (e_flags)
2155         {
2156           unsigned flag;
2157
2158           /* Process flags one bit at a time.  */
2159           flag = e_flags & - e_flags;
2160           e_flags &= ~ flag;
2161
2162           switch (flag)
2163             {
2164             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2165               strcat (buf, ", sorted symbol tables");
2166               break;
2167
2168             case EF_ARM_DYNSYMSUSESEGIDX:
2169               strcat (buf, ", dynamic symbols use segment index");
2170               break;
2171
2172             case EF_ARM_MAPSYMSFIRST:
2173               strcat (buf, ", mapping symbols precede others");
2174               break;
2175
2176             default:
2177               unknown = 1;
2178               break;
2179             }
2180         }
2181       break;
2182
2183     case EF_ARM_EABI_VER3:
2184       strcat (buf, ", Version3 EABI");
2185       break;
2186
2187     case EF_ARM_EABI_VER4:
2188       strcat (buf, ", Version4 EABI");
2189       while (e_flags)
2190         {
2191           unsigned flag;
2192
2193           /* Process flags one bit at a time.  */
2194           flag = e_flags & - e_flags;
2195           e_flags &= ~ flag;
2196
2197           switch (flag)
2198             {
2199             case EF_ARM_BE8:
2200               strcat (buf, ", BE8");
2201               break;
2202
2203             case EF_ARM_LE8:
2204               strcat (buf, ", LE8");
2205               break;
2206
2207             default:
2208               unknown = 1;
2209               break;
2210             }
2211       break;
2212         }
2213       break;
2214
2215     case EF_ARM_EABI_VER5:
2216       strcat (buf, ", Version5 EABI");
2217       while (e_flags)
2218         {
2219           unsigned flag;
2220
2221           /* Process flags one bit at a time.  */
2222           flag = e_flags & - e_flags;
2223           e_flags &= ~ flag;
2224
2225           switch (flag)
2226             {
2227             case EF_ARM_BE8:
2228               strcat (buf, ", BE8");
2229               break;
2230
2231             case EF_ARM_LE8:
2232               strcat (buf, ", LE8");
2233               break;
2234
2235             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2236               strcat (buf, ", soft-float ABI");
2237               break;
2238
2239             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2240               strcat (buf, ", hard-float ABI");
2241               break;
2242
2243             default:
2244               unknown = 1;
2245               break;
2246             }
2247         }
2248       break;
2249
2250     case EF_ARM_EABI_UNKNOWN:
2251       strcat (buf, ", GNU EABI");
2252       while (e_flags)
2253         {
2254           unsigned flag;
2255
2256           /* Process flags one bit at a time.  */
2257           flag = e_flags & - e_flags;
2258           e_flags &= ~ flag;
2259
2260           switch (flag)
2261             {
2262             case EF_ARM_INTERWORK:
2263               strcat (buf, ", interworking enabled");
2264               break;
2265
2266             case EF_ARM_APCS_26:
2267               strcat (buf, ", uses APCS/26");
2268               break;
2269
2270             case EF_ARM_APCS_FLOAT:
2271               strcat (buf, ", uses APCS/float");
2272               break;
2273
2274             case EF_ARM_PIC:
2275               strcat (buf, ", position independent");
2276               break;
2277
2278             case EF_ARM_ALIGN8:
2279               strcat (buf, ", 8 bit structure alignment");
2280               break;
2281
2282             case EF_ARM_NEW_ABI:
2283               strcat (buf, ", uses new ABI");
2284               break;
2285
2286             case EF_ARM_OLD_ABI:
2287               strcat (buf, ", uses old ABI");
2288               break;
2289
2290             case EF_ARM_SOFT_FLOAT:
2291               strcat (buf, ", software FP");
2292               break;
2293
2294             case EF_ARM_VFP_FLOAT:
2295               strcat (buf, ", VFP");
2296               break;
2297
2298             case EF_ARM_MAVERICK_FLOAT:
2299               strcat (buf, ", Maverick FP");
2300               break;
2301
2302             default:
2303               unknown = 1;
2304               break;
2305             }
2306         }
2307     }
2308
2309   if (unknown)
2310     strcat (buf,_(", <unknown>"));
2311 }
2312
2313 static void
2314 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2315 {
2316   unsigned abi;
2317   unsigned arch;
2318   unsigned config;
2319   unsigned version;
2320   int has_fpu = 0;
2321   int r = 0;
2322
2323   static const char *ABI_STRINGS[] =
2324   {
2325     "ABI v0", /* use r5 as return register; only used in N1213HC */
2326     "ABI v1", /* use r0 as return register */
2327     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2328     "ABI v2fp", /* for FPU */
2329     "AABI",
2330     "ABI2 FP+"
2331   };
2332   static const char *VER_STRINGS[] =
2333   {
2334     "Andes ELF V1.3 or older",
2335     "Andes ELF V1.3.1",
2336     "Andes ELF V1.4"
2337   };
2338   static const char *ARCH_STRINGS[] =
2339   {
2340     "",
2341     "Andes Star v1.0",
2342     "Andes Star v2.0",
2343     "Andes Star v3.0",
2344     "Andes Star v3.0m"
2345   };
2346
2347   abi = EF_NDS_ABI & e_flags;
2348   arch = EF_NDS_ARCH & e_flags;
2349   config = EF_NDS_INST & e_flags;
2350   version = EF_NDS32_ELF_VERSION & e_flags;
2351
2352   memset (buf, 0, size);
2353
2354   switch (abi)
2355     {
2356     case E_NDS_ABI_V0:
2357     case E_NDS_ABI_V1:
2358     case E_NDS_ABI_V2:
2359     case E_NDS_ABI_V2FP:
2360     case E_NDS_ABI_AABI:
2361     case E_NDS_ABI_V2FP_PLUS:
2362       /* In case there are holes in the array.  */
2363       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2364       break;
2365
2366     default:
2367       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2368       break;
2369     }
2370
2371   switch (version)
2372     {
2373     case E_NDS32_ELF_VER_1_2:
2374     case E_NDS32_ELF_VER_1_3:
2375     case E_NDS32_ELF_VER_1_4:
2376       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2377       break;
2378
2379     default:
2380       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2381       break;
2382     }
2383
2384   if (E_NDS_ABI_V0 == abi)
2385     {
2386       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2387       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2388       if (arch == E_NDS_ARCH_STAR_V1_0)
2389         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2390       return;
2391     }
2392
2393   switch (arch)
2394     {
2395     case E_NDS_ARCH_STAR_V1_0:
2396     case E_NDS_ARCH_STAR_V2_0:
2397     case E_NDS_ARCH_STAR_V3_0:
2398     case E_NDS_ARCH_STAR_V3_M:
2399       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2400       break;
2401
2402     default:
2403       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2404       /* ARCH version determines how the e_flags are interpreted.
2405          If it is unknown, we cannot proceed.  */
2406       return;
2407     }
2408
2409   /* Newer ABI; Now handle architecture specific flags.  */
2410   if (arch == E_NDS_ARCH_STAR_V1_0)
2411     {
2412       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2413         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2414
2415       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2416         r += snprintf (buf + r, size -r, ", MAC");
2417
2418       if (config & E_NDS32_HAS_DIV_INST)
2419         r += snprintf (buf + r, size -r, ", DIV");
2420
2421       if (config & E_NDS32_HAS_16BIT_INST)
2422         r += snprintf (buf + r, size -r, ", 16b");
2423     }
2424   else
2425     {
2426       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2427         {
2428           if (version <= E_NDS32_ELF_VER_1_3)
2429             r += snprintf (buf + r, size -r, ", [B8]");
2430           else
2431             r += snprintf (buf + r, size -r, ", EX9");
2432         }
2433
2434       if (config & E_NDS32_HAS_MAC_DX_INST)
2435         r += snprintf (buf + r, size -r, ", MAC_DX");
2436
2437       if (config & E_NDS32_HAS_DIV_DX_INST)
2438         r += snprintf (buf + r, size -r, ", DIV_DX");
2439
2440       if (config & E_NDS32_HAS_16BIT_INST)
2441         {
2442           if (version <= E_NDS32_ELF_VER_1_3)
2443             r += snprintf (buf + r, size -r, ", 16b");
2444           else
2445             r += snprintf (buf + r, size -r, ", IFC");
2446         }
2447     }
2448
2449   if (config & E_NDS32_HAS_EXT_INST)
2450     r += snprintf (buf + r, size -r, ", PERF1");
2451
2452   if (config & E_NDS32_HAS_EXT2_INST)
2453     r += snprintf (buf + r, size -r, ", PERF2");
2454
2455   if (config & E_NDS32_HAS_FPU_INST)
2456     {
2457       has_fpu = 1;
2458       r += snprintf (buf + r, size -r, ", FPU_SP");
2459     }
2460
2461   if (config & E_NDS32_HAS_FPU_DP_INST)
2462     {
2463       has_fpu = 1;
2464       r += snprintf (buf + r, size -r, ", FPU_DP");
2465     }
2466
2467   if (config & E_NDS32_HAS_FPU_MAC_INST)
2468     {
2469       has_fpu = 1;
2470       r += snprintf (buf + r, size -r, ", FPU_MAC");
2471     }
2472
2473   if (has_fpu)
2474     {
2475       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2476         {
2477         case E_NDS32_FPU_REG_8SP_4DP:
2478           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2479           break;
2480         case E_NDS32_FPU_REG_16SP_8DP:
2481           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2482           break;
2483         case E_NDS32_FPU_REG_32SP_16DP:
2484           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2485           break;
2486         case E_NDS32_FPU_REG_32SP_32DP:
2487           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2488           break;
2489         }
2490     }
2491
2492   if (config & E_NDS32_HAS_AUDIO_INST)
2493     r += snprintf (buf + r, size -r, ", AUDIO");
2494
2495   if (config & E_NDS32_HAS_STRING_INST)
2496     r += snprintf (buf + r, size -r, ", STR");
2497
2498   if (config & E_NDS32_HAS_REDUCED_REGS)
2499     r += snprintf (buf + r, size -r, ", 16REG");
2500
2501   if (config & E_NDS32_HAS_VIDEO_INST)
2502     {
2503       if (version <= E_NDS32_ELF_VER_1_3)
2504         r += snprintf (buf + r, size -r, ", VIDEO");
2505       else
2506         r += snprintf (buf + r, size -r, ", SATURATION");
2507     }
2508
2509   if (config & E_NDS32_HAS_ENCRIPT_INST)
2510     r += snprintf (buf + r, size -r, ", ENCRP");
2511
2512   if (config & E_NDS32_HAS_L2C_INST)
2513     r += snprintf (buf + r, size -r, ", L2C");
2514 }
2515
2516 static char *
2517 get_machine_flags (unsigned e_flags, unsigned e_machine)
2518 {
2519   static char buf[1024];
2520
2521   buf[0] = '\0';
2522
2523   if (e_flags)
2524     {
2525       switch (e_machine)
2526         {
2527         default:
2528           break;
2529
2530         case EM_ARM:
2531           decode_ARM_machine_flags (e_flags, buf);
2532           break;
2533
2534         case EM_BLACKFIN:
2535           if (e_flags & EF_BFIN_PIC)
2536             strcat (buf, ", PIC");
2537
2538           if (e_flags & EF_BFIN_FDPIC)
2539             strcat (buf, ", FDPIC");
2540
2541           if (e_flags & EF_BFIN_CODE_IN_L1)
2542             strcat (buf, ", code in L1");
2543
2544           if (e_flags & EF_BFIN_DATA_IN_L1)
2545             strcat (buf, ", data in L1");
2546
2547           break;
2548
2549         case EM_CYGNUS_FRV:
2550           switch (e_flags & EF_FRV_CPU_MASK)
2551             {
2552             case EF_FRV_CPU_GENERIC:
2553               break;
2554
2555             default:
2556               strcat (buf, ", fr???");
2557               break;
2558
2559             case EF_FRV_CPU_FR300:
2560               strcat (buf, ", fr300");
2561               break;
2562
2563             case EF_FRV_CPU_FR400:
2564               strcat (buf, ", fr400");
2565               break;
2566             case EF_FRV_CPU_FR405:
2567               strcat (buf, ", fr405");
2568               break;
2569
2570             case EF_FRV_CPU_FR450:
2571               strcat (buf, ", fr450");
2572               break;
2573
2574             case EF_FRV_CPU_FR500:
2575               strcat (buf, ", fr500");
2576               break;
2577             case EF_FRV_CPU_FR550:
2578               strcat (buf, ", fr550");
2579               break;
2580
2581             case EF_FRV_CPU_SIMPLE:
2582               strcat (buf, ", simple");
2583               break;
2584             case EF_FRV_CPU_TOMCAT:
2585               strcat (buf, ", tomcat");
2586               break;
2587             }
2588           break;
2589
2590         case EM_68K:
2591           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2592             strcat (buf, ", m68000");
2593           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2594             strcat (buf, ", cpu32");
2595           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2596             strcat (buf, ", fido_a");
2597           else
2598             {
2599               char const * isa = _("unknown");
2600               char const * mac = _("unknown mac");
2601               char const * additional = NULL;
2602
2603               switch (e_flags & EF_M68K_CF_ISA_MASK)
2604                 {
2605                 case EF_M68K_CF_ISA_A_NODIV:
2606                   isa = "A";
2607                   additional = ", nodiv";
2608                   break;
2609                 case EF_M68K_CF_ISA_A:
2610                   isa = "A";
2611                   break;
2612                 case EF_M68K_CF_ISA_A_PLUS:
2613                   isa = "A+";
2614                   break;
2615                 case EF_M68K_CF_ISA_B_NOUSP:
2616                   isa = "B";
2617                   additional = ", nousp";
2618                   break;
2619                 case EF_M68K_CF_ISA_B:
2620                   isa = "B";
2621                   break;
2622                 case EF_M68K_CF_ISA_C:
2623                   isa = "C";
2624                   break;
2625                 case EF_M68K_CF_ISA_C_NODIV:
2626                   isa = "C";
2627                   additional = ", nodiv";
2628                   break;
2629                 }
2630               strcat (buf, ", cf, isa ");
2631               strcat (buf, isa);
2632               if (additional)
2633                 strcat (buf, additional);
2634               if (e_flags & EF_M68K_CF_FLOAT)
2635                 strcat (buf, ", float");
2636               switch (e_flags & EF_M68K_CF_MAC_MASK)
2637                 {
2638                 case 0:
2639                   mac = NULL;
2640                   break;
2641                 case EF_M68K_CF_MAC:
2642                   mac = "mac";
2643                   break;
2644                 case EF_M68K_CF_EMAC:
2645                   mac = "emac";
2646                   break;
2647                 case EF_M68K_CF_EMAC_B:
2648                   mac = "emac_b";
2649                   break;
2650                 }
2651               if (mac)
2652                 {
2653                   strcat (buf, ", ");
2654                   strcat (buf, mac);
2655                 }
2656             }
2657           break;
2658
2659         case EM_PPC:
2660           if (e_flags & EF_PPC_EMB)
2661             strcat (buf, ", emb");
2662
2663           if (e_flags & EF_PPC_RELOCATABLE)
2664             strcat (buf, _(", relocatable"));
2665
2666           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2667             strcat (buf, _(", relocatable-lib"));
2668           break;
2669
2670         case EM_PPC64:
2671           if (e_flags & EF_PPC64_ABI)
2672             {
2673               char abi[] = ", abiv0";
2674
2675               abi[6] += e_flags & EF_PPC64_ABI;
2676               strcat (buf, abi);
2677             }
2678           break;
2679
2680         case EM_V800:
2681           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2682             strcat (buf, ", RH850 ABI");
2683
2684           if (e_flags & EF_V800_850E3)
2685             strcat (buf, ", V3 architecture");
2686
2687           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2688             strcat (buf, ", FPU not used");
2689
2690           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2691             strcat (buf, ", regmode: COMMON");
2692
2693           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2694             strcat (buf, ", r4 not used");
2695
2696           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2697             strcat (buf, ", r30 not used");
2698
2699           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2700             strcat (buf, ", r5 not used");
2701
2702           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2703             strcat (buf, ", r2 not used");
2704
2705           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2706             {
2707               switch (e_flags & - e_flags)
2708                 {
2709                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2710                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2711                 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2712                 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2713                 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2714                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2715                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2716                 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2717                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2718                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2719                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2720                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2721                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2722                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2723                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2724                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2725                 default: break;
2726                 }
2727             }
2728           break;
2729
2730         case EM_V850:
2731         case EM_CYGNUS_V850:
2732           switch (e_flags & EF_V850_ARCH)
2733             {
2734             case E_V850E3V5_ARCH:
2735               strcat (buf, ", v850e3v5");
2736               break;
2737             case E_V850E2V3_ARCH:
2738               strcat (buf, ", v850e2v3");
2739               break;
2740             case E_V850E2_ARCH:
2741               strcat (buf, ", v850e2");
2742               break;
2743             case E_V850E1_ARCH:
2744               strcat (buf, ", v850e1");
2745               break;
2746             case E_V850E_ARCH:
2747               strcat (buf, ", v850e");
2748               break;
2749             case E_V850_ARCH:
2750               strcat (buf, ", v850");
2751               break;
2752             default:
2753               strcat (buf, _(", unknown v850 architecture variant"));
2754               break;
2755             }
2756           break;
2757
2758         case EM_M32R:
2759         case EM_CYGNUS_M32R:
2760           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2761             strcat (buf, ", m32r");
2762           break;
2763
2764         case EM_MIPS:
2765         case EM_MIPS_RS3_LE:
2766           if (e_flags & EF_MIPS_NOREORDER)
2767             strcat (buf, ", noreorder");
2768
2769           if (e_flags & EF_MIPS_PIC)
2770             strcat (buf, ", pic");
2771
2772           if (e_flags & EF_MIPS_CPIC)
2773             strcat (buf, ", cpic");
2774
2775           if (e_flags & EF_MIPS_UCODE)
2776             strcat (buf, ", ugen_reserved");
2777
2778           if (e_flags & EF_MIPS_ABI2)
2779             strcat (buf, ", abi2");
2780
2781           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2782             strcat (buf, ", odk first");
2783
2784           if (e_flags & EF_MIPS_32BITMODE)
2785             strcat (buf, ", 32bitmode");
2786
2787           if (e_flags & EF_MIPS_NAN2008)
2788             strcat (buf, ", nan2008");
2789
2790           if (e_flags & EF_MIPS_FP64)
2791             strcat (buf, ", fp64");
2792
2793           switch ((e_flags & EF_MIPS_MACH))
2794             {
2795             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2796             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2797             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2798             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2799             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2800             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2801             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2802             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2803             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2804             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2805             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2806             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2807             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2808             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2809             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2810             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
2811             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2812             case 0:
2813             /* We simply ignore the field in this case to avoid confusion:
2814                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2815                extension.  */
2816               break;
2817             default: strcat (buf, _(", unknown CPU")); break;
2818             }
2819
2820           switch ((e_flags & EF_MIPS_ABI))
2821             {
2822             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2823             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2824             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2825             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2826             case 0:
2827             /* We simply ignore the field in this case to avoid confusion:
2828                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2829                This means it is likely to be an o32 file, but not for
2830                sure.  */
2831               break;
2832             default: strcat (buf, _(", unknown ABI")); break;
2833             }
2834
2835           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2836             strcat (buf, ", mdmx");
2837
2838           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2839             strcat (buf, ", mips16");
2840
2841           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2842             strcat (buf, ", micromips");
2843
2844           switch ((e_flags & EF_MIPS_ARCH))
2845             {
2846             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2847             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2848             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2849             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2850             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2851             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2852             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2853             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
2854             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2855             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2856             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2857             default: strcat (buf, _(", unknown ISA")); break;
2858             }
2859           break;
2860
2861         case EM_NDS32:
2862           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2863           break;
2864
2865         case EM_SH:
2866           switch ((e_flags & EF_SH_MACH_MASK))
2867             {
2868             case EF_SH1: strcat (buf, ", sh1"); break;
2869             case EF_SH2: strcat (buf, ", sh2"); break;
2870             case EF_SH3: strcat (buf, ", sh3"); break;
2871             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2872             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2873             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2874             case EF_SH3E: strcat (buf, ", sh3e"); break;
2875             case EF_SH4: strcat (buf, ", sh4"); break;
2876             case EF_SH5: strcat (buf, ", sh5"); break;
2877             case EF_SH2E: strcat (buf, ", sh2e"); break;
2878             case EF_SH4A: strcat (buf, ", sh4a"); break;
2879             case EF_SH2A: strcat (buf, ", sh2a"); break;
2880             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2881             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2882             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2883             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2884             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2885             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2886             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2887             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2888             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2889             default: strcat (buf, _(", unknown ISA")); break;
2890             }
2891
2892           if (e_flags & EF_SH_PIC)
2893             strcat (buf, ", pic");
2894
2895           if (e_flags & EF_SH_FDPIC)
2896             strcat (buf, ", fdpic");
2897           break;
2898           
2899         case EM_OR1K:
2900           if (e_flags & EF_OR1K_NODELAY)
2901             strcat (buf, ", no delay");
2902           break;
2903
2904         case EM_SPARCV9:
2905           if (e_flags & EF_SPARC_32PLUS)
2906             strcat (buf, ", v8+");
2907
2908           if (e_flags & EF_SPARC_SUN_US1)
2909             strcat (buf, ", ultrasparcI");
2910
2911           if (e_flags & EF_SPARC_SUN_US3)
2912             strcat (buf, ", ultrasparcIII");
2913
2914           if (e_flags & EF_SPARC_HAL_R1)
2915             strcat (buf, ", halr1");
2916
2917           if (e_flags & EF_SPARC_LEDATA)
2918             strcat (buf, ", ledata");
2919
2920           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2921             strcat (buf, ", tso");
2922
2923           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2924             strcat (buf, ", pso");
2925
2926           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2927             strcat (buf, ", rmo");
2928           break;
2929
2930         case EM_PARISC:
2931           switch (e_flags & EF_PARISC_ARCH)
2932             {
2933             case EFA_PARISC_1_0:
2934               strcpy (buf, ", PA-RISC 1.0");
2935               break;
2936             case EFA_PARISC_1_1:
2937               strcpy (buf, ", PA-RISC 1.1");
2938               break;
2939             case EFA_PARISC_2_0:
2940               strcpy (buf, ", PA-RISC 2.0");
2941               break;
2942             default:
2943               break;
2944             }
2945           if (e_flags & EF_PARISC_TRAPNIL)
2946             strcat (buf, ", trapnil");
2947           if (e_flags & EF_PARISC_EXT)
2948             strcat (buf, ", ext");
2949           if (e_flags & EF_PARISC_LSB)
2950             strcat (buf, ", lsb");
2951           if (e_flags & EF_PARISC_WIDE)
2952             strcat (buf, ", wide");
2953           if (e_flags & EF_PARISC_NO_KABP)
2954             strcat (buf, ", no kabp");
2955           if (e_flags & EF_PARISC_LAZYSWAP)
2956             strcat (buf, ", lazyswap");
2957           break;
2958
2959         case EM_PJ:
2960         case EM_PJ_OLD:
2961           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2962             strcat (buf, ", new calling convention");
2963
2964           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2965             strcat (buf, ", gnu calling convention");
2966           break;
2967
2968         case EM_IA_64:
2969           if ((e_flags & EF_IA_64_ABI64))
2970             strcat (buf, ", 64-bit");
2971           else
2972             strcat (buf, ", 32-bit");
2973           if ((e_flags & EF_IA_64_REDUCEDFP))
2974             strcat (buf, ", reduced fp model");
2975           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2976             strcat (buf, ", no function descriptors, constant gp");
2977           else if ((e_flags & EF_IA_64_CONS_GP))
2978             strcat (buf, ", constant gp");
2979           if ((e_flags & EF_IA_64_ABSOLUTE))
2980             strcat (buf, ", absolute");
2981           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2982             {
2983               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2984                 strcat (buf, ", vms_linkages");
2985               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2986                 {
2987                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2988                   break;
2989                 case EF_IA_64_VMS_COMCOD_WARNING:
2990                   strcat (buf, ", warning");
2991                   break;
2992                 case EF_IA_64_VMS_COMCOD_ERROR:
2993                   strcat (buf, ", error");
2994                   break;
2995                 case EF_IA_64_VMS_COMCOD_ABORT:
2996                   strcat (buf, ", abort");
2997                   break;
2998                 default:
2999                   abort ();
3000                 }
3001             }
3002           break;
3003
3004         case EM_VAX:
3005           if ((e_flags & EF_VAX_NONPIC))
3006             strcat (buf, ", non-PIC");
3007           if ((e_flags & EF_VAX_DFLOAT))
3008             strcat (buf, ", D-Float");
3009           if ((e_flags & EF_VAX_GFLOAT))
3010             strcat (buf, ", G-Float");
3011           break;
3012
3013         case EM_RL78:
3014           if (e_flags & E_FLAG_RL78_G10)
3015             strcat (buf, ", G10");
3016           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3017             strcat (buf, ", 64-bit doubles");
3018           break;
3019
3020         case EM_RX:
3021           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3022             strcat (buf, ", 64-bit doubles");
3023           if (e_flags & E_FLAG_RX_DSP)
3024             strcat (buf, ", dsp");
3025           if (e_flags & E_FLAG_RX_PID)
3026             strcat (buf, ", pid");
3027           if (e_flags & E_FLAG_RX_ABI)
3028             strcat (buf, ", RX ABI");
3029           break;
3030
3031         case EM_S390:
3032           if (e_flags & EF_S390_HIGH_GPRS)
3033             strcat (buf, ", highgprs");
3034           break;
3035
3036         case EM_TI_C6000:
3037           if ((e_flags & EF_C6000_REL))
3038             strcat (buf, ", relocatable module");
3039           break;
3040
3041         case EM_MSP430:
3042           strcat (buf, _(": architecture variant: "));
3043           switch (e_flags & EF_MSP430_MACH)
3044             {
3045             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3046             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3047             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3048             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3049             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3050             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3051             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3052             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3053             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3054             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3055             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3056             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3057             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3058             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3059             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3060             default:
3061               strcat (buf, _(": unknown")); break;
3062             }
3063
3064           if (e_flags & ~ EF_MSP430_MACH)
3065             strcat (buf, _(": unknown extra flag bits also present"));
3066         }
3067     }
3068
3069   return buf;
3070 }
3071
3072 static const char *
3073 get_osabi_name (unsigned int osabi)
3074 {
3075   static char buff[32];
3076
3077   switch (osabi)
3078     {
3079     case ELFOSABI_NONE:         return "UNIX - System V";
3080     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3081     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3082     case ELFOSABI_GNU:          return "UNIX - GNU";
3083     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3084     case ELFOSABI_AIX:          return "UNIX - AIX";
3085     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3086     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3087     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3088     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3089     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3090     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3091     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3092     case ELFOSABI_AROS:         return "AROS";
3093     case ELFOSABI_FENIXOS:      return "FenixOS";
3094     default:
3095       if (osabi >= 64)
3096         switch (elf_header.e_machine)
3097           {
3098           case EM_ARM:
3099             switch (osabi)
3100               {
3101               case ELFOSABI_ARM:        return "ARM";
3102               default:
3103                 break;
3104               }
3105             break;
3106
3107           case EM_MSP430:
3108           case EM_MSP430_OLD:
3109             switch (osabi)
3110               {
3111               case ELFOSABI_STANDALONE: return _("Standalone App");
3112               default:
3113                 break;
3114               }
3115             break;
3116
3117           case EM_TI_C6000:
3118             switch (osabi)
3119               {
3120               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3121               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3122               default:
3123                 break;
3124               }
3125             break;
3126
3127           default:
3128             break;
3129           }
3130       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3131       return buff;
3132     }
3133 }
3134
3135 static const char *
3136 get_aarch64_segment_type (unsigned long type)
3137 {
3138   switch (type)
3139     {
3140     case PT_AARCH64_ARCHEXT:
3141       return "AARCH64_ARCHEXT";
3142     default:
3143       break;
3144     }
3145
3146   return NULL;
3147 }
3148
3149 static const char *
3150 get_arm_segment_type (unsigned long type)
3151 {
3152   switch (type)
3153     {
3154     case PT_ARM_EXIDX:
3155       return "EXIDX";
3156     default:
3157       break;
3158     }
3159
3160   return NULL;
3161 }
3162
3163 static const char *
3164 get_mips_segment_type (unsigned long type)
3165 {
3166   switch (type)
3167     {
3168     case PT_MIPS_REGINFO:
3169       return "REGINFO";
3170     case PT_MIPS_RTPROC:
3171       return "RTPROC";
3172     case PT_MIPS_OPTIONS:
3173       return "OPTIONS";
3174     case PT_MIPS_ABIFLAGS:
3175       return "ABIFLAGS";
3176     default:
3177       break;
3178     }
3179
3180   return NULL;
3181 }
3182
3183 static const char *
3184 get_parisc_segment_type (unsigned long type)
3185 {
3186   switch (type)
3187     {
3188     case PT_HP_TLS:             return "HP_TLS";
3189     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3190     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3191     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3192     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3193     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3194     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3195     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3196     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3197     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3198     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3199     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3200     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3201     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3202     case PT_HP_STACK:           return "HP_STACK";
3203     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3204     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3205     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3206     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3207     default:
3208       break;
3209     }
3210
3211   return NULL;
3212 }
3213
3214 static const char *
3215 get_ia64_segment_type (unsigned long type)
3216 {
3217   switch (type)
3218     {
3219     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3220     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3221     case PT_HP_TLS:             return "HP_TLS";
3222     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3223     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3224     case PT_IA_64_HP_STACK:     return "HP_STACK";
3225     default:
3226       break;
3227     }
3228
3229   return NULL;
3230 }
3231
3232 static const char *
3233 get_tic6x_segment_type (unsigned long type)
3234 {
3235   switch (type)
3236     {
3237     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3238     default:
3239       break;
3240     }
3241
3242   return NULL;
3243 }
3244
3245 static const char *
3246 get_segment_type (unsigned long p_type)
3247 {
3248   static char buff[32];
3249
3250   switch (p_type)
3251     {
3252     case PT_NULL:       return "NULL";
3253     case PT_LOAD:       return "LOAD";
3254     case PT_DYNAMIC:    return "DYNAMIC";
3255     case PT_INTERP:     return "INTERP";
3256     case PT_NOTE:       return "NOTE";
3257     case PT_SHLIB:      return "SHLIB";
3258     case PT_PHDR:       return "PHDR";
3259     case PT_TLS:        return "TLS";
3260
3261     case PT_GNU_EH_FRAME:
3262                         return "GNU_EH_FRAME";
3263     case PT_GNU_STACK:  return "GNU_STACK";
3264     case PT_GNU_RELRO:  return "GNU_RELRO";
3265
3266     default:
3267       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3268         {
3269           const char * result;
3270
3271           switch (elf_header.e_machine)
3272             {
3273             case EM_AARCH64:
3274               result = get_aarch64_segment_type (p_type);
3275               break;
3276             case EM_ARM:
3277               result = get_arm_segment_type (p_type);
3278               break;
3279             case EM_MIPS:
3280             case EM_MIPS_RS3_LE:
3281               result = get_mips_segment_type (p_type);
3282               break;
3283             case EM_PARISC:
3284               result = get_parisc_segment_type (p_type);
3285               break;
3286             case EM_IA_64:
3287               result = get_ia64_segment_type (p_type);
3288               break;
3289             case EM_TI_C6000:
3290               result = get_tic6x_segment_type (p_type);
3291               break;
3292             default:
3293               result = NULL;
3294               break;
3295             }
3296
3297           if (result != NULL)
3298             return result;
3299
3300           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3301         }
3302       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3303         {
3304           const char * result;
3305
3306           switch (elf_header.e_machine)
3307             {
3308             case EM_PARISC:
3309               result = get_parisc_segment_type (p_type);
3310               break;
3311             case EM_IA_64:
3312               result = get_ia64_segment_type (p_type);
3313               break;
3314             default:
3315               result = NULL;
3316               break;
3317             }
3318
3319           if (result != NULL)
3320             return result;
3321
3322           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3323         }
3324       else
3325         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3326
3327       return buff;
3328     }
3329 }
3330
3331 static const char *
3332 get_mips_section_type_name (unsigned int sh_type)
3333 {
3334   switch (sh_type)
3335     {
3336     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3337     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3338     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3339     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3340     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3341     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3342     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3343     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3344     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3345     case SHT_MIPS_RELD:          return "MIPS_RELD";
3346     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3347     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3348     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3349     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3350     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3351     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3352     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3353     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3354     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3355     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3356     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3357     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3358     case SHT_MIPS_LINE:          return "MIPS_LINE";
3359     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3360     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3361     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3362     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3363     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3364     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3365     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3366     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3367     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3368     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3369     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3370     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3371     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3372     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3373     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3374     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3375     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3376     default:
3377       break;
3378     }
3379   return NULL;
3380 }
3381
3382 static const char *
3383 get_parisc_section_type_name (unsigned int sh_type)
3384 {
3385   switch (sh_type)
3386     {
3387     case SHT_PARISC_EXT:        return "PARISC_EXT";
3388     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3389     case SHT_PARISC_DOC:        return "PARISC_DOC";
3390     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3391     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3392     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3393     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3394     default:
3395       break;
3396     }
3397   return NULL;
3398 }
3399
3400 static const char *
3401 get_ia64_section_type_name (unsigned int sh_type)
3402 {
3403   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3404   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3405     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3406
3407   switch (sh_type)
3408     {
3409     case SHT_IA_64_EXT:                return "IA_64_EXT";
3410     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3411     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3412     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3413     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3414     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3415     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3416     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3417     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3418     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3419     default:
3420       break;
3421     }
3422   return NULL;
3423 }
3424
3425 static const char *
3426 get_x86_64_section_type_name (unsigned int sh_type)
3427 {
3428   switch (sh_type)
3429     {
3430     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3431     default:
3432       break;
3433     }
3434   return NULL;
3435 }
3436
3437 static const char *
3438 get_aarch64_section_type_name (unsigned int sh_type)
3439 {
3440   switch (sh_type)
3441     {
3442     case SHT_AARCH64_ATTRIBUTES:
3443       return "AARCH64_ATTRIBUTES";
3444     default:
3445       break;
3446     }
3447   return NULL;
3448 }
3449
3450 static const char *
3451 get_arm_section_type_name (unsigned int sh_type)
3452 {
3453   switch (sh_type)
3454     {
3455     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3456     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3457     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3458     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3459     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3460     default:
3461       break;
3462     }
3463   return NULL;
3464 }
3465
3466 static const char *
3467 get_tic6x_section_type_name (unsigned int sh_type)
3468 {
3469   switch (sh_type)
3470     {
3471     case SHT_C6000_UNWIND:
3472       return "C6000_UNWIND";
3473     case SHT_C6000_PREEMPTMAP:
3474       return "C6000_PREEMPTMAP";
3475     case SHT_C6000_ATTRIBUTES:
3476       return "C6000_ATTRIBUTES";
3477     case SHT_TI_ICODE:
3478       return "TI_ICODE";
3479     case SHT_TI_XREF:
3480       return "TI_XREF";
3481     case SHT_TI_HANDLER:
3482       return "TI_HANDLER";
3483     case SHT_TI_INITINFO:
3484       return "TI_INITINFO";
3485     case SHT_TI_PHATTRS:
3486       return "TI_PHATTRS";
3487     default:
3488       break;
3489     }
3490   return NULL;
3491 }
3492
3493 static const char *
3494 get_msp430x_section_type_name (unsigned int sh_type)
3495 {
3496   switch (sh_type)
3497     {
3498     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3499     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3500     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3501     default: return NULL;
3502     }
3503 }
3504
3505 static const char *
3506 get_section_type_name (unsigned int sh_type)
3507 {
3508   static char buff[32];
3509
3510   switch (sh_type)
3511     {
3512     case SHT_NULL:              return "NULL";
3513     case SHT_PROGBITS:          return "PROGBITS";
3514     case SHT_SYMTAB:            return "SYMTAB";
3515     case SHT_STRTAB:            return "STRTAB";
3516     case SHT_RELA:              return "RELA";
3517     case SHT_HASH:              return "HASH";
3518     case SHT_DYNAMIC:           return "DYNAMIC";
3519     case SHT_NOTE:              return "NOTE";
3520     case SHT_NOBITS:            return "NOBITS";
3521     case SHT_REL:               return "REL";
3522     case SHT_SHLIB:             return "SHLIB";
3523     case SHT_DYNSYM:            return "DYNSYM";
3524     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3525     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3526     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3527     case SHT_GNU_HASH:          return "GNU_HASH";
3528     case SHT_GROUP:             return "GROUP";
3529     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3530     case SHT_GNU_verdef:        return "VERDEF";
3531     case SHT_GNU_verneed:       return "VERNEED";
3532     case SHT_GNU_versym:        return "VERSYM";
3533     case 0x6ffffff0:            return "VERSYM";
3534     case 0x6ffffffc:            return "VERDEF";
3535     case 0x7ffffffd:            return "AUXILIARY";
3536     case 0x7fffffff:            return "FILTER";
3537     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3538
3539     default:
3540       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3541         {
3542           const char * result;
3543
3544           switch (elf_header.e_machine)
3545             {
3546             case EM_MIPS:
3547             case EM_MIPS_RS3_LE:
3548               result = get_mips_section_type_name (sh_type);
3549               break;
3550             case EM_PARISC:
3551               result = get_parisc_section_type_name (sh_type);
3552               break;
3553             case EM_IA_64:
3554               result = get_ia64_section_type_name (sh_type);
3555               break;
3556             case EM_X86_64:
3557             case EM_L1OM:
3558             case EM_K1OM:
3559               result = get_x86_64_section_type_name (sh_type);
3560               break;
3561             case EM_AARCH64:
3562               result = get_aarch64_section_type_name (sh_type);
3563               break;
3564             case EM_ARM:
3565               result = get_arm_section_type_name (sh_type);
3566               break;
3567             case EM_TI_C6000:
3568               result = get_tic6x_section_type_name (sh_type);
3569               break;
3570             case EM_MSP430:
3571               result = get_msp430x_section_type_name (sh_type);
3572               break;
3573             default:
3574               result = NULL;
3575               break;
3576             }
3577
3578           if (result != NULL)
3579             return result;
3580
3581           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3582         }
3583       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3584         {
3585           const char * result;
3586
3587           switch (elf_header.e_machine)
3588             {
3589             case EM_IA_64:
3590               result = get_ia64_section_type_name (sh_type);
3591               break;
3592             default:
3593               result = NULL;
3594               break;
3595             }
3596
3597           if (result != NULL)
3598             return result;
3599
3600           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3601         }
3602       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3603         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3604       else
3605         /* This message is probably going to be displayed in a 15
3606            character wide field, so put the hex value first.  */
3607         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3608
3609       return buff;
3610     }
3611 }
3612
3613 #define OPTION_DEBUG_DUMP       512
3614 #define OPTION_DYN_SYMS         513
3615 #define OPTION_DWARF_DEPTH      514
3616 #define OPTION_DWARF_START      515
3617 #define OPTION_DWARF_CHECK      516
3618
3619 static struct option options[] =
3620 {
3621   {"all",              no_argument, 0, 'a'},
3622   {"file-header",      no_argument, 0, 'h'},
3623   {"program-headers",  no_argument, 0, 'l'},
3624   {"headers",          no_argument, 0, 'e'},
3625   {"histogram",        no_argument, 0, 'I'},
3626   {"segments",         no_argument, 0, 'l'},
3627   {"sections",         no_argument, 0, 'S'},
3628   {"section-headers",  no_argument, 0, 'S'},
3629   {"section-groups",   no_argument, 0, 'g'},
3630   {"section-details",  no_argument, 0, 't'},
3631   {"full-section-name",no_argument, 0, 'N'},
3632   {"symbols",          no_argument, 0, 's'},
3633   {"syms",             no_argument, 0, 's'},
3634   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3635   {"relocs",           no_argument, 0, 'r'},
3636   {"notes",            no_argument, 0, 'n'},
3637   {"dynamic",          no_argument, 0, 'd'},
3638   {"arch-specific",    no_argument, 0, 'A'},
3639   {"version-info",     no_argument, 0, 'V'},
3640   {"use-dynamic",      no_argument, 0, 'D'},
3641   {"unwind",           no_argument, 0, 'u'},
3642   {"archive-index",    no_argument, 0, 'c'},
3643   {"hex-dump",         required_argument, 0, 'x'},
3644   {"relocated-dump",   required_argument, 0, 'R'},
3645   {"string-dump",      required_argument, 0, 'p'},
3646 #ifdef SUPPORT_DISASSEMBLY
3647   {"instruction-dump", required_argument, 0, 'i'},
3648 #endif
3649   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3650
3651   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3652   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3653   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3654
3655   {"version",          no_argument, 0, 'v'},
3656   {"wide",             no_argument, 0, 'W'},
3657   {"help",             no_argument, 0, 'H'},
3658   {0,                  no_argument, 0, 0}
3659 };
3660
3661 static void
3662 usage (FILE * stream)
3663 {
3664   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3665   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3666   fprintf (stream, _(" Options are:\n\
3667   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3668   -h --file-header       Display the ELF file header\n\
3669   -l --program-headers   Display the program headers\n\
3670      --segments          An alias for --program-headers\n\
3671   -S --section-headers   Display the sections' header\n\
3672      --sections          An alias for --section-headers\n\
3673   -g --section-groups    Display the section groups\n\
3674   -t --section-details   Display the section details\n\
3675   -e --headers           Equivalent to: -h -l -S\n\
3676   -s --syms              Display the symbol table\n\
3677      --symbols           An alias for --syms\n\
3678   --dyn-syms             Display the dynamic symbol table\n\
3679   -n --notes             Display the core notes (if present)\n\
3680   -r --relocs            Display the relocations (if present)\n\
3681   -u --unwind            Display the unwind info (if present)\n\
3682   -d --dynamic           Display the dynamic section (if present)\n\
3683   -V --version-info      Display the version sections (if present)\n\
3684   -A --arch-specific     Display architecture specific information (if any)\n\
3685   -c --archive-index     Display the symbol/file index in an archive\n\
3686   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3687   -x --hex-dump=<number|name>\n\
3688                          Dump the contents of section <number|name> as bytes\n\
3689   -p --string-dump=<number|name>\n\
3690                          Dump the contents of section <number|name> as strings\n\
3691   -R --relocated-dump=<number|name>\n\
3692                          Dump the contents of section <number|name> as relocated bytes\n\
3693   -w[lLiaprmfFsoRt] or\n\
3694   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3695                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3696                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3697                =addr,=cu_index]\n\
3698                          Display the contents of DWARF2 debug sections\n"));
3699   fprintf (stream, _("\
3700   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3701   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3702                          or deeper\n"));
3703 #ifdef SUPPORT_DISASSEMBLY
3704   fprintf (stream, _("\
3705   -i --instruction-dump=<number|name>\n\
3706                          Disassemble the contents of section <number|name>\n"));
3707 #endif
3708   fprintf (stream, _("\
3709   -I --histogram         Display histogram of bucket list lengths\n\
3710   -W --wide              Allow output width to exceed 80 characters\n\
3711   @<file>                Read options from <file>\n\
3712   -H --help              Display this information\n\
3713   -v --version           Display the version number of readelf\n"));
3714
3715   if (REPORT_BUGS_TO[0] && stream == stdout)
3716     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3717
3718   exit (stream == stdout ? 0 : 1);
3719 }
3720
3721 /* Record the fact that the user wants the contents of section number
3722    SECTION to be displayed using the method(s) encoded as flags bits
3723    in TYPE.  Note, TYPE can be zero if we are creating the array for
3724    the first time.  */
3725
3726 static void
3727 request_dump_bynumber (unsigned int section, dump_type type)
3728 {
3729   if (section >= num_dump_sects)
3730     {
3731       dump_type * new_dump_sects;
3732
3733       new_dump_sects = (dump_type *) calloc (section + 1,
3734                                              sizeof (* dump_sects));
3735
3736       if (new_dump_sects == NULL)
3737         error (_("Out of memory allocating dump request table.\n"));
3738       else
3739         {
3740           /* Copy current flag settings.  */
3741           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3742
3743           free (dump_sects);
3744
3745           dump_sects = new_dump_sects;
3746           num_dump_sects = section + 1;
3747         }
3748     }
3749
3750   if (dump_sects)
3751     dump_sects[section] |= type;
3752
3753   return;
3754 }
3755
3756 /* Request a dump by section name.  */
3757
3758 static void
3759 request_dump_byname (const char * section, dump_type type)
3760 {
3761   struct dump_list_entry * new_request;
3762
3763   new_request = (struct dump_list_entry *)
3764       malloc (sizeof (struct dump_list_entry));
3765   if (!new_request)
3766     error (_("Out of memory allocating dump request table.\n"));
3767
3768   new_request->name = strdup (section);
3769   if (!new_request->name)
3770     error (_("Out of memory allocating dump request table.\n"));
3771
3772   new_request->type = type;
3773
3774   new_request->next = dump_sects_byname;
3775   dump_sects_byname = new_request;
3776 }
3777
3778 static inline void
3779 request_dump (dump_type type)
3780 {
3781   int section;
3782   char * cp;
3783
3784   do_dump++;
3785   section = strtoul (optarg, & cp, 0);
3786
3787   if (! *cp && section >= 0)
3788     request_dump_bynumber (section, type);
3789   else
3790     request_dump_byname (optarg, type);
3791 }
3792
3793
3794 static void
3795 parse_args (int argc, char ** argv)
3796 {
3797   int c;
3798
3799   if (argc < 2)
3800     usage (stderr);
3801
3802   while ((c = getopt_long
3803           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3804     {
3805       switch (c)
3806         {
3807         case 0:
3808           /* Long options.  */
3809           break;
3810         case 'H':
3811           usage (stdout);
3812           break;
3813
3814         case 'a':
3815           do_syms++;
3816           do_reloc++;
3817           do_unwind++;
3818           do_dynamic++;
3819           do_header++;
3820           do_sections++;
3821           do_section_groups++;
3822           do_segments++;
3823           do_version++;
3824           do_histogram++;
3825           do_arch++;
3826           do_notes++;
3827           break;
3828         case 'g':
3829           do_section_groups++;
3830           break;
3831         case 't':
3832         case 'N':
3833           do_sections++;
3834           do_section_details++;
3835           break;
3836         case 'e':
3837           do_header++;
3838           do_sections++;
3839           do_segments++;
3840           break;
3841         case 'A':
3842           do_arch++;
3843           break;
3844         case 'D':
3845           do_using_dynamic++;
3846           break;
3847         case 'r':
3848           do_reloc++;
3849           break;
3850         case 'u':
3851           do_unwind++;
3852           break;
3853         case 'h':
3854           do_header++;
3855           break;
3856         case 'l':
3857           do_segments++;
3858           break;
3859         case 's':
3860           do_syms++;
3861           break;
3862         case 'S':
3863           do_sections++;
3864           break;
3865         case 'd':
3866           do_dynamic++;
3867           break;
3868         case 'I':
3869           do_histogram++;
3870           break;
3871         case 'n':
3872           do_notes++;
3873           break;
3874         case 'c':
3875           do_archive_index++;
3876           break;
3877         case 'x':
3878           request_dump (HEX_DUMP);
3879           break;
3880         case 'p':
3881           request_dump (STRING_DUMP);
3882           break;
3883         case 'R':
3884           request_dump (RELOC_DUMP);
3885           break;
3886         case 'w':
3887           do_dump++;
3888           if (optarg == 0)
3889             {
3890               do_debugging = 1;
3891               dwarf_select_sections_all ();
3892             }
3893           else
3894             {
3895               do_debugging = 0;
3896               dwarf_select_sections_by_letters (optarg);
3897             }
3898           break;
3899         case OPTION_DEBUG_DUMP:
3900           do_dump++;
3901           if (optarg == 0)
3902             do_debugging = 1;
3903           else
3904             {
3905               do_debugging = 0;
3906               dwarf_select_sections_by_names (optarg);
3907             }
3908           break;
3909         case OPTION_DWARF_DEPTH:
3910           {
3911             char *cp;
3912
3913             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3914           }
3915           break;
3916         case OPTION_DWARF_START:
3917           {
3918             char *cp;
3919
3920             dwarf_start_die = strtoul (optarg, & cp, 0);
3921           }
3922           break;
3923         case OPTION_DWARF_CHECK:
3924           dwarf_check = 1;
3925           break;
3926         case OPTION_DYN_SYMS:
3927           do_dyn_syms++;
3928           break;
3929 #ifdef SUPPORT_DISASSEMBLY
3930         case 'i':
3931           request_dump (DISASS_DUMP);
3932           break;
3933 #endif
3934         case 'v':
3935           print_version (program_name);
3936           break;
3937         case 'V':
3938           do_version++;
3939           break;
3940         case 'W':
3941           do_wide++;
3942           break;
3943         default:
3944           /* xgettext:c-format */
3945           error (_("Invalid option '-%c'\n"), c);
3946           /* Drop through.  */
3947         case '?':
3948           usage (stderr);
3949         }
3950     }
3951
3952   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3953       && !do_segments && !do_header && !do_dump && !do_version
3954       && !do_histogram && !do_debugging && !do_arch && !do_notes
3955       && !do_section_groups && !do_archive_index
3956       && !do_dyn_syms)
3957     usage (stderr);
3958   else if (argc < 3)
3959     {
3960       warn (_("Nothing to do.\n"));
3961       usage (stderr);
3962     }
3963 }
3964
3965 static const char *
3966 get_elf_class (unsigned int elf_class)
3967 {
3968   static char buff[32];
3969
3970   switch (elf_class)
3971     {
3972     case ELFCLASSNONE: return _("none");
3973     case ELFCLASS32:   return "ELF32";
3974     case ELFCLASS64:   return "ELF64";
3975     default:
3976       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3977       return buff;
3978     }
3979 }
3980
3981 static const char *
3982 get_data_encoding (unsigned int encoding)
3983 {
3984   static char buff[32];
3985
3986   switch (encoding)
3987     {
3988     case ELFDATANONE: return _("none");
3989     case ELFDATA2LSB: return _("2's complement, little endian");
3990     case ELFDATA2MSB: return _("2's complement, big endian");
3991     default:
3992       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3993       return buff;
3994     }
3995 }
3996
3997 /* Decode the data held in 'elf_header'.  */
3998
3999 static int
4000 process_file_header (void)
4001 {
4002   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4003       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4004       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4005       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4006     {
4007       error
4008         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4009       return 0;
4010     }
4011
4012   init_dwarf_regnames (elf_header.e_machine);
4013
4014   if (do_header)
4015     {
4016       int i;
4017
4018       printf (_("ELF Header:\n"));
4019       printf (_("  Magic:   "));
4020       for (i = 0; i < EI_NIDENT; i++)
4021         printf ("%2.2x ", elf_header.e_ident[i]);
4022       printf ("\n");
4023       printf (_("  Class:                             %s\n"),
4024               get_elf_class (elf_header.e_ident[EI_CLASS]));
4025       printf (_("  Data:                              %s\n"),
4026               get_data_encoding (elf_header.e_ident[EI_DATA]));
4027       printf (_("  Version:                           %d %s\n"),
4028               elf_header.e_ident[EI_VERSION],
4029               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4030                ? "(current)"
4031                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4032                   ? _("<unknown: %lx>")
4033                   : "")));
4034       printf (_("  OS/ABI:                            %s\n"),
4035               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4036       printf (_("  ABI Version:                       %d\n"),
4037               elf_header.e_ident[EI_ABIVERSION]);
4038       printf (_("  Type:                              %s\n"),
4039               get_file_type (elf_header.e_type));
4040       printf (_("  Machine:                           %s\n"),
4041               get_machine_name (elf_header.e_machine));
4042       printf (_("  Version:                           0x%lx\n"),
4043               (unsigned long) elf_header.e_version);
4044
4045       printf (_("  Entry point address:               "));
4046       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4047       printf (_("\n  Start of program headers:          "));
4048       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4049       printf (_(" (bytes into file)\n  Start of section headers:          "));
4050       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4051       printf (_(" (bytes into file)\n"));
4052
4053       printf (_("  Flags:                             0x%lx%s\n"),
4054               (unsigned long) elf_header.e_flags,
4055               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4056       printf (_("  Size of this header:               %ld (bytes)\n"),
4057               (long) elf_header.e_ehsize);
4058       printf (_("  Size of program headers:           %ld (bytes)\n"),
4059               (long) elf_header.e_phentsize);
4060       printf (_("  Number of program headers:         %ld"),
4061               (long) elf_header.e_phnum);
4062       if (section_headers != NULL
4063           && elf_header.e_phnum == PN_XNUM
4064           && section_headers[0].sh_info != 0)
4065         printf (" (%ld)", (long) section_headers[0].sh_info);
4066       putc ('\n', stdout);
4067       printf (_("  Size of section headers:           %ld (bytes)\n"),
4068               (long) elf_header.e_shentsize);
4069       printf (_("  Number of section headers:         %ld"),
4070               (long) elf_header.e_shnum);
4071       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4072         printf (" (%ld)", (long) section_headers[0].sh_size);
4073       putc ('\n', stdout);
4074       printf (_("  Section header string table index: %ld"),
4075               (long) elf_header.e_shstrndx);
4076       if (section_headers != NULL
4077           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4078         printf (" (%u)", section_headers[0].sh_link);
4079       else if (elf_header.e_shstrndx != SHN_UNDEF
4080                && elf_header.e_shstrndx >= elf_header.e_shnum)
4081         printf (_(" <corrupt: out of range>"));
4082       putc ('\n', stdout);
4083     }
4084
4085   if (section_headers != NULL)
4086     {
4087       if (elf_header.e_phnum == PN_XNUM
4088           && section_headers[0].sh_info != 0)
4089         elf_header.e_phnum = section_headers[0].sh_info;
4090       if (elf_header.e_shnum == SHN_UNDEF)
4091         elf_header.e_shnum = section_headers[0].sh_size;
4092       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4093         elf_header.e_shstrndx = section_headers[0].sh_link;
4094       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4095         elf_header.e_shstrndx = SHN_UNDEF;
4096       free (section_headers);
4097       section_headers = NULL;
4098     }
4099
4100   return 1;
4101 }
4102
4103
4104 static int
4105 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4106 {
4107   Elf32_External_Phdr * phdrs;
4108   Elf32_External_Phdr * external;
4109   Elf_Internal_Phdr *   internal;
4110   unsigned int i;
4111
4112   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4113                                             elf_header.e_phentsize,
4114                                             elf_header.e_phnum,
4115                                             _("program headers"));
4116   if (!phdrs)
4117     return 0;
4118
4119   for (i = 0, internal = pheaders, external = phdrs;
4120        i < elf_header.e_phnum;
4121        i++, internal++, external++)
4122     {
4123       internal->p_type   = BYTE_GET (external->p_type);
4124       internal->p_offset = BYTE_GET (external->p_offset);
4125       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4126       internal->p_paddr  = BYTE_GET (external->p_paddr);
4127       internal->p_filesz = BYTE_GET (external->p_filesz);
4128       internal->p_memsz  = BYTE_GET (external->p_memsz);
4129       internal->p_flags  = BYTE_GET (external->p_flags);
4130       internal->p_align  = BYTE_GET (external->p_align);
4131     }
4132
4133   free (phdrs);
4134
4135   return 1;
4136 }
4137
4138 static int
4139 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4140 {
4141   Elf64_External_Phdr * phdrs;
4142   Elf64_External_Phdr * external;
4143   Elf_Internal_Phdr *   internal;
4144   unsigned int i;
4145
4146   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4147                                             elf_header.e_phentsize,
4148                                             elf_header.e_phnum,
4149                                             _("program headers"));
4150   if (!phdrs)
4151     return 0;
4152
4153   for (i = 0, internal = pheaders, external = phdrs;
4154        i < elf_header.e_phnum;
4155        i++, internal++, external++)
4156     {
4157       internal->p_type   = BYTE_GET (external->p_type);
4158       internal->p_flags  = BYTE_GET (external->p_flags);
4159       internal->p_offset = BYTE_GET (external->p_offset);
4160       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4161       internal->p_paddr  = BYTE_GET (external->p_paddr);
4162       internal->p_filesz = BYTE_GET (external->p_filesz);
4163       internal->p_memsz  = BYTE_GET (external->p_memsz);
4164       internal->p_align  = BYTE_GET (external->p_align);
4165     }
4166
4167   free (phdrs);
4168
4169   return 1;
4170 }
4171
4172 /* Returns 1 if the program headers were read into `program_headers'.  */
4173
4174 static int
4175 get_program_headers (FILE * file)
4176 {
4177   Elf_Internal_Phdr * phdrs;
4178
4179   /* Check cache of prior read.  */
4180   if (program_headers != NULL)
4181     return 1;
4182
4183   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4184                                          sizeof (Elf_Internal_Phdr));
4185
4186   if (phdrs == NULL)
4187     {
4188       error (_("Out of memory\n"));
4189       return 0;
4190     }
4191
4192   if (is_32bit_elf
4193       ? get_32bit_program_headers (file, phdrs)
4194       : get_64bit_program_headers (file, phdrs))
4195     {
4196       program_headers = phdrs;
4197       return 1;
4198     }
4199
4200   free (phdrs);
4201   return 0;
4202 }
4203
4204 /* Returns 1 if the program headers were loaded.  */
4205
4206 static int
4207 process_program_headers (FILE * file)
4208 {
4209   Elf_Internal_Phdr * segment;
4210   unsigned int i;
4211
4212   if (elf_header.e_phnum == 0)
4213     {
4214       /* PR binutils/12467.  */
4215       if (elf_header.e_phoff != 0)
4216         warn (_("possibly corrupt ELF header - it has a non-zero program"
4217                 " header offset, but no program headers"));
4218       else if (do_segments)
4219         printf (_("\nThere are no program headers in this file.\n"));
4220       return 0;
4221     }
4222
4223   if (do_segments && !do_header)
4224     {
4225       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4226       printf (_("Entry point "));
4227       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4228       printf (_("\nThere are %d program headers, starting at offset "),
4229               elf_header.e_phnum);
4230       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4231       printf ("\n");
4232     }
4233
4234   if (! get_program_headers (file))
4235       return 0;
4236
4237   if (do_segments)
4238     {
4239       if (elf_header.e_phnum > 1)
4240         printf (_("\nProgram Headers:\n"));
4241       else
4242         printf (_("\nProgram Headers:\n"));
4243
4244       if (is_32bit_elf)
4245         printf
4246           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4247       else if (do_wide)
4248         printf
4249           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4250       else
4251         {
4252           printf
4253             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4254           printf
4255             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4256         }
4257     }
4258
4259   dynamic_addr = 0;
4260   dynamic_size = 0;
4261
4262   for (i = 0, segment = program_headers;
4263        i < elf_header.e_phnum;
4264        i++, segment++)
4265     {
4266       if (do_segments)
4267         {
4268           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4269
4270           if (is_32bit_elf)
4271             {
4272               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4273               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4274               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4275               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4276               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4277               printf ("%c%c%c ",
4278                       (segment->p_flags & PF_R ? 'R' : ' '),
4279                       (segment->p_flags & PF_W ? 'W' : ' '),
4280                       (segment->p_flags & PF_X ? 'E' : ' '));
4281               printf ("%#lx", (unsigned long) segment->p_align);
4282             }
4283           else if (do_wide)
4284             {
4285               if ((unsigned long) segment->p_offset == segment->p_offset)
4286                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4287               else
4288                 {
4289                   print_vma (segment->p_offset, FULL_HEX);
4290                   putchar (' ');
4291                 }
4292
4293               print_vma (segment->p_vaddr, FULL_HEX);
4294               putchar (' ');
4295               print_vma (segment->p_paddr, FULL_HEX);
4296               putchar (' ');
4297
4298               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4299                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4300               else
4301                 {
4302                   print_vma (segment->p_filesz, FULL_HEX);
4303                   putchar (' ');
4304                 }
4305
4306               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4307                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4308               else
4309                 {
4310                   print_vma (segment->p_memsz, FULL_HEX);
4311                 }
4312
4313               printf (" %c%c%c ",
4314                       (segment->p_flags & PF_R ? 'R' : ' '),
4315                       (segment->p_flags & PF_W ? 'W' : ' '),
4316                       (segment->p_flags & PF_X ? 'E' : ' '));
4317
4318               if ((unsigned long) segment->p_align == segment->p_align)
4319                 printf ("%#lx", (unsigned long) segment->p_align);
4320               else
4321                 {
4322                   print_vma (segment->p_align, PREFIX_HEX);
4323                 }
4324             }
4325           else
4326             {
4327               print_vma (segment->p_offset, FULL_HEX);
4328               putchar (' ');
4329               print_vma (segment->p_vaddr, FULL_HEX);
4330               putchar (' ');
4331               print_vma (segment->p_paddr, FULL_HEX);
4332               printf ("\n                 ");
4333               print_vma (segment->p_filesz, FULL_HEX);
4334               putchar (' ');
4335               print_vma (segment->p_memsz, FULL_HEX);
4336               printf ("  %c%c%c    ",
4337                       (segment->p_flags & PF_R ? 'R' : ' '),
4338                       (segment->p_flags & PF_W ? 'W' : ' '),
4339                       (segment->p_flags & PF_X ? 'E' : ' '));
4340               print_vma (segment->p_align, HEX);
4341             }
4342         }
4343
4344       switch (segment->p_type)
4345         {
4346         case PT_DYNAMIC:
4347           if (dynamic_addr)
4348             error (_("more than one dynamic segment\n"));
4349
4350           /* By default, assume that the .dynamic section is the first
4351              section in the DYNAMIC segment.  */
4352           dynamic_addr = segment->p_offset;
4353           dynamic_size = segment->p_filesz;
4354
4355           /* Try to locate the .dynamic section. If there is
4356              a section header table, we can easily locate it.  */
4357           if (section_headers != NULL)
4358             {
4359               Elf_Internal_Shdr * sec;
4360
4361               sec = find_section (".dynamic");
4362               if (sec == NULL || sec->sh_size == 0)
4363                 {
4364                   /* A corresponding .dynamic section is expected, but on
4365                      IA-64/OpenVMS it is OK for it to be missing.  */
4366                   if (!is_ia64_vms ())
4367                     error (_("no .dynamic section in the dynamic segment\n"));
4368                   break;
4369                 }
4370
4371               if (sec->sh_type == SHT_NOBITS)
4372                 {
4373                   dynamic_size = 0;
4374                   break;
4375                 }
4376
4377               dynamic_addr = sec->sh_offset;
4378               dynamic_size = sec->sh_size;
4379
4380               if (dynamic_addr < segment->p_offset
4381                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4382                 warn (_("the .dynamic section is not contained"
4383                         " within the dynamic segment\n"));
4384               else if (dynamic_addr > segment->p_offset)
4385                 warn (_("the .dynamic section is not the first section"
4386                         " in the dynamic segment.\n"));
4387             }
4388           break;
4389
4390         case PT_INTERP:
4391           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4392                      SEEK_SET))
4393             error (_("Unable to find program interpreter name\n"));
4394           else
4395             {
4396               char fmt [32];
4397               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4398
4399               if (ret >= (int) sizeof (fmt) || ret < 0)
4400                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4401
4402               program_interpreter[0] = 0;
4403               if (fscanf (file, fmt, program_interpreter) <= 0)
4404                 error (_("Unable to read program interpreter name\n"));
4405
4406               if (do_segments)
4407                 printf (_("\n      [Requesting program interpreter: %s]"),
4408                     program_interpreter);
4409             }
4410           break;
4411         }
4412
4413       if (do_segments)
4414         putc ('\n', stdout);
4415     }
4416
4417   if (do_segments && section_headers != NULL && string_table != NULL)
4418     {
4419       printf (_("\n Section to Segment mapping:\n"));
4420       printf (_("  Segment Sections...\n"));
4421
4422       for (i = 0; i < elf_header.e_phnum; i++)
4423         {
4424           unsigned int j;
4425           Elf_Internal_Shdr * section;
4426
4427           segment = program_headers + i;
4428           section = section_headers + 1;
4429
4430           printf ("   %2.2d     ", i);
4431
4432           for (j = 1; j < elf_header.e_shnum; j++, section++)
4433             {
4434               if (!ELF_TBSS_SPECIAL (section, segment)
4435                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4436                 printf ("%s ", SECTION_NAME (section));
4437             }
4438
4439           putc ('\n',stdout);
4440         }
4441     }
4442
4443   return 1;
4444 }
4445
4446
4447 /* Find the file offset corresponding to VMA by using the program headers.  */
4448
4449 static long
4450 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4451 {
4452   Elf_Internal_Phdr * seg;
4453
4454   if (! get_program_headers (file))
4455     {
4456       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4457       return (long) vma;
4458     }
4459
4460   for (seg = program_headers;
4461        seg < program_headers + elf_header.e_phnum;
4462        ++seg)
4463     {
4464       if (seg->p_type != PT_LOAD)
4465         continue;
4466
4467       if (vma >= (seg->p_vaddr & -seg->p_align)
4468           && vma + size <= seg->p_vaddr + seg->p_filesz)
4469         return vma - seg->p_vaddr + seg->p_offset;
4470     }
4471
4472   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4473         (unsigned long) vma);
4474   return (long) vma;
4475 }
4476
4477
4478 static int
4479 get_32bit_section_headers (FILE * file, unsigned int num)
4480 {
4481   Elf32_External_Shdr * shdrs;
4482   Elf_Internal_Shdr *   internal;
4483   unsigned int i;
4484
4485   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4486                                             elf_header.e_shentsize, num,
4487                                             _("section headers"));
4488   if (!shdrs)
4489     return 0;
4490
4491   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4492                                                    sizeof (Elf_Internal_Shdr));
4493
4494   if (section_headers == NULL)
4495     {
4496       error (_("Out of memory\n"));
4497       return 0;
4498     }
4499
4500   for (i = 0, internal = section_headers;
4501        i < num;
4502        i++, internal++)
4503     {
4504       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4505       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4506       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4507       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4508       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4509       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4510       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4511       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4512       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4513       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4514     }
4515
4516   free (shdrs);
4517
4518   return 1;
4519 }
4520
4521 static int
4522 get_64bit_section_headers (FILE * file, unsigned int num)
4523 {
4524   Elf64_External_Shdr * shdrs;
4525   Elf_Internal_Shdr *   internal;
4526   unsigned int i;
4527
4528   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4529                                             elf_header.e_shentsize, num,
4530                                             _("section headers"));
4531   if (!shdrs)
4532     return 0;
4533
4534   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4535                                                    sizeof (Elf_Internal_Shdr));
4536
4537   if (section_headers == NULL)
4538     {
4539       error (_("Out of memory\n"));
4540       return 0;
4541     }
4542
4543   for (i = 0, internal = section_headers;
4544        i < num;
4545        i++, internal++)
4546     {
4547       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4548       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4549       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4550       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4551       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4552       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4553       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4554       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4555       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4556       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4557     }
4558
4559   free (shdrs);
4560
4561   return 1;
4562 }
4563
4564 static Elf_Internal_Sym *
4565 get_32bit_elf_symbols (FILE * file,
4566                        Elf_Internal_Shdr * section,
4567                        unsigned long * num_syms_return)
4568 {
4569   unsigned long number = 0;
4570   Elf32_External_Sym * esyms = NULL;
4571   Elf_External_Sym_Shndx * shndx = NULL;
4572   Elf_Internal_Sym * isyms = NULL;
4573   Elf_Internal_Sym * psym;
4574   unsigned int j;
4575
4576   /* Run some sanity checks first.  */
4577   if (section->sh_entsize == 0)
4578     {
4579       error (_("sh_entsize is zero\n"));
4580       goto exit_point;
4581     }
4582
4583   number = section->sh_size / section->sh_entsize;
4584
4585   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4586     {
4587       error (_("Invalid sh_entsize\n"));
4588       goto exit_point;
4589     }
4590
4591   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4592                                            section->sh_size, _("symbols"));
4593   if (esyms == NULL)
4594     goto exit_point;
4595
4596   shndx = NULL;
4597   if (symtab_shndx_hdr != NULL
4598       && (symtab_shndx_hdr->sh_link
4599           == (unsigned long) (section - section_headers)))
4600     {
4601       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4602                                                    symtab_shndx_hdr->sh_offset,
4603                                                    1, symtab_shndx_hdr->sh_size,
4604                                                    _("symbol table section indicies"));
4605       if (shndx == NULL)
4606         goto exit_point;
4607     }
4608
4609   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4610
4611   if (isyms == NULL)
4612     {
4613       error (_("Out of memory\n"));
4614       goto exit_point;
4615     }
4616
4617   for (j = 0, psym = isyms; j < number; j++, psym++)
4618     {
4619       psym->st_name  = BYTE_GET (esyms[j].st_name);
4620       psym->st_value = BYTE_GET (esyms[j].st_value);
4621       psym->st_size  = BYTE_GET (esyms[j].st_size);
4622       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4623       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4624         psym->st_shndx
4625           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4626       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4627         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4628       psym->st_info  = BYTE_GET (esyms[j].st_info);
4629       psym->st_other = BYTE_GET (esyms[j].st_other);
4630     }
4631
4632  exit_point:
4633   if (shndx != NULL)
4634     free (shndx);
4635   if (esyms != NULL)
4636     free (esyms);
4637
4638   if (num_syms_return != NULL)
4639     * num_syms_return = isyms == NULL ? 0 : number;
4640
4641   return isyms;
4642 }
4643
4644 static Elf_Internal_Sym *
4645 get_64bit_elf_symbols (FILE * file,
4646                        Elf_Internal_Shdr * section,
4647                        unsigned long * num_syms_return)
4648 {
4649   unsigned long number = 0;
4650   Elf64_External_Sym * esyms = NULL;
4651   Elf_External_Sym_Shndx * shndx = NULL;
4652   Elf_Internal_Sym * isyms = NULL;
4653   Elf_Internal_Sym * psym;
4654   unsigned int j;
4655
4656   /* Run some sanity checks first.  */
4657   if (section->sh_entsize == 0)
4658     {
4659       error (_("sh_entsize is zero\n"));
4660       goto exit_point;
4661     }
4662
4663   number = section->sh_size / section->sh_entsize;
4664
4665   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4666     {
4667       error (_("Invalid sh_entsize\n"));
4668       goto exit_point;
4669     }
4670
4671   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4672                                            section->sh_size, _("symbols"));
4673   if (!esyms)
4674     goto exit_point;
4675
4676   if (symtab_shndx_hdr != NULL
4677       && (symtab_shndx_hdr->sh_link
4678           == (unsigned long) (section - section_headers)))
4679     {
4680       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4681                                                    symtab_shndx_hdr->sh_offset,
4682                                                    1, symtab_shndx_hdr->sh_size,
4683                                                    _("symbol table section indicies"));
4684       if (shndx == NULL)
4685         goto exit_point;
4686     }
4687
4688   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4689
4690   if (isyms == NULL)
4691     {
4692       error (_("Out of memory\n"));
4693       goto exit_point;
4694     }
4695
4696   for (j = 0, psym = isyms; j < number; j++, psym++)
4697     {
4698       psym->st_name  = BYTE_GET (esyms[j].st_name);
4699       psym->st_info  = BYTE_GET (esyms[j].st_info);
4700       psym->st_other = BYTE_GET (esyms[j].st_other);
4701       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4702
4703       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4704         psym->st_shndx
4705           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4706       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4707         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4708
4709       psym->st_value = BYTE_GET (esyms[j].st_value);
4710       psym->st_size  = BYTE_GET (esyms[j].st_size);
4711     }
4712
4713  exit_point:
4714   if (shndx != NULL)
4715     free (shndx);
4716   if (esyms != NULL)
4717     free (esyms);
4718
4719   if (num_syms_return != NULL)
4720     * num_syms_return = isyms == NULL ? 0 : number;
4721
4722   return isyms;
4723 }
4724
4725 static const char *
4726 get_elf_section_flags (bfd_vma sh_flags)
4727 {
4728   static char buff[1024];
4729   char * p = buff;
4730   int field_size = is_32bit_elf ? 8 : 16;
4731   int sindex;
4732   int size = sizeof (buff) - (field_size + 4 + 1);
4733   bfd_vma os_flags = 0;
4734   bfd_vma proc_flags = 0;
4735   bfd_vma unknown_flags = 0;
4736   static const struct
4737     {
4738       const char * str;
4739       int len;
4740     }
4741   flags [] =
4742     {
4743       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4744       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4745       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4746       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4747       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4748       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4749       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4750       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4751       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4752       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4753       /* IA-64 specific.  */
4754       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4755       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4756       /* IA-64 OpenVMS specific.  */
4757       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4758       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4759       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4760       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4761       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4762       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4763       /* Generic.  */
4764       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4765       /* SPARC specific.  */
4766       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4767     };
4768
4769   if (do_section_details)
4770     {
4771       sprintf (buff, "[%*.*lx]: ",
4772                field_size, field_size, (unsigned long) sh_flags);
4773       p += field_size + 4;
4774     }
4775
4776   while (sh_flags)
4777     {
4778       bfd_vma flag;
4779
4780       flag = sh_flags & - sh_flags;
4781       sh_flags &= ~ flag;
4782
4783       if (do_section_details)
4784         {
4785           switch (flag)
4786             {
4787             case SHF_WRITE:             sindex = 0; break;
4788             case SHF_ALLOC:             sindex = 1; break;
4789             case SHF_EXECINSTR:         sindex = 2; break;
4790             case SHF_MERGE:             sindex = 3; break;
4791             case SHF_STRINGS:           sindex = 4; break;
4792             case SHF_INFO_LINK:         sindex = 5; break;
4793             case SHF_LINK_ORDER:        sindex = 6; break;
4794             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4795             case SHF_GROUP:             sindex = 8; break;
4796             case SHF_TLS:               sindex = 9; break;
4797             case SHF_EXCLUDE:           sindex = 18; break;
4798
4799             default:
4800               sindex = -1;
4801               switch (elf_header.e_machine)
4802                 {
4803                 case EM_IA_64:
4804                   if (flag == SHF_IA_64_SHORT)
4805                     sindex = 10;
4806                   else if (flag == SHF_IA_64_NORECOV)
4807                     sindex = 11;
4808 #ifdef BFD64
4809                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4810                     switch (flag)
4811                       {
4812                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4813                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4814                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4815                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4816                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4817                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4818                       default:                        break;
4819                       }
4820 #endif
4821                   break;
4822
4823                 case EM_386:
4824                 case EM_486:
4825                 case EM_X86_64:
4826                 case EM_L1OM:
4827                 case EM_K1OM:
4828                 case EM_OLD_SPARCV9:
4829                 case EM_SPARC32PLUS:
4830                 case EM_SPARCV9:
4831                 case EM_SPARC:
4832                   if (flag == SHF_ORDERED)
4833                     sindex = 19;
4834                   break;
4835                 default:
4836                   break;
4837                 }
4838             }
4839
4840           if (sindex != -1)
4841             {
4842               if (p != buff + field_size + 4)
4843                 {
4844                   if (size < (10 + 2))
4845                     abort ();
4846                   size -= 2;
4847                   *p++ = ',';
4848                   *p++ = ' ';
4849                 }
4850
4851               size -= flags [sindex].len;
4852               p = stpcpy (p, flags [sindex].str);
4853             }
4854           else if (flag & SHF_MASKOS)
4855             os_flags |= flag;
4856           else if (flag & SHF_MASKPROC)
4857             proc_flags |= flag;
4858           else
4859             unknown_flags |= flag;
4860         }
4861       else
4862         {
4863           switch (flag)
4864             {
4865             case SHF_WRITE:             *p = 'W'; break;
4866             case SHF_ALLOC:             *p = 'A'; break;
4867             case SHF_EXECINSTR:         *p = 'X'; break;
4868             case SHF_MERGE:             *p = 'M'; break;
4869             case SHF_STRINGS:           *p = 'S'; break;
4870             case SHF_INFO_LINK:         *p = 'I'; break;
4871             case SHF_LINK_ORDER:        *p = 'L'; break;
4872             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4873             case SHF_GROUP:             *p = 'G'; break;
4874             case SHF_TLS:               *p = 'T'; break;
4875             case SHF_EXCLUDE:           *p = 'E'; break;
4876
4877             default:
4878               if ((elf_header.e_machine == EM_X86_64
4879                    || elf_header.e_machine == EM_L1OM
4880                    || elf_header.e_machine == EM_K1OM)
4881                   && flag == SHF_X86_64_LARGE)
4882                 *p = 'l';
4883               else if (flag & SHF_MASKOS)
4884                 {
4885                   *p = 'o';
4886                   sh_flags &= ~ SHF_MASKOS;
4887                 }
4888               else if (flag & SHF_MASKPROC)
4889                 {
4890                   *p = 'p';
4891                   sh_flags &= ~ SHF_MASKPROC;
4892                 }
4893               else
4894                 *p = 'x';
4895               break;
4896             }
4897           p++;
4898         }
4899     }
4900
4901   if (do_section_details)
4902     {
4903       if (os_flags)
4904         {
4905           size -= 5 + field_size;
4906           if (p != buff + field_size + 4)
4907             {
4908               if (size < (2 + 1))
4909                 abort ();
4910               size -= 2;
4911               *p++ = ',';
4912               *p++ = ' ';
4913             }
4914           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4915                    (unsigned long) os_flags);
4916           p += 5 + field_size;
4917         }
4918       if (proc_flags)
4919         {
4920           size -= 7 + field_size;
4921           if (p != buff + field_size + 4)
4922             {
4923               if (size < (2 + 1))
4924                 abort ();
4925               size -= 2;
4926               *p++ = ',';
4927               *p++ = ' ';
4928             }
4929           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4930                    (unsigned long) proc_flags);
4931           p += 7 + field_size;
4932         }
4933       if (unknown_flags)
4934         {
4935           size -= 10 + field_size;
4936           if (p != buff + field_size + 4)
4937             {
4938               if (size < (2 + 1))
4939                 abort ();
4940               size -= 2;
4941               *p++ = ',';
4942               *p++ = ' ';
4943             }
4944           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4945                    (unsigned long) unknown_flags);
4946           p += 10 + field_size;
4947         }
4948     }
4949
4950   *p = '\0';
4951   return buff;
4952 }
4953
4954 static int
4955 process_section_headers (FILE * file)
4956 {
4957   Elf_Internal_Shdr * section;
4958   unsigned int i;
4959
4960   section_headers = NULL;
4961
4962   if (elf_header.e_shnum == 0)
4963     {
4964       /* PR binutils/12467.  */
4965       if (elf_header.e_shoff != 0)
4966         warn (_("possibly corrupt ELF file header - it has a non-zero"
4967                 " section header offset, but no section headers\n"));
4968       else if (do_sections)
4969         printf (_("\nThere are no sections in this file.\n"));
4970
4971       return 1;
4972     }
4973
4974   if (do_sections && !do_header)
4975     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4976             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4977
4978   if (is_32bit_elf)
4979     {
4980       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4981         return 0;
4982     }
4983   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4984     return 0;
4985
4986   /* Read in the string table, so that we have names to display.  */
4987   if (elf_header.e_shstrndx != SHN_UNDEF
4988        && elf_header.e_shstrndx < elf_header.e_shnum)
4989     {
4990       section = section_headers + elf_header.e_shstrndx;
4991
4992       if (section->sh_size != 0)
4993         {
4994           string_table = (char *) get_data (NULL, file, section->sh_offset,
4995                                             1, section->sh_size,
4996                                             _("string table"));
4997
4998           string_table_length = string_table != NULL ? section->sh_size : 0;
4999         }
5000     }
5001
5002   /* Scan the sections for the dynamic symbol table
5003      and dynamic string table and debug sections.  */
5004   dynamic_symbols = NULL;
5005   dynamic_strings = NULL;
5006   dynamic_syminfo = NULL;
5007   symtab_shndx_hdr = NULL;
5008
5009   eh_addr_size = is_32bit_elf ? 4 : 8;
5010   switch (elf_header.e_machine)
5011     {
5012     case EM_MIPS:
5013     case EM_MIPS_RS3_LE:
5014       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5015          FDE addresses.  However, the ABI also has a semi-official ILP32
5016          variant for which the normal FDE address size rules apply.
5017
5018          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5019          section, where XX is the size of longs in bits.  Unfortunately,
5020          earlier compilers provided no way of distinguishing ILP32 objects
5021          from LP64 objects, so if there's any doubt, we should assume that
5022          the official LP64 form is being used.  */
5023       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5024           && find_section (".gcc_compiled_long32") == NULL)
5025         eh_addr_size = 8;
5026       break;
5027
5028     case EM_H8_300:
5029     case EM_H8_300H:
5030       switch (elf_header.e_flags & EF_H8_MACH)
5031         {
5032         case E_H8_MACH_H8300:
5033         case E_H8_MACH_H8300HN:
5034         case E_H8_MACH_H8300SN:
5035         case E_H8_MACH_H8300SXN:
5036           eh_addr_size = 2;
5037           break;
5038         case E_H8_MACH_H8300H:
5039         case E_H8_MACH_H8300S:
5040         case E_H8_MACH_H8300SX:
5041           eh_addr_size = 4;
5042           break;
5043         }
5044       break;
5045
5046     case EM_M32C_OLD:
5047     case EM_M32C:
5048       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5049         {
5050         case EF_M32C_CPU_M16C:
5051           eh_addr_size = 2;
5052           break;
5053         }
5054       break;
5055     }
5056
5057 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5058   do                                                                        \
5059     {                                                                       \
5060       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;      \
5061       if (section->sh_entsize != expected_entsize)                          \
5062         {                                                               \
5063           error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
5064                  i, section->sh_entsize);       \
5065           error (_("(Using the expected size of %d for the rest of this dump)\n"), \
5066                    (int) expected_entsize); \
5067           section->sh_entsize = expected_entsize;                       \
5068         } \
5069     }                                                                       \
5070   while (0)
5071
5072 #define CHECK_ENTSIZE(section, i, type)                                 \
5073   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5074                         sizeof (Elf64_External_##type))
5075
5076   for (i = 0, section = section_headers;
5077        i < elf_header.e_shnum;
5078        i++, section++)
5079     {
5080       char * name = SECTION_NAME (section);
5081
5082       if (section->sh_type == SHT_DYNSYM)
5083         {
5084           if (dynamic_symbols != NULL)
5085             {
5086               error (_("File contains multiple dynamic symbol tables\n"));
5087               continue;
5088             }
5089
5090           CHECK_ENTSIZE (section, i, Sym);
5091           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5092         }
5093       else if (section->sh_type == SHT_STRTAB
5094                && streq (name, ".dynstr"))
5095         {
5096           if (dynamic_strings != NULL)
5097             {
5098               error (_("File contains multiple dynamic string tables\n"));
5099               continue;
5100             }
5101
5102           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5103                                                1, section->sh_size,
5104                                                _("dynamic strings"));
5105           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5106         }
5107       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5108         {
5109           if (symtab_shndx_hdr != NULL)
5110             {
5111               error (_("File contains multiple symtab shndx tables\n"));
5112               continue;
5113             }
5114           symtab_shndx_hdr = section;
5115         }
5116       else if (section->sh_type == SHT_SYMTAB)
5117         CHECK_ENTSIZE (section, i, Sym);
5118       else if (section->sh_type == SHT_GROUP)
5119         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5120       else if (section->sh_type == SHT_REL)
5121         CHECK_ENTSIZE (section, i, Rel);
5122       else if (section->sh_type == SHT_RELA)
5123         CHECK_ENTSIZE (section, i, Rela);
5124       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5125                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5126                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5127                 || do_debug_str || do_debug_loc || do_debug_ranges
5128                 || do_debug_addr || do_debug_cu_index)
5129                && (const_strneq (name, ".debug_")
5130                    || const_strneq (name, ".zdebug_")))
5131         {
5132           if (name[1] == 'z')
5133             name += sizeof (".zdebug_") - 1;
5134           else
5135             name += sizeof (".debug_") - 1;
5136
5137           if (do_debugging
5138               || (do_debug_info     && const_strneq (name, "info"))
5139               || (do_debug_info     && const_strneq (name, "types"))
5140               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5141               || (do_debug_lines    && strcmp (name, "line") == 0)
5142               || (do_debug_lines    && const_strneq (name, "line."))
5143               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5144               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5145               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5146               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5147               || (do_debug_aranges  && const_strneq (name, "aranges"))
5148               || (do_debug_ranges   && const_strneq (name, "ranges"))
5149               || (do_debug_frames   && const_strneq (name, "frame"))
5150               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5151               || (do_debug_macinfo  && const_strneq (name, "macro"))
5152               || (do_debug_str      && const_strneq (name, "str"))
5153               || (do_debug_loc      && const_strneq (name, "loc"))
5154               || (do_debug_addr     && const_strneq (name, "addr"))
5155               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5156               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5157               )
5158             request_dump_bynumber (i, DEBUG_DUMP);
5159         }
5160       /* Linkonce section to be combined with .debug_info at link time.  */
5161       else if ((do_debugging || do_debug_info)
5162                && const_strneq (name, ".gnu.linkonce.wi."))
5163         request_dump_bynumber (i, DEBUG_DUMP);
5164       else if (do_debug_frames && streq (name, ".eh_frame"))
5165         request_dump_bynumber (i, DEBUG_DUMP);
5166       else if (do_gdb_index && streq (name, ".gdb_index"))
5167         request_dump_bynumber (i, DEBUG_DUMP);
5168       /* Trace sections for Itanium VMS.  */
5169       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5170                 || do_trace_aranges)
5171                && const_strneq (name, ".trace_"))
5172         {
5173           name += sizeof (".trace_") - 1;
5174
5175           if (do_debugging
5176               || (do_trace_info     && streq (name, "info"))
5177               || (do_trace_abbrevs  && streq (name, "abbrev"))
5178               || (do_trace_aranges  && streq (name, "aranges"))
5179               )
5180             request_dump_bynumber (i, DEBUG_DUMP);
5181         }
5182
5183     }
5184
5185   if (! do_sections)
5186     return 1;
5187
5188   if (elf_header.e_shnum > 1)
5189     printf (_("\nSection Headers:\n"));
5190   else
5191     printf (_("\nSection Header:\n"));
5192
5193   if (is_32bit_elf)
5194     {
5195       if (do_section_details)
5196         {
5197           printf (_("  [Nr] Name\n"));
5198           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5199         }
5200       else
5201         printf
5202           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5203     }
5204   else if (do_wide)
5205     {
5206       if (do_section_details)
5207         {
5208           printf (_("  [Nr] Name\n"));
5209           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5210         }
5211       else
5212         printf
5213           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5214     }
5215   else
5216     {
5217       if (do_section_details)
5218         {
5219           printf (_("  [Nr] Name\n"));
5220           printf (_("       Type              Address          Offset            Link\n"));
5221           printf (_("       Size              EntSize          Info              Align\n"));
5222         }
5223       else
5224         {
5225           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5226           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5227         }
5228     }
5229
5230   if (do_section_details)
5231     printf (_("       Flags\n"));
5232
5233   for (i = 0, section = section_headers;
5234        i < elf_header.e_shnum;
5235        i++, section++)
5236     {
5237       printf ("  [%2u] ", i);
5238       if (do_section_details)
5239         {
5240           print_symbol (INT_MAX, SECTION_NAME (section));
5241           printf ("\n      ");
5242         }
5243       else
5244         {
5245           print_symbol (-17, SECTION_NAME (section));
5246         }
5247
5248       printf (do_wide ? " %-15s " : " %-15.15s ",
5249               get_section_type_name (section->sh_type));
5250
5251       if (is_32bit_elf)
5252         {
5253           const char * link_too_big = NULL;
5254
5255           print_vma (section->sh_addr, LONG_HEX);
5256
5257           printf ( " %6.6lx %6.6lx %2.2lx",
5258                    (unsigned long) section->sh_offset,
5259                    (unsigned long) section->sh_size,
5260                    (unsigned long) section->sh_entsize);
5261
5262           if (do_section_details)
5263             fputs ("  ", stdout);
5264           else
5265             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5266
5267           if (section->sh_link >= elf_header.e_shnum)
5268             {
5269               link_too_big = "";
5270               /* The sh_link value is out of range.  Normally this indicates
5271                  an error but it can have special values in Solaris binaries.  */
5272               switch (elf_header.e_machine)
5273                 {
5274                 case EM_386:
5275                 case EM_486:
5276                 case EM_X86_64:
5277                 case EM_L1OM:
5278                 case EM_K1OM:
5279                 case EM_OLD_SPARCV9:
5280                 case EM_SPARC32PLUS:
5281                 case EM_SPARCV9:
5282                 case EM_SPARC:
5283                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5284                     link_too_big = "BEFORE";
5285                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5286                     link_too_big = "AFTER";
5287                   break;
5288                 default:
5289                   break;
5290                 }
5291             }
5292
5293           if (do_section_details)
5294             {
5295               if (link_too_big != NULL && * link_too_big)
5296                 printf ("<%s> ", link_too_big);
5297               else
5298                 printf ("%2u ", section->sh_link);
5299               printf ("%3u %2lu\n", section->sh_info,
5300                       (unsigned long) section->sh_addralign);
5301             }
5302           else
5303             printf ("%2u %3u %2lu\n",
5304                     section->sh_link,
5305                     section->sh_info,
5306                     (unsigned long) section->sh_addralign);
5307
5308           if (link_too_big && ! * link_too_big)
5309             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5310                   i, section->sh_link);
5311         }
5312       else if (do_wide)
5313         {
5314           print_vma (section->sh_addr, LONG_HEX);
5315
5316           if ((long) section->sh_offset == section->sh_offset)
5317             printf (" %6.6lx", (unsigned long) section->sh_offset);
5318           else
5319             {
5320               putchar (' ');
5321               print_vma (section->sh_offset, LONG_HEX);
5322             }
5323
5324           if ((unsigned long) section->sh_size == section->sh_size)
5325             printf (" %6.6lx", (unsigned long) section->sh_size);
5326           else
5327             {
5328               putchar (' ');
5329               print_vma (section->sh_size, LONG_HEX);
5330             }
5331
5332           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5333             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5334           else
5335             {
5336               putchar (' ');
5337               print_vma (section->sh_entsize, LONG_HEX);
5338             }
5339
5340           if (do_section_details)
5341             fputs ("  ", stdout);
5342           else
5343             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5344
5345           printf ("%2u %3u ", section->sh_link, section->sh_info);
5346
5347           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5348             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5349           else
5350             {
5351               print_vma (section->sh_addralign, DEC);
5352               putchar ('\n');
5353             }
5354         }
5355       else if (do_section_details)
5356         {
5357           printf ("       %-15.15s  ",
5358                   get_section_type_name (section->sh_type));
5359           print_vma (section->sh_addr, LONG_HEX);
5360           if ((long) section->sh_offset == section->sh_offset)
5361             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5362           else
5363             {
5364               printf ("  ");
5365               print_vma (section->sh_offset, LONG_HEX);
5366             }
5367           printf ("  %u\n       ", section->sh_link);
5368           print_vma (section->sh_size, LONG_HEX);
5369           putchar (' ');
5370           print_vma (section->sh_entsize, LONG_HEX);
5371
5372           printf ("  %-16u  %lu\n",
5373                   section->sh_info,
5374                   (unsigned long) section->sh_addralign);
5375         }
5376       else
5377         {
5378           putchar (' ');
5379           print_vma (section->sh_addr, LONG_HEX);
5380           if ((long) section->sh_offset == section->sh_offset)
5381             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5382           else
5383             {
5384               printf ("  ");
5385               print_vma (section->sh_offset, LONG_HEX);
5386             }
5387           printf ("\n       ");
5388           print_vma (section->sh_size, LONG_HEX);
5389           printf ("  ");
5390           print_vma (section->sh_entsize, LONG_HEX);
5391
5392           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5393
5394           printf ("     %2u   %3u     %lu\n",
5395                   section->sh_link,
5396                   section->sh_info,
5397                   (unsigned long) section->sh_addralign);
5398         }
5399
5400       if (do_section_details)
5401         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5402     }
5403
5404   if (!do_section_details)
5405     {
5406       if (elf_header.e_machine == EM_X86_64
5407           || elf_header.e_machine == EM_L1OM
5408           || elf_header.e_machine == EM_K1OM)
5409         printf (_("Key to Flags:\n\
5410   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5411   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5412   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5413       else
5414         printf (_("Key to Flags:\n\
5415   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5416   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5417   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5418     }
5419
5420   return 1;
5421 }
5422
5423 static const char *
5424 get_group_flags (unsigned int flags)
5425 {
5426   static char buff[32];
5427   switch (flags)
5428     {
5429     case 0:
5430       return "";
5431
5432     case GRP_COMDAT:
5433       return "COMDAT ";
5434
5435    default:
5436       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5437       break;
5438     }
5439   return buff;
5440 }
5441
5442 static int
5443 process_section_groups (FILE * file)
5444 {
5445   Elf_Internal_Shdr * section;
5446   unsigned int i;
5447   struct group * group;
5448   Elf_Internal_Shdr * symtab_sec;
5449   Elf_Internal_Shdr * strtab_sec;
5450   Elf_Internal_Sym * symtab;
5451   unsigned long num_syms;
5452   char * strtab;
5453   size_t strtab_size;
5454
5455   /* Don't process section groups unless needed.  */
5456   if (!do_unwind && !do_section_groups)
5457     return 1;
5458
5459   if (elf_header.e_shnum == 0)
5460     {
5461       if (do_section_groups)
5462         printf (_("\nThere are no sections to group in this file.\n"));
5463
5464       return 1;
5465     }
5466
5467   if (section_headers == NULL)
5468     {
5469       error (_("Section headers are not available!\n"));
5470       /* PR 13622: This can happen with a corrupt ELF header.  */
5471       return 0;
5472     }
5473
5474   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5475                                                      sizeof (struct group *));
5476
5477   if (section_headers_groups == NULL)
5478     {
5479       error (_("Out of memory\n"));
5480       return 0;
5481     }
5482
5483   /* Scan the sections for the group section.  */
5484   group_count = 0;
5485   for (i = 0, section = section_headers;
5486        i < elf_header.e_shnum;
5487        i++, section++)
5488     if (section->sh_type == SHT_GROUP)
5489       group_count++;
5490
5491   if (group_count == 0)
5492     {
5493       if (do_section_groups)
5494         printf (_("\nThere are no section groups in this file.\n"));
5495
5496       return 1;
5497     }
5498
5499   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5500
5501   if (section_groups == NULL)
5502     {
5503       error (_("Out of memory\n"));
5504       return 0;
5505     }
5506
5507   symtab_sec = NULL;
5508   strtab_sec = NULL;
5509   symtab = NULL;
5510   num_syms = 0;
5511   strtab = NULL;
5512   strtab_size = 0;
5513   for (i = 0, section = section_headers, group = section_groups;
5514        i < elf_header.e_shnum;
5515        i++, section++)
5516     {
5517       if (section->sh_type == SHT_GROUP)
5518         {
5519           char * name = SECTION_NAME (section);
5520           char * group_name;
5521           unsigned char * start;
5522           unsigned char * indices;
5523           unsigned int entry, j, size;
5524           Elf_Internal_Shdr * sec;
5525           Elf_Internal_Sym * sym;
5526
5527           /* Get the symbol table.  */
5528           if (section->sh_link >= elf_header.e_shnum
5529               || ((sec = section_headers + section->sh_link)->sh_type
5530                   != SHT_SYMTAB))
5531             {
5532               error (_("Bad sh_link in group section `%s'\n"), name);
5533               continue;
5534             }
5535
5536           if (symtab_sec != sec)
5537             {
5538               symtab_sec = sec;
5539               if (symtab)
5540                 free (symtab);
5541               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5542             }
5543
5544           if (symtab == NULL)
5545             {
5546               error (_("Corrupt header in group section `%s'\n"), name);
5547               continue;
5548             }
5549
5550           if (section->sh_info >= num_syms)
5551             {
5552               error (_("Bad sh_info in group section `%s'\n"), name);
5553               continue;
5554             }
5555
5556           sym = symtab + section->sh_info;
5557
5558           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5559             {
5560               if (sym->st_shndx == 0
5561                   || sym->st_shndx >= elf_header.e_shnum)
5562                 {
5563                   error (_("Bad sh_info in group section `%s'\n"), name);
5564                   continue;
5565                 }
5566
5567               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5568               strtab_sec = NULL;
5569               if (strtab)
5570                 free (strtab);
5571               strtab = NULL;
5572               strtab_size = 0;
5573             }
5574           else
5575             {
5576               /* Get the string table.  */
5577               if (symtab_sec->sh_link >= elf_header.e_shnum)
5578                 {
5579                   strtab_sec = NULL;
5580                   if (strtab)
5581                     free (strtab);
5582                   strtab = NULL;
5583                   strtab_size = 0;
5584                 }
5585               else if (strtab_sec
5586                        != (sec = section_headers + symtab_sec->sh_link))
5587                 {
5588                   strtab_sec = sec;
5589                   if (strtab)
5590                     free (strtab);
5591                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5592                                               1, strtab_sec->sh_size,
5593                                               _("string table"));
5594                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5595                 }
5596               group_name = sym->st_name < strtab_size
5597                 ? strtab + sym->st_name : _("<corrupt>");
5598             }
5599
5600           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5601                                               1, section->sh_size,
5602                                               _("section data"));
5603           if (start == NULL)
5604             continue;
5605
5606           indices = start;
5607           size = (section->sh_size / section->sh_entsize) - 1;
5608           entry = byte_get (indices, 4);
5609           indices += 4;
5610
5611           if (do_section_groups)
5612             {
5613               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5614                       get_group_flags (entry), i, name, group_name, size);
5615
5616               printf (_("   [Index]    Name\n"));
5617             }
5618
5619           group->group_index = i;
5620
5621           for (j = 0; j < size; j++)
5622             {
5623               struct group_list * g;
5624
5625               entry = byte_get (indices, 4);
5626               indices += 4;
5627
5628               if (entry >= elf_header.e_shnum)
5629                 {
5630                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5631                          entry, i, elf_header.e_shnum - 1);
5632                   continue;
5633                 }
5634
5635               if (section_headers_groups [entry] != NULL)
5636                 {
5637                   if (entry)
5638                     {
5639                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5640                              entry, i,
5641                              section_headers_groups [entry]->group_index);
5642                       continue;
5643                     }
5644                   else
5645                     {
5646                       /* Intel C/C++ compiler may put section 0 in a
5647                          section group. We just warn it the first time
5648                          and ignore it afterwards.  */
5649                       static int warned = 0;
5650                       if (!warned)
5651                         {
5652                           error (_("section 0 in group section [%5u]\n"),
5653                                  section_headers_groups [entry]->group_index);
5654                           warned++;
5655                         }
5656                     }
5657                 }
5658
5659               section_headers_groups [entry] = group;
5660
5661               if (do_section_groups)
5662                 {
5663                   sec = section_headers + entry;
5664                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5665                 }
5666
5667               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5668               g->section_index = entry;
5669               g->next = group->root;
5670               group->root = g;
5671             }
5672
5673           if (start)
5674             free (start);
5675
5676           group++;
5677         }
5678     }
5679
5680   if (symtab)
5681     free (symtab);
5682   if (strtab)
5683     free (strtab);
5684   return 1;
5685 }
5686
5687 /* Data used to display dynamic fixups.  */
5688
5689 struct ia64_vms_dynfixup
5690 {
5691   bfd_vma needed_ident;         /* Library ident number.  */
5692   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5693   bfd_vma fixup_needed;         /* Index of the library.  */
5694   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5695   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5696 };
5697
5698 /* Data used to display dynamic relocations.  */
5699
5700 struct ia64_vms_dynimgrela
5701 {
5702   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5703   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5704 };
5705
5706 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5707    library).  */
5708
5709 static void
5710 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5711                               const char *strtab, unsigned int strtab_sz)
5712 {
5713   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5714   long i;
5715   const char *lib_name;
5716
5717   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5718                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5719                    _("dynamic section image fixups"));
5720   if (!imfs)
5721     return;
5722
5723   if (fixup->needed < strtab_sz)
5724     lib_name = strtab + fixup->needed;
5725   else
5726     {
5727       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5728             (unsigned long) fixup->needed);
5729       lib_name = "???";
5730     }
5731   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5732           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5733   printf
5734     (_("Seg Offset           Type                             SymVec DataType\n"));
5735
5736   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5737     {
5738       unsigned int type;
5739       const char *rtype;
5740
5741       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5742       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5743       type = BYTE_GET (imfs [i].type);
5744       rtype = elf_ia64_reloc_type (type);
5745       if (rtype == NULL)
5746         printf (" 0x%08x                       ", type);
5747       else
5748         printf (" %-32s ", rtype);
5749       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5750       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5751     }
5752
5753   free (imfs);
5754 }
5755
5756 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5757
5758 static void
5759 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5760 {
5761   Elf64_External_VMS_IMAGE_RELA *imrs;
5762   long i;
5763
5764   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5765                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5766                    _("dynamic section image relocations"));
5767   if (!imrs)
5768     return;
5769
5770   printf (_("\nImage relocs\n"));
5771   printf
5772     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5773
5774   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5775     {
5776       unsigned int type;
5777       const char *rtype;
5778
5779       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5780       printf ("%08" BFD_VMA_FMT "x ",
5781               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5782       type = BYTE_GET (imrs [i].type);
5783       rtype = elf_ia64_reloc_type (type);
5784       if (rtype == NULL)
5785         printf ("0x%08x                      ", type);
5786       else
5787         printf ("%-31s ", rtype);
5788       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5789       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5790       printf ("%08" BFD_VMA_FMT "x\n",
5791               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5792     }
5793
5794   free (imrs);
5795 }
5796
5797 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5798
5799 static int
5800 process_ia64_vms_dynamic_relocs (FILE *file)
5801 {
5802   struct ia64_vms_dynfixup fixup;
5803   struct ia64_vms_dynimgrela imgrela;
5804   Elf_Internal_Dyn *entry;
5805   int res = 0;
5806   bfd_vma strtab_off = 0;
5807   bfd_vma strtab_sz = 0;
5808   char *strtab = NULL;
5809
5810   memset (&fixup, 0, sizeof (fixup));
5811   memset (&imgrela, 0, sizeof (imgrela));
5812
5813   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5814   for (entry = dynamic_section;
5815        entry < dynamic_section + dynamic_nent;
5816        entry++)
5817     {
5818       switch (entry->d_tag)
5819         {
5820         case DT_IA_64_VMS_STRTAB_OFFSET:
5821           strtab_off = entry->d_un.d_val;
5822           break;
5823         case DT_STRSZ:
5824           strtab_sz = entry->d_un.d_val;
5825           if (strtab == NULL)
5826             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5827                                1, strtab_sz, _("dynamic string section"));
5828           break;
5829
5830         case DT_IA_64_VMS_NEEDED_IDENT:
5831           fixup.needed_ident = entry->d_un.d_val;
5832           break;
5833         case DT_NEEDED:
5834           fixup.needed = entry->d_un.d_val;
5835           break;
5836         case DT_IA_64_VMS_FIXUP_NEEDED:
5837           fixup.fixup_needed = entry->d_un.d_val;
5838           break;
5839         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5840           fixup.fixup_rela_cnt = entry->d_un.d_val;
5841           break;
5842         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5843           fixup.fixup_rela_off = entry->d_un.d_val;
5844           res++;
5845           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5846           break;
5847
5848         case DT_IA_64_VMS_IMG_RELA_CNT:
5849           imgrela.img_rela_cnt = entry->d_un.d_val;
5850           break;
5851         case DT_IA_64_VMS_IMG_RELA_OFF:
5852           imgrela.img_rela_off = entry->d_un.d_val;
5853           res++;
5854           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5855           break;
5856
5857         default:
5858           break;
5859         }
5860     }
5861
5862   if (strtab != NULL)
5863     free (strtab);
5864
5865   return res;
5866 }
5867
5868 static struct
5869 {
5870   const char * name;
5871   int reloc;
5872   int size;
5873   int rela;
5874 } dynamic_relocations [] =
5875 {
5876     { "REL", DT_REL, DT_RELSZ, FALSE },
5877     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5878     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5879 };
5880
5881 /* Process the reloc section.  */
5882
5883 static int
5884 process_relocs (FILE * file)
5885 {
5886   unsigned long rel_size;
5887   unsigned long rel_offset;
5888
5889
5890   if (!do_reloc)
5891     return 1;
5892
5893   if (do_using_dynamic)
5894     {
5895       int is_rela;
5896       const char * name;
5897       int has_dynamic_reloc;
5898       unsigned int i;
5899
5900       has_dynamic_reloc = 0;
5901
5902       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5903         {
5904           is_rela = dynamic_relocations [i].rela;
5905           name = dynamic_relocations [i].name;
5906           rel_size = dynamic_info [dynamic_relocations [i].size];
5907           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5908
5909           has_dynamic_reloc |= rel_size;
5910
5911           if (is_rela == UNKNOWN)
5912             {
5913               if (dynamic_relocations [i].reloc == DT_JMPREL)
5914                 switch (dynamic_info[DT_PLTREL])
5915                   {
5916                   case DT_REL:
5917                     is_rela = FALSE;
5918                     break;
5919                   case DT_RELA:
5920                     is_rela = TRUE;
5921                     break;
5922                   }
5923             }
5924
5925           if (rel_size)
5926             {
5927               printf
5928                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5929                  name, rel_offset, rel_size);
5930
5931               dump_relocations (file,
5932                                 offset_from_vma (file, rel_offset, rel_size),
5933                                 rel_size,
5934                                 dynamic_symbols, num_dynamic_syms,
5935                                 dynamic_strings, dynamic_strings_length, is_rela);
5936             }
5937         }
5938
5939       if (is_ia64_vms ())
5940         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5941
5942       if (! has_dynamic_reloc)
5943         printf (_("\nThere are no dynamic relocations in this file.\n"));
5944     }
5945   else
5946     {
5947       Elf_Internal_Shdr * section;
5948       unsigned long i;
5949       int found = 0;
5950
5951       for (i = 0, section = section_headers;
5952            i < elf_header.e_shnum;
5953            i++, section++)
5954         {
5955           if (   section->sh_type != SHT_RELA
5956               && section->sh_type != SHT_REL)
5957             continue;
5958
5959           rel_offset = section->sh_offset;
5960           rel_size   = section->sh_size;
5961
5962           if (rel_size)
5963             {
5964               Elf_Internal_Shdr * strsec;
5965               int is_rela;
5966
5967               printf (_("\nRelocation section "));
5968
5969               if (string_table == NULL)
5970                 printf ("%d", section->sh_name);
5971               else
5972                 printf ("'%s'", SECTION_NAME (section));
5973
5974               printf (_(" at offset 0x%lx contains %lu entries:\n"),
5975                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5976
5977               is_rela = section->sh_type == SHT_RELA;
5978
5979               if (section->sh_link != 0
5980                   && section->sh_link < elf_header.e_shnum)
5981                 {
5982                   Elf_Internal_Shdr * symsec;
5983                   Elf_Internal_Sym *  symtab;
5984                   unsigned long nsyms;
5985                   unsigned long strtablen = 0;
5986                   char * strtab = NULL;
5987
5988                   symsec = section_headers + section->sh_link;
5989                   if (symsec->sh_type != SHT_SYMTAB
5990                       && symsec->sh_type != SHT_DYNSYM)
5991                     continue;
5992
5993                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5994
5995                   if (symtab == NULL)
5996                     continue;
5997
5998                   if (symsec->sh_link != 0
5999                       && symsec->sh_link < elf_header.e_shnum)
6000                     {
6001                       strsec = section_headers + symsec->sh_link;
6002
6003                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6004                                                   1, strsec->sh_size,
6005                                                   _("string table"));
6006                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6007                     }
6008
6009                   dump_relocations (file, rel_offset, rel_size,
6010                                     symtab, nsyms, strtab, strtablen, is_rela);
6011                   if (strtab)
6012                     free (strtab);
6013                   free (symtab);
6014                 }
6015               else
6016                 dump_relocations (file, rel_offset, rel_size,
6017                                   NULL, 0, NULL, 0, is_rela);
6018
6019               found = 1;
6020             }
6021         }
6022
6023       if (! found)
6024         printf (_("\nThere are no relocations in this file.\n"));
6025     }
6026
6027   return 1;
6028 }
6029
6030 /* Process the unwind section.  */
6031
6032 #include "unwind-ia64.h"
6033
6034 /* An absolute address consists of a section and an offset.  If the
6035    section is NULL, the offset itself is the address, otherwise, the
6036    address equals to LOAD_ADDRESS(section) + offset.  */
6037
6038 struct absaddr
6039   {
6040     unsigned short section;
6041     bfd_vma offset;
6042   };
6043
6044 #define ABSADDR(a) \
6045   ((a).section \
6046    ? section_headers [(a).section].sh_addr + (a).offset \
6047    : (a).offset)
6048
6049 struct ia64_unw_table_entry
6050   {
6051     struct absaddr start;
6052     struct absaddr end;
6053     struct absaddr info;
6054   };
6055
6056 struct ia64_unw_aux_info
6057   {
6058
6059     struct ia64_unw_table_entry *table; /* Unwind table.  */
6060     unsigned long table_len;    /* Length of unwind table.  */
6061     unsigned char * info;       /* Unwind info.  */
6062     unsigned long info_size;    /* Size of unwind info.  */
6063     bfd_vma info_addr;          /* starting address of unwind info.  */
6064     bfd_vma seg_base;           /* Starting address of segment.  */
6065     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6066     unsigned long nsyms;        /* Number of symbols.  */
6067     char * strtab;              /* The string table.  */
6068     unsigned long strtab_size;  /* Size of string table.  */
6069   };
6070
6071 static void
6072 find_symbol_for_address (Elf_Internal_Sym * symtab,
6073                          unsigned long nsyms,
6074                          const char * strtab,
6075                          unsigned long strtab_size,
6076                          struct absaddr addr,
6077                          const char ** symname,
6078                          bfd_vma * offset)
6079 {
6080   bfd_vma dist = 0x100000;
6081   Elf_Internal_Sym * sym;
6082   Elf_Internal_Sym * best = NULL;
6083   unsigned long i;
6084
6085   REMOVE_ARCH_BITS (addr.offset);
6086
6087   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6088     {
6089       bfd_vma value = sym->st_value;
6090
6091       REMOVE_ARCH_BITS (value);
6092
6093       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6094           && sym->st_name != 0
6095           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6096           && addr.offset >= value
6097           && addr.offset - value < dist)
6098         {
6099           best = sym;
6100           dist = addr.offset - value;
6101           if (!dist)
6102             break;
6103         }
6104     }
6105
6106   if (best)
6107     {
6108       *symname = (best->st_name >= strtab_size
6109                   ? _("<corrupt>") : strtab + best->st_name);
6110       *offset = dist;
6111       return;
6112     }
6113
6114   *symname = NULL;
6115   *offset = addr.offset;
6116 }
6117
6118 static void
6119 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6120 {
6121   struct ia64_unw_table_entry * tp;
6122   int in_body;
6123
6124   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6125     {
6126       bfd_vma stamp;
6127       bfd_vma offset;
6128       const unsigned char * dp;
6129       const unsigned char * head;
6130       const char * procname;
6131
6132       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6133                                aux->strtab_size, tp->start, &procname, &offset);
6134
6135       fputs ("\n<", stdout);
6136
6137       if (procname)
6138         {
6139           fputs (procname, stdout);
6140
6141           if (offset)
6142             printf ("+%lx", (unsigned long) offset);
6143         }
6144
6145       fputs (">: [", stdout);
6146       print_vma (tp->start.offset, PREFIX_HEX);
6147       fputc ('-', stdout);
6148       print_vma (tp->end.offset, PREFIX_HEX);
6149       printf ("], info at +0x%lx\n",
6150               (unsigned long) (tp->info.offset - aux->seg_base));
6151
6152       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6153       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6154
6155       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6156               (unsigned) UNW_VER (stamp),
6157               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6158               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6159               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6160               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6161
6162       if (UNW_VER (stamp) != 1)
6163         {
6164           printf (_("\tUnknown version.\n"));
6165           continue;
6166         }
6167
6168       in_body = 0;
6169       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
6170         dp = unw_decode (dp, in_body, & in_body);
6171     }
6172 }
6173
6174 static int
6175 slurp_ia64_unwind_table (FILE * file,
6176                          struct ia64_unw_aux_info * aux,
6177                          Elf_Internal_Shdr * sec)
6178 {
6179   unsigned long size, nrelas, i;
6180   Elf_Internal_Phdr * seg;
6181   struct ia64_unw_table_entry * tep;
6182   Elf_Internal_Shdr * relsec;
6183   Elf_Internal_Rela * rela;
6184   Elf_Internal_Rela * rp;
6185   unsigned char * table;
6186   unsigned char * tp;
6187   Elf_Internal_Sym * sym;
6188   const char * relname;
6189
6190   /* First, find the starting address of the segment that includes
6191      this section: */
6192
6193   if (elf_header.e_phnum)
6194     {
6195       if (! get_program_headers (file))
6196           return 0;
6197
6198       for (seg = program_headers;
6199            seg < program_headers + elf_header.e_phnum;
6200            ++seg)
6201         {
6202           if (seg->p_type != PT_LOAD)
6203             continue;
6204
6205           if (sec->sh_addr >= seg->p_vaddr
6206               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6207             {
6208               aux->seg_base = seg->p_vaddr;
6209               break;
6210             }
6211         }
6212     }
6213
6214   /* Second, build the unwind table from the contents of the unwind section:  */
6215   size = sec->sh_size;
6216   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6217                                       _("unwind table"));
6218   if (!table)
6219     return 0;
6220
6221   aux->table = (struct ia64_unw_table_entry *)
6222       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
6223   tep = aux->table;
6224   for (tp = table; tp < table + size; ++tep)
6225     {
6226       tep->start.section = SHN_UNDEF;
6227       tep->end.section   = SHN_UNDEF;
6228       tep->info.section  = SHN_UNDEF;
6229       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6230       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6231       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6232       tep->start.offset += aux->seg_base;
6233       tep->end.offset   += aux->seg_base;
6234       tep->info.offset  += aux->seg_base;
6235     }
6236   free (table);
6237
6238   /* Third, apply any relocations to the unwind table:  */
6239   for (relsec = section_headers;
6240        relsec < section_headers + elf_header.e_shnum;
6241        ++relsec)
6242     {
6243       if (relsec->sh_type != SHT_RELA
6244           || relsec->sh_info >= elf_header.e_shnum
6245           || section_headers + relsec->sh_info != sec)
6246         continue;
6247
6248       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6249                               & rela, & nrelas))
6250         return 0;
6251
6252       for (rp = rela; rp < rela + nrelas; ++rp)
6253         {
6254           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6255           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6256
6257           if (! const_strneq (relname, "R_IA64_SEGREL"))
6258             {
6259               warn (_("Skipping unexpected relocation type %s\n"), relname);
6260               continue;
6261             }
6262
6263           i = rp->r_offset / (3 * eh_addr_size);
6264
6265           switch (rp->r_offset/eh_addr_size % 3)
6266             {
6267             case 0:
6268               aux->table[i].start.section = sym->st_shndx;
6269               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6270               break;
6271             case 1:
6272               aux->table[i].end.section   = sym->st_shndx;
6273               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6274               break;
6275             case 2:
6276               aux->table[i].info.section  = sym->st_shndx;
6277               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6278               break;
6279             default:
6280               break;
6281             }
6282         }
6283
6284       free (rela);
6285     }
6286
6287   aux->table_len = size / (3 * eh_addr_size);
6288   return 1;
6289 }
6290
6291 static void
6292 ia64_process_unwind (FILE * file)
6293 {
6294   Elf_Internal_Shdr * sec;
6295   Elf_Internal_Shdr * unwsec = NULL;
6296   Elf_Internal_Shdr * strsec;
6297   unsigned long i, unwcount = 0, unwstart = 0;
6298   struct ia64_unw_aux_info aux;
6299
6300   memset (& aux, 0, sizeof (aux));
6301
6302   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6303     {
6304       if (sec->sh_type == SHT_SYMTAB
6305           && sec->sh_link < elf_header.e_shnum)
6306         {
6307           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6308
6309           strsec = section_headers + sec->sh_link;
6310           assert (aux.strtab == NULL);
6311           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6312                                           1, strsec->sh_size,
6313                                           _("string table"));
6314           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6315         }
6316       else if (sec->sh_type == SHT_IA_64_UNWIND)
6317         unwcount++;
6318     }
6319
6320   if (!unwcount)
6321     printf (_("\nThere are no unwind sections in this file.\n"));
6322
6323   while (unwcount-- > 0)
6324     {
6325       char * suffix;
6326       size_t len, len2;
6327
6328       for (i = unwstart, sec = section_headers + unwstart;
6329            i < elf_header.e_shnum; ++i, ++sec)
6330         if (sec->sh_type == SHT_IA_64_UNWIND)
6331           {
6332             unwsec = sec;
6333             break;
6334           }
6335
6336       unwstart = i + 1;
6337       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6338
6339       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6340         {
6341           /* We need to find which section group it is in.  */
6342           struct group_list * g = section_headers_groups [i]->root;
6343
6344           for (; g != NULL; g = g->next)
6345             {
6346               sec = section_headers + g->section_index;
6347
6348               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6349                 break;
6350             }
6351
6352           if (g == NULL)
6353             i = elf_header.e_shnum;
6354         }
6355       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6356         {
6357           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6358           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6359           suffix = SECTION_NAME (unwsec) + len;
6360           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6361                ++i, ++sec)
6362             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6363                 && streq (SECTION_NAME (sec) + len2, suffix))
6364               break;
6365         }
6366       else
6367         {
6368           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6369              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6370           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6371           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6372           suffix = "";
6373           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6374             suffix = SECTION_NAME (unwsec) + len;
6375           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6376                ++i, ++sec)
6377             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6378                 && streq (SECTION_NAME (sec) + len2, suffix))
6379               break;
6380         }
6381
6382       if (i == elf_header.e_shnum)
6383         {
6384           printf (_("\nCould not find unwind info section for "));
6385
6386           if (string_table == NULL)
6387             printf ("%d", unwsec->sh_name);
6388           else
6389             printf (_("'%s'"), SECTION_NAME (unwsec));
6390         }
6391       else
6392         {
6393           aux.info_addr = sec->sh_addr;
6394           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6395                                                  sec->sh_size,
6396                                                  _("unwind info"));
6397           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6398
6399           printf (_("\nUnwind section "));
6400
6401           if (string_table == NULL)
6402             printf ("%d", unwsec->sh_name);
6403           else
6404             printf (_("'%s'"), SECTION_NAME (unwsec));
6405
6406           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6407                   (unsigned long) unwsec->sh_offset,
6408                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6409
6410           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6411
6412           if (aux.table_len > 0)
6413             dump_ia64_unwind (& aux);
6414
6415           if (aux.table)
6416             free ((char *) aux.table);
6417           if (aux.info)
6418             free ((char *) aux.info);
6419           aux.table = NULL;
6420           aux.info = NULL;
6421         }
6422     }
6423
6424   if (aux.symtab)
6425     free (aux.symtab);
6426   if (aux.strtab)
6427     free ((char *) aux.strtab);
6428 }
6429
6430 struct hppa_unw_table_entry
6431   {
6432     struct absaddr start;
6433     struct absaddr end;
6434     unsigned int Cannot_unwind:1;                       /* 0 */
6435     unsigned int Millicode:1;                   /* 1 */
6436     unsigned int Millicode_save_sr0:1;          /* 2 */
6437     unsigned int Region_description:2;          /* 3..4 */
6438     unsigned int reserved1:1;                   /* 5 */
6439     unsigned int Entry_SR:1;                    /* 6 */
6440     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6441     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6442     unsigned int Args_stored:1;                 /* 16 */
6443     unsigned int Variable_Frame:1;                      /* 17 */
6444     unsigned int Separate_Package_Body:1;               /* 18 */
6445     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6446     unsigned int Stack_Overflow_Check:1;                /* 20 */
6447     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6448     unsigned int Ada_Region:1;                  /* 22 */
6449     unsigned int cxx_info:1;                    /* 23 */
6450     unsigned int cxx_try_catch:1;                       /* 24 */
6451     unsigned int sched_entry_seq:1;                     /* 25 */
6452     unsigned int reserved2:1;                   /* 26 */
6453     unsigned int Save_SP:1;                             /* 27 */
6454     unsigned int Save_RP:1;                             /* 28 */
6455     unsigned int Save_MRP_in_frame:1;           /* 29 */
6456     unsigned int extn_ptr_defined:1;            /* 30 */
6457     unsigned int Cleanup_defined:1;                     /* 31 */
6458
6459     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6460     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6461     unsigned int Large_frame:1;                 /* 2 */
6462     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6463     unsigned int reserved4:1;                   /* 4 */
6464     unsigned int Total_frame_size:27;           /* 5..31 */
6465   };
6466
6467 struct hppa_unw_aux_info
6468   {
6469     struct hppa_unw_table_entry *table; /* Unwind table.  */
6470     unsigned long table_len;    /* Length of unwind table.  */
6471     bfd_vma seg_base;           /* Starting address of segment.  */
6472     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6473     unsigned long nsyms;        /* Number of symbols.  */
6474     char * strtab;              /* The string table.  */
6475     unsigned long strtab_size;  /* Size of string table.  */
6476   };
6477
6478 static void
6479 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6480 {
6481   struct hppa_unw_table_entry * tp;
6482
6483   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6484     {
6485       bfd_vma offset;
6486       const char * procname;
6487
6488       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6489                                aux->strtab_size, tp->start, &procname,
6490                                &offset);
6491
6492       fputs ("\n<", stdout);
6493
6494       if (procname)
6495         {
6496           fputs (procname, stdout);
6497
6498           if (offset)
6499             printf ("+%lx", (unsigned long) offset);
6500         }
6501
6502       fputs (">: [", stdout);
6503       print_vma (tp->start.offset, PREFIX_HEX);
6504       fputc ('-', stdout);
6505       print_vma (tp->end.offset, PREFIX_HEX);
6506       printf ("]\n\t");
6507
6508 #define PF(_m) if (tp->_m) printf (#_m " ");
6509 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6510       PF(Cannot_unwind);
6511       PF(Millicode);
6512       PF(Millicode_save_sr0);
6513       /* PV(Region_description);  */
6514       PF(Entry_SR);
6515       PV(Entry_FR);
6516       PV(Entry_GR);
6517       PF(Args_stored);
6518       PF(Variable_Frame);
6519       PF(Separate_Package_Body);
6520       PF(Frame_Extension_Millicode);
6521       PF(Stack_Overflow_Check);
6522       PF(Two_Instruction_SP_Increment);
6523       PF(Ada_Region);
6524       PF(cxx_info);
6525       PF(cxx_try_catch);
6526       PF(sched_entry_seq);
6527       PF(Save_SP);
6528       PF(Save_RP);
6529       PF(Save_MRP_in_frame);
6530       PF(extn_ptr_defined);
6531       PF(Cleanup_defined);
6532       PF(MPE_XL_interrupt_marker);
6533       PF(HP_UX_interrupt_marker);
6534       PF(Large_frame);
6535       PF(Pseudo_SP_Set);
6536       PV(Total_frame_size);
6537 #undef PF
6538 #undef PV
6539     }
6540
6541   printf ("\n");
6542 }
6543
6544 static int
6545 slurp_hppa_unwind_table (FILE * file,
6546                          struct hppa_unw_aux_info * aux,
6547                          Elf_Internal_Shdr * sec)
6548 {
6549   unsigned long size, unw_ent_size, nentries, nrelas, i;
6550   Elf_Internal_Phdr * seg;
6551   struct hppa_unw_table_entry * tep;
6552   Elf_Internal_Shdr * relsec;
6553   Elf_Internal_Rela * rela;
6554   Elf_Internal_Rela * rp;
6555   unsigned char * table;
6556   unsigned char * tp;
6557   Elf_Internal_Sym * sym;
6558   const char * relname;
6559
6560   /* First, find the starting address of the segment that includes
6561      this section.  */
6562
6563   if (elf_header.e_phnum)
6564     {
6565       if (! get_program_headers (file))
6566         return 0;
6567
6568       for (seg = program_headers;
6569            seg < program_headers + elf_header.e_phnum;
6570            ++seg)
6571         {
6572           if (seg->p_type != PT_LOAD)
6573             continue;
6574
6575           if (sec->sh_addr >= seg->p_vaddr
6576               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6577             {
6578               aux->seg_base = seg->p_vaddr;
6579               break;
6580             }
6581         }
6582     }
6583
6584   /* Second, build the unwind table from the contents of the unwind
6585      section.  */
6586   size = sec->sh_size;
6587   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6588                                       _("unwind table"));
6589   if (!table)
6590     return 0;
6591
6592   unw_ent_size = 16;
6593   nentries = size / unw_ent_size;
6594   size = unw_ent_size * nentries;
6595
6596   tep = aux->table = (struct hppa_unw_table_entry *)
6597       xcmalloc (nentries, sizeof (aux->table[0]));
6598
6599   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6600     {
6601       unsigned int tmp1, tmp2;
6602
6603       tep->start.section = SHN_UNDEF;
6604       tep->end.section   = SHN_UNDEF;
6605
6606       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6607       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6608       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6609       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6610
6611       tep->start.offset += aux->seg_base;
6612       tep->end.offset   += aux->seg_base;
6613
6614       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6615       tep->Millicode = (tmp1 >> 30) & 0x1;
6616       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6617       tep->Region_description = (tmp1 >> 27) & 0x3;
6618       tep->reserved1 = (tmp1 >> 26) & 0x1;
6619       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6620       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6621       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6622       tep->Args_stored = (tmp1 >> 15) & 0x1;
6623       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6624       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6625       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6626       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6627       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6628       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6629       tep->cxx_info = (tmp1 >> 8) & 0x1;
6630       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6631       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6632       tep->reserved2 = (tmp1 >> 5) & 0x1;
6633       tep->Save_SP = (tmp1 >> 4) & 0x1;
6634       tep->Save_RP = (tmp1 >> 3) & 0x1;
6635       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6636       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6637       tep->Cleanup_defined = tmp1 & 0x1;
6638
6639       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6640       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6641       tep->Large_frame = (tmp2 >> 29) & 0x1;
6642       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6643       tep->reserved4 = (tmp2 >> 27) & 0x1;
6644       tep->Total_frame_size = tmp2 & 0x7ffffff;
6645     }
6646   free (table);
6647
6648   /* Third, apply any relocations to the unwind table.  */
6649   for (relsec = section_headers;
6650        relsec < section_headers + elf_header.e_shnum;
6651        ++relsec)
6652     {
6653       if (relsec->sh_type != SHT_RELA
6654           || relsec->sh_info >= elf_header.e_shnum
6655           || section_headers + relsec->sh_info != sec)
6656         continue;
6657
6658       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6659                               & rela, & nrelas))
6660         return 0;
6661
6662       for (rp = rela; rp < rela + nrelas; ++rp)
6663         {
6664           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6665           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6666
6667           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6668           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6669             {
6670               warn (_("Skipping unexpected relocation type %s\n"), relname);
6671               continue;
6672             }
6673
6674           i = rp->r_offset / unw_ent_size;
6675
6676           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6677             {
6678             case 0:
6679               aux->table[i].start.section = sym->st_shndx;
6680               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6681               break;
6682             case 1:
6683               aux->table[i].end.section   = sym->st_shndx;
6684               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6685               break;
6686             default:
6687               break;
6688             }
6689         }
6690
6691       free (rela);
6692     }
6693
6694   aux->table_len = nentries;
6695
6696   return 1;
6697 }
6698
6699 static void
6700 hppa_process_unwind (FILE * file)
6701 {
6702   struct hppa_unw_aux_info aux;
6703   Elf_Internal_Shdr * unwsec = NULL;
6704   Elf_Internal_Shdr * strsec;
6705   Elf_Internal_Shdr * sec;
6706   unsigned long i;
6707
6708   if (string_table == NULL)
6709     return;
6710
6711   memset (& aux, 0, sizeof (aux));
6712
6713   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6714     {
6715       if (sec->sh_type == SHT_SYMTAB
6716           && sec->sh_link < elf_header.e_shnum)
6717         {
6718           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6719
6720           strsec = section_headers + sec->sh_link;
6721           assert (aux.strtab == NULL);
6722           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6723                                           1, strsec->sh_size,
6724                                           _("string table"));
6725           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6726         }
6727       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6728         unwsec = sec;
6729     }
6730
6731   if (!unwsec)
6732     printf (_("\nThere are no unwind sections in this file.\n"));
6733
6734   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6735     {
6736       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6737         {
6738           printf (_("\nUnwind section "));
6739           printf (_("'%s'"), SECTION_NAME (sec));
6740
6741           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6742                   (unsigned long) sec->sh_offset,
6743                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6744
6745           slurp_hppa_unwind_table (file, &aux, sec);
6746           if (aux.table_len > 0)
6747             dump_hppa_unwind (&aux);
6748
6749           if (aux.table)
6750             free ((char *) aux.table);
6751           aux.table = NULL;
6752         }
6753     }
6754
6755   if (aux.symtab)
6756     free (aux.symtab);
6757   if (aux.strtab)
6758     free ((char *) aux.strtab);
6759 }
6760
6761 struct arm_section
6762 {
6763   unsigned char *      data;            /* The unwind data.  */
6764   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6765   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6766   unsigned long        nrelas;          /* The number of relocations.  */
6767   unsigned int         rel_type;        /* REL or RELA ?  */
6768   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6769 };
6770
6771 struct arm_unw_aux_info
6772 {
6773   FILE *              file;             /* The file containing the unwind sections.  */
6774   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6775   unsigned long       nsyms;            /* Number of symbols.  */
6776   char *              strtab;           /* The file's string table.  */
6777   unsigned long       strtab_size;      /* Size of string table.  */
6778 };
6779
6780 static const char *
6781 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6782                         bfd_vma fn, struct absaddr addr)
6783 {
6784   const char *procname;
6785   bfd_vma sym_offset;
6786
6787   if (addr.section == SHN_UNDEF)
6788     addr.offset = fn;
6789
6790   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6791                            aux->strtab_size, addr, &procname,
6792                            &sym_offset);
6793
6794   print_vma (fn, PREFIX_HEX);
6795
6796   if (procname)
6797     {
6798       fputs (" <", stdout);
6799       fputs (procname, stdout);
6800
6801       if (sym_offset)
6802         printf ("+0x%lx", (unsigned long) sym_offset);
6803       fputc ('>', stdout);
6804     }
6805
6806   return procname;
6807 }
6808
6809 static void
6810 arm_free_section (struct arm_section *arm_sec)
6811 {
6812   if (arm_sec->data != NULL)
6813     free (arm_sec->data);
6814
6815   if (arm_sec->rela != NULL)
6816     free (arm_sec->rela);
6817 }
6818
6819 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6820       cached section and install SEC instead.
6821    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6822       and return its valued in * WORDP, relocating if necessary.
6823    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6824       relocation's offset in ADDR.
6825    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6826       into the string table of the symbol associated with the reloc.  If no
6827       reloc was applied store -1 there.
6828    5) Return TRUE upon success, FALSE otherwise.  */
6829
6830 static bfd_boolean
6831 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6832                          struct arm_section *       arm_sec,
6833                          Elf_Internal_Shdr *        sec,
6834                          bfd_vma                    word_offset,
6835                          unsigned int *             wordp,
6836                          struct absaddr *           addr,
6837                          bfd_vma *                  sym_name)
6838 {
6839   Elf_Internal_Rela *rp;
6840   Elf_Internal_Sym *sym;
6841   const char * relname;
6842   unsigned int word;
6843   bfd_boolean wrapped;
6844
6845   addr->section = SHN_UNDEF;
6846   addr->offset = 0;
6847
6848   if (sym_name != NULL)
6849     *sym_name = (bfd_vma) -1;
6850
6851   /* If necessary, update the section cache.  */
6852   if (sec != arm_sec->sec)
6853     {
6854       Elf_Internal_Shdr *relsec;
6855
6856       arm_free_section (arm_sec);
6857
6858       arm_sec->sec = sec;
6859       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6860                                 sec->sh_size, _("unwind data"));
6861       arm_sec->rela = NULL;
6862       arm_sec->nrelas = 0;
6863
6864       for (relsec = section_headers;
6865            relsec < section_headers + elf_header.e_shnum;
6866            ++relsec)
6867         {
6868           if (relsec->sh_info >= elf_header.e_shnum
6869               || section_headers + relsec->sh_info != sec
6870               /* PR 15745: Check the section type as well.  */
6871               || (relsec->sh_type != SHT_REL
6872                   && relsec->sh_type != SHT_RELA))
6873             continue;
6874
6875           arm_sec->rel_type = relsec->sh_type;
6876           if (relsec->sh_type == SHT_REL)
6877             {
6878               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6879                                      relsec->sh_size,
6880                                      & arm_sec->rela, & arm_sec->nrelas))
6881                 return FALSE;
6882             }
6883           else /* relsec->sh_type == SHT_RELA */
6884             {
6885               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6886                                       relsec->sh_size,
6887                                       & arm_sec->rela, & arm_sec->nrelas))
6888                 return FALSE;
6889             }
6890           break;
6891         }
6892
6893       arm_sec->next_rela = arm_sec->rela;
6894     }
6895
6896   /* If there is no unwind data we can do nothing.  */
6897   if (arm_sec->data == NULL)
6898     return FALSE;
6899
6900   /* Get the word at the required offset.  */
6901   word = byte_get (arm_sec->data + word_offset, 4);
6902
6903   /* Look through the relocs to find the one that applies to the provided offset.  */
6904   wrapped = FALSE;
6905   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6906     {
6907       bfd_vma prelval, offset;
6908
6909       if (rp->r_offset > word_offset && !wrapped)
6910         {
6911           rp = arm_sec->rela;
6912           wrapped = TRUE;
6913         }
6914       if (rp->r_offset > word_offset)
6915         break;
6916
6917       if (rp->r_offset & 3)
6918         {
6919           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6920                 (unsigned long) rp->r_offset);
6921           continue;
6922         }
6923
6924       if (rp->r_offset < word_offset)
6925         continue;
6926
6927       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6928
6929       if (arm_sec->rel_type == SHT_REL)
6930         {
6931           offset = word & 0x7fffffff;
6932           if (offset & 0x40000000)
6933             offset |= ~ (bfd_vma) 0x7fffffff;
6934         }
6935       else if (arm_sec->rel_type == SHT_RELA)
6936         offset = rp->r_addend;
6937       else
6938         abort ();
6939
6940       offset += sym->st_value;
6941       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6942
6943       /* Check that we are processing the expected reloc type.  */
6944       if (elf_header.e_machine == EM_ARM)
6945         {
6946           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6947
6948           if (streq (relname, "R_ARM_NONE"))
6949               continue;
6950
6951           if (! streq (relname, "R_ARM_PREL31"))
6952             {
6953               warn (_("Skipping unexpected relocation type %s\n"), relname);
6954               continue;
6955             }
6956         }
6957       else if (elf_header.e_machine == EM_TI_C6000)
6958         {
6959           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6960
6961           if (streq (relname, "R_C6000_NONE"))
6962             continue;
6963
6964           if (! streq (relname, "R_C6000_PREL31"))
6965             {
6966               warn (_("Skipping unexpected relocation type %s\n"), relname);
6967               continue;
6968             }
6969
6970           prelval >>= 1;
6971         }
6972       else
6973         /* This function currently only supports ARM and TI unwinders.  */
6974         abort ();
6975
6976       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6977       addr->section = sym->st_shndx;
6978       addr->offset = offset;
6979       if (sym_name)
6980         * sym_name = sym->st_name;
6981       break;
6982     }
6983
6984   *wordp = word;
6985   arm_sec->next_rela = rp;
6986
6987   return TRUE;
6988 }
6989
6990 static const char *tic6x_unwind_regnames[16] =
6991 {
6992   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6993   "A14", "A13", "A12", "A11", "A10",
6994   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6995 };
6996
6997 static void
6998 decode_tic6x_unwind_regmask (unsigned int mask)
6999 {
7000   int i;
7001
7002   for (i = 12; mask; mask >>= 1, i--)
7003     {
7004       if (mask & 1)
7005         {
7006           fputs (tic6x_unwind_regnames[i], stdout);
7007           if (mask > 1)
7008             fputs (", ", stdout);
7009         }
7010     }
7011 }
7012
7013 #define ADVANCE                                                 \
7014   if (remaining == 0 && more_words)                             \
7015     {                                                           \
7016       data_offset += 4;                                         \
7017       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7018                                      data_offset, & word, & addr, NULL))        \
7019         return;                                                 \
7020       remaining = 4;                                            \
7021       more_words--;                                             \
7022     }                                                           \
7023
7024 #define GET_OP(OP)                      \
7025   ADVANCE;                              \
7026   if (remaining)                        \
7027     {                                   \
7028       remaining--;                      \
7029       (OP) = word >> 24;                \
7030       word <<= 8;                       \
7031     }                                   \
7032   else                                  \
7033     {                                   \
7034       printf (_("[Truncated opcode]\n"));       \
7035       return;                           \
7036     }                                   \
7037   printf ("0x%02x ", OP)
7038
7039 static void
7040 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7041                             unsigned int word, unsigned int remaining,
7042                             unsigned int more_words,
7043                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7044                             struct arm_section *data_arm_sec)
7045 {
7046   struct absaddr addr;
7047
7048   /* Decode the unwinding instructions.  */
7049   while (1)
7050     {
7051       unsigned int op, op2;
7052
7053       ADVANCE;
7054       if (remaining == 0)
7055         break;
7056       remaining--;
7057       op = word >> 24;
7058       word <<= 8;
7059
7060       printf ("  0x%02x ", op);
7061
7062       if ((op & 0xc0) == 0x00)
7063         {
7064           int offset = ((op & 0x3f) << 2) + 4;
7065
7066           printf ("     vsp = vsp + %d", offset);
7067         }
7068       else if ((op & 0xc0) == 0x40)
7069         {
7070           int offset = ((op & 0x3f) << 2) + 4;
7071
7072           printf ("     vsp = vsp - %d", offset);
7073         }
7074       else if ((op & 0xf0) == 0x80)
7075         {
7076           GET_OP (op2);
7077           if (op == 0x80 && op2 == 0)
7078             printf (_("Refuse to unwind"));
7079           else
7080             {
7081               unsigned int mask = ((op & 0x0f) << 8) | op2;
7082               int first = 1;
7083               int i;
7084
7085               printf ("pop {");
7086               for (i = 0; i < 12; i++)
7087                 if (mask & (1 << i))
7088                   {
7089                     if (first)
7090                       first = 0;
7091                     else
7092                       printf (", ");
7093                     printf ("r%d", 4 + i);
7094                   }
7095               printf ("}");
7096             }
7097         }
7098       else if ((op & 0xf0) == 0x90)
7099         {
7100           if (op == 0x9d || op == 0x9f)
7101             printf (_("     [Reserved]"));
7102           else
7103             printf ("     vsp = r%d", op & 0x0f);
7104         }
7105       else if ((op & 0xf0) == 0xa0)
7106         {
7107           int end = 4 + (op & 0x07);
7108           int first = 1;
7109           int i;
7110
7111           printf ("     pop {");
7112           for (i = 4; i <= end; i++)
7113             {
7114               if (first)
7115                 first = 0;
7116               else
7117                 printf (", ");
7118               printf ("r%d", i);
7119             }
7120           if (op & 0x08)
7121             {
7122               if (!first)
7123                 printf (", ");
7124               printf ("r14");
7125             }
7126           printf ("}");
7127         }
7128       else if (op == 0xb0)
7129         printf (_("     finish"));
7130       else if (op == 0xb1)
7131         {
7132           GET_OP (op2);
7133           if (op2 == 0 || (op2 & 0xf0) != 0)
7134             printf (_("[Spare]"));
7135           else
7136             {
7137               unsigned int mask = op2 & 0x0f;
7138               int first = 1;
7139               int i;
7140
7141               printf ("pop {");
7142               for (i = 0; i < 12; i++)
7143                 if (mask & (1 << i))
7144                   {
7145                     if (first)
7146                       first = 0;
7147                     else
7148                       printf (", ");
7149                     printf ("r%d", i);
7150                   }
7151               printf ("}");
7152             }
7153         }
7154       else if (op == 0xb2)
7155         {
7156           unsigned char buf[9];
7157           unsigned int i, len;
7158           unsigned long offset;
7159
7160           for (i = 0; i < sizeof (buf); i++)
7161             {
7162               GET_OP (buf[i]);
7163               if ((buf[i] & 0x80) == 0)
7164                 break;
7165             }
7166           assert (i < sizeof (buf));
7167           offset = read_uleb128 (buf, &len, buf + i + 1);
7168           assert (len == i + 1);
7169           offset = offset * 4 + 0x204;
7170           printf ("vsp = vsp + %ld", offset);
7171         }
7172       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7173         {
7174           unsigned int first, last;
7175
7176           GET_OP (op2);
7177           first = op2 >> 4;
7178           last = op2 & 0x0f;
7179           if (op == 0xc8)
7180             first = first + 16;
7181           printf ("pop {D%d", first);
7182           if (last)
7183             printf ("-D%d", first + last);
7184           printf ("}");
7185         }
7186       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7187         {
7188           unsigned int count = op & 0x07;
7189
7190           printf ("pop {D8");
7191           if (count)
7192             printf ("-D%d", 8 + count);
7193           printf ("}");
7194         }
7195       else if (op >= 0xc0 && op <= 0xc5)
7196         {
7197           unsigned int count = op & 0x07;
7198
7199           printf ("     pop {wR10");
7200           if (count)
7201             printf ("-wR%d", 10 + count);
7202           printf ("}");
7203         }
7204       else if (op == 0xc6)
7205         {
7206           unsigned int first, last;
7207
7208           GET_OP (op2);
7209           first = op2 >> 4;
7210           last = op2 & 0x0f;
7211           printf ("pop {wR%d", first);
7212           if (last)
7213             printf ("-wR%d", first + last);
7214           printf ("}");
7215         }
7216       else if (op == 0xc7)
7217         {
7218           GET_OP (op2);
7219           if (op2 == 0 || (op2 & 0xf0) != 0)
7220             printf (_("[Spare]"));
7221           else
7222             {
7223               unsigned int mask = op2 & 0x0f;
7224               int first = 1;
7225               int i;
7226
7227               printf ("pop {");
7228               for (i = 0; i < 4; i++)
7229                 if (mask & (1 << i))
7230                   {
7231                     if (first)
7232                       first = 0;
7233                     else
7234                       printf (", ");
7235                     printf ("wCGR%d", i);
7236                   }
7237               printf ("}");
7238             }
7239         }
7240       else
7241         printf (_("     [unsupported opcode]"));
7242       printf ("\n");
7243     }
7244 }
7245
7246 static void
7247 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7248                             unsigned int word, unsigned int remaining,
7249                             unsigned int more_words,
7250                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7251                             struct arm_section *data_arm_sec)
7252 {
7253   struct absaddr addr;
7254
7255   /* Decode the unwinding instructions.  */
7256   while (1)
7257     {
7258       unsigned int op, op2;
7259
7260       ADVANCE;
7261       if (remaining == 0)
7262         break;
7263       remaining--;
7264       op = word >> 24;
7265       word <<= 8;
7266
7267       printf ("  0x%02x ", op);
7268
7269       if ((op & 0xc0) == 0x00)
7270         {
7271           int offset = ((op & 0x3f) << 3) + 8;
7272           printf ("     sp = sp + %d", offset);
7273         }
7274       else if ((op & 0xc0) == 0x80)
7275         {
7276           GET_OP (op2);
7277           if (op == 0x80 && op2 == 0)
7278             printf (_("Refuse to unwind"));
7279           else
7280             {
7281               unsigned int mask = ((op & 0x1f) << 8) | op2;
7282               if (op & 0x20)
7283                 printf ("pop compact {");
7284               else
7285                 printf ("pop {");
7286
7287               decode_tic6x_unwind_regmask (mask);
7288               printf("}");
7289             }
7290         }
7291       else if ((op & 0xf0) == 0xc0)
7292         {
7293           unsigned int reg;
7294           unsigned int nregs;
7295           unsigned int i;
7296           const char *name;
7297           struct
7298           {
7299               unsigned int offset;
7300               unsigned int reg;
7301           } regpos[16];
7302
7303           /* Scan entire instruction first so that GET_OP output is not
7304              interleaved with disassembly.  */
7305           nregs = 0;
7306           for (i = 0; nregs < (op & 0xf); i++)
7307             {
7308               GET_OP (op2);
7309               reg = op2 >> 4;
7310               if (reg != 0xf)
7311                 {
7312                   regpos[nregs].offset = i * 2;
7313                   regpos[nregs].reg = reg;
7314                   nregs++;
7315                 }
7316
7317               reg = op2 & 0xf;
7318               if (reg != 0xf)
7319                 {
7320                   regpos[nregs].offset = i * 2 + 1;
7321                   regpos[nregs].reg = reg;
7322                   nregs++;
7323                 }
7324             }
7325
7326           printf (_("pop frame {"));
7327           reg = nregs - 1;
7328           for (i = i * 2; i > 0; i--)
7329             {
7330               if (regpos[reg].offset == i - 1)
7331                 {
7332                   name = tic6x_unwind_regnames[regpos[reg].reg];
7333                   if (reg > 0)
7334                     reg--;
7335                 }
7336               else
7337                 name = _("[pad]");
7338
7339               fputs (name, stdout);
7340               if (i > 1)
7341                 printf (", ");
7342             }
7343
7344           printf ("}");
7345         }
7346       else if (op == 0xd0)
7347         printf ("     MOV FP, SP");
7348       else if (op == 0xd1)
7349         printf ("     __c6xabi_pop_rts");
7350       else if (op == 0xd2)
7351         {
7352           unsigned char buf[9];
7353           unsigned int i, len;
7354           unsigned long offset;
7355
7356           for (i = 0; i < sizeof (buf); i++)
7357             {
7358               GET_OP (buf[i]);
7359               if ((buf[i] & 0x80) == 0)
7360                 break;
7361             }
7362           assert (i < sizeof (buf));
7363           offset = read_uleb128 (buf, &len, buf + i + 1);
7364           assert (len == i + 1);
7365           offset = offset * 8 + 0x408;
7366           printf (_("sp = sp + %ld"), offset);
7367         }
7368       else if ((op & 0xf0) == 0xe0)
7369         {
7370           if ((op & 0x0f) == 7)
7371             printf ("     RETURN");
7372           else
7373             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7374         }
7375       else
7376         {
7377           printf (_("     [unsupported opcode]"));
7378         }
7379       putchar ('\n');
7380     }
7381 }
7382
7383 static bfd_vma
7384 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7385 {
7386   bfd_vma offset;
7387
7388   offset = word & 0x7fffffff;
7389   if (offset & 0x40000000)
7390     offset |= ~ (bfd_vma) 0x7fffffff;
7391
7392   if (elf_header.e_machine == EM_TI_C6000)
7393     offset <<= 1;
7394
7395   return offset + where;
7396 }
7397
7398 static void
7399 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7400                    unsigned int               word,
7401                    unsigned int               remaining,
7402                    bfd_vma                    data_offset,
7403                    Elf_Internal_Shdr *        data_sec,
7404                    struct arm_section *       data_arm_sec)
7405 {
7406   int per_index;
7407   unsigned int more_words = 0;
7408   struct absaddr addr;
7409   bfd_vma sym_name = (bfd_vma) -1;
7410
7411   if (remaining == 0)
7412     {
7413       /* Fetch the first word.
7414          Note - when decoding an object file the address extracted
7415          here will always be 0.  So we also pass in the sym_name
7416          parameter so that we can find the symbol associated with
7417          the personality routine.  */
7418       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7419                                      & word, & addr, & sym_name))
7420         return;
7421
7422       remaining = 4;
7423     }
7424
7425   if ((word & 0x80000000) == 0)
7426     {
7427       /* Expand prel31 for personality routine.  */
7428       bfd_vma fn;
7429       const char *procname;
7430
7431       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7432       printf (_("  Personality routine: "));
7433       if (fn == 0
7434           && addr.section == SHN_UNDEF && addr.offset == 0
7435           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7436         {
7437           procname = aux->strtab + sym_name;
7438           print_vma (fn, PREFIX_HEX);
7439           if (procname)
7440             {
7441               fputs (" <", stdout);
7442               fputs (procname, stdout);
7443               fputc ('>', stdout);
7444             }
7445         }
7446       else
7447         procname = arm_print_vma_and_name (aux, fn, addr);
7448       fputc ('\n', stdout);
7449
7450       /* The GCC personality routines use the standard compact
7451          encoding, starting with one byte giving the number of
7452          words.  */
7453       if (procname != NULL
7454           && (const_strneq (procname, "__gcc_personality_v0")
7455               || const_strneq (procname, "__gxx_personality_v0")
7456               || const_strneq (procname, "__gcj_personality_v0")
7457               || const_strneq (procname, "__gnu_objc_personality_v0")))
7458         {
7459           remaining = 0;
7460           more_words = 1;
7461           ADVANCE;
7462           if (!remaining)
7463             {
7464               printf (_("  [Truncated data]\n"));
7465               return;
7466             }
7467           more_words = word >> 24;
7468           word <<= 8;
7469           remaining--;
7470           per_index = -1;
7471         }
7472       else
7473         return;
7474     }
7475   else
7476     {
7477       /* ARM EHABI Section 6.3:
7478
7479          An exception-handling table entry for the compact model looks like:
7480
7481            31 30-28 27-24 23-0
7482            -- ----- ----- ----
7483             1   0   index Data for personalityRoutine[index]    */
7484
7485       if (elf_header.e_machine == EM_ARM
7486           && (word & 0x70000000))
7487         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7488
7489       per_index = (word >> 24) & 0x7f;
7490       printf (_("  Compact model index: %d\n"), per_index);
7491       if (per_index == 0)
7492         {
7493           more_words = 0;
7494           word <<= 8;
7495           remaining--;
7496         }
7497       else if (per_index < 3)
7498         {
7499           more_words = (word >> 16) & 0xff;
7500           word <<= 16;
7501           remaining -= 2;
7502         }
7503     }
7504
7505   switch (elf_header.e_machine)
7506     {
7507     case EM_ARM:
7508       if (per_index < 3)
7509         {
7510           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7511                                       data_offset, data_sec, data_arm_sec);
7512         }
7513       else
7514         {
7515           warn (_("Unknown ARM compact model index encountered\n"));
7516           printf (_("  [reserved]\n"));
7517         }
7518       break;
7519
7520     case EM_TI_C6000:
7521       if (per_index < 3)
7522         {
7523           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7524                                         data_offset, data_sec, data_arm_sec);
7525         }
7526       else if (per_index < 5)
7527         {
7528           if (((word >> 17) & 0x7f) == 0x7f)
7529             printf (_("  Restore stack from frame pointer\n"));
7530           else
7531             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7532           printf (_("  Registers restored: "));
7533           if (per_index == 4)
7534             printf (" (compact) ");
7535           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7536           putchar ('\n');
7537           printf (_("  Return register: %s\n"),
7538                   tic6x_unwind_regnames[word & 0xf]);
7539         }
7540       else
7541         printf (_("  [reserved (%d)]\n"), per_index);
7542       break;
7543
7544     default:
7545       error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7546              elf_header.e_machine);
7547     }
7548
7549   /* Decode the descriptors.  Not implemented.  */
7550 }
7551
7552 static void
7553 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7554 {
7555   struct arm_section exidx_arm_sec, extab_arm_sec;
7556   unsigned int i, exidx_len;
7557
7558   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7559   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7560   exidx_len = exidx_sec->sh_size / 8;
7561
7562   for (i = 0; i < exidx_len; i++)
7563     {
7564       unsigned int exidx_fn, exidx_entry;
7565       struct absaddr fn_addr, entry_addr;
7566       bfd_vma fn;
7567
7568       fputc ('\n', stdout);
7569
7570       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7571                                      8 * i, & exidx_fn, & fn_addr, NULL)
7572           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7573                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7574         {
7575           arm_free_section (& exidx_arm_sec);
7576           arm_free_section (& extab_arm_sec);
7577           return;
7578         }
7579
7580       /* ARM EHABI, Section 5:
7581          An index table entry consists of 2 words.
7582          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7583       if (exidx_fn & 0x80000000)
7584         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7585
7586       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7587
7588       arm_print_vma_and_name (aux, fn, fn_addr);
7589       fputs (": ", stdout);
7590
7591       if (exidx_entry == 1)
7592         {
7593           print_vma (exidx_entry, PREFIX_HEX);
7594           fputs (" [cantunwind]\n", stdout);
7595         }
7596       else if (exidx_entry & 0x80000000)
7597         {
7598           print_vma (exidx_entry, PREFIX_HEX);
7599           fputc ('\n', stdout);
7600           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7601         }
7602       else
7603         {
7604           bfd_vma table, table_offset = 0;
7605           Elf_Internal_Shdr *table_sec;
7606
7607           fputs ("@", stdout);
7608           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7609           print_vma (table, PREFIX_HEX);
7610           printf ("\n");
7611
7612           /* Locate the matching .ARM.extab.  */
7613           if (entry_addr.section != SHN_UNDEF
7614               && entry_addr.section < elf_header.e_shnum)
7615             {
7616               table_sec = section_headers + entry_addr.section;
7617               table_offset = entry_addr.offset;
7618             }
7619           else
7620             {
7621               table_sec = find_section_by_address (table);
7622               if (table_sec != NULL)
7623                 table_offset = table - table_sec->sh_addr;
7624             }
7625           if (table_sec == NULL)
7626             {
7627               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7628                     (unsigned long) table);
7629               continue;
7630             }
7631           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7632                              &extab_arm_sec);
7633         }
7634     }
7635
7636   printf ("\n");
7637
7638   arm_free_section (&exidx_arm_sec);
7639   arm_free_section (&extab_arm_sec);
7640 }
7641
7642 /* Used for both ARM and C6X unwinding tables.  */
7643
7644 static void
7645 arm_process_unwind (FILE *file)
7646 {
7647   struct arm_unw_aux_info aux;
7648   Elf_Internal_Shdr *unwsec = NULL;
7649   Elf_Internal_Shdr *strsec;
7650   Elf_Internal_Shdr *sec;
7651   unsigned long i;
7652   unsigned int sec_type;
7653
7654   switch (elf_header.e_machine)
7655     {
7656     case EM_ARM:
7657       sec_type = SHT_ARM_EXIDX;
7658       break;
7659
7660     case EM_TI_C6000:
7661       sec_type = SHT_C6000_UNWIND;
7662       break;
7663
7664     default:
7665       error (_("Unsupported architecture type %d encountered when processing unwind table"),
7666              elf_header.e_machine);
7667       return;
7668     }
7669
7670   if (string_table == NULL)
7671     return;
7672
7673   memset (& aux, 0, sizeof (aux));
7674   aux.file = file;
7675
7676   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7677     {
7678       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7679         {
7680           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7681
7682           strsec = section_headers + sec->sh_link;
7683           assert (aux.strtab == NULL);
7684           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7685                                  1, strsec->sh_size, _("string table"));
7686           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7687         }
7688       else if (sec->sh_type == sec_type)
7689         unwsec = sec;
7690     }
7691
7692   if (unwsec == NULL)
7693     printf (_("\nThere are no unwind sections in this file.\n"));
7694   else
7695     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7696       {
7697         if (sec->sh_type == sec_type)
7698           {
7699             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7700                     SECTION_NAME (sec),
7701                     (unsigned long) sec->sh_offset,
7702                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7703
7704             dump_arm_unwind (&aux, sec);
7705           }
7706       }
7707
7708   if (aux.symtab)
7709     free (aux.symtab);
7710   if (aux.strtab)
7711     free ((char *) aux.strtab);
7712 }
7713
7714 static void
7715 process_unwind (FILE * file)
7716 {
7717   struct unwind_handler
7718   {
7719     int machtype;
7720     void (* handler)(FILE *);
7721   } handlers[] =
7722   {
7723     { EM_ARM, arm_process_unwind },
7724     { EM_IA_64, ia64_process_unwind },
7725     { EM_PARISC, hppa_process_unwind },
7726     { EM_TI_C6000, arm_process_unwind },
7727     { 0, 0 }
7728   };
7729   int i;
7730
7731   if (!do_unwind)
7732     return;
7733
7734   for (i = 0; handlers[i].handler != NULL; i++)
7735     if (elf_header.e_machine == handlers[i].machtype)
7736       {
7737         handlers[i].handler (file);
7738         return;
7739       }
7740
7741   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7742           get_machine_name (elf_header.e_machine));
7743 }
7744
7745 static void
7746 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7747 {
7748   switch (entry->d_tag)
7749     {
7750     case DT_MIPS_FLAGS:
7751       if (entry->d_un.d_val == 0)
7752         printf (_("NONE"));
7753       else
7754         {
7755           static const char * opts[] =
7756           {
7757             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7758             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7759             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7760             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7761             "RLD_ORDER_SAFE"
7762           };
7763           unsigned int cnt;
7764           int first = 1;
7765
7766           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7767             if (entry->d_un.d_val & (1 << cnt))
7768               {
7769                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7770                 first = 0;
7771               }
7772         }
7773       break;
7774
7775     case DT_MIPS_IVERSION:
7776       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7777         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7778       else
7779         printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7780       break;
7781
7782     case DT_MIPS_TIME_STAMP:
7783       {
7784         char timebuf[20];
7785         struct tm * tmp;
7786
7787         time_t atime = entry->d_un.d_val;
7788         tmp = gmtime (&atime);
7789         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7790                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7791                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7792         printf (_("Time Stamp: %s"), timebuf);
7793       }
7794       break;
7795
7796     case DT_MIPS_RLD_VERSION:
7797     case DT_MIPS_LOCAL_GOTNO:
7798     case DT_MIPS_CONFLICTNO:
7799     case DT_MIPS_LIBLISTNO:
7800     case DT_MIPS_SYMTABNO:
7801     case DT_MIPS_UNREFEXTNO:
7802     case DT_MIPS_HIPAGENO:
7803     case DT_MIPS_DELTA_CLASS_NO:
7804     case DT_MIPS_DELTA_INSTANCE_NO:
7805     case DT_MIPS_DELTA_RELOC_NO:
7806     case DT_MIPS_DELTA_SYM_NO:
7807     case DT_MIPS_DELTA_CLASSSYM_NO:
7808     case DT_MIPS_COMPACT_SIZE:
7809       print_vma (entry->d_un.d_ptr, DEC);
7810       break;
7811
7812     default:
7813       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7814     }
7815     putchar ('\n');
7816 }
7817
7818 static void
7819 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7820 {
7821   switch (entry->d_tag)
7822     {
7823     case DT_HP_DLD_FLAGS:
7824       {
7825         static struct
7826         {
7827           long int bit;
7828           const char * str;
7829         }
7830         flags[] =
7831         {
7832           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7833           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7834           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7835           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7836           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7837           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7838           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7839           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7840           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7841           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7842           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7843           { DT_HP_GST, "HP_GST" },
7844           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7845           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7846           { DT_HP_NODELETE, "HP_NODELETE" },
7847           { DT_HP_GROUP, "HP_GROUP" },
7848           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7849         };
7850         int first = 1;
7851         size_t cnt;
7852         bfd_vma val = entry->d_un.d_val;
7853
7854         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7855           if (val & flags[cnt].bit)
7856             {
7857               if (! first)
7858                 putchar (' ');
7859               fputs (flags[cnt].str, stdout);
7860               first = 0;
7861               val ^= flags[cnt].bit;
7862             }
7863
7864         if (val != 0 || first)
7865           {
7866             if (! first)
7867               putchar (' ');
7868             print_vma (val, HEX);
7869           }
7870       }
7871       break;
7872
7873     default:
7874       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7875       break;
7876     }
7877   putchar ('\n');
7878 }
7879
7880 #ifdef BFD64
7881
7882 /* VMS vs Unix time offset and factor.  */
7883
7884 #define VMS_EPOCH_OFFSET 35067168000000000LL
7885 #define VMS_GRANULARITY_FACTOR 10000000
7886
7887 /* Display a VMS time in a human readable format.  */
7888
7889 static void
7890 print_vms_time (bfd_int64_t vmstime)
7891 {
7892   struct tm *tm;
7893   time_t unxtime;
7894
7895   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7896   tm = gmtime (&unxtime);
7897   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7898           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7899           tm->tm_hour, tm->tm_min, tm->tm_sec);
7900 }
7901 #endif /* BFD64 */
7902
7903 static void
7904 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7905 {
7906   switch (entry->d_tag)
7907     {
7908     case DT_IA_64_PLT_RESERVE:
7909       /* First 3 slots reserved.  */
7910       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7911       printf (" -- ");
7912       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7913       break;
7914
7915     case DT_IA_64_VMS_LINKTIME:
7916 #ifdef BFD64
7917       print_vms_time (entry->d_un.d_val);
7918 #endif
7919       break;
7920
7921     case DT_IA_64_VMS_LNKFLAGS:
7922       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7923       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7924         printf (" CALL_DEBUG");
7925       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7926         printf (" NOP0BUFS");
7927       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7928         printf (" P0IMAGE");
7929       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7930         printf (" MKTHREADS");
7931       if (entry->d_un.d_val & VMS_LF_UPCALLS)
7932         printf (" UPCALLS");
7933       if (entry->d_un.d_val & VMS_LF_IMGSTA)
7934         printf (" IMGSTA");
7935       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7936         printf (" INITIALIZE");
7937       if (entry->d_un.d_val & VMS_LF_MAIN)
7938         printf (" MAIN");
7939       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7940         printf (" EXE_INIT");
7941       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7942         printf (" TBK_IN_IMG");
7943       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7944         printf (" DBG_IN_IMG");
7945       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7946         printf (" TBK_IN_DSF");
7947       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7948         printf (" DBG_IN_DSF");
7949       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7950         printf (" SIGNATURES");
7951       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7952         printf (" REL_SEG_OFF");
7953       break;
7954
7955     default:
7956       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7957       break;
7958     }
7959   putchar ('\n');
7960 }
7961
7962 static int
7963 get_32bit_dynamic_section (FILE * file)
7964 {
7965   Elf32_External_Dyn * edyn;
7966   Elf32_External_Dyn * ext;
7967   Elf_Internal_Dyn * entry;
7968
7969   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7970                                           dynamic_size, _("dynamic section"));
7971   if (!edyn)
7972     return 0;
7973
7974 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7975    might not have the luxury of section headers.  Look for the DT_NULL
7976    terminator to determine the number of entries.  */
7977   for (ext = edyn, dynamic_nent = 0;
7978        (char *) ext < (char *) edyn + dynamic_size;
7979        ext++)
7980     {
7981       dynamic_nent++;
7982       if (BYTE_GET (ext->d_tag) == DT_NULL)
7983         break;
7984     }
7985
7986   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7987                                                   sizeof (* entry));
7988   if (dynamic_section == NULL)
7989     {
7990       error (_("Out of memory\n"));
7991       free (edyn);
7992       return 0;
7993     }
7994
7995   for (ext = edyn, entry = dynamic_section;
7996        entry < dynamic_section + dynamic_nent;
7997        ext++, entry++)
7998     {
7999       entry->d_tag      = BYTE_GET (ext->d_tag);
8000       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8001     }
8002
8003   free (edyn);
8004
8005   return 1;
8006 }
8007
8008 static int
8009 get_64bit_dynamic_section (FILE * file)
8010 {
8011   Elf64_External_Dyn * edyn;
8012   Elf64_External_Dyn * ext;
8013   Elf_Internal_Dyn * entry;
8014
8015   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8016                                           dynamic_size, _("dynamic section"));
8017   if (!edyn)
8018     return 0;
8019
8020 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8021    might not have the luxury of section headers.  Look for the DT_NULL
8022    terminator to determine the number of entries.  */
8023   for (ext = edyn, dynamic_nent = 0;
8024        (char *) ext < (char *) edyn + dynamic_size;
8025        ext++)
8026     {
8027       dynamic_nent++;
8028       if (BYTE_GET (ext->d_tag) == DT_NULL)
8029         break;
8030     }
8031
8032   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8033                                                   sizeof (* entry));
8034   if (dynamic_section == NULL)
8035     {
8036       error (_("Out of memory\n"));
8037       free (edyn);
8038       return 0;
8039     }
8040
8041   for (ext = edyn, entry = dynamic_section;
8042        entry < dynamic_section + dynamic_nent;
8043        ext++, entry++)
8044     {
8045       entry->d_tag      = BYTE_GET (ext->d_tag);
8046       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8047     }
8048
8049   free (edyn);
8050
8051   return 1;
8052 }
8053
8054 static void
8055 print_dynamic_flags (bfd_vma flags)
8056 {
8057   int first = 1;
8058
8059   while (flags)
8060     {
8061       bfd_vma flag;
8062
8063       flag = flags & - flags;
8064       flags &= ~ flag;
8065
8066       if (first)
8067         first = 0;
8068       else
8069         putc (' ', stdout);
8070
8071       switch (flag)
8072         {
8073         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8074         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8075         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8076         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8077         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8078         default:                fputs (_("unknown"), stdout); break;
8079         }
8080     }
8081   puts ("");
8082 }
8083
8084 /* Parse and display the contents of the dynamic section.  */
8085
8086 static int
8087 process_dynamic_section (FILE * file)
8088 {
8089   Elf_Internal_Dyn * entry;
8090
8091   if (dynamic_size == 0)
8092     {
8093       if (do_dynamic)
8094         printf (_("\nThere is no dynamic section in this file.\n"));
8095
8096       return 1;
8097     }
8098
8099   if (is_32bit_elf)
8100     {
8101       if (! get_32bit_dynamic_section (file))
8102         return 0;
8103     }
8104   else if (! get_64bit_dynamic_section (file))
8105     return 0;
8106
8107   /* Find the appropriate symbol table.  */
8108   if (dynamic_symbols == NULL)
8109     {
8110       for (entry = dynamic_section;
8111            entry < dynamic_section + dynamic_nent;
8112            ++entry)
8113         {
8114           Elf_Internal_Shdr section;
8115
8116           if (entry->d_tag != DT_SYMTAB)
8117             continue;
8118
8119           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8120
8121           /* Since we do not know how big the symbol table is,
8122              we default to reading in the entire file (!) and
8123              processing that.  This is overkill, I know, but it
8124              should work.  */
8125           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8126
8127           if (archive_file_offset != 0)
8128             section.sh_size = archive_file_size - section.sh_offset;
8129           else
8130             {
8131               if (fseek (file, 0, SEEK_END))
8132                 error (_("Unable to seek to end of file!\n"));
8133
8134               section.sh_size = ftell (file) - section.sh_offset;
8135             }
8136
8137           if (is_32bit_elf)
8138             section.sh_entsize = sizeof (Elf32_External_Sym);
8139           else
8140             section.sh_entsize = sizeof (Elf64_External_Sym);
8141
8142           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8143           if (num_dynamic_syms < 1)
8144             {
8145               error (_("Unable to determine the number of symbols to load\n"));
8146               continue;
8147             }
8148         }
8149     }
8150
8151   /* Similarly find a string table.  */
8152   if (dynamic_strings == NULL)
8153     {
8154       for (entry = dynamic_section;
8155            entry < dynamic_section + dynamic_nent;
8156            ++entry)
8157         {
8158           unsigned long offset;
8159           long str_tab_len;
8160
8161           if (entry->d_tag != DT_STRTAB)
8162             continue;
8163
8164           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8165
8166           /* Since we do not know how big the string table is,
8167              we default to reading in the entire file (!) and
8168              processing that.  This is overkill, I know, but it
8169              should work.  */
8170
8171           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8172
8173           if (archive_file_offset != 0)
8174             str_tab_len = archive_file_size - offset;
8175           else
8176             {
8177               if (fseek (file, 0, SEEK_END))
8178                 error (_("Unable to seek to end of file\n"));
8179               str_tab_len = ftell (file) - offset;
8180             }
8181
8182           if (str_tab_len < 1)
8183             {
8184               error
8185                 (_("Unable to determine the length of the dynamic string table\n"));
8186               continue;
8187             }
8188
8189           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8190                                                str_tab_len,
8191                                                _("dynamic string table"));
8192           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8193           break;
8194         }
8195     }
8196
8197   /* And find the syminfo section if available.  */
8198   if (dynamic_syminfo == NULL)
8199     {
8200       unsigned long syminsz = 0;
8201
8202       for (entry = dynamic_section;
8203            entry < dynamic_section + dynamic_nent;
8204            ++entry)
8205         {
8206           if (entry->d_tag == DT_SYMINENT)
8207             {
8208               /* Note: these braces are necessary to avoid a syntax
8209                  error from the SunOS4 C compiler.  */
8210               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
8211             }
8212           else if (entry->d_tag == DT_SYMINSZ)
8213             syminsz = entry->d_un.d_val;
8214           else if (entry->d_tag == DT_SYMINFO)
8215             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8216                                                       syminsz);
8217         }
8218
8219       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8220         {
8221           Elf_External_Syminfo * extsyminfo;
8222           Elf_External_Syminfo * extsym;
8223           Elf_Internal_Syminfo * syminfo;
8224
8225           /* There is a syminfo section.  Read the data.  */
8226           extsyminfo = (Elf_External_Syminfo *)
8227               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8228                         _("symbol information"));
8229           if (!extsyminfo)
8230             return 0;
8231
8232           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8233           if (dynamic_syminfo == NULL)
8234             {
8235               error (_("Out of memory\n"));
8236               return 0;
8237             }
8238
8239           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8240           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8241                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8242                ++syminfo, ++extsym)
8243             {
8244               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8245               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8246             }
8247
8248           free (extsyminfo);
8249         }
8250     }
8251
8252   if (do_dynamic && dynamic_addr)
8253     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8254             dynamic_addr, dynamic_nent);
8255   if (do_dynamic)
8256     printf (_("  Tag        Type                         Name/Value\n"));
8257
8258   for (entry = dynamic_section;
8259        entry < dynamic_section + dynamic_nent;
8260        entry++)
8261     {
8262       if (do_dynamic)
8263         {
8264           const char * dtype;
8265
8266           putchar (' ');
8267           print_vma (entry->d_tag, FULL_HEX);
8268           dtype = get_dynamic_type (entry->d_tag);
8269           printf (" (%s)%*s", dtype,
8270                   ((is_32bit_elf ? 27 : 19)
8271                    - (int) strlen (dtype)),
8272                   " ");
8273         }
8274
8275       switch (entry->d_tag)
8276         {
8277         case DT_FLAGS:
8278           if (do_dynamic)
8279             print_dynamic_flags (entry->d_un.d_val);
8280           break;
8281
8282         case DT_AUXILIARY:
8283         case DT_FILTER:
8284         case DT_CONFIG:
8285         case DT_DEPAUDIT:
8286         case DT_AUDIT:
8287           if (do_dynamic)
8288             {
8289               switch (entry->d_tag)
8290                 {
8291                 case DT_AUXILIARY:
8292                   printf (_("Auxiliary library"));
8293                   break;
8294
8295                 case DT_FILTER:
8296                   printf (_("Filter library"));
8297                   break;
8298
8299                 case DT_CONFIG:
8300                   printf (_("Configuration file"));
8301                   break;
8302
8303                 case DT_DEPAUDIT:
8304                   printf (_("Dependency audit library"));
8305                   break;
8306
8307                 case DT_AUDIT:
8308                   printf (_("Audit library"));
8309                   break;
8310                 }
8311
8312               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8313                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8314               else
8315                 {
8316                   printf (": ");
8317                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8318                   putchar ('\n');
8319                 }
8320             }
8321           break;
8322
8323         case DT_FEATURE:
8324           if (do_dynamic)
8325             {
8326               printf (_("Flags:"));
8327
8328               if (entry->d_un.d_val == 0)
8329                 printf (_(" None\n"));
8330               else
8331                 {
8332                   unsigned long int val = entry->d_un.d_val;
8333
8334                   if (val & DTF_1_PARINIT)
8335                     {
8336                       printf (" PARINIT");
8337                       val ^= DTF_1_PARINIT;
8338                     }
8339                   if (val & DTF_1_CONFEXP)
8340                     {
8341                       printf (" CONFEXP");
8342                       val ^= DTF_1_CONFEXP;
8343                     }
8344                   if (val != 0)
8345                     printf (" %lx", val);
8346                   puts ("");
8347                 }
8348             }
8349           break;
8350
8351         case DT_POSFLAG_1:
8352           if (do_dynamic)
8353             {
8354               printf (_("Flags:"));
8355
8356               if (entry->d_un.d_val == 0)
8357                 printf (_(" None\n"));
8358               else
8359                 {
8360                   unsigned long int val = entry->d_un.d_val;
8361
8362                   if (val & DF_P1_LAZYLOAD)
8363                     {
8364                       printf (" LAZYLOAD");
8365                       val ^= DF_P1_LAZYLOAD;
8366                     }
8367                   if (val & DF_P1_GROUPPERM)
8368                     {
8369                       printf (" GROUPPERM");
8370                       val ^= DF_P1_GROUPPERM;
8371                     }
8372                   if (val != 0)
8373                     printf (" %lx", val);
8374                   puts ("");
8375                 }
8376             }
8377           break;
8378
8379         case DT_FLAGS_1:
8380           if (do_dynamic)
8381             {
8382               printf (_("Flags:"));
8383               if (entry->d_un.d_val == 0)
8384                 printf (_(" None\n"));
8385               else
8386                 {
8387                   unsigned long int val = entry->d_un.d_val;
8388
8389                   if (val & DF_1_NOW)
8390                     {
8391                       printf (" NOW");
8392                       val ^= DF_1_NOW;
8393                     }
8394                   if (val & DF_1_GLOBAL)
8395                     {
8396                       printf (" GLOBAL");
8397                       val ^= DF_1_GLOBAL;
8398                     }
8399                   if (val & DF_1_GROUP)
8400                     {
8401                       printf (" GROUP");
8402                       val ^= DF_1_GROUP;
8403                     }
8404                   if (val & DF_1_NODELETE)
8405                     {
8406                       printf (" NODELETE");
8407                       val ^= DF_1_NODELETE;
8408                     }
8409                   if (val & DF_1_LOADFLTR)
8410                     {
8411                       printf (" LOADFLTR");
8412                       val ^= DF_1_LOADFLTR;
8413                     }
8414                   if (val & DF_1_INITFIRST)
8415                     {
8416                       printf (" INITFIRST");
8417                       val ^= DF_1_INITFIRST;
8418                     }
8419                   if (val & DF_1_NOOPEN)
8420                     {
8421                       printf (" NOOPEN");
8422                       val ^= DF_1_NOOPEN;
8423                     }
8424                   if (val & DF_1_ORIGIN)
8425                     {
8426                       printf (" ORIGIN");
8427                       val ^= DF_1_ORIGIN;
8428                     }
8429                   if (val & DF_1_DIRECT)
8430                     {
8431                       printf (" DIRECT");
8432                       val ^= DF_1_DIRECT;
8433                     }
8434                   if (val & DF_1_TRANS)
8435                     {
8436                       printf (" TRANS");
8437                       val ^= DF_1_TRANS;
8438                     }
8439                   if (val & DF_1_INTERPOSE)
8440                     {
8441                       printf (" INTERPOSE");
8442                       val ^= DF_1_INTERPOSE;
8443                     }
8444                   if (val & DF_1_NODEFLIB)
8445                     {
8446                       printf (" NODEFLIB");
8447                       val ^= DF_1_NODEFLIB;
8448                     }
8449                   if (val & DF_1_NODUMP)
8450                     {
8451                       printf (" NODUMP");
8452                       val ^= DF_1_NODUMP;
8453                     }
8454                   if (val & DF_1_CONFALT)
8455                     {
8456                       printf (" CONFALT");
8457                       val ^= DF_1_CONFALT;
8458                     }
8459                   if (val & DF_1_ENDFILTEE)
8460                     {
8461                       printf (" ENDFILTEE");
8462                       val ^= DF_1_ENDFILTEE;
8463                     }
8464                   if (val & DF_1_DISPRELDNE)
8465                     {
8466                       printf (" DISPRELDNE");
8467                       val ^= DF_1_DISPRELDNE;
8468                     }
8469                   if (val & DF_1_DISPRELPND)
8470                     {
8471                       printf (" DISPRELPND");
8472                       val ^= DF_1_DISPRELPND;
8473                     }
8474                   if (val & DF_1_NODIRECT)
8475                     {
8476                       printf (" NODIRECT");
8477                       val ^= DF_1_NODIRECT;
8478                     }
8479                   if (val & DF_1_IGNMULDEF)
8480                     {
8481                       printf (" IGNMULDEF");
8482                       val ^= DF_1_IGNMULDEF;
8483                     }
8484                   if (val & DF_1_NOKSYMS)
8485                     {
8486                       printf (" NOKSYMS");
8487                       val ^= DF_1_NOKSYMS;
8488                     }
8489                   if (val & DF_1_NOHDR)
8490                     {
8491                       printf (" NOHDR");
8492                       val ^= DF_1_NOHDR;
8493                     }
8494                   if (val & DF_1_EDITED)
8495                     {
8496                       printf (" EDITED");
8497                       val ^= DF_1_EDITED;
8498                     }
8499                   if (val & DF_1_NORELOC)
8500                     {
8501                       printf (" NORELOC");
8502                       val ^= DF_1_NORELOC;
8503                     }
8504                   if (val & DF_1_SYMINTPOSE)
8505                     {
8506                       printf (" SYMINTPOSE");
8507                       val ^= DF_1_SYMINTPOSE;
8508                     }
8509                   if (val & DF_1_GLOBAUDIT)
8510                     {
8511                       printf (" GLOBAUDIT");
8512                       val ^= DF_1_GLOBAUDIT;
8513                     }
8514                   if (val & DF_1_SINGLETON)
8515                     {
8516                       printf (" SINGLETON");
8517                       val ^= DF_1_SINGLETON;
8518                     }
8519                   if (val != 0)
8520                     printf (" %lx", val);
8521                   puts ("");
8522                 }
8523             }
8524           break;
8525
8526         case DT_PLTREL:
8527           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8528           if (do_dynamic)
8529             puts (get_dynamic_type (entry->d_un.d_val));
8530           break;
8531
8532         case DT_NULL    :
8533         case DT_NEEDED  :
8534         case DT_PLTGOT  :
8535         case DT_HASH    :
8536         case DT_STRTAB  :
8537         case DT_SYMTAB  :
8538         case DT_RELA    :
8539         case DT_INIT    :
8540         case DT_FINI    :
8541         case DT_SONAME  :
8542         case DT_RPATH   :
8543         case DT_SYMBOLIC:
8544         case DT_REL     :
8545         case DT_DEBUG   :
8546         case DT_TEXTREL :
8547         case DT_JMPREL  :
8548         case DT_RUNPATH :
8549           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8550
8551           if (do_dynamic)
8552             {
8553               char * name;
8554
8555               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8556                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8557               else
8558                 name = NULL;
8559
8560               if (name)
8561                 {
8562                   switch (entry->d_tag)
8563                     {
8564                     case DT_NEEDED:
8565                       printf (_("Shared library: [%s]"), name);
8566
8567                       if (streq (name, program_interpreter))
8568                         printf (_(" program interpreter"));
8569                       break;
8570
8571                     case DT_SONAME:
8572                       printf (_("Library soname: [%s]"), name);
8573                       break;
8574
8575                     case DT_RPATH:
8576                       printf (_("Library rpath: [%s]"), name);
8577                       break;
8578
8579                     case DT_RUNPATH:
8580                       printf (_("Library runpath: [%s]"), name);
8581                       break;
8582
8583                     default:
8584                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8585                       break;
8586                     }
8587                 }
8588               else
8589                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8590
8591               putchar ('\n');
8592             }
8593           break;
8594
8595         case DT_PLTRELSZ:
8596         case DT_RELASZ  :
8597         case DT_STRSZ   :
8598         case DT_RELSZ   :
8599         case DT_RELAENT :
8600         case DT_SYMENT  :
8601         case DT_RELENT  :
8602           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8603         case DT_PLTPADSZ:
8604         case DT_MOVEENT :
8605         case DT_MOVESZ  :
8606         case DT_INIT_ARRAYSZ:
8607         case DT_FINI_ARRAYSZ:
8608         case DT_GNU_CONFLICTSZ:
8609         case DT_GNU_LIBLISTSZ:
8610           if (do_dynamic)
8611             {
8612               print_vma (entry->d_un.d_val, UNSIGNED);
8613               printf (_(" (bytes)\n"));
8614             }
8615           break;
8616
8617         case DT_VERDEFNUM:
8618         case DT_VERNEEDNUM:
8619         case DT_RELACOUNT:
8620         case DT_RELCOUNT:
8621           if (do_dynamic)
8622             {
8623               print_vma (entry->d_un.d_val, UNSIGNED);
8624               putchar ('\n');
8625             }
8626           break;
8627
8628         case DT_SYMINSZ:
8629         case DT_SYMINENT:
8630         case DT_SYMINFO:
8631         case DT_USED:
8632         case DT_INIT_ARRAY:
8633         case DT_FINI_ARRAY:
8634           if (do_dynamic)
8635             {
8636               if (entry->d_tag == DT_USED
8637                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8638                 {
8639                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8640
8641                   if (*name)
8642                     {
8643                       printf (_("Not needed object: [%s]\n"), name);
8644                       break;
8645                     }
8646                 }
8647
8648               print_vma (entry->d_un.d_val, PREFIX_HEX);
8649               putchar ('\n');
8650             }
8651           break;
8652
8653         case DT_BIND_NOW:
8654           /* The value of this entry is ignored.  */
8655           if (do_dynamic)
8656             putchar ('\n');
8657           break;
8658
8659         case DT_GNU_PRELINKED:
8660           if (do_dynamic)
8661             {
8662               struct tm * tmp;
8663               time_t atime = entry->d_un.d_val;
8664
8665               tmp = gmtime (&atime);
8666               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8667                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8668                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8669
8670             }
8671           break;
8672
8673         case DT_GNU_HASH:
8674           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8675           if (do_dynamic)
8676             {
8677               print_vma (entry->d_un.d_val, PREFIX_HEX);
8678               putchar ('\n');
8679             }
8680           break;
8681
8682         default:
8683           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8684             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8685               entry->d_un.d_val;
8686
8687           if (do_dynamic)
8688             {
8689               switch (elf_header.e_machine)
8690                 {
8691                 case EM_MIPS:
8692                 case EM_MIPS_RS3_LE:
8693                   dynamic_section_mips_val (entry);
8694                   break;
8695                 case EM_PARISC:
8696                   dynamic_section_parisc_val (entry);
8697                   break;
8698                 case EM_IA_64:
8699                   dynamic_section_ia64_val (entry);
8700                   break;
8701                 default:
8702                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8703                   putchar ('\n');
8704                 }
8705             }
8706           break;
8707         }
8708     }
8709
8710   return 1;
8711 }
8712
8713 static char *
8714 get_ver_flags (unsigned int flags)
8715 {
8716   static char buff[32];
8717
8718   buff[0] = 0;
8719
8720   if (flags == 0)
8721     return _("none");
8722
8723   if (flags & VER_FLG_BASE)
8724     strcat (buff, "BASE ");
8725
8726   if (flags & VER_FLG_WEAK)
8727     {
8728       if (flags & VER_FLG_BASE)
8729         strcat (buff, "| ");
8730
8731       strcat (buff, "WEAK ");
8732     }
8733
8734   if (flags & VER_FLG_INFO)
8735     {
8736       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8737         strcat (buff, "| ");
8738
8739       strcat (buff, "INFO ");
8740     }
8741
8742   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8743     strcat (buff, _("| <unknown>"));
8744
8745   return buff;
8746 }
8747
8748 /* Display the contents of the version sections.  */
8749
8750 static int
8751 process_version_sections (FILE * file)
8752 {
8753   Elf_Internal_Shdr * section;
8754   unsigned i;
8755   int found = 0;
8756
8757   if (! do_version)
8758     return 1;
8759
8760   for (i = 0, section = section_headers;
8761        i < elf_header.e_shnum;
8762        i++, section++)
8763     {
8764       switch (section->sh_type)
8765         {
8766         case SHT_GNU_verdef:
8767           {
8768             Elf_External_Verdef * edefs;
8769             unsigned int idx;
8770             unsigned int cnt;
8771             char * endbuf;
8772
8773             found = 1;
8774
8775             printf
8776               (_("\nVersion definition section '%s' contains %u entries:\n"),
8777                SECTION_NAME (section), section->sh_info);
8778
8779             printf (_("  Addr: 0x"));
8780             printf_vma (section->sh_addr);
8781             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8782                     (unsigned long) section->sh_offset, section->sh_link,
8783                     section->sh_link < elf_header.e_shnum
8784                     ? SECTION_NAME (section_headers + section->sh_link)
8785                     : _("<corrupt>"));
8786
8787             edefs = (Elf_External_Verdef *)
8788                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8789                           _("version definition section"));
8790             if (!edefs)
8791               break;
8792             endbuf = (char *) edefs + section->sh_size;
8793
8794             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8795               {
8796                 char * vstart;
8797                 Elf_External_Verdef * edef;
8798                 Elf_Internal_Verdef ent;
8799                 Elf_External_Verdaux * eaux;
8800                 Elf_Internal_Verdaux aux;
8801                 int j;
8802                 int isum;
8803
8804                 /* Check for very large indicies.  */
8805                 if (idx > (size_t) (endbuf - (char *) edefs))
8806                   break;
8807
8808                 vstart = ((char *) edefs) + idx;
8809                 if (vstart + sizeof (*edef) > endbuf)
8810                   break;
8811
8812                 edef = (Elf_External_Verdef *) vstart;
8813
8814                 ent.vd_version = BYTE_GET (edef->vd_version);
8815                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8816                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8817                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8818                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8819                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8820                 ent.vd_next    = BYTE_GET (edef->vd_next);
8821
8822                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8823                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8824
8825                 printf (_("  Index: %d  Cnt: %d  "),
8826                         ent.vd_ndx, ent.vd_cnt);
8827
8828                 /* Check for overflow.  */
8829                 if (ent.vd_aux > (size_t) (endbuf - vstart))
8830                   break;
8831
8832                 vstart += ent.vd_aux;
8833
8834                 eaux = (Elf_External_Verdaux *) vstart;
8835
8836                 aux.vda_name = BYTE_GET (eaux->vda_name);
8837                 aux.vda_next = BYTE_GET (eaux->vda_next);
8838
8839                 if (VALID_DYNAMIC_NAME (aux.vda_name))
8840                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8841                 else
8842                   printf (_("Name index: %ld\n"), aux.vda_name);
8843
8844                 isum = idx + ent.vd_aux;
8845
8846                 for (j = 1; j < ent.vd_cnt; j++)
8847                   {
8848                     /* Check for overflow.  */
8849                     if (aux.vda_next > (size_t) (endbuf - vstart))
8850                       break;
8851
8852                     isum   += aux.vda_next;
8853                     vstart += aux.vda_next;
8854
8855                     eaux = (Elf_External_Verdaux *) vstart;
8856                     if (vstart + sizeof (*eaux) > endbuf)
8857                       break;
8858
8859                     aux.vda_name = BYTE_GET (eaux->vda_name);
8860                     aux.vda_next = BYTE_GET (eaux->vda_next);
8861
8862                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8863                       printf (_("  %#06x: Parent %d: %s\n"),
8864                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8865                     else
8866                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8867                               isum, j, aux.vda_name);
8868                   }
8869
8870                 if (j < ent.vd_cnt)
8871                   printf (_("  Version def aux past end of section\n"));
8872
8873                 idx += ent.vd_next;
8874               }
8875
8876             if (cnt < section->sh_info)
8877               printf (_("  Version definition past end of section\n"));
8878
8879             free (edefs);
8880           }
8881           break;
8882
8883         case SHT_GNU_verneed:
8884           {
8885             Elf_External_Verneed * eneed;
8886             unsigned int idx;
8887             unsigned int cnt;
8888             char * endbuf;
8889
8890             found = 1;
8891
8892             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8893                     SECTION_NAME (section), section->sh_info);
8894
8895             printf (_(" Addr: 0x"));
8896             printf_vma (section->sh_addr);
8897             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8898                     (unsigned long) section->sh_offset, section->sh_link,
8899                     section->sh_link < elf_header.e_shnum
8900                     ? SECTION_NAME (section_headers + section->sh_link)
8901                     : _("<corrupt>"));
8902
8903             eneed = (Elf_External_Verneed *) get_data (NULL, file,
8904                                                        section->sh_offset, 1,
8905                                                        section->sh_size,
8906                                                        _("Version Needs section"));
8907             if (!eneed)
8908               break;
8909             endbuf = (char *) eneed + section->sh_size;
8910
8911             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8912               {
8913                 Elf_External_Verneed * entry;
8914                 Elf_Internal_Verneed ent;
8915                 int j;
8916                 int isum;
8917                 char * vstart;
8918
8919                 if (idx > (size_t) (endbuf - (char *) eneed))
8920                   break;
8921
8922                 vstart = ((char *) eneed) + idx;
8923                 if (vstart + sizeof (*entry) > endbuf)
8924                   break;
8925
8926                 entry = (Elf_External_Verneed *) vstart;
8927
8928                 ent.vn_version = BYTE_GET (entry->vn_version);
8929                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
8930                 ent.vn_file    = BYTE_GET (entry->vn_file);
8931                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
8932                 ent.vn_next    = BYTE_GET (entry->vn_next);
8933
8934                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
8935
8936                 if (VALID_DYNAMIC_NAME (ent.vn_file))
8937                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8938                 else
8939                   printf (_("  File: %lx"), ent.vn_file);
8940
8941                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
8942
8943                 /* Check for overflow.  */
8944                 if (ent.vn_aux > (size_t) (endbuf - vstart))
8945                   break;
8946
8947                 vstart += ent.vn_aux;
8948
8949                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8950                   {
8951                     Elf_External_Vernaux * eaux;
8952                     Elf_Internal_Vernaux aux;
8953
8954                     if (vstart + sizeof (*eaux) > endbuf)
8955                       break;
8956                     eaux = (Elf_External_Vernaux *) vstart;
8957
8958                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
8959                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
8960                     aux.vna_other = BYTE_GET (eaux->vna_other);
8961                     aux.vna_name  = BYTE_GET (eaux->vna_name);
8962                     aux.vna_next  = BYTE_GET (eaux->vna_next);
8963
8964                     if (VALID_DYNAMIC_NAME (aux.vna_name))
8965                       printf (_("  %#06x:   Name: %s"),
8966                               isum, GET_DYNAMIC_NAME (aux.vna_name));
8967                     else
8968                       printf (_("  %#06x:   Name index: %lx"),
8969                               isum, aux.vna_name);
8970
8971                     printf (_("  Flags: %s  Version: %d\n"),
8972                             get_ver_flags (aux.vna_flags), aux.vna_other);
8973
8974                     /* Check for overflow.  */
8975                     if (aux.vna_next > (size_t) (endbuf - vstart))
8976                       break;
8977
8978                     isum   += aux.vna_next;
8979                     vstart += aux.vna_next;
8980                   }
8981
8982                 if (j < ent.vn_cnt)
8983                   warn (_("Missing Version Needs auxillary information\n"));
8984
8985                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
8986                   {
8987                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
8988                     cnt = section->sh_info;
8989                     break;
8990                   }
8991                 idx += ent.vn_next;
8992               }
8993
8994             if (cnt < section->sh_info)
8995               warn (_("Missing Version Needs information\n"));
8996
8997             free (eneed);
8998           }
8999           break;
9000
9001         case SHT_GNU_versym:
9002           {
9003             Elf_Internal_Shdr * link_section;
9004             int total;
9005             int cnt;
9006             unsigned char * edata;
9007             unsigned short * data;
9008             char * strtab;
9009             Elf_Internal_Sym * symbols;
9010             Elf_Internal_Shdr * string_sec;
9011             unsigned long num_syms;
9012             long off;
9013
9014             if (section->sh_link >= elf_header.e_shnum)
9015               break;
9016
9017             link_section = section_headers + section->sh_link;
9018             total = section->sh_size / sizeof (Elf_External_Versym);
9019
9020             if (link_section->sh_link >= elf_header.e_shnum)
9021               break;
9022
9023             found = 1;
9024
9025             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9026             if (symbols == NULL)
9027               break;
9028
9029             string_sec = section_headers + link_section->sh_link;
9030
9031             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9032                                         string_sec->sh_size,
9033                                         _("version string table"));
9034             if (!strtab)
9035               {
9036                 free (symbols);
9037                 break;
9038               }
9039
9040             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9041                     SECTION_NAME (section), total);
9042
9043             printf (_(" Addr: "));
9044             printf_vma (section->sh_addr);
9045             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9046                     (unsigned long) section->sh_offset, section->sh_link,
9047                     SECTION_NAME (link_section));
9048
9049             off = offset_from_vma (file,
9050                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9051                                    total * sizeof (short));
9052             edata = (unsigned char *) get_data (NULL, file, off, total,
9053                                                 sizeof (short),
9054                                                 _("version symbol data"));
9055             if (!edata)
9056               {
9057                 free (strtab);
9058                 free (symbols);
9059                 break;
9060               }
9061
9062             data = (short unsigned int *) cmalloc (total, sizeof (short));
9063
9064             for (cnt = total; cnt --;)
9065               data[cnt] = byte_get (edata + cnt * sizeof (short),
9066                                     sizeof (short));
9067
9068             free (edata);
9069
9070             for (cnt = 0; cnt < total; cnt += 4)
9071               {
9072                 int j, nn;
9073                 int check_def, check_need;
9074                 char * name;
9075
9076                 printf ("  %03x:", cnt);
9077
9078                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9079                   switch (data[cnt + j])
9080                     {
9081                     case 0:
9082                       fputs (_("   0 (*local*)    "), stdout);
9083                       break;
9084
9085                     case 1:
9086                       fputs (_("   1 (*global*)   "), stdout);
9087                       break;
9088
9089                     default:
9090                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9091                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9092
9093                       /* If this index value is greater than the size of the symbols
9094                          array, break to avoid an out-of-bounds read.  */
9095                       if ((unsigned long)(cnt + j) >= num_syms)
9096                         {
9097                           warn (_("invalid index into symbol array\n"));
9098                           break;
9099                         }
9100
9101                       check_def = 1;
9102                       check_need = 1;
9103                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9104                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9105                              != SHT_NOBITS)
9106                         {
9107                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9108                             check_def = 0;
9109                           else
9110                             check_need = 0;
9111                         }
9112
9113                       if (check_need
9114                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9115                         {
9116                           Elf_Internal_Verneed ivn;
9117                           unsigned long offset;
9118
9119                           offset = offset_from_vma
9120                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9121                              sizeof (Elf_External_Verneed));
9122
9123                           do
9124                             {
9125                               Elf_Internal_Vernaux ivna;
9126                               Elf_External_Verneed evn;
9127                               Elf_External_Vernaux evna;
9128                               unsigned long a_off;
9129
9130                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9131                                             _("version need")) == NULL)
9132                                 break;
9133
9134                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9135                               ivn.vn_next = BYTE_GET (evn.vn_next);
9136
9137                               a_off = offset + ivn.vn_aux;
9138
9139                               do
9140                                 {
9141                                   if (get_data (&evna, file, a_off, sizeof (evna),
9142                                                 1, _("version need aux (2)")) == NULL)
9143                                     {
9144                                       ivna.vna_next  = 0;
9145                                       ivna.vna_other = 0;
9146                                     }
9147                                   else
9148                                     {
9149                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9150                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9151                                     }
9152
9153                                   a_off += ivna.vna_next;
9154                                 }
9155                               while (ivna.vna_other != data[cnt + j]
9156                                      && ivna.vna_next != 0);
9157
9158                               if (ivna.vna_other == data[cnt + j])
9159                                 {
9160                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9161
9162                                   if (ivna.vna_name >= string_sec->sh_size)
9163                                     name = _("*invalid*");
9164                                   else
9165                                     name = strtab + ivna.vna_name;
9166                                   nn += printf ("(%s%-*s",
9167                                                 name,
9168                                                 12 - (int) strlen (name),
9169                                                 ")");
9170                                   check_def = 0;
9171                                   break;
9172                                 }
9173
9174                               offset += ivn.vn_next;
9175                             }
9176                           while (ivn.vn_next);
9177                         }
9178
9179                       if (check_def && data[cnt + j] != 0x8001
9180                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9181                         {
9182                           Elf_Internal_Verdef ivd;
9183                           Elf_External_Verdef evd;
9184                           unsigned long offset;
9185
9186                           offset = offset_from_vma
9187                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9188                              sizeof evd);
9189
9190                           do
9191                             {
9192                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9193                                             _("version def")) == NULL)
9194                                 {
9195                                   ivd.vd_next = 0;
9196                                   ivd.vd_ndx  = 0;
9197                                 }
9198                               else
9199                                 {
9200                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9201                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9202                                 }
9203
9204                               offset += ivd.vd_next;
9205                             }
9206                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9207                                  && ivd.vd_next != 0);
9208
9209                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9210                             {
9211                               Elf_External_Verdaux evda;
9212                               Elf_Internal_Verdaux ivda;
9213
9214                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9215
9216                               if (get_data (&evda, file,
9217                                             offset - ivd.vd_next + ivd.vd_aux,
9218                                             sizeof (evda), 1,
9219                                             _("version def aux")) == NULL)
9220                                 break;
9221
9222                               ivda.vda_name = BYTE_GET (evda.vda_name);
9223
9224                               if (ivda.vda_name >= string_sec->sh_size)
9225                                 name = _("*invalid*");
9226                               else
9227                                 name = strtab + ivda.vda_name;
9228                               nn += printf ("(%s%-*s",
9229                                             name,
9230                                             12 - (int) strlen (name),
9231                                             ")");
9232                             }
9233                         }
9234
9235                       if (nn < 18)
9236                         printf ("%*c", 18 - nn, ' ');
9237                     }
9238
9239                 putchar ('\n');
9240               }
9241
9242             free (data);
9243             free (strtab);
9244             free (symbols);
9245           }
9246           break;
9247
9248         default:
9249           break;
9250         }
9251     }
9252
9253   if (! found)
9254     printf (_("\nNo version information found in this file.\n"));
9255
9256   return 1;
9257 }
9258
9259 static const char *
9260 get_symbol_binding (unsigned int binding)
9261 {
9262   static char buff[32];
9263
9264   switch (binding)
9265     {
9266     case STB_LOCAL:     return "LOCAL";
9267     case STB_GLOBAL:    return "GLOBAL";
9268     case STB_WEAK:      return "WEAK";
9269     default:
9270       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9271         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9272                   binding);
9273       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9274         {
9275           if (binding == STB_GNU_UNIQUE
9276               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9277                   /* GNU is still using the default value 0.  */
9278                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9279             return "UNIQUE";
9280           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9281         }
9282       else
9283         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9284       return buff;
9285     }
9286 }
9287
9288 static const char *
9289 get_symbol_type (unsigned int type)
9290 {
9291   static char buff[32];
9292
9293   switch (type)
9294     {
9295     case STT_NOTYPE:    return "NOTYPE";
9296     case STT_OBJECT:    return "OBJECT";
9297     case STT_FUNC:      return "FUNC";
9298     case STT_SECTION:   return "SECTION";
9299     case STT_FILE:      return "FILE";
9300     case STT_COMMON:    return "COMMON";
9301     case STT_TLS:       return "TLS";
9302     case STT_RELC:      return "RELC";
9303     case STT_SRELC:     return "SRELC";
9304     default:
9305       if (type >= STT_LOPROC && type <= STT_HIPROC)
9306         {
9307           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9308             return "THUMB_FUNC";
9309
9310           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9311             return "REGISTER";
9312
9313           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9314             return "PARISC_MILLI";
9315
9316           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9317         }
9318       else if (type >= STT_LOOS && type <= STT_HIOS)
9319         {
9320           if (elf_header.e_machine == EM_PARISC)
9321             {
9322               if (type == STT_HP_OPAQUE)
9323                 return "HP_OPAQUE";
9324               if (type == STT_HP_STUB)
9325                 return "HP_STUB";
9326             }
9327
9328           if (type == STT_GNU_IFUNC
9329               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9330                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9331                   /* GNU is still using the default value 0.  */
9332                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9333             return "IFUNC";
9334
9335           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9336         }
9337       else
9338         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9339       return buff;
9340     }
9341 }
9342
9343 static const char *
9344 get_symbol_visibility (unsigned int visibility)
9345 {
9346   switch (visibility)
9347     {
9348     case STV_DEFAULT:   return "DEFAULT";
9349     case STV_INTERNAL:  return "INTERNAL";
9350     case STV_HIDDEN:    return "HIDDEN";
9351     case STV_PROTECTED: return "PROTECTED";
9352     default: abort ();
9353     }
9354 }
9355
9356 static const char *
9357 get_mips_symbol_other (unsigned int other)
9358 {
9359   switch (other)
9360     {
9361     case STO_OPTIONAL:
9362       return "OPTIONAL";
9363     case STO_MIPS_PLT:
9364       return "MIPS PLT";
9365     case STO_MIPS_PIC:
9366       return "MIPS PIC";
9367     case STO_MICROMIPS:
9368       return "MICROMIPS";
9369     case STO_MICROMIPS | STO_MIPS_PIC:
9370       return "MICROMIPS, MIPS PIC";
9371     case STO_MIPS16:
9372       return "MIPS16";
9373     default:
9374       return NULL;
9375     }
9376 }
9377
9378 static const char *
9379 get_ia64_symbol_other (unsigned int other)
9380 {
9381   if (is_ia64_vms ())
9382     {
9383       static char res[32];
9384
9385       res[0] = 0;
9386
9387       /* Function types is for images and .STB files only.  */
9388       switch (elf_header.e_type)
9389         {
9390         case ET_DYN:
9391         case ET_EXEC:
9392           switch (VMS_ST_FUNC_TYPE (other))
9393             {
9394             case VMS_SFT_CODE_ADDR:
9395               strcat (res, " CA");
9396               break;
9397             case VMS_SFT_SYMV_IDX:
9398               strcat (res, " VEC");
9399               break;
9400             case VMS_SFT_FD:
9401               strcat (res, " FD");
9402               break;
9403             case VMS_SFT_RESERVE:
9404               strcat (res, " RSV");
9405               break;
9406             default:
9407               abort ();
9408             }
9409           break;
9410         default:
9411           break;
9412         }
9413       switch (VMS_ST_LINKAGE (other))
9414         {
9415         case VMS_STL_IGNORE:
9416           strcat (res, " IGN");
9417           break;
9418         case VMS_STL_RESERVE:
9419           strcat (res, " RSV");
9420           break;
9421         case VMS_STL_STD:
9422           strcat (res, " STD");
9423           break;
9424         case VMS_STL_LNK:
9425           strcat (res, " LNK");
9426           break;
9427         default:
9428           abort ();
9429         }
9430
9431       if (res[0] != 0)
9432         return res + 1;
9433       else
9434         return res;
9435     }
9436   return NULL;
9437 }
9438
9439 static const char *
9440 get_ppc64_symbol_other (unsigned int other)
9441 {
9442   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9443     {
9444       static char buf[32];
9445       snprintf (buf, sizeof buf, _("<localentry>: %d"),
9446                 PPC64_LOCAL_ENTRY_OFFSET (other));
9447       return buf;
9448     }
9449   return NULL;
9450 }
9451
9452 static const char *
9453 get_symbol_other (unsigned int other)
9454 {
9455   const char * result = NULL;
9456   static char buff [32];
9457
9458   if (other == 0)
9459     return "";
9460
9461   switch (elf_header.e_machine)
9462     {
9463     case EM_MIPS:
9464       result = get_mips_symbol_other (other);
9465       break;
9466     case EM_IA_64:
9467       result = get_ia64_symbol_other (other);
9468       break;
9469     case EM_PPC64:
9470       result = get_ppc64_symbol_other (other);
9471       break;
9472     default:
9473       break;
9474     }
9475
9476   if (result)
9477     return result;
9478
9479   snprintf (buff, sizeof buff, _("<other>: %x"), other);
9480   return buff;
9481 }
9482
9483 static const char *
9484 get_symbol_index_type (unsigned int type)
9485 {
9486   static char buff[32];
9487
9488   switch (type)
9489     {
9490     case SHN_UNDEF:     return "UND";
9491     case SHN_ABS:       return "ABS";
9492     case SHN_COMMON:    return "COM";
9493     default:
9494       if (type == SHN_IA_64_ANSI_COMMON
9495           && elf_header.e_machine == EM_IA_64
9496           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9497         return "ANSI_COM";
9498       else if ((elf_header.e_machine == EM_X86_64
9499                 || elf_header.e_machine == EM_L1OM
9500                 || elf_header.e_machine == EM_K1OM)
9501                && type == SHN_X86_64_LCOMMON)
9502         return "LARGE_COM";
9503       else if ((type == SHN_MIPS_SCOMMON
9504                 && elf_header.e_machine == EM_MIPS)
9505                || (type == SHN_TIC6X_SCOMMON
9506                    && elf_header.e_machine == EM_TI_C6000))
9507         return "SCOM";
9508       else if (type == SHN_MIPS_SUNDEFINED
9509                && elf_header.e_machine == EM_MIPS)
9510         return "SUND";
9511       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9512         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9513       else if (type >= SHN_LOOS && type <= SHN_HIOS)
9514         sprintf (buff, "OS [0x%04x]", type & 0xffff);
9515       else if (type >= SHN_LORESERVE)
9516         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9517       else if (type >= elf_header.e_shnum)
9518         sprintf (buff, "bad section index[%3d]", type);
9519       else
9520         sprintf (buff, "%3d", type);
9521       break;
9522     }
9523
9524   return buff;
9525 }
9526
9527 static bfd_vma *
9528 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9529 {
9530   unsigned char * e_data;
9531   bfd_vma * i_data;
9532
9533   e_data = (unsigned char *) cmalloc (number, ent_size);
9534
9535   if (e_data == NULL)
9536     {
9537       error (_("Out of memory\n"));
9538       return NULL;
9539     }
9540
9541   if (fread (e_data, ent_size, number, file) != number)
9542     {
9543       error (_("Unable to read in dynamic data\n"));
9544       return NULL;
9545     }
9546
9547   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9548
9549   if (i_data == NULL)
9550     {
9551       error (_("Out of memory\n"));
9552       free (e_data);
9553       return NULL;
9554     }
9555
9556   while (number--)
9557     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9558
9559   free (e_data);
9560
9561   return i_data;
9562 }
9563
9564 static void
9565 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9566 {
9567   Elf_Internal_Sym * psym;
9568   int n;
9569
9570   psym = dynamic_symbols + si;
9571
9572   n = print_vma (si, DEC_5);
9573   if (n < 5)
9574     fputs (&"     "[n], stdout);
9575   printf (" %3lu: ", hn);
9576   print_vma (psym->st_value, LONG_HEX);
9577   putchar (' ');
9578   print_vma (psym->st_size, DEC_5);
9579
9580   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9581   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9582   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9583   /* Check to see if any other bits in the st_other field are set.
9584      Note - displaying this information disrupts the layout of the
9585      table being generated, but for the moment this case is very
9586      rare.  */
9587   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9588     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9589   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9590   if (VALID_DYNAMIC_NAME (psym->st_name))
9591     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9592   else
9593     printf (_(" <corrupt: %14ld>"), psym->st_name);
9594   putchar ('\n');
9595 }
9596
9597 /* Dump the symbol table.  */
9598 static int
9599 process_symbol_table (FILE * file)
9600 {
9601   Elf_Internal_Shdr * section;
9602   bfd_vma nbuckets = 0;
9603   bfd_vma nchains = 0;
9604   bfd_vma * buckets = NULL;
9605   bfd_vma * chains = NULL;
9606   bfd_vma ngnubuckets = 0;
9607   bfd_vma * gnubuckets = NULL;
9608   bfd_vma * gnuchains = NULL;
9609   bfd_vma gnusymidx = 0;
9610
9611   if (!do_syms && !do_dyn_syms && !do_histogram)
9612     return 1;
9613
9614   if (dynamic_info[DT_HASH]
9615       && (do_histogram
9616           || (do_using_dynamic
9617               && !do_dyn_syms
9618               && dynamic_strings != NULL)))
9619     {
9620       unsigned char nb[8];
9621       unsigned char nc[8];
9622       int hash_ent_size = 4;
9623
9624       if ((elf_header.e_machine == EM_ALPHA
9625            || elf_header.e_machine == EM_S390
9626            || elf_header.e_machine == EM_S390_OLD)
9627           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9628         hash_ent_size = 8;
9629
9630       if (fseek (file,
9631                  (archive_file_offset
9632                   + offset_from_vma (file, dynamic_info[DT_HASH],
9633                                      sizeof nb + sizeof nc)),
9634                  SEEK_SET))
9635         {
9636           error (_("Unable to seek to start of dynamic information\n"));
9637           goto no_hash;
9638         }
9639
9640       if (fread (nb, hash_ent_size, 1, file) != 1)
9641         {
9642           error (_("Failed to read in number of buckets\n"));
9643           goto no_hash;
9644         }
9645
9646       if (fread (nc, hash_ent_size, 1, file) != 1)
9647         {
9648           error (_("Failed to read in number of chains\n"));
9649           goto no_hash;
9650         }
9651
9652       nbuckets = byte_get (nb, hash_ent_size);
9653       nchains  = byte_get (nc, hash_ent_size);
9654
9655       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9656       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9657
9658     no_hash:
9659       if (buckets == NULL || chains == NULL)
9660         {
9661           if (do_using_dynamic)
9662             return 0;
9663           free (buckets);
9664           free (chains);
9665           buckets = NULL;
9666           chains = NULL;
9667           nbuckets = 0;
9668           nchains = 0;
9669         }
9670     }
9671
9672   if (dynamic_info_DT_GNU_HASH
9673       && (do_histogram
9674           || (do_using_dynamic
9675               && !do_dyn_syms
9676               && dynamic_strings != NULL)))
9677     {
9678       unsigned char nb[16];
9679       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9680       bfd_vma buckets_vma;
9681
9682       if (fseek (file,
9683                  (archive_file_offset
9684                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9685                                      sizeof nb)),
9686                  SEEK_SET))
9687         {
9688           error (_("Unable to seek to start of dynamic information\n"));
9689           goto no_gnu_hash;
9690         }
9691
9692       if (fread (nb, 16, 1, file) != 1)
9693         {
9694           error (_("Failed to read in number of buckets\n"));
9695           goto no_gnu_hash;
9696         }
9697
9698       ngnubuckets = byte_get (nb, 4);
9699       gnusymidx = byte_get (nb + 4, 4);
9700       bitmaskwords = byte_get (nb + 8, 4);
9701       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9702       if (is_32bit_elf)
9703         buckets_vma += bitmaskwords * 4;
9704       else
9705         buckets_vma += bitmaskwords * 8;
9706
9707       if (fseek (file,
9708                  (archive_file_offset
9709                   + offset_from_vma (file, buckets_vma, 4)),
9710                  SEEK_SET))
9711         {
9712           error (_("Unable to seek to start of dynamic information\n"));
9713           goto no_gnu_hash;
9714         }
9715
9716       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9717
9718       if (gnubuckets == NULL)
9719         goto no_gnu_hash;
9720
9721       for (i = 0; i < ngnubuckets; i++)
9722         if (gnubuckets[i] != 0)
9723           {
9724             if (gnubuckets[i] < gnusymidx)
9725               return 0;
9726
9727             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9728               maxchain = gnubuckets[i];
9729           }
9730
9731       if (maxchain == 0xffffffff)
9732         goto no_gnu_hash;
9733
9734       maxchain -= gnusymidx;
9735
9736       if (fseek (file,
9737                  (archive_file_offset
9738                   + offset_from_vma (file, buckets_vma
9739                                            + 4 * (ngnubuckets + maxchain), 4)),
9740                  SEEK_SET))
9741         {
9742           error (_("Unable to seek to start of dynamic information\n"));
9743           goto no_gnu_hash;
9744         }
9745
9746       do
9747         {
9748           if (fread (nb, 4, 1, file) != 1)
9749             {
9750               error (_("Failed to determine last chain length\n"));
9751               goto no_gnu_hash;
9752             }
9753
9754           if (maxchain + 1 == 0)
9755             goto no_gnu_hash;
9756
9757           ++maxchain;
9758         }
9759       while ((byte_get (nb, 4) & 1) == 0);
9760
9761       if (fseek (file,
9762                  (archive_file_offset
9763                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9764                  SEEK_SET))
9765         {
9766           error (_("Unable to seek to start of dynamic information\n"));
9767           goto no_gnu_hash;
9768         }
9769
9770       gnuchains = get_dynamic_data (file, maxchain, 4);
9771
9772     no_gnu_hash:
9773       if (gnuchains == NULL)
9774         {
9775           free (gnubuckets);
9776           gnubuckets = NULL;
9777           ngnubuckets = 0;
9778           if (do_using_dynamic)
9779             return 0;
9780         }
9781     }
9782
9783   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9784       && do_syms
9785       && do_using_dynamic
9786       && dynamic_strings != NULL)
9787     {
9788       unsigned long hn;
9789
9790       if (dynamic_info[DT_HASH])
9791         {
9792           bfd_vma si;
9793
9794           printf (_("\nSymbol table for image:\n"));
9795           if (is_32bit_elf)
9796             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9797           else
9798             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9799
9800           for (hn = 0; hn < nbuckets; hn++)
9801             {
9802               if (! buckets[hn])
9803                 continue;
9804
9805               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9806                 print_dynamic_symbol (si, hn);
9807             }
9808         }
9809
9810       if (dynamic_info_DT_GNU_HASH)
9811         {
9812           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9813           if (is_32bit_elf)
9814             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9815           else
9816             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9817
9818           for (hn = 0; hn < ngnubuckets; ++hn)
9819             if (gnubuckets[hn] != 0)
9820               {
9821                 bfd_vma si = gnubuckets[hn];
9822                 bfd_vma off = si - gnusymidx;
9823
9824                 do
9825                   {
9826                     print_dynamic_symbol (si, hn);
9827                     si++;
9828                   }
9829                 while ((gnuchains[off++] & 1) == 0);
9830               }
9831         }
9832     }
9833   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9834     {
9835       unsigned int i;
9836
9837       for (i = 0, section = section_headers;
9838            i < elf_header.e_shnum;
9839            i++, section++)
9840         {
9841           unsigned int si;
9842           char * strtab = NULL;
9843           unsigned long int strtab_size = 0;
9844           Elf_Internal_Sym * symtab;
9845           Elf_Internal_Sym * psym;
9846           unsigned long num_syms;
9847
9848           if ((section->sh_type != SHT_SYMTAB
9849                && section->sh_type != SHT_DYNSYM)
9850               || (!do_syms
9851                   && section->sh_type == SHT_SYMTAB))
9852             continue;
9853
9854           if (section->sh_entsize == 0)
9855             {
9856               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9857                       SECTION_NAME (section));
9858               continue;
9859             }
9860
9861           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9862                   SECTION_NAME (section),
9863                   (unsigned long) (section->sh_size / section->sh_entsize));
9864
9865           if (is_32bit_elf)
9866             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9867           else
9868             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9869
9870           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9871           if (symtab == NULL)
9872             continue;
9873
9874           if (section->sh_link == elf_header.e_shstrndx)
9875             {
9876               strtab = string_table;
9877               strtab_size = string_table_length;
9878             }
9879           else if (section->sh_link < elf_header.e_shnum)
9880             {
9881               Elf_Internal_Shdr * string_sec;
9882
9883               string_sec = section_headers + section->sh_link;
9884
9885               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9886                                           1, string_sec->sh_size,
9887                                           _("string table"));
9888               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9889             }
9890
9891           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9892             {
9893               printf ("%6d: ", si);
9894               print_vma (psym->st_value, LONG_HEX);
9895               putchar (' ');
9896               print_vma (psym->st_size, DEC_5);
9897               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9898               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9899               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9900               /* Check to see if any other bits in the st_other field are set.
9901                  Note - displaying this information disrupts the layout of the
9902                  table being generated, but for the moment this case is very rare.  */
9903               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9904                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9905               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9906               print_symbol (25, psym->st_name < strtab_size
9907                             ? strtab + psym->st_name : _("<corrupt>"));
9908
9909               if (section->sh_type == SHT_DYNSYM
9910                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9911                 {
9912                   unsigned char data[2];
9913                   unsigned short vers_data;
9914                   unsigned long offset;
9915                   int is_nobits;
9916                   int check_def;
9917
9918                   offset = offset_from_vma
9919                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9920                      sizeof data + si * sizeof (vers_data));
9921
9922                   if (get_data (&data, file, offset + si * sizeof (vers_data),
9923                                 sizeof (data), 1, _("version data")) == NULL)
9924                     break;
9925
9926                   vers_data = byte_get (data, 2);
9927
9928                   is_nobits = (psym->st_shndx < elf_header.e_shnum
9929                                && section_headers[psym->st_shndx].sh_type
9930                                   == SHT_NOBITS);
9931
9932                   check_def = (psym->st_shndx != SHN_UNDEF);
9933
9934                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9935                     {
9936                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9937                           && (is_nobits || ! check_def))
9938                         {
9939                           Elf_External_Verneed evn;
9940                           Elf_Internal_Verneed ivn;
9941                           Elf_Internal_Vernaux ivna;
9942
9943                           /* We must test both.  */
9944                           offset = offset_from_vma
9945                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9946                              sizeof evn);
9947
9948                           do
9949                             {
9950                               unsigned long vna_off;
9951
9952                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9953                                             _("version need")) == NULL)
9954                                 {
9955                                   ivna.vna_next = 0;
9956                                   ivna.vna_other = 0;
9957                                   ivna.vna_name = 0;
9958                                   break;
9959                                 }
9960
9961                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9962                               ivn.vn_next = BYTE_GET (evn.vn_next);
9963
9964                               vna_off = offset + ivn.vn_aux;
9965
9966                               do
9967                                 {
9968                                   Elf_External_Vernaux evna;
9969
9970                                   if (get_data (&evna, file, vna_off,
9971                                                 sizeof (evna), 1,
9972                                                 _("version need aux (3)")) == NULL)
9973                                     {
9974                                       ivna.vna_next = 0;
9975                                       ivna.vna_other = 0;
9976                                       ivna.vna_name = 0;
9977                                     }
9978                                   else
9979                                     {
9980                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9981                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9982                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
9983                                     }
9984
9985                                   vna_off += ivna.vna_next;
9986                                 }
9987                               while (ivna.vna_other != vers_data
9988                                      && ivna.vna_next != 0);
9989
9990                               if (ivna.vna_other == vers_data)
9991                                 break;
9992
9993                               offset += ivn.vn_next;
9994                             }
9995                           while (ivn.vn_next != 0);
9996
9997                           if (ivna.vna_other == vers_data)
9998                             {
9999                               printf ("@%s (%d)",
10000                                       ivna.vna_name < strtab_size
10001                                       ? strtab + ivna.vna_name : _("<corrupt>"),
10002                                       ivna.vna_other);
10003                               check_def = 0;
10004                             }
10005                           else if (! is_nobits)
10006                             error (_("bad dynamic symbol\n"));
10007                           else
10008                             check_def = 1;
10009                         }
10010
10011                       if (check_def)
10012                         {
10013                           if (vers_data != 0x8001
10014                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10015                             {
10016                               Elf_Internal_Verdef ivd;
10017                               Elf_Internal_Verdaux ivda;
10018                               Elf_External_Verdaux evda;
10019                               unsigned long off;
10020
10021                               off = offset_from_vma
10022                                 (file,
10023                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10024                                  sizeof (Elf_External_Verdef));
10025
10026                               do
10027                                 {
10028                                   Elf_External_Verdef evd;
10029
10030                                   if (get_data (&evd, file, off, sizeof (evd),
10031                                                 1, _("version def")) == NULL)
10032                                     {
10033                                       ivd.vd_ndx = 0;
10034                                       ivd.vd_aux = 0;
10035                                       ivd.vd_next = 0;
10036                                     }
10037                                   else
10038                                     {
10039                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10040                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
10041                                       ivd.vd_next = BYTE_GET (evd.vd_next);
10042                                     }
10043
10044                                   off += ivd.vd_next;
10045                                 }
10046                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10047                                      && ivd.vd_next != 0);
10048
10049                               off -= ivd.vd_next;
10050                               off += ivd.vd_aux;
10051
10052                               if (get_data (&evda, file, off, sizeof (evda),
10053                                             1, _("version def aux")) == NULL)
10054                                 break;
10055
10056                               ivda.vda_name = BYTE_GET (evda.vda_name);
10057
10058                               if (psym->st_name != ivda.vda_name)
10059                                 printf ((vers_data & VERSYM_HIDDEN)
10060                                         ? "@%s" : "@@%s",
10061                                         ivda.vda_name < strtab_size
10062                                         ? strtab + ivda.vda_name : _("<corrupt>"));
10063                             }
10064                         }
10065                     }
10066                 }
10067
10068               putchar ('\n');
10069             }
10070
10071           free (symtab);
10072           if (strtab != string_table)
10073             free (strtab);
10074         }
10075     }
10076   else if (do_syms)
10077     printf
10078       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10079
10080   if (do_histogram && buckets != NULL)
10081     {
10082       unsigned long * lengths;
10083       unsigned long * counts;
10084       unsigned long hn;
10085       bfd_vma si;
10086       unsigned long maxlength = 0;
10087       unsigned long nzero_counts = 0;
10088       unsigned long nsyms = 0;
10089
10090       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10091               (unsigned long) nbuckets);
10092       printf (_(" Length  Number     %% of total  Coverage\n"));
10093
10094       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10095       if (lengths == NULL)
10096         {
10097           error (_("Out of memory\n"));
10098           return 0;
10099         }
10100       for (hn = 0; hn < nbuckets; ++hn)
10101         {
10102           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
10103             {
10104               ++nsyms;
10105               if (maxlength < ++lengths[hn])
10106                 ++maxlength;
10107             }
10108         }
10109
10110       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10111       if (counts == NULL)
10112         {
10113           free (lengths);
10114           error (_("Out of memory\n"));
10115           return 0;
10116         }
10117
10118       for (hn = 0; hn < nbuckets; ++hn)
10119         ++counts[lengths[hn]];
10120
10121       if (nbuckets > 0)
10122         {
10123           unsigned long i;
10124           printf ("      0  %-10lu (%5.1f%%)\n",
10125                   counts[0], (counts[0] * 100.0) / nbuckets);
10126           for (i = 1; i <= maxlength; ++i)
10127             {
10128               nzero_counts += counts[i] * i;
10129               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10130                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10131                       (nzero_counts * 100.0) / nsyms);
10132             }
10133         }
10134
10135       free (counts);
10136       free (lengths);
10137     }
10138
10139   if (buckets != NULL)
10140     {
10141       free (buckets);
10142       free (chains);
10143     }
10144
10145   if (do_histogram && gnubuckets != NULL)
10146     {
10147       unsigned long * lengths;
10148       unsigned long * counts;
10149       unsigned long hn;
10150       unsigned long maxlength = 0;
10151       unsigned long nzero_counts = 0;
10152       unsigned long nsyms = 0;
10153
10154       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10155       if (lengths == NULL)
10156         {
10157           error (_("Out of memory\n"));
10158           return 0;
10159         }
10160
10161       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10162               (unsigned long) ngnubuckets);
10163       printf (_(" Length  Number     %% of total  Coverage\n"));
10164
10165       for (hn = 0; hn < ngnubuckets; ++hn)
10166         if (gnubuckets[hn] != 0)
10167           {
10168             bfd_vma off, length = 1;
10169
10170             for (off = gnubuckets[hn] - gnusymidx;
10171                  (gnuchains[off] & 1) == 0; ++off)
10172               ++length;
10173             lengths[hn] = length;
10174             if (length > maxlength)
10175               maxlength = length;
10176             nsyms += length;
10177           }
10178
10179       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10180       if (counts == NULL)
10181         {
10182           free (lengths);
10183           error (_("Out of memory\n"));
10184           return 0;
10185         }
10186
10187       for (hn = 0; hn < ngnubuckets; ++hn)
10188         ++counts[lengths[hn]];
10189
10190       if (ngnubuckets > 0)
10191         {
10192           unsigned long j;
10193           printf ("      0  %-10lu (%5.1f%%)\n",
10194                   counts[0], (counts[0] * 100.0) / ngnubuckets);
10195           for (j = 1; j <= maxlength; ++j)
10196             {
10197               nzero_counts += counts[j] * j;
10198               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10199                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10200                       (nzero_counts * 100.0) / nsyms);
10201             }
10202         }
10203
10204       free (counts);
10205       free (lengths);
10206       free (gnubuckets);
10207       free (gnuchains);
10208     }
10209
10210   return 1;
10211 }
10212
10213 static int
10214 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10215 {
10216   unsigned int i;
10217
10218   if (dynamic_syminfo == NULL
10219       || !do_dynamic)
10220     /* No syminfo, this is ok.  */
10221     return 1;
10222
10223   /* There better should be a dynamic symbol section.  */
10224   if (dynamic_symbols == NULL || dynamic_strings == NULL)
10225     return 0;
10226
10227   if (dynamic_addr)
10228     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10229             dynamic_syminfo_offset, dynamic_syminfo_nent);
10230
10231   printf (_(" Num: Name                           BoundTo     Flags\n"));
10232   for (i = 0; i < dynamic_syminfo_nent; ++i)
10233     {
10234       unsigned short int flags = dynamic_syminfo[i].si_flags;
10235
10236       printf ("%4d: ", i);
10237       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10238         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10239       else
10240         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10241       putchar (' ');
10242
10243       switch (dynamic_syminfo[i].si_boundto)
10244         {
10245         case SYMINFO_BT_SELF:
10246           fputs ("SELF       ", stdout);
10247           break;
10248         case SYMINFO_BT_PARENT:
10249           fputs ("PARENT     ", stdout);
10250           break;
10251         default:
10252           if (dynamic_syminfo[i].si_boundto > 0
10253               && dynamic_syminfo[i].si_boundto < dynamic_nent
10254               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10255             {
10256               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10257               putchar (' ' );
10258             }
10259           else
10260             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10261           break;
10262         }
10263
10264       if (flags & SYMINFO_FLG_DIRECT)
10265         printf (" DIRECT");
10266       if (flags & SYMINFO_FLG_PASSTHRU)
10267         printf (" PASSTHRU");
10268       if (flags & SYMINFO_FLG_COPY)
10269         printf (" COPY");
10270       if (flags & SYMINFO_FLG_LAZYLOAD)
10271         printf (" LAZYLOAD");
10272
10273       puts ("");
10274     }
10275
10276   return 1;
10277 }
10278
10279 /* Check to see if the given reloc needs to be handled in a target specific
10280    manner.  If so then process the reloc and return TRUE otherwise return
10281    FALSE.  */
10282
10283 static bfd_boolean
10284 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10285                                 unsigned char *     start,
10286                                 Elf_Internal_Sym *  symtab)
10287 {
10288   unsigned int reloc_type = get_reloc_type (reloc->r_info);
10289
10290   switch (elf_header.e_machine)
10291     {
10292     case EM_MSP430:
10293     case EM_MSP430_OLD:
10294       {
10295         static Elf_Internal_Sym * saved_sym = NULL;
10296
10297         switch (reloc_type)
10298           {
10299           case 10: /* R_MSP430_SYM_DIFF */
10300             if (uses_msp430x_relocs ())
10301               break;
10302           case 21: /* R_MSP430X_SYM_DIFF */
10303             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10304             return TRUE;
10305
10306           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10307           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10308             goto handle_sym_diff;
10309
10310           case 5: /* R_MSP430_16_BYTE */
10311           case 9: /* R_MSP430_8 */
10312             if (uses_msp430x_relocs ())
10313               break;
10314             goto handle_sym_diff;
10315
10316           case 2: /* R_MSP430_ABS16 */
10317           case 15: /* R_MSP430X_ABS16 */
10318             if (! uses_msp430x_relocs ())
10319               break;
10320             goto handle_sym_diff;
10321
10322           handle_sym_diff:
10323             if (saved_sym != NULL)
10324               {
10325                 bfd_vma value;
10326
10327                 value = reloc->r_addend
10328                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10329                      - saved_sym->st_value);
10330
10331                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10332
10333                 saved_sym = NULL;
10334                 return TRUE;
10335               }
10336             break;
10337
10338           default:
10339             if (saved_sym != NULL)
10340               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10341             break;
10342           }
10343         break;
10344       }
10345
10346     case EM_MN10300:
10347     case EM_CYGNUS_MN10300:
10348       {
10349         static Elf_Internal_Sym * saved_sym = NULL;
10350
10351         switch (reloc_type)
10352           {
10353           case 34: /* R_MN10300_ALIGN */
10354             return TRUE;
10355           case 33: /* R_MN10300_SYM_DIFF */
10356             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10357             return TRUE;
10358           case 1: /* R_MN10300_32 */
10359           case 2: /* R_MN10300_16 */
10360             if (saved_sym != NULL)
10361               {
10362                 bfd_vma value;
10363
10364                 value = reloc->r_addend
10365                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10366                      - saved_sym->st_value);
10367
10368                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10369
10370                 saved_sym = NULL;
10371                 return TRUE;
10372               }
10373             break;
10374           default:
10375             if (saved_sym != NULL)
10376               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10377             break;
10378           }
10379         break;
10380       }
10381     }
10382
10383   return FALSE;
10384 }
10385
10386 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10387    DWARF debug sections.  This is a target specific test.  Note - we do not
10388    go through the whole including-target-headers-multiple-times route, (as
10389    we have already done with <elf/h8.h>) because this would become very
10390    messy and even then this function would have to contain target specific
10391    information (the names of the relocs instead of their numeric values).
10392    FIXME: This is not the correct way to solve this problem.  The proper way
10393    is to have target specific reloc sizing and typing functions created by
10394    the reloc-macros.h header, in the same way that it already creates the
10395    reloc naming functions.  */
10396
10397 static bfd_boolean
10398 is_32bit_abs_reloc (unsigned int reloc_type)
10399 {
10400   switch (elf_header.e_machine)
10401     {
10402     case EM_386:
10403     case EM_486:
10404       return reloc_type == 1; /* R_386_32.  */
10405     case EM_68K:
10406       return reloc_type == 1; /* R_68K_32.  */
10407     case EM_860:
10408       return reloc_type == 1; /* R_860_32.  */
10409     case EM_960:
10410       return reloc_type == 2; /* R_960_32.  */
10411     case EM_AARCH64:
10412       return reloc_type == 258; /* R_AARCH64_ABS32 */
10413     case EM_ALPHA:
10414       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
10415     case EM_ARC:
10416       return reloc_type == 1; /* R_ARC_32.  */
10417     case EM_ARM:
10418       return reloc_type == 2; /* R_ARM_ABS32 */
10419     case EM_AVR_OLD:
10420     case EM_AVR:
10421       return reloc_type == 1;
10422     case EM_ADAPTEVA_EPIPHANY:
10423       return reloc_type == 3;
10424     case EM_BLACKFIN:
10425       return reloc_type == 0x12; /* R_byte4_data.  */
10426     case EM_CRIS:
10427       return reloc_type == 3; /* R_CRIS_32.  */
10428     case EM_CR16:
10429       return reloc_type == 3; /* R_CR16_NUM32.  */
10430     case EM_CRX:
10431       return reloc_type == 15; /* R_CRX_NUM32.  */
10432     case EM_CYGNUS_FRV:
10433       return reloc_type == 1;
10434     case EM_CYGNUS_D10V:
10435     case EM_D10V:
10436       return reloc_type == 6; /* R_D10V_32.  */
10437     case EM_CYGNUS_D30V:
10438     case EM_D30V:
10439       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
10440     case EM_DLX:
10441       return reloc_type == 3; /* R_DLX_RELOC_32.  */
10442     case EM_CYGNUS_FR30:
10443     case EM_FR30:
10444       return reloc_type == 3; /* R_FR30_32.  */
10445     case EM_H8S:
10446     case EM_H8_300:
10447     case EM_H8_300H:
10448       return reloc_type == 1; /* R_H8_DIR32.  */
10449     case EM_IA_64:
10450       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
10451     case EM_IP2K_OLD:
10452     case EM_IP2K:
10453       return reloc_type == 2; /* R_IP2K_32.  */
10454     case EM_IQ2000:
10455       return reloc_type == 2; /* R_IQ2000_32.  */
10456     case EM_LATTICEMICO32:
10457       return reloc_type == 3; /* R_LM32_32.  */
10458     case EM_M32C_OLD:
10459     case EM_M32C:
10460       return reloc_type == 3; /* R_M32C_32.  */
10461     case EM_M32R:
10462       return reloc_type == 34; /* R_M32R_32_RELA.  */
10463     case EM_MCORE:
10464       return reloc_type == 1; /* R_MCORE_ADDR32.  */
10465     case EM_CYGNUS_MEP:
10466       return reloc_type == 4; /* R_MEP_32.  */
10467     case EM_METAG:
10468       return reloc_type == 2; /* R_METAG_ADDR32.  */
10469     case EM_MICROBLAZE:
10470       return reloc_type == 1; /* R_MICROBLAZE_32.  */
10471     case EM_MIPS:
10472       return reloc_type == 2; /* R_MIPS_32.  */
10473     case EM_MMIX:
10474       return reloc_type == 4; /* R_MMIX_32.  */
10475     case EM_CYGNUS_MN10200:
10476     case EM_MN10200:
10477       return reloc_type == 1; /* R_MN10200_32.  */
10478     case EM_CYGNUS_MN10300:
10479     case EM_MN10300:
10480       return reloc_type == 1; /* R_MN10300_32.  */
10481     case EM_MOXIE:
10482       return reloc_type == 1; /* R_MOXIE_32.  */
10483     case EM_MSP430_OLD:
10484     case EM_MSP430:
10485       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
10486     case EM_MT:
10487       return reloc_type == 2; /* R_MT_32.  */
10488     case EM_NDS32:
10489       return reloc_type == 20; /* R_NDS32_RELA.  */
10490     case EM_ALTERA_NIOS2:
10491       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
10492     case EM_NIOS32:
10493       return reloc_type == 1; /* R_NIOS_32.  */
10494     case EM_OR1K:
10495       return reloc_type == 1; /* R_OR1K_32.  */
10496     case EM_PARISC:
10497       return (reloc_type == 1 /* R_PARISC_DIR32.  */
10498               || reloc_type == 41); /* R_PARISC_SECREL32.  */
10499     case EM_PJ:
10500     case EM_PJ_OLD:
10501       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
10502     case EM_PPC64:
10503       return reloc_type == 1; /* R_PPC64_ADDR32.  */
10504     case EM_PPC:
10505       return reloc_type == 1; /* R_PPC_ADDR32.  */
10506     case EM_RL78:
10507       return reloc_type == 1; /* R_RL78_DIR32.  */
10508     case EM_RX:
10509       return reloc_type == 1; /* R_RX_DIR32.  */
10510     case EM_S370:
10511       return reloc_type == 1; /* R_I370_ADDR31.  */
10512     case EM_S390_OLD:
10513     case EM_S390:
10514       return reloc_type == 4; /* R_S390_32.  */
10515     case EM_SCORE:
10516       return reloc_type == 8; /* R_SCORE_ABS32.  */
10517     case EM_SH:
10518       return reloc_type == 1; /* R_SH_DIR32.  */
10519     case EM_SPARC32PLUS:
10520     case EM_SPARCV9:
10521     case EM_SPARC:
10522       return reloc_type == 3 /* R_SPARC_32.  */
10523         || reloc_type == 23; /* R_SPARC_UA32.  */
10524     case EM_SPU:
10525       return reloc_type == 6; /* R_SPU_ADDR32 */
10526     case EM_TI_C6000:
10527       return reloc_type == 1; /* R_C6000_ABS32.  */
10528     case EM_TILEGX:
10529       return reloc_type == 2; /* R_TILEGX_32.  */
10530     case EM_TILEPRO:
10531       return reloc_type == 1; /* R_TILEPRO_32.  */
10532     case EM_CYGNUS_V850:
10533     case EM_V850:
10534       return reloc_type == 6; /* R_V850_ABS32.  */
10535     case EM_V800:
10536       return reloc_type == 0x33; /* R_V810_WORD.  */
10537     case EM_VAX:
10538       return reloc_type == 1; /* R_VAX_32.  */
10539     case EM_X86_64:
10540     case EM_L1OM:
10541     case EM_K1OM:
10542       return reloc_type == 10; /* R_X86_64_32.  */
10543     case EM_XC16X:
10544     case EM_C166:
10545       return reloc_type == 3; /* R_XC16C_ABS_32.  */
10546     case EM_XGATE:
10547       return reloc_type == 4; /* R_XGATE_32.  */
10548     case EM_XSTORMY16:
10549       return reloc_type == 1; /* R_XSTROMY16_32.  */
10550     case EM_XTENSA_OLD:
10551     case EM_XTENSA:
10552       return reloc_type == 1; /* R_XTENSA_32.  */
10553     default:
10554       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10555              elf_header.e_machine);
10556       abort ();
10557     }
10558 }
10559
10560 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10561    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
10562
10563 static bfd_boolean
10564 is_32bit_pcrel_reloc (unsigned int reloc_type)
10565 {
10566   switch (elf_header.e_machine)
10567     {
10568     case EM_386:
10569     case EM_486:
10570       return reloc_type == 2;  /* R_386_PC32.  */
10571     case EM_68K:
10572       return reloc_type == 4;  /* R_68K_PC32.  */
10573     case EM_AARCH64:
10574       return reloc_type == 261; /* R_AARCH64_PREL32 */
10575     case EM_ADAPTEVA_EPIPHANY:
10576       return reloc_type == 6;
10577     case EM_ALPHA:
10578       return reloc_type == 10; /* R_ALPHA_SREL32.  */
10579     case EM_ARM:
10580       return reloc_type == 3;  /* R_ARM_REL32 */
10581     case EM_MICROBLAZE:
10582       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
10583     case EM_OR1K:
10584       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
10585     case EM_PARISC:
10586       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
10587     case EM_PPC:
10588       return reloc_type == 26; /* R_PPC_REL32.  */
10589     case EM_PPC64:
10590       return reloc_type == 26; /* R_PPC64_REL32.  */
10591     case EM_S390_OLD:
10592     case EM_S390:
10593       return reloc_type == 5;  /* R_390_PC32.  */
10594     case EM_SH:
10595       return reloc_type == 2;  /* R_SH_REL32.  */
10596     case EM_SPARC32PLUS:
10597     case EM_SPARCV9:
10598     case EM_SPARC:
10599       return reloc_type == 6;  /* R_SPARC_DISP32.  */
10600     case EM_SPU:
10601       return reloc_type == 13; /* R_SPU_REL32.  */
10602     case EM_TILEGX:
10603       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
10604     case EM_TILEPRO:
10605       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
10606     case EM_X86_64:
10607     case EM_L1OM:
10608     case EM_K1OM:
10609       return reloc_type == 2;  /* R_X86_64_PC32.  */
10610     case EM_XTENSA_OLD:
10611     case EM_XTENSA:
10612       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
10613     default:
10614       /* Do not abort or issue an error message here.  Not all targets use
10615          pc-relative 32-bit relocs in their DWARF debug information and we
10616          have already tested for target coverage in is_32bit_abs_reloc.  A
10617          more helpful warning message will be generated by apply_relocations
10618          anyway, so just return.  */
10619       return FALSE;
10620     }
10621 }
10622
10623 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10624    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
10625
10626 static bfd_boolean
10627 is_64bit_abs_reloc (unsigned int reloc_type)
10628 {
10629   switch (elf_header.e_machine)
10630     {
10631     case EM_AARCH64:
10632       return reloc_type == 257; /* R_AARCH64_ABS64.  */
10633     case EM_ALPHA:
10634       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
10635     case EM_IA_64:
10636       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
10637     case EM_PARISC:
10638       return reloc_type == 80; /* R_PARISC_DIR64.  */
10639     case EM_PPC64:
10640       return reloc_type == 38; /* R_PPC64_ADDR64.  */
10641     case EM_SPARC32PLUS:
10642     case EM_SPARCV9:
10643     case EM_SPARC:
10644       return reloc_type == 54; /* R_SPARC_UA64.  */
10645     case EM_X86_64:
10646     case EM_L1OM:
10647     case EM_K1OM:
10648       return reloc_type == 1; /* R_X86_64_64.  */
10649     case EM_S390_OLD:
10650     case EM_S390:
10651       return reloc_type == 22;  /* R_S390_64.  */
10652     case EM_TILEGX:
10653       return reloc_type == 1; /* R_TILEGX_64.  */
10654     case EM_MIPS:
10655       return reloc_type == 18;  /* R_MIPS_64.  */
10656     default:
10657       return FALSE;
10658     }
10659 }
10660
10661 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10662    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10663
10664 static bfd_boolean
10665 is_64bit_pcrel_reloc (unsigned int reloc_type)
10666 {
10667   switch (elf_header.e_machine)
10668     {
10669     case EM_AARCH64:
10670       return reloc_type == 260; /* R_AARCH64_PREL64.  */
10671     case EM_ALPHA:
10672       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10673     case EM_IA_64:
10674       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10675     case EM_PARISC:
10676       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10677     case EM_PPC64:
10678       return reloc_type == 44; /* R_PPC64_REL64.  */
10679     case EM_SPARC32PLUS:
10680     case EM_SPARCV9:
10681     case EM_SPARC:
10682       return reloc_type == 46; /* R_SPARC_DISP64.  */
10683     case EM_X86_64:
10684     case EM_L1OM:
10685     case EM_K1OM:
10686       return reloc_type == 24; /* R_X86_64_PC64.  */
10687     case EM_S390_OLD:
10688     case EM_S390:
10689       return reloc_type == 23;  /* R_S390_PC64.  */
10690     case EM_TILEGX:
10691       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10692     default:
10693       return FALSE;
10694     }
10695 }
10696
10697 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10698    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10699
10700 static bfd_boolean
10701 is_24bit_abs_reloc (unsigned int reloc_type)
10702 {
10703   switch (elf_header.e_machine)
10704     {
10705     case EM_CYGNUS_MN10200:
10706     case EM_MN10200:
10707       return reloc_type == 4; /* R_MN10200_24.  */
10708     default:
10709       return FALSE;
10710     }
10711 }
10712
10713 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10714    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10715
10716 static bfd_boolean
10717 is_16bit_abs_reloc (unsigned int reloc_type)
10718 {
10719   switch (elf_header.e_machine)
10720     {
10721     case EM_AVR_OLD:
10722     case EM_AVR:
10723       return reloc_type == 4; /* R_AVR_16.  */
10724     case EM_ADAPTEVA_EPIPHANY:
10725       return reloc_type == 5;
10726     case EM_CYGNUS_D10V:
10727     case EM_D10V:
10728       return reloc_type == 3; /* R_D10V_16.  */
10729     case EM_H8S:
10730     case EM_H8_300:
10731     case EM_H8_300H:
10732       return reloc_type == R_H8_DIR16;
10733     case EM_IP2K_OLD:
10734     case EM_IP2K:
10735       return reloc_type == 1; /* R_IP2K_16.  */
10736     case EM_M32C_OLD:
10737     case EM_M32C:
10738       return reloc_type == 1; /* R_M32C_16 */
10739     case EM_MSP430:
10740       if (uses_msp430x_relocs ())
10741         return reloc_type == 2; /* R_MSP430_ABS16.  */
10742     case EM_MSP430_OLD:
10743       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10744     case EM_NDS32:
10745       return reloc_type == 19; /* R_NDS32_RELA.  */
10746     case EM_ALTERA_NIOS2:
10747       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
10748     case EM_NIOS32:
10749       return reloc_type == 9; /* R_NIOS_16.  */
10750     case EM_OR1K:
10751       return reloc_type == 2; /* R_OR1K_16.  */
10752     case EM_TI_C6000:
10753       return reloc_type == 2; /* R_C6000_ABS16.  */
10754     case EM_XC16X:
10755     case EM_C166:
10756       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10757     case EM_CYGNUS_MN10200:
10758     case EM_MN10200:
10759       return reloc_type == 2; /* R_MN10200_16.  */
10760     case EM_CYGNUS_MN10300:
10761     case EM_MN10300:
10762       return reloc_type == 2; /* R_MN10300_16.  */
10763     case EM_XGATE:
10764       return reloc_type == 3; /* R_XGATE_16.  */
10765     default:
10766       return FALSE;
10767     }
10768 }
10769
10770 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10771    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10772
10773 static bfd_boolean
10774 is_none_reloc (unsigned int reloc_type)
10775 {
10776   switch (elf_header.e_machine)
10777     {
10778     case EM_68K:     /* R_68K_NONE.  */
10779     case EM_386:     /* R_386_NONE.  */
10780     case EM_SPARC32PLUS:
10781     case EM_SPARCV9:
10782     case EM_SPARC:   /* R_SPARC_NONE.  */
10783     case EM_MIPS:    /* R_MIPS_NONE.  */
10784     case EM_PARISC:  /* R_PARISC_NONE.  */
10785     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10786     case EM_ADAPTEVA_EPIPHANY:
10787     case EM_PPC:     /* R_PPC_NONE.  */
10788     case EM_PPC64:   /* R_PPC64_NONE.  */
10789     case EM_ARM:     /* R_ARM_NONE.  */
10790     case EM_IA_64:   /* R_IA64_NONE.  */
10791     case EM_SH:      /* R_SH_NONE.  */
10792     case EM_S390_OLD:
10793     case EM_S390:    /* R_390_NONE.  */
10794     case EM_CRIS:    /* R_CRIS_NONE.  */
10795     case EM_X86_64:  /* R_X86_64_NONE.  */
10796     case EM_L1OM:    /* R_X86_64_NONE.  */
10797     case EM_K1OM:    /* R_X86_64_NONE.  */
10798     case EM_MN10300: /* R_MN10300_NONE.  */
10799     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10800     case EM_M32R:    /* R_M32R_NONE.  */
10801     case EM_TI_C6000:/* R_C6000_NONE.  */
10802     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10803     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10804     case EM_XC16X:
10805     case EM_C166:    /* R_XC16X_NONE.  */
10806     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
10807     case EM_NIOS32:  /* R_NIOS_NONE.  */
10808     case EM_OR1K:    /* R_OR1K_NONE. */
10809       return reloc_type == 0;
10810     case EM_AARCH64:
10811       return reloc_type == 0 || reloc_type == 256;
10812     case EM_NDS32:
10813       return (reloc_type == 0       /* R_XTENSA_NONE.  */
10814               || reloc_type == 204  /* R_NDS32_DIFF8.  */
10815               || reloc_type == 205  /* R_NDS32_DIFF16.  */
10816               || reloc_type == 206  /* R_NDS32_DIFF32.  */
10817               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
10818     case EM_XTENSA_OLD:
10819     case EM_XTENSA:
10820       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10821               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
10822               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
10823               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
10824     case EM_METAG:
10825       return reloc_type == 3; /* R_METAG_NONE.  */
10826     }
10827   return FALSE;
10828 }
10829
10830 /* Apply relocations to a section.
10831    Note: So far support has been added only for those relocations
10832    which can be found in debug sections.
10833    FIXME: Add support for more relocations ?  */
10834
10835 static void
10836 apply_relocations (void * file,
10837                    Elf_Internal_Shdr * section,
10838                    unsigned char * start)
10839 {
10840   Elf_Internal_Shdr * relsec;
10841   unsigned char * end = start + section->sh_size;
10842
10843   if (elf_header.e_type != ET_REL)
10844     return;
10845
10846   /* Find the reloc section associated with the section.  */
10847   for (relsec = section_headers;
10848        relsec < section_headers + elf_header.e_shnum;
10849        ++relsec)
10850     {
10851       bfd_boolean is_rela;
10852       unsigned long num_relocs;
10853       Elf_Internal_Rela * relocs;
10854       Elf_Internal_Rela * rp;
10855       Elf_Internal_Shdr * symsec;
10856       Elf_Internal_Sym * symtab;
10857       unsigned long num_syms;
10858       Elf_Internal_Sym * sym;
10859
10860       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10861           || relsec->sh_info >= elf_header.e_shnum
10862           || section_headers + relsec->sh_info != section
10863           || relsec->sh_size == 0
10864           || relsec->sh_link >= elf_header.e_shnum)
10865         continue;
10866
10867       is_rela = relsec->sh_type == SHT_RELA;
10868
10869       if (is_rela)
10870         {
10871           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10872                                   relsec->sh_size, & relocs, & num_relocs))
10873             return;
10874         }
10875       else
10876         {
10877           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10878                                  relsec->sh_size, & relocs, & num_relocs))
10879             return;
10880         }
10881
10882       /* SH uses RELA but uses in place value instead of the addend field.  */
10883       if (elf_header.e_machine == EM_SH)
10884         is_rela = FALSE;
10885
10886       symsec = section_headers + relsec->sh_link;
10887       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10888
10889       for (rp = relocs; rp < relocs + num_relocs; ++rp)
10890         {
10891           bfd_vma         addend;
10892           unsigned int    reloc_type;
10893           unsigned int    reloc_size;
10894           unsigned char * rloc;
10895           unsigned long   sym_index;
10896
10897           reloc_type = get_reloc_type (rp->r_info);
10898
10899           if (target_specific_reloc_handling (rp, start, symtab))
10900             continue;
10901           else if (is_none_reloc (reloc_type))
10902             continue;
10903           else if (is_32bit_abs_reloc (reloc_type)
10904                    || is_32bit_pcrel_reloc (reloc_type))
10905             reloc_size = 4;
10906           else if (is_64bit_abs_reloc (reloc_type)
10907                    || is_64bit_pcrel_reloc (reloc_type))
10908             reloc_size = 8;
10909           else if (is_24bit_abs_reloc (reloc_type))
10910             reloc_size = 3;
10911           else if (is_16bit_abs_reloc (reloc_type))
10912             reloc_size = 2;
10913           else
10914             {
10915               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10916                     reloc_type, SECTION_NAME (section));
10917               continue;
10918             }
10919
10920           rloc = start + rp->r_offset;
10921           if ((rloc + reloc_size) > end || (rloc < start))
10922             {
10923               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10924                     (unsigned long) rp->r_offset,
10925                     SECTION_NAME (section));
10926               continue;
10927             }
10928
10929           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10930           if (sym_index >= num_syms)
10931             {
10932               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10933                     sym_index, SECTION_NAME (section));
10934               continue;
10935             }
10936           sym = symtab + sym_index;
10937
10938           /* If the reloc has a symbol associated with it,
10939              make sure that it is of an appropriate type.
10940
10941              Relocations against symbols without type can happen.
10942              Gcc -feliminate-dwarf2-dups may generate symbols
10943              without type for debug info.
10944
10945              Icc generates relocations against function symbols
10946              instead of local labels.
10947
10948              Relocations against object symbols can happen, eg when
10949              referencing a global array.  For an example of this see
10950              the _clz.o binary in libgcc.a.  */
10951           if (sym != symtab
10952               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10953             {
10954               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10955                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10956                     (long int)(rp - relocs),
10957                     SECTION_NAME (relsec));
10958               continue;
10959             }
10960
10961           addend = 0;
10962           if (is_rela)
10963             addend += rp->r_addend;
10964           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10965              partial_inplace.  */
10966           if (!is_rela
10967               || (elf_header.e_machine == EM_XTENSA
10968                   && reloc_type == 1)
10969               || ((elf_header.e_machine == EM_PJ
10970                    || elf_header.e_machine == EM_PJ_OLD)
10971                   && reloc_type == 1)
10972               || ((elf_header.e_machine == EM_D30V
10973                    || elf_header.e_machine == EM_CYGNUS_D30V)
10974                   && reloc_type == 12))
10975             addend += byte_get (rloc, reloc_size);
10976
10977           if (is_32bit_pcrel_reloc (reloc_type)
10978               || is_64bit_pcrel_reloc (reloc_type))
10979             {
10980               /* On HPPA, all pc-relative relocations are biased by 8.  */
10981               if (elf_header.e_machine == EM_PARISC)
10982                 addend -= 8;
10983               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10984                         reloc_size);
10985             }
10986           else
10987             byte_put (rloc, addend + sym->st_value, reloc_size);
10988         }
10989
10990       free (symtab);
10991       free (relocs);
10992       break;
10993     }
10994 }
10995
10996 #ifdef SUPPORT_DISASSEMBLY
10997 static int
10998 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10999 {
11000   printf (_("\nAssembly dump of section %s\n"),
11001           SECTION_NAME (section));
11002
11003   /* XXX -- to be done --- XXX */
11004
11005   return 1;
11006 }
11007 #endif
11008
11009 /* Reads in the contents of SECTION from FILE, returning a pointer
11010    to a malloc'ed buffer or NULL if something went wrong.  */
11011
11012 static char *
11013 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11014 {
11015   bfd_size_type num_bytes;
11016
11017   num_bytes = section->sh_size;
11018
11019   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11020     {
11021       printf (_("\nSection '%s' has no data to dump.\n"),
11022               SECTION_NAME (section));
11023       return NULL;
11024     }
11025
11026   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11027                              _("section contents"));
11028 }
11029
11030
11031 static void
11032 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11033 {
11034   Elf_Internal_Shdr * relsec;
11035   bfd_size_type num_bytes;
11036   char * data;
11037   char * end;
11038   char * start;
11039   char * name = SECTION_NAME (section);
11040   bfd_boolean some_strings_shown;
11041
11042   start = get_section_contents (section, file);
11043   if (start == NULL)
11044     return;
11045
11046   printf (_("\nString dump of section '%s':\n"), name);
11047
11048   /* If the section being dumped has relocations against it the user might
11049      be expecting these relocations to have been applied.  Check for this
11050      case and issue a warning message in order to avoid confusion.
11051      FIXME: Maybe we ought to have an option that dumps a section with
11052      relocs applied ?  */
11053   for (relsec = section_headers;
11054        relsec < section_headers + elf_header.e_shnum;
11055        ++relsec)
11056     {
11057       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11058           || relsec->sh_info >= elf_header.e_shnum
11059           || section_headers + relsec->sh_info != section
11060           || relsec->sh_size == 0
11061           || relsec->sh_link >= elf_header.e_shnum)
11062         continue;
11063
11064       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11065       break;
11066     }
11067
11068   num_bytes = section->sh_size;
11069   data = start;
11070   end  = start + num_bytes;
11071   some_strings_shown = FALSE;
11072
11073   while (data < end)
11074     {
11075       while (!ISPRINT (* data))
11076         if (++ data >= end)
11077           break;
11078
11079       if (data < end)
11080         {
11081 #ifndef __MSVCRT__
11082           /* PR 11128: Use two separate invocations in order to work
11083              around bugs in the Solaris 8 implementation of printf.  */
11084           printf ("  [%6tx]  ", data - start);
11085           printf ("%s\n", data);
11086 #else
11087           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
11088 #endif
11089           data += strlen (data);
11090           some_strings_shown = TRUE;
11091         }
11092     }
11093
11094   if (! some_strings_shown)
11095     printf (_("  No strings found in this section."));
11096
11097   free (start);
11098
11099   putchar ('\n');
11100 }
11101
11102 static void
11103 dump_section_as_bytes (Elf_Internal_Shdr * section,
11104                        FILE * file,
11105                        bfd_boolean relocate)
11106 {
11107   Elf_Internal_Shdr * relsec;
11108   bfd_size_type bytes;
11109   bfd_vma addr;
11110   unsigned char * data;
11111   unsigned char * start;
11112
11113   start = (unsigned char *) get_section_contents (section, file);
11114   if (start == NULL)
11115     return;
11116
11117   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
11118
11119   if (relocate)
11120     {
11121       apply_relocations (file, section, start);
11122     }
11123   else
11124     {
11125       /* If the section being dumped has relocations against it the user might
11126          be expecting these relocations to have been applied.  Check for this
11127          case and issue a warning message in order to avoid confusion.
11128          FIXME: Maybe we ought to have an option that dumps a section with
11129          relocs applied ?  */
11130       for (relsec = section_headers;
11131            relsec < section_headers + elf_header.e_shnum;
11132            ++relsec)
11133         {
11134           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11135               || relsec->sh_info >= elf_header.e_shnum
11136               || section_headers + relsec->sh_info != section
11137               || relsec->sh_size == 0
11138               || relsec->sh_link >= elf_header.e_shnum)
11139             continue;
11140
11141           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11142           break;
11143         }
11144     }
11145
11146   addr = section->sh_addr;
11147   bytes = section->sh_size;
11148   data = start;
11149
11150   while (bytes)
11151     {
11152       int j;
11153       int k;
11154       int lbytes;
11155
11156       lbytes = (bytes > 16 ? 16 : bytes);
11157
11158       printf ("  0x%8.8lx ", (unsigned long) addr);
11159
11160       for (j = 0; j < 16; j++)
11161         {
11162           if (j < lbytes)
11163             printf ("%2.2x", data[j]);
11164           else
11165             printf ("  ");
11166
11167           if ((j & 3) == 3)
11168             printf (" ");
11169         }
11170
11171       for (j = 0; j < lbytes; j++)
11172         {
11173           k = data[j];
11174           if (k >= ' ' && k < 0x7f)
11175             printf ("%c", k);
11176           else
11177             printf (".");
11178         }
11179
11180       putchar ('\n');
11181
11182       data  += lbytes;
11183       addr  += lbytes;
11184       bytes -= lbytes;
11185     }
11186
11187   free (start);
11188
11189   putchar ('\n');
11190 }
11191
11192 /* Uncompresses a section that was compressed using zlib, in place.  */
11193
11194 static int
11195 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11196                              dwarf_size_type *size ATTRIBUTE_UNUSED)
11197 {
11198 #ifndef HAVE_ZLIB_H
11199   return FALSE;
11200 #else
11201   dwarf_size_type compressed_size = *size;
11202   unsigned char * compressed_buffer = *buffer;
11203   dwarf_size_type uncompressed_size;
11204   unsigned char * uncompressed_buffer;
11205   z_stream strm;
11206   int rc;
11207   dwarf_size_type header_size = 12;
11208
11209   /* Read the zlib header.  In this case, it should be "ZLIB" followed
11210      by the uncompressed section size, 8 bytes in big-endian order.  */
11211   if (compressed_size < header_size
11212       || ! streq ((char *) compressed_buffer, "ZLIB"))
11213     return 0;
11214
11215   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11216   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11217   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11218   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11219   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11220   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11221   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11222   uncompressed_size += compressed_buffer[11];
11223
11224   /* It is possible the section consists of several compressed
11225      buffers concatenated together, so we uncompress in a loop.  */
11226   strm.zalloc = NULL;
11227   strm.zfree = NULL;
11228   strm.opaque = NULL;
11229   strm.avail_in = compressed_size - header_size;
11230   strm.next_in = (Bytef *) compressed_buffer + header_size;
11231   strm.avail_out = uncompressed_size;
11232   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11233
11234   rc = inflateInit (& strm);
11235   while (strm.avail_in > 0)
11236     {
11237       if (rc != Z_OK)
11238         goto fail;
11239       strm.next_out = ((Bytef *) uncompressed_buffer
11240                        + (uncompressed_size - strm.avail_out));
11241       rc = inflate (&strm, Z_FINISH);
11242       if (rc != Z_STREAM_END)
11243         goto fail;
11244       rc = inflateReset (& strm);
11245     }
11246   rc = inflateEnd (& strm);
11247   if (rc != Z_OK
11248       || strm.avail_out != 0)
11249     goto fail;
11250
11251   free (compressed_buffer);
11252   *buffer = uncompressed_buffer;
11253   *size = uncompressed_size;
11254   return 1;
11255
11256  fail:
11257   free (uncompressed_buffer);
11258   /* Indicate decompression failure.  */
11259   *buffer = NULL;
11260   return 0;
11261 #endif  /* HAVE_ZLIB_H */
11262 }
11263
11264 static int
11265 load_specific_debug_section (enum dwarf_section_display_enum debug,
11266                              Elf_Internal_Shdr * sec, void * file)
11267 {
11268   struct dwarf_section * section = &debug_displays [debug].section;
11269   char buf [64];
11270
11271   /* If it is already loaded, do nothing.  */
11272   if (section->start != NULL)
11273     return 1;
11274
11275   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11276   section->address = sec->sh_addr;
11277   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11278                                                sec->sh_offset, 1,
11279                                                sec->sh_size, buf);
11280   if (section->start == NULL)
11281     section->size = 0;
11282   else
11283     {
11284       section->size = sec->sh_size;
11285       if (uncompress_section_contents (&section->start, &section->size))
11286         sec->sh_size = section->size;
11287     }
11288
11289   if (section->start == NULL)
11290     return 0;
11291
11292   if (debug_displays [debug].relocate)
11293     apply_relocations ((FILE *) file, sec, section->start);
11294
11295   return 1;
11296 }
11297
11298 /* If this is not NULL, load_debug_section will only look for sections
11299    within the list of sections given here.  */
11300 unsigned int *section_subset = NULL;
11301
11302 int
11303 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11304 {
11305   struct dwarf_section * section = &debug_displays [debug].section;
11306   Elf_Internal_Shdr * sec;
11307
11308   /* Locate the debug section.  */
11309   sec = find_section_in_set (section->uncompressed_name, section_subset);
11310   if (sec != NULL)
11311     section->name = section->uncompressed_name;
11312   else
11313     {
11314       sec = find_section_in_set (section->compressed_name, section_subset);
11315       if (sec != NULL)
11316         section->name = section->compressed_name;
11317     }
11318   if (sec == NULL)
11319     return 0;
11320
11321   /* If we're loading from a subset of sections, and we've loaded
11322      a section matching this name before, it's likely that it's a
11323      different one.  */
11324   if (section_subset != NULL)
11325     free_debug_section (debug);
11326
11327   return load_specific_debug_section (debug, sec, (FILE *) file);
11328 }
11329
11330 void
11331 free_debug_section (enum dwarf_section_display_enum debug)
11332 {
11333   struct dwarf_section * section = &debug_displays [debug].section;
11334
11335   if (section->start == NULL)
11336     return;
11337
11338   free ((char *) section->start);
11339   section->start = NULL;
11340   section->address = 0;
11341   section->size = 0;
11342 }
11343
11344 static int
11345 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11346 {
11347   char * name = SECTION_NAME (section);
11348   bfd_size_type length;
11349   int result = 1;
11350   int i;
11351
11352   length = section->sh_size;
11353   if (length == 0)
11354     {
11355       printf (_("\nSection '%s' has no debugging data.\n"), name);
11356       return 0;
11357     }
11358   if (section->sh_type == SHT_NOBITS)
11359     {
11360       /* There is no point in dumping the contents of a debugging section
11361          which has the NOBITS type - the bits in the file will be random.
11362          This can happen when a file containing a .eh_frame section is
11363          stripped with the --only-keep-debug command line option.  */
11364       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11365       return 0;
11366     }
11367
11368   if (const_strneq (name, ".gnu.linkonce.wi."))
11369     name = ".debug_info";
11370
11371   /* See if we know how to display the contents of this section.  */
11372   for (i = 0; i < max; i++)
11373     if (streq (debug_displays[i].section.uncompressed_name, name)
11374         || (i == line && const_strneq (name, ".debug_line."))
11375         || streq (debug_displays[i].section.compressed_name, name))
11376       {
11377         struct dwarf_section * sec = &debug_displays [i].section;
11378         int secondary = (section != find_section (name));
11379
11380         if (secondary)
11381           free_debug_section ((enum dwarf_section_display_enum) i);
11382
11383         if (i == line && const_strneq (name, ".debug_line."))
11384           sec->name = name;
11385         else if (streq (sec->uncompressed_name, name))
11386           sec->name = sec->uncompressed_name;
11387         else
11388           sec->name = sec->compressed_name;
11389         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11390                                          section, file))
11391           {
11392             /* If this debug section is part of a CU/TU set in a .dwp file,
11393                restrict load_debug_section to the sections in that set.  */
11394             section_subset = find_cu_tu_set (file, shndx);
11395
11396             result &= debug_displays[i].display (sec, file);
11397
11398             section_subset = NULL;
11399
11400             if (secondary || (i != info && i != abbrev))
11401               free_debug_section ((enum dwarf_section_display_enum) i);
11402           }
11403
11404         break;
11405       }
11406
11407   if (i == max)
11408     {
11409       printf (_("Unrecognized debug section: %s\n"), name);
11410       result = 0;
11411     }
11412
11413   return result;
11414 }
11415
11416 /* Set DUMP_SECTS for all sections where dumps were requested
11417    based on section name.  */
11418
11419 static void
11420 initialise_dumps_byname (void)
11421 {
11422   struct dump_list_entry * cur;
11423
11424   for (cur = dump_sects_byname; cur; cur = cur->next)
11425     {
11426       unsigned int i;
11427       int any;
11428
11429       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11430         if (streq (SECTION_NAME (section_headers + i), cur->name))
11431           {
11432             request_dump_bynumber (i, cur->type);
11433             any = 1;
11434           }
11435
11436       if (!any)
11437         warn (_("Section '%s' was not dumped because it does not exist!\n"),
11438               cur->name);
11439     }
11440 }
11441
11442 static void
11443 process_section_contents (FILE * file)
11444 {
11445   Elf_Internal_Shdr * section;
11446   unsigned int i;
11447
11448   if (! do_dump)
11449     return;
11450
11451   initialise_dumps_byname ();
11452
11453   for (i = 0, section = section_headers;
11454        i < elf_header.e_shnum && i < num_dump_sects;
11455        i++, section++)
11456     {
11457 #ifdef SUPPORT_DISASSEMBLY
11458       if (dump_sects[i] & DISASS_DUMP)
11459         disassemble_section (section, file);
11460 #endif
11461       if (dump_sects[i] & HEX_DUMP)
11462         dump_section_as_bytes (section, file, FALSE);
11463
11464       if (dump_sects[i] & RELOC_DUMP)
11465         dump_section_as_bytes (section, file, TRUE);
11466
11467       if (dump_sects[i] & STRING_DUMP)
11468         dump_section_as_strings (section, file);
11469
11470       if (dump_sects[i] & DEBUG_DUMP)
11471         display_debug_section (i, section, file);
11472     }
11473
11474   /* Check to see if the user requested a
11475      dump of a section that does not exist.  */
11476   while (i++ < num_dump_sects)
11477     if (dump_sects[i])
11478       warn (_("Section %d was not dumped because it does not exist!\n"), i);
11479 }
11480
11481 static void
11482 process_mips_fpe_exception (int mask)
11483 {
11484   if (mask)
11485     {
11486       int first = 1;
11487       if (mask & OEX_FPU_INEX)
11488         fputs ("INEX", stdout), first = 0;
11489       if (mask & OEX_FPU_UFLO)
11490         printf ("%sUFLO", first ? "" : "|"), first = 0;
11491       if (mask & OEX_FPU_OFLO)
11492         printf ("%sOFLO", first ? "" : "|"), first = 0;
11493       if (mask & OEX_FPU_DIV0)
11494         printf ("%sDIV0", first ? "" : "|"), first = 0;
11495       if (mask & OEX_FPU_INVAL)
11496         printf ("%sINVAL", first ? "" : "|");
11497     }
11498   else
11499     fputs ("0", stdout);
11500 }
11501
11502 /* Display's the value of TAG at location P.  If TAG is
11503    greater than 0 it is assumed to be an unknown tag, and
11504    a message is printed to this effect.  Otherwise it is
11505    assumed that a message has already been printed.
11506
11507    If the bottom bit of TAG is set it assumed to have a
11508    string value, otherwise it is assumed to have an integer
11509    value.
11510
11511    Returns an updated P pointing to the first unread byte
11512    beyond the end of TAG's value.
11513
11514    Reads at or beyond END will not be made.  */
11515
11516 static unsigned char *
11517 display_tag_value (int tag,
11518                    unsigned char * p,
11519                    const unsigned char * const end)
11520 {
11521   unsigned long val;
11522
11523   if (tag > 0)
11524     printf ("  Tag_unknown_%d: ", tag);
11525
11526   if (p >= end)
11527     {
11528       warn (_("corrupt tag\n"));
11529     }
11530   else if (tag & 1)
11531     {
11532       /* FIXME: we could read beyond END here.  */
11533       printf ("\"%s\"\n", p);
11534       p += strlen ((char *) p) + 1;
11535     }
11536   else
11537     {
11538       unsigned int len;
11539
11540       val = read_uleb128 (p, &len, end);
11541       p += len;
11542       printf ("%ld (0x%lx)\n", val, val);
11543     }
11544
11545   return p;
11546 }
11547
11548 /* ARM EABI attributes section.  */
11549 typedef struct
11550 {
11551   unsigned int tag;
11552   const char * name;
11553   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
11554   unsigned int type;
11555   const char ** table;
11556 } arm_attr_public_tag;
11557
11558 static const char * arm_attr_tag_CPU_arch[] =
11559   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11560    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11561 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11562 static const char * arm_attr_tag_THUMB_ISA_use[] =
11563   {"No", "Thumb-1", "Thumb-2"};
11564 static const char * arm_attr_tag_FP_arch[] =
11565   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11566    "FP for ARMv8"};
11567 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11568 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11569   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11570 static const char * arm_attr_tag_PCS_config[] =
11571   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11572    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11573 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11574   {"V6", "SB", "TLS", "Unused"};
11575 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11576   {"Absolute", "PC-relative", "SB-relative", "None"};
11577 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11578   {"Absolute", "PC-relative", "None"};
11579 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11580   {"None", "direct", "GOT-indirect"};
11581 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11582   {"None", "??? 1", "2", "??? 3", "4"};
11583 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11584 static const char * arm_attr_tag_ABI_FP_denormal[] =
11585   {"Unused", "Needed", "Sign only"};
11586 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11587 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11588 static const char * arm_attr_tag_ABI_FP_number_model[] =
11589   {"Unused", "Finite", "RTABI", "IEEE 754"};
11590 static const char * arm_attr_tag_ABI_enum_size[] =
11591   {"Unused", "small", "int", "forced to int"};
11592 static const char * arm_attr_tag_ABI_HardFP_use[] =
11593   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11594 static const char * arm_attr_tag_ABI_VFP_args[] =
11595   {"AAPCS", "VFP registers", "custom"};
11596 static const char * arm_attr_tag_ABI_WMMX_args[] =
11597   {"AAPCS", "WMMX registers", "custom"};
11598 static const char * arm_attr_tag_ABI_optimization_goals[] =
11599   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11600     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11601 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11602   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11603     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11604 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11605 static const char * arm_attr_tag_FP_HP_extension[] =
11606   {"Not Allowed", "Allowed"};
11607 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11608   {"None", "IEEE 754", "Alternative Format"};
11609 static const char * arm_attr_tag_MPextension_use[] =
11610   {"Not Allowed", "Allowed"};
11611 static const char * arm_attr_tag_DIV_use[] =
11612   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11613     "Allowed in v7-A with integer division extension"};
11614 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11615 static const char * arm_attr_tag_Virtualization_use[] =
11616   {"Not Allowed", "TrustZone", "Virtualization Extensions",
11617     "TrustZone and Virtualization Extensions"};
11618 static const char * arm_attr_tag_MPextension_use_legacy[] =
11619   {"Not Allowed", "Allowed"};
11620
11621 #define LOOKUP(id, name) \
11622   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11623 static arm_attr_public_tag arm_attr_public_tags[] =
11624 {
11625   {4, "CPU_raw_name", 1, NULL},
11626   {5, "CPU_name", 1, NULL},
11627   LOOKUP(6, CPU_arch),
11628   {7, "CPU_arch_profile", 0, NULL},
11629   LOOKUP(8, ARM_ISA_use),
11630   LOOKUP(9, THUMB_ISA_use),
11631   LOOKUP(10, FP_arch),
11632   LOOKUP(11, WMMX_arch),
11633   LOOKUP(12, Advanced_SIMD_arch),
11634   LOOKUP(13, PCS_config),
11635   LOOKUP(14, ABI_PCS_R9_use),
11636   LOOKUP(15, ABI_PCS_RW_data),
11637   LOOKUP(16, ABI_PCS_RO_data),
11638   LOOKUP(17, ABI_PCS_GOT_use),
11639   LOOKUP(18, ABI_PCS_wchar_t),
11640   LOOKUP(19, ABI_FP_rounding),
11641   LOOKUP(20, ABI_FP_denormal),
11642   LOOKUP(21, ABI_FP_exceptions),
11643   LOOKUP(22, ABI_FP_user_exceptions),
11644   LOOKUP(23, ABI_FP_number_model),
11645   {24, "ABI_align_needed", 0, NULL},
11646   {25, "ABI_align_preserved", 0, NULL},
11647   LOOKUP(26, ABI_enum_size),
11648   LOOKUP(27, ABI_HardFP_use),
11649   LOOKUP(28, ABI_VFP_args),
11650   LOOKUP(29, ABI_WMMX_args),
11651   LOOKUP(30, ABI_optimization_goals),
11652   LOOKUP(31, ABI_FP_optimization_goals),
11653   {32, "compatibility", 0, NULL},
11654   LOOKUP(34, CPU_unaligned_access),
11655   LOOKUP(36, FP_HP_extension),
11656   LOOKUP(38, ABI_FP_16bit_format),
11657   LOOKUP(42, MPextension_use),
11658   LOOKUP(44, DIV_use),
11659   {64, "nodefaults", 0, NULL},
11660   {65, "also_compatible_with", 0, NULL},
11661   LOOKUP(66, T2EE_use),
11662   {67, "conformance", 1, NULL},
11663   LOOKUP(68, Virtualization_use),
11664   LOOKUP(70, MPextension_use_legacy)
11665 };
11666 #undef LOOKUP
11667
11668 static unsigned char *
11669 display_arm_attribute (unsigned char * p,
11670                        const unsigned char * const end)
11671 {
11672   unsigned int tag;
11673   unsigned int len;
11674   unsigned int val;
11675   arm_attr_public_tag * attr;
11676   unsigned i;
11677   unsigned int type;
11678
11679   tag = read_uleb128 (p, &len, end);
11680   p += len;
11681   attr = NULL;
11682   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11683     {
11684       if (arm_attr_public_tags[i].tag == tag)
11685         {
11686           attr = &arm_attr_public_tags[i];
11687           break;
11688         }
11689     }
11690
11691   if (attr)
11692     {
11693       printf ("  Tag_%s: ", attr->name);
11694       switch (attr->type)
11695         {
11696         case 0:
11697           switch (tag)
11698             {
11699             case 7: /* Tag_CPU_arch_profile.  */
11700               val = read_uleb128 (p, &len, end);
11701               p += len;
11702               switch (val)
11703                 {
11704                 case 0: printf (_("None\n")); break;
11705                 case 'A': printf (_("Application\n")); break;
11706                 case 'R': printf (_("Realtime\n")); break;
11707                 case 'M': printf (_("Microcontroller\n")); break;
11708                 case 'S': printf (_("Application or Realtime\n")); break;
11709                 default: printf ("??? (%d)\n", val); break;
11710                 }
11711               break;
11712
11713             case 24: /* Tag_align_needed.  */
11714               val = read_uleb128 (p, &len, end);
11715               p += len;
11716               switch (val)
11717                 {
11718                 case 0: printf (_("None\n")); break;
11719                 case 1: printf (_("8-byte\n")); break;
11720                 case 2: printf (_("4-byte\n")); break;
11721                 case 3: printf ("??? 3\n"); break;
11722                 default:
11723                   if (val <= 12)
11724                     printf (_("8-byte and up to %d-byte extended\n"),
11725                             1 << val);
11726                   else
11727                     printf ("??? (%d)\n", val);
11728                   break;
11729                 }
11730               break;
11731
11732             case 25: /* Tag_align_preserved.  */
11733               val = read_uleb128 (p, &len, end);
11734               p += len;
11735               switch (val)
11736                 {
11737                 case 0: printf (_("None\n")); break;
11738                 case 1: printf (_("8-byte, except leaf SP\n")); break;
11739                 case 2: printf (_("8-byte\n")); break;
11740                 case 3: printf ("??? 3\n"); break;
11741                 default:
11742                   if (val <= 12)
11743                     printf (_("8-byte and up to %d-byte extended\n"),
11744                             1 << val);
11745                   else
11746                     printf ("??? (%d)\n", val);
11747                   break;
11748                 }
11749               break;
11750
11751             case 32: /* Tag_compatibility.  */
11752               val = read_uleb128 (p, &len, end);
11753               p += len;
11754               printf (_("flag = %d, vendor = %s\n"), val, p);
11755               p += strlen ((char *) p) + 1;
11756               break;
11757
11758             case 64: /* Tag_nodefaults.  */
11759               p++;
11760               printf (_("True\n"));
11761               break;
11762
11763             case 65: /* Tag_also_compatible_with.  */
11764               val = read_uleb128 (p, &len, end);
11765               p += len;
11766               if (val == 6 /* Tag_CPU_arch.  */)
11767                 {
11768                   val = read_uleb128 (p, &len, end);
11769                   p += len;
11770                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11771                     printf ("??? (%d)\n", val);
11772                   else
11773                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11774                 }
11775               else
11776                 printf ("???\n");
11777               while (*(p++) != '\0' /* NUL terminator.  */);
11778               break;
11779
11780             default:
11781               abort ();
11782             }
11783           return p;
11784
11785         case 1:
11786           return display_tag_value (-1, p, end);
11787         case 2:
11788           return display_tag_value (0, p, end);
11789
11790         default:
11791           assert (attr->type & 0x80);
11792           val = read_uleb128 (p, &len, end);
11793           p += len;
11794           type = attr->type & 0x7f;
11795           if (val >= type)
11796             printf ("??? (%d)\n", val);
11797           else
11798             printf ("%s\n", attr->table[val]);
11799           return p;
11800         }
11801     }
11802
11803   return display_tag_value (tag, p, end);
11804 }
11805
11806 static unsigned char *
11807 display_gnu_attribute (unsigned char * p,
11808                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11809                        const unsigned char * const end)
11810 {
11811   int tag;
11812   unsigned int len;
11813   int val;
11814
11815   tag = read_uleb128 (p, &len, end);
11816   p += len;
11817
11818   /* Tag_compatibility is the only generic GNU attribute defined at
11819      present.  */
11820   if (tag == 32)
11821     {
11822       val = read_uleb128 (p, &len, end);
11823       p += len;
11824       if (p == end)
11825         {
11826           printf (_("flag = %d, vendor = <corrupt>\n"), val);
11827           warn (_("corrupt vendor attribute\n"));
11828         }
11829       else
11830         {
11831           printf (_("flag = %d, vendor = %s\n"), val, p);
11832           p += strlen ((char *) p) + 1;
11833         }
11834       return p;
11835     }
11836
11837   if ((tag & 2) == 0 && display_proc_gnu_attribute)
11838     return display_proc_gnu_attribute (p, tag, end);
11839
11840   return display_tag_value (tag, p, end);
11841 }
11842
11843 static unsigned char *
11844 display_power_gnu_attribute (unsigned char * p,
11845                              int tag,
11846                              const unsigned char * const end)
11847 {
11848   unsigned int len;
11849   int val;
11850
11851   if (tag == Tag_GNU_Power_ABI_FP)
11852     {
11853       val = read_uleb128 (p, &len, end);
11854       p += len;
11855       printf ("  Tag_GNU_Power_ABI_FP: ");
11856
11857       switch (val)
11858         {
11859         case 0:
11860           printf (_("Hard or soft float\n"));
11861           break;
11862         case 1:
11863           printf (_("Hard float\n"));
11864           break;
11865         case 2:
11866           printf (_("Soft float\n"));
11867           break;
11868         case 3:
11869           printf (_("Single-precision hard float\n"));
11870           break;
11871         default:
11872           printf ("??? (%d)\n", val);
11873           break;
11874         }
11875       return p;
11876    }
11877
11878   if (tag == Tag_GNU_Power_ABI_Vector)
11879     {
11880       val = read_uleb128 (p, &len, end);
11881       p += len;
11882       printf ("  Tag_GNU_Power_ABI_Vector: ");
11883       switch (val)
11884         {
11885         case 0:
11886           printf (_("Any\n"));
11887           break;
11888         case 1:
11889           printf (_("Generic\n"));
11890           break;
11891         case 2:
11892           printf ("AltiVec\n");
11893           break;
11894         case 3:
11895           printf ("SPE\n");
11896           break;
11897         default:
11898           printf ("??? (%d)\n", val);
11899           break;
11900         }
11901       return p;
11902    }
11903
11904   if (tag == Tag_GNU_Power_ABI_Struct_Return)
11905     {
11906       if (p == end)
11907         {
11908           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11909           return p;
11910         }
11911
11912       val = read_uleb128 (p, &len, end);
11913       p += len;
11914       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
11915       switch (val)
11916        {
11917        case 0:
11918          printf (_("Any\n"));
11919          break;
11920        case 1:
11921          printf ("r3/r4\n");
11922          break;
11923        case 2:
11924          printf (_("Memory\n"));
11925          break;
11926        default:
11927          printf ("??? (%d)\n", val);
11928          break;
11929        }
11930       return p;
11931     }
11932
11933   return display_tag_value (tag & 1, p, end);
11934 }
11935
11936 static void
11937 display_sparc_hwcaps (int mask)
11938 {
11939   if (mask)
11940     {
11941       int first = 1;
11942       if (mask & ELF_SPARC_HWCAP_MUL32)
11943         fputs ("mul32", stdout), first = 0;
11944       if (mask & ELF_SPARC_HWCAP_DIV32)
11945         printf ("%sdiv32", first ? "" : "|"), first = 0;
11946       if (mask & ELF_SPARC_HWCAP_FSMULD)
11947         printf ("%sfsmuld", first ? "" : "|"), first = 0;
11948       if (mask & ELF_SPARC_HWCAP_V8PLUS)
11949         printf ("%sv8plus", first ? "" : "|"), first = 0;
11950       if (mask & ELF_SPARC_HWCAP_POPC)
11951         printf ("%spopc", first ? "" : "|"), first = 0;
11952       if (mask & ELF_SPARC_HWCAP_VIS)
11953         printf ("%svis", first ? "" : "|"), first = 0;
11954       if (mask & ELF_SPARC_HWCAP_VIS2)
11955         printf ("%svis2", first ? "" : "|"), first = 0;
11956       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11957         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11958       if (mask & ELF_SPARC_HWCAP_FMAF)
11959         printf ("%sfmaf", first ? "" : "|"), first = 0;
11960       if (mask & ELF_SPARC_HWCAP_VIS3)
11961         printf ("%svis3", first ? "" : "|"), first = 0;
11962       if (mask & ELF_SPARC_HWCAP_HPC)
11963         printf ("%shpc", first ? "" : "|"), first = 0;
11964       if (mask & ELF_SPARC_HWCAP_RANDOM)
11965         printf ("%srandom", first ? "" : "|"), first = 0;
11966       if (mask & ELF_SPARC_HWCAP_TRANS)
11967         printf ("%strans", first ? "" : "|"), first = 0;
11968       if (mask & ELF_SPARC_HWCAP_FJFMAU)
11969         printf ("%sfjfmau", first ? "" : "|"), first = 0;
11970       if (mask & ELF_SPARC_HWCAP_IMA)
11971         printf ("%sima", first ? "" : "|"), first = 0;
11972       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11973         printf ("%scspare", first ? "" : "|"), first = 0;
11974     }
11975   else
11976     fputc('0', stdout);
11977   fputc('\n', stdout);
11978 }
11979
11980 static void
11981 display_sparc_hwcaps2 (int mask)
11982 {
11983   if (mask)
11984     {
11985       int first = 1;
11986       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
11987         fputs ("fjathplus", stdout), first = 0;
11988       if (mask & ELF_SPARC_HWCAP2_VIS3B)
11989         printf ("%svis3b", first ? "" : "|"), first = 0;
11990       if (mask & ELF_SPARC_HWCAP2_ADP)
11991         printf ("%sadp", first ? "" : "|"), first = 0;
11992       if (mask & ELF_SPARC_HWCAP2_SPARC5)
11993         printf ("%ssparc5", first ? "" : "|"), first = 0;
11994       if (mask & ELF_SPARC_HWCAP2_MWAIT)
11995         printf ("%smwait", first ? "" : "|"), first = 0;
11996       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
11997         printf ("%sxmpmul", first ? "" : "|"), first = 0;
11998       if (mask & ELF_SPARC_HWCAP2_XMONT)
11999         printf ("%sxmont2", first ? "" : "|"), first = 0;
12000       if (mask & ELF_SPARC_HWCAP2_NSEC)
12001         printf ("%snsec", first ? "" : "|"), first = 0;
12002       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12003         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12004       if (mask & ELF_SPARC_HWCAP2_FJDES)
12005         printf ("%sfjdes", first ? "" : "|"), first = 0;
12006       if (mask & ELF_SPARC_HWCAP2_FJAES)
12007         printf ("%sfjaes", first ? "" : "|"), first = 0;
12008     }
12009   else
12010     fputc('0', stdout);
12011   fputc('\n', stdout);
12012 }
12013
12014 static unsigned char *
12015 display_sparc_gnu_attribute (unsigned char * p,
12016                              int tag,
12017                              const unsigned char * const end)
12018 {
12019   unsigned int len;
12020   int val;
12021
12022   if (tag == Tag_GNU_Sparc_HWCAPS)
12023     {
12024       val = read_uleb128 (p, &len, end);
12025       p += len;
12026       printf ("  Tag_GNU_Sparc_HWCAPS: ");
12027       display_sparc_hwcaps (val);
12028       return p;
12029     }
12030   if (tag == Tag_GNU_Sparc_HWCAPS2)
12031     {
12032       val = read_uleb128 (p, &len, end);
12033       p += len;
12034       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
12035       display_sparc_hwcaps2 (val);
12036       return p;
12037     }
12038
12039   return display_tag_value (tag, p, end);
12040 }
12041
12042 static void
12043 print_mips_fp_abi_value (int val)
12044 {
12045   switch (val)
12046     {
12047     case Val_GNU_MIPS_ABI_FP_ANY:
12048       printf (_("Hard or soft float\n"));
12049       break;
12050     case Val_GNU_MIPS_ABI_FP_DOUBLE:
12051       printf (_("Hard float (double precision)\n"));
12052       break;
12053     case Val_GNU_MIPS_ABI_FP_SINGLE:
12054       printf (_("Hard float (single precision)\n"));
12055       break;
12056     case Val_GNU_MIPS_ABI_FP_SOFT:
12057       printf (_("Soft float\n"));
12058       break;
12059     case Val_GNU_MIPS_ABI_FP_OLD_64:
12060       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12061       break;
12062     case Val_GNU_MIPS_ABI_FP_XX:
12063       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12064       break;
12065     case Val_GNU_MIPS_ABI_FP_64:
12066       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12067       break;
12068     case Val_GNU_MIPS_ABI_FP_64A:
12069       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12070       break;
12071     default:
12072       printf ("??? (%d)\n", val);
12073       break;
12074     }
12075 }
12076
12077 static unsigned char *
12078 display_mips_gnu_attribute (unsigned char * p,
12079                             int tag,
12080                             const unsigned char * const end)
12081 {
12082   if (tag == Tag_GNU_MIPS_ABI_FP)
12083     {
12084       unsigned int len;
12085       int val;
12086
12087       val = read_uleb128 (p, &len, end);
12088       p += len;
12089       printf ("  Tag_GNU_MIPS_ABI_FP: ");
12090
12091       print_mips_fp_abi_value (val);
12092
12093       return p;
12094    }
12095
12096   if (tag == Tag_GNU_MIPS_ABI_MSA)
12097     {
12098       unsigned int len;
12099       int val;
12100
12101       val = read_uleb128 (p, &len, end);
12102       p += len;
12103       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
12104
12105       switch (val)
12106         {
12107         case Val_GNU_MIPS_ABI_MSA_ANY:
12108           printf (_("Any MSA or not\n"));
12109           break;
12110         case Val_GNU_MIPS_ABI_MSA_128:
12111           printf (_("128-bit MSA\n"));
12112           break;
12113         default:
12114           printf ("??? (%d)\n", val);
12115           break;
12116         }
12117       return p;
12118     }
12119
12120   return display_tag_value (tag & 1, p, end);
12121 }
12122
12123 static unsigned char *
12124 display_tic6x_attribute (unsigned char * p,
12125                          const unsigned char * const end)
12126 {
12127   int tag;
12128   unsigned int len;
12129   int val;
12130
12131   tag = read_uleb128 (p, &len, end);
12132   p += len;
12133
12134   switch (tag)
12135     {
12136     case Tag_ISA:
12137       val = read_uleb128 (p, &len, end);
12138       p += len;
12139       printf ("  Tag_ISA: ");
12140
12141       switch (val)
12142         {
12143         case C6XABI_Tag_ISA_none:
12144           printf (_("None\n"));
12145           break;
12146         case C6XABI_Tag_ISA_C62X:
12147           printf ("C62x\n");
12148           break;
12149         case C6XABI_Tag_ISA_C67X:
12150           printf ("C67x\n");
12151           break;
12152         case C6XABI_Tag_ISA_C67XP:
12153           printf ("C67x+\n");
12154           break;
12155         case C6XABI_Tag_ISA_C64X:
12156           printf ("C64x\n");
12157           break;
12158         case C6XABI_Tag_ISA_C64XP:
12159           printf ("C64x+\n");
12160           break;
12161         case C6XABI_Tag_ISA_C674X:
12162           printf ("C674x\n");
12163           break;
12164         default:
12165           printf ("??? (%d)\n", val);
12166           break;
12167         }
12168       return p;
12169
12170     case Tag_ABI_wchar_t:
12171       val = read_uleb128 (p, &len, end);
12172       p += len;
12173       printf ("  Tag_ABI_wchar_t: ");
12174       switch (val)
12175         {
12176         case 0:
12177           printf (_("Not used\n"));
12178           break;
12179         case 1:
12180           printf (_("2 bytes\n"));
12181           break;
12182         case 2:
12183           printf (_("4 bytes\n"));
12184           break;
12185         default:
12186           printf ("??? (%d)\n", val);
12187           break;
12188         }
12189       return p;
12190
12191     case Tag_ABI_stack_align_needed:
12192       val = read_uleb128 (p, &len, end);
12193       p += len;
12194       printf ("  Tag_ABI_stack_align_needed: ");
12195       switch (val)
12196         {
12197         case 0:
12198           printf (_("8-byte\n"));
12199           break;
12200         case 1:
12201           printf (_("16-byte\n"));
12202           break;
12203         default:
12204           printf ("??? (%d)\n", val);
12205           break;
12206         }
12207       return p;
12208
12209     case Tag_ABI_stack_align_preserved:
12210       val = read_uleb128 (p, &len, end);
12211       p += len;
12212       printf ("  Tag_ABI_stack_align_preserved: ");
12213       switch (val)
12214         {
12215         case 0:
12216           printf (_("8-byte\n"));
12217           break;
12218         case 1:
12219           printf (_("16-byte\n"));
12220           break;
12221         default:
12222           printf ("??? (%d)\n", val);
12223           break;
12224         }
12225       return p;
12226
12227     case Tag_ABI_DSBT:
12228       val = read_uleb128 (p, &len, end);
12229       p += len;
12230       printf ("  Tag_ABI_DSBT: ");
12231       switch (val)
12232         {
12233         case 0:
12234           printf (_("DSBT addressing not used\n"));
12235           break;
12236         case 1:
12237           printf (_("DSBT addressing used\n"));
12238           break;
12239         default:
12240           printf ("??? (%d)\n", val);
12241           break;
12242         }
12243       return p;
12244
12245     case Tag_ABI_PID:
12246       val = read_uleb128 (p, &len, end);
12247       p += len;
12248       printf ("  Tag_ABI_PID: ");
12249       switch (val)
12250         {
12251         case 0:
12252           printf (_("Data addressing position-dependent\n"));
12253           break;
12254         case 1:
12255           printf (_("Data addressing position-independent, GOT near DP\n"));
12256           break;
12257         case 2:
12258           printf (_("Data addressing position-independent, GOT far from DP\n"));
12259           break;
12260         default:
12261           printf ("??? (%d)\n", val);
12262           break;
12263         }
12264       return p;
12265
12266     case Tag_ABI_PIC:
12267       val = read_uleb128 (p, &len, end);
12268       p += len;
12269       printf ("  Tag_ABI_PIC: ");
12270       switch (val)
12271         {
12272         case 0:
12273           printf (_("Code addressing position-dependent\n"));
12274           break;
12275         case 1:
12276           printf (_("Code addressing position-independent\n"));
12277           break;
12278         default:
12279           printf ("??? (%d)\n", val);
12280           break;
12281         }
12282       return p;
12283
12284     case Tag_ABI_array_object_alignment:
12285       val = read_uleb128 (p, &len, end);
12286       p += len;
12287       printf ("  Tag_ABI_array_object_alignment: ");
12288       switch (val)
12289         {
12290         case 0:
12291           printf (_("8-byte\n"));
12292           break;
12293         case 1:
12294           printf (_("4-byte\n"));
12295           break;
12296         case 2:
12297           printf (_("16-byte\n"));
12298           break;
12299         default:
12300           printf ("??? (%d)\n", val);
12301           break;
12302         }
12303       return p;
12304
12305     case Tag_ABI_array_object_align_expected:
12306       val = read_uleb128 (p, &len, end);
12307       p += len;
12308       printf ("  Tag_ABI_array_object_align_expected: ");
12309       switch (val)
12310         {
12311         case 0:
12312           printf (_("8-byte\n"));
12313           break;
12314         case 1:
12315           printf (_("4-byte\n"));
12316           break;
12317         case 2:
12318           printf (_("16-byte\n"));
12319           break;
12320         default:
12321           printf ("??? (%d)\n", val);
12322           break;
12323         }
12324       return p;
12325
12326     case Tag_ABI_compatibility:
12327       val = read_uleb128 (p, &len, end);
12328       p += len;
12329       printf ("  Tag_ABI_compatibility: ");
12330       printf (_("flag = %d, vendor = %s\n"), val, p);
12331       p += strlen ((char *) p) + 1;
12332       return p;
12333
12334     case Tag_ABI_conformance:
12335       printf ("  Tag_ABI_conformance: ");
12336       printf ("\"%s\"\n", p);
12337       p += strlen ((char *) p) + 1;
12338       return p;
12339     }
12340
12341   return display_tag_value (tag, p, end);
12342 }
12343
12344 static void
12345 display_raw_attribute (unsigned char * p, unsigned char * end)
12346 {
12347   unsigned long addr = 0;
12348   size_t bytes = end - p;
12349
12350   while (bytes)
12351     {
12352       int j;
12353       int k;
12354       int lbytes = (bytes > 16 ? 16 : bytes);
12355
12356       printf ("  0x%8.8lx ", addr);
12357
12358       for (j = 0; j < 16; j++)
12359         {
12360           if (j < lbytes)
12361             printf ("%2.2x", p[j]);
12362           else
12363             printf ("  ");
12364
12365           if ((j & 3) == 3)
12366             printf (" ");
12367         }
12368
12369       for (j = 0; j < lbytes; j++)
12370         {
12371           k = p[j];
12372           if (k >= ' ' && k < 0x7f)
12373             printf ("%c", k);
12374           else
12375             printf (".");
12376         }
12377
12378       putchar ('\n');
12379
12380       p  += lbytes;
12381       bytes -= lbytes;
12382       addr += lbytes;
12383     }
12384
12385   putchar ('\n');
12386 }
12387
12388 static unsigned char *
12389 display_msp430x_attribute (unsigned char * p,
12390                            const unsigned char * const end)
12391 {
12392   unsigned int len;
12393   int val;
12394   int tag;
12395
12396   tag = read_uleb128 (p, & len, end);
12397   p += len;
12398
12399   switch (tag)
12400     {
12401     case OFBA_MSPABI_Tag_ISA:
12402       val = read_uleb128 (p, &len, end);
12403       p += len;
12404       printf ("  Tag_ISA: ");
12405       switch (val)
12406         {
12407         case 0: printf (_("None\n")); break;
12408         case 1: printf (_("MSP430\n")); break;
12409         case 2: printf (_("MSP430X\n")); break;
12410         default: printf ("??? (%d)\n", val); break;
12411         }
12412       break;
12413
12414     case OFBA_MSPABI_Tag_Code_Model:
12415       val = read_uleb128 (p, &len, end);
12416       p += len;
12417       printf ("  Tag_Code_Model: ");
12418       switch (val)
12419         {
12420         case 0: printf (_("None\n")); break;
12421         case 1: printf (_("Small\n")); break;
12422         case 2: printf (_("Large\n")); break;
12423         default: printf ("??? (%d)\n", val); break;
12424         }
12425       break;
12426
12427     case OFBA_MSPABI_Tag_Data_Model:
12428       val = read_uleb128 (p, &len, end);
12429       p += len;
12430       printf ("  Tag_Data_Model: ");
12431       switch (val)
12432         {
12433         case 0: printf (_("None\n")); break;
12434         case 1: printf (_("Small\n")); break;
12435         case 2: printf (_("Large\n")); break;
12436         case 3: printf (_("Restricted Large\n")); break;
12437         default: printf ("??? (%d)\n", val); break;
12438         }
12439       break;
12440
12441     default:
12442       printf (_("  <unknown tag %d>: "), tag);
12443
12444       if (tag & 1)
12445         {
12446           printf ("\"%s\"\n", p);
12447           p += strlen ((char *) p) + 1;
12448         }
12449       else
12450         {
12451           val = read_uleb128 (p, &len, end);
12452           p += len;
12453           printf ("%d (0x%x)\n", val, val);
12454         }
12455       break;
12456    }
12457
12458   return p;
12459 }
12460
12461 static int
12462 process_attributes (FILE * file,
12463                     const char * public_name,
12464                     unsigned int proc_type,
12465                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12466                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12467 {
12468   Elf_Internal_Shdr * sect;
12469   unsigned char * contents;
12470   unsigned char * p;
12471   unsigned char * end;
12472   bfd_vma section_len;
12473   bfd_vma len;
12474   unsigned i;
12475
12476   /* Find the section header so that we get the size.  */
12477   for (i = 0, sect = section_headers;
12478        i < elf_header.e_shnum;
12479        i++, sect++)
12480     {
12481       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
12482         continue;
12483
12484       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12485                                              sect->sh_size, _("attributes"));
12486       if (contents == NULL)
12487         continue;
12488
12489       p = contents;
12490       if (*p == 'A')
12491         {
12492           len = sect->sh_size - 1;
12493           p++;
12494
12495           while (len > 0)
12496             {
12497               unsigned int namelen;
12498               bfd_boolean public_section;
12499               bfd_boolean gnu_section;
12500
12501               section_len = byte_get (p, 4);
12502               p += 4;
12503
12504               if (section_len > len)
12505                 {
12506                   error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12507                           (unsigned) section_len, (unsigned) len);
12508                   section_len = len;
12509                 }
12510
12511               len -= section_len;
12512               section_len -= 4;
12513
12514               namelen = strnlen ((char *) p, section_len) + 1;
12515               if (namelen == 0 || namelen >= section_len)
12516                 {
12517                   error (_("Corrupt attribute section name\n"));
12518                   break;
12519                 }
12520
12521               printf (_("Attribute Section: %s\n"), p);
12522
12523               if (public_name && streq ((char *) p, public_name))
12524                 public_section = TRUE;
12525               else
12526                 public_section = FALSE;
12527
12528               if (streq ((char *) p, "gnu"))
12529                 gnu_section = TRUE;
12530               else
12531                 gnu_section = FALSE;
12532
12533               p += namelen;
12534               section_len -= namelen;
12535               while (section_len > 0)
12536                 {
12537                   int tag = *(p++);
12538                   int val;
12539                   bfd_vma size;
12540
12541                   size = byte_get (p, 4);
12542                   if (size > section_len)
12543                     {
12544                       error (_("Bad subsection length (%u > %u)\n"),
12545                               (unsigned) size, (unsigned) section_len);
12546                       size = section_len;
12547                     }
12548
12549                   section_len -= size;
12550                   end = p + size - 1;
12551                   p += 4;
12552
12553                   switch (tag)
12554                     {
12555                     case 1:
12556                       printf (_("File Attributes\n"));
12557                       break;
12558                     case 2:
12559                       printf (_("Section Attributes:"));
12560                       goto do_numlist;
12561                     case 3:
12562                       printf (_("Symbol Attributes:"));
12563                     do_numlist:
12564                       for (;;)
12565                         {
12566                           unsigned int j;
12567
12568                           val = read_uleb128 (p, &j, end);
12569                           p += j;
12570                           if (val == 0)
12571                             break;
12572                           printf (" %d", val);
12573                         }
12574                       printf ("\n");
12575                       break;
12576                     default:
12577                       printf (_("Unknown tag: %d\n"), tag);
12578                       public_section = FALSE;
12579                       break;
12580                     }
12581
12582                   if (public_section)
12583                     {
12584                       while (p < end)
12585                         p = display_pub_attribute (p, end);
12586                     }
12587                   else if (gnu_section)
12588                     {
12589                       while (p < end)
12590                         p = display_gnu_attribute (p,
12591                                                    display_proc_gnu_attribute,
12592                                                    end);
12593                     }
12594                   else
12595                     {
12596                       printf (_("  Unknown section contexts\n"));
12597                       display_raw_attribute (p, end);
12598                       p = end;
12599                     }
12600                 }
12601             }
12602         }
12603       else
12604         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
12605
12606       free (contents);
12607     }
12608   return 1;
12609 }
12610
12611 static int
12612 process_arm_specific (FILE * file)
12613 {
12614   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12615                              display_arm_attribute, NULL);
12616 }
12617
12618 static int
12619 process_power_specific (FILE * file)
12620 {
12621   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12622                              display_power_gnu_attribute);
12623 }
12624
12625 static int
12626 process_sparc_specific (FILE * file)
12627 {
12628   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12629                              display_sparc_gnu_attribute);
12630 }
12631
12632 static int
12633 process_tic6x_specific (FILE * file)
12634 {
12635   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12636                              display_tic6x_attribute, NULL);
12637 }
12638
12639 static int
12640 process_msp430x_specific (FILE * file)
12641 {
12642   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12643                              display_msp430x_attribute, NULL);
12644 }
12645
12646 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12647    Print the Address, Access and Initial fields of an entry at VMA ADDR
12648    and return the VMA of the next entry.  */
12649
12650 static bfd_vma
12651 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12652 {
12653   printf ("  ");
12654   print_vma (addr, LONG_HEX);
12655   printf (" ");
12656   if (addr < pltgot + 0xfff0)
12657     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12658   else
12659     printf ("%10s", "");
12660   printf (" ");
12661   if (data == NULL)
12662     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12663   else
12664     {
12665       bfd_vma entry;
12666
12667       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12668       print_vma (entry, LONG_HEX);
12669     }
12670   return addr + (is_32bit_elf ? 4 : 8);
12671 }
12672
12673 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12674    PLTGOT.  Print the Address and Initial fields of an entry at VMA
12675    ADDR and return the VMA of the next entry.  */
12676
12677 static bfd_vma
12678 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12679 {
12680   printf ("  ");
12681   print_vma (addr, LONG_HEX);
12682   printf (" ");
12683   if (data == NULL)
12684     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12685   else
12686     {
12687       bfd_vma entry;
12688
12689       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12690       print_vma (entry, LONG_HEX);
12691     }
12692   return addr + (is_32bit_elf ? 4 : 8);
12693 }
12694
12695 static void
12696 print_mips_ases (unsigned int mask)
12697 {
12698   if (mask & AFL_ASE_DSP)
12699     fputs ("\n\tDSP ASE", stdout);
12700   if (mask & AFL_ASE_DSPR2)
12701     fputs ("\n\tDSP R2 ASE", stdout);
12702   if (mask & AFL_ASE_EVA)
12703     fputs ("\n\tEnhanced VA Scheme", stdout);
12704   if (mask & AFL_ASE_MCU)
12705     fputs ("\n\tMCU (MicroController) ASE", stdout);
12706   if (mask & AFL_ASE_MDMX)
12707     fputs ("\n\tMDMX ASE", stdout);
12708   if (mask & AFL_ASE_MIPS3D)
12709     fputs ("\n\tMIPS-3D ASE", stdout);
12710   if (mask & AFL_ASE_MT)
12711     fputs ("\n\tMT ASE", stdout);
12712   if (mask & AFL_ASE_SMARTMIPS)
12713     fputs ("\n\tSmartMIPS ASE", stdout);
12714   if (mask & AFL_ASE_VIRT)
12715     fputs ("\n\tVZ ASE", stdout);
12716   if (mask & AFL_ASE_MSA)
12717     fputs ("\n\tMSA ASE", stdout);
12718   if (mask & AFL_ASE_MIPS16)
12719     fputs ("\n\tMIPS16 ASE", stdout);
12720   if (mask & AFL_ASE_MICROMIPS)
12721     fputs ("\n\tMICROMIPS ASE", stdout);
12722   if (mask & AFL_ASE_XPA)
12723     fputs ("\n\tXPA ASE", stdout);
12724   if (mask == 0)
12725     fprintf (stdout, "\n\t%s", _("None"));
12726 }
12727
12728 static void
12729 print_mips_isa_ext (unsigned int isa_ext)
12730 {
12731   switch (isa_ext)
12732     {
12733     case 0:
12734       fputs (_("None"), stdout);
12735       break;
12736     case AFL_EXT_XLR:
12737       fputs ("RMI XLR", stdout);
12738       break;
12739     case AFL_EXT_OCTEON2:
12740       fputs ("Cavium Networks Octeon2", stdout);
12741       break;
12742     case AFL_EXT_OCTEONP:
12743       fputs ("Cavium Networks OcteonP", stdout);
12744       break;
12745     case AFL_EXT_LOONGSON_3A:
12746       fputs ("Loongson 3A", stdout);
12747       break;
12748     case AFL_EXT_OCTEON:
12749       fputs ("Cavium Networks Octeon", stdout);
12750       break;
12751     case AFL_EXT_5900:
12752       fputs ("Toshiba R5900", stdout);
12753       break;
12754     case AFL_EXT_4650:
12755       fputs ("MIPS R4650", stdout);
12756       break;
12757     case AFL_EXT_4010:
12758       fputs ("LSI R4010", stdout);
12759       break;
12760     case AFL_EXT_4100:
12761       fputs ("NEC VR4100", stdout);
12762       break;
12763     case AFL_EXT_3900:
12764       fputs ("Toshiba R3900", stdout);
12765       break;
12766     case AFL_EXT_10000:
12767       fputs ("MIPS R10000", stdout);
12768       break;
12769     case AFL_EXT_SB1:
12770       fputs ("Broadcom SB-1", stdout);
12771       break;
12772     case AFL_EXT_4111:
12773       fputs ("NEC VR4111/VR4181", stdout);
12774       break;
12775     case AFL_EXT_4120:
12776       fputs ("NEC VR4120", stdout);
12777       break;
12778     case AFL_EXT_5400:
12779       fputs ("NEC VR5400", stdout);
12780       break;
12781     case AFL_EXT_5500:
12782       fputs ("NEC VR5500", stdout);
12783       break;
12784     case AFL_EXT_LOONGSON_2E:
12785       fputs ("ST Microelectronics Loongson 2E", stdout);
12786       break;
12787     case AFL_EXT_LOONGSON_2F:
12788       fputs ("ST Microelectronics Loongson 2F", stdout);
12789       break;
12790     default:
12791       fputs (_("Unknown"), stdout);
12792     }
12793 }
12794
12795 static int
12796 get_mips_reg_size (int reg_size)
12797 {
12798   return (reg_size == AFL_REG_NONE) ? 0
12799          : (reg_size == AFL_REG_32) ? 32
12800          : (reg_size == AFL_REG_64) ? 64
12801          : (reg_size == AFL_REG_128) ? 128
12802          : -1;
12803 }
12804
12805 static int
12806 process_mips_specific (FILE * file)
12807 {
12808   Elf_Internal_Dyn * entry;
12809   Elf_Internal_Shdr *sect = NULL;
12810   size_t liblist_offset = 0;
12811   size_t liblistno = 0;
12812   size_t conflictsno = 0;
12813   size_t options_offset = 0;
12814   size_t conflicts_offset = 0;
12815   size_t pltrelsz = 0;
12816   size_t pltrel = 0;
12817   bfd_vma pltgot = 0;
12818   bfd_vma mips_pltgot = 0;
12819   bfd_vma jmprel = 0;
12820   bfd_vma local_gotno = 0;
12821   bfd_vma gotsym = 0;
12822   bfd_vma symtabno = 0;
12823
12824   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12825                       display_mips_gnu_attribute);
12826
12827   sect = find_section (".MIPS.abiflags");
12828
12829   if (sect != NULL)
12830     {
12831       Elf_External_ABIFlags_v0 *abiflags_ext;
12832       Elf_Internal_ABIFlags_v0 abiflags_in;
12833
12834       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
12835         fputs ("\nCorrupt ABI Flags section.\n", stdout);
12836       else
12837         {
12838           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
12839                                    sect->sh_size, _("MIPS ABI Flags section"));
12840           if (abiflags_ext)
12841             {
12842               abiflags_in.version = BYTE_GET (abiflags_ext->version);
12843               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
12844               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
12845               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
12846               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
12847               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
12848               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
12849               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
12850               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
12851               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
12852               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
12853
12854               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
12855               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
12856               if (abiflags_in.isa_rev > 1)
12857                 printf ("r%d", abiflags_in.isa_rev);
12858               printf ("\nGPR size: %d",
12859                       get_mips_reg_size (abiflags_in.gpr_size));
12860               printf ("\nCPR1 size: %d",
12861                       get_mips_reg_size (abiflags_in.cpr1_size));
12862               printf ("\nCPR2 size: %d",
12863                       get_mips_reg_size (abiflags_in.cpr2_size));
12864               fputs ("\nFP ABI: ", stdout);
12865               print_mips_fp_abi_value (abiflags_in.fp_abi);
12866               fputs ("ISA Extension: ", stdout);
12867               print_mips_isa_ext (abiflags_in.isa_ext);
12868               fputs ("\nASEs:", stdout);
12869               print_mips_ases (abiflags_in.ases);
12870               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
12871               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
12872               fputc ('\n', stdout);
12873               free (abiflags_ext);
12874             }
12875         }
12876     }
12877
12878   /* We have a lot of special sections.  Thanks SGI!  */
12879   if (dynamic_section == NULL)
12880     /* No information available.  */
12881     return 0;
12882
12883   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12884     switch (entry->d_tag)
12885       {
12886       case DT_MIPS_LIBLIST:
12887         liblist_offset
12888           = offset_from_vma (file, entry->d_un.d_val,
12889                              liblistno * sizeof (Elf32_External_Lib));
12890         break;
12891       case DT_MIPS_LIBLISTNO:
12892         liblistno = entry->d_un.d_val;
12893         break;
12894       case DT_MIPS_OPTIONS:
12895         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12896         break;
12897       case DT_MIPS_CONFLICT:
12898         conflicts_offset
12899           = offset_from_vma (file, entry->d_un.d_val,
12900                              conflictsno * sizeof (Elf32_External_Conflict));
12901         break;
12902       case DT_MIPS_CONFLICTNO:
12903         conflictsno = entry->d_un.d_val;
12904         break;
12905       case DT_PLTGOT:
12906         pltgot = entry->d_un.d_ptr;
12907         break;
12908       case DT_MIPS_LOCAL_GOTNO:
12909         local_gotno = entry->d_un.d_val;
12910         break;
12911       case DT_MIPS_GOTSYM:
12912         gotsym = entry->d_un.d_val;
12913         break;
12914       case DT_MIPS_SYMTABNO:
12915         symtabno = entry->d_un.d_val;
12916         break;
12917       case DT_MIPS_PLTGOT:
12918         mips_pltgot = entry->d_un.d_ptr;
12919         break;
12920       case DT_PLTREL:
12921         pltrel = entry->d_un.d_val;
12922         break;
12923       case DT_PLTRELSZ:
12924         pltrelsz = entry->d_un.d_val;
12925         break;
12926       case DT_JMPREL:
12927         jmprel = entry->d_un.d_ptr;
12928         break;
12929       default:
12930         break;
12931       }
12932
12933   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12934     {
12935       Elf32_External_Lib * elib;
12936       size_t cnt;
12937
12938       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12939                                               liblistno,
12940                                               sizeof (Elf32_External_Lib),
12941                                               _("liblist section data"));
12942       if (elib)
12943         {
12944           printf (_("\nSection '.liblist' contains %lu entries:\n"),
12945                   (unsigned long) liblistno);
12946           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
12947                  stdout);
12948
12949           for (cnt = 0; cnt < liblistno; ++cnt)
12950             {
12951               Elf32_Lib liblist;
12952               time_t atime;
12953               char timebuf[20];
12954               struct tm * tmp;
12955
12956               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12957               atime = BYTE_GET (elib[cnt].l_time_stamp);
12958               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12959               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12960               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12961
12962               tmp = gmtime (&atime);
12963               snprintf (timebuf, sizeof (timebuf),
12964                         "%04u-%02u-%02uT%02u:%02u:%02u",
12965                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12966                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12967
12968               printf ("%3lu: ", (unsigned long) cnt);
12969               if (VALID_DYNAMIC_NAME (liblist.l_name))
12970                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12971               else
12972                 printf (_("<corrupt: %9ld>"), liblist.l_name);
12973               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12974                       liblist.l_version);
12975
12976               if (liblist.l_flags == 0)
12977                 puts (_(" NONE"));
12978               else
12979                 {
12980                   static const struct
12981                   {
12982                     const char * name;
12983                     int bit;
12984                   }
12985                   l_flags_vals[] =
12986                   {
12987                     { " EXACT_MATCH", LL_EXACT_MATCH },
12988                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12989                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12990                     { " EXPORTS", LL_EXPORTS },
12991                     { " DELAY_LOAD", LL_DELAY_LOAD },
12992                     { " DELTA", LL_DELTA }
12993                   };
12994                   int flags = liblist.l_flags;
12995                   size_t fcnt;
12996
12997                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12998                     if ((flags & l_flags_vals[fcnt].bit) != 0)
12999                       {
13000                         fputs (l_flags_vals[fcnt].name, stdout);
13001                         flags ^= l_flags_vals[fcnt].bit;
13002                       }
13003                   if (flags != 0)
13004                     printf (" %#x", (unsigned int) flags);
13005
13006                   puts ("");
13007                 }
13008             }
13009
13010           free (elib);
13011         }
13012     }
13013
13014   if (options_offset != 0)
13015     {
13016       Elf_External_Options * eopt;
13017       Elf_Internal_Options * iopt;
13018       Elf_Internal_Options * option;
13019       size_t offset;
13020       int cnt;
13021       sect = section_headers;
13022
13023       /* Find the section header so that we get the size.  */
13024       while (sect->sh_type != SHT_MIPS_OPTIONS)
13025         ++sect;
13026
13027       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13028                                                 sect->sh_size, _("options"));
13029       if (eopt)
13030         {
13031           iopt = (Elf_Internal_Options *)
13032               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13033           if (iopt == NULL)
13034             {
13035               error (_("Out of memory\n"));
13036               return 0;
13037             }
13038
13039           offset = cnt = 0;
13040           option = iopt;
13041
13042           while (offset < sect->sh_size)
13043             {
13044               Elf_External_Options * eoption;
13045
13046               eoption = (Elf_External_Options *) ((char *) eopt + offset);
13047
13048               option->kind = BYTE_GET (eoption->kind);
13049               option->size = BYTE_GET (eoption->size);
13050               option->section = BYTE_GET (eoption->section);
13051               option->info = BYTE_GET (eoption->info);
13052
13053               offset += option->size;
13054
13055               ++option;
13056               ++cnt;
13057             }
13058
13059           printf (_("\nSection '%s' contains %d entries:\n"),
13060                   SECTION_NAME (sect), cnt);
13061
13062           option = iopt;
13063
13064           while (cnt-- > 0)
13065             {
13066               size_t len;
13067
13068               switch (option->kind)
13069                 {
13070                 case ODK_NULL:
13071                   /* This shouldn't happen.  */
13072                   printf (" NULL       %d %lx", option->section, option->info);
13073                   break;
13074                 case ODK_REGINFO:
13075                   printf (" REGINFO    ");
13076                   if (elf_header.e_machine == EM_MIPS)
13077                     {
13078                       /* 32bit form.  */
13079                       Elf32_External_RegInfo * ereg;
13080                       Elf32_RegInfo reginfo;
13081
13082                       ereg = (Elf32_External_RegInfo *) (option + 1);
13083                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13084                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13085                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13086                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13087                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13088                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13089
13090                       printf ("GPR %08lx  GP 0x%lx\n",
13091                               reginfo.ri_gprmask,
13092                               (unsigned long) reginfo.ri_gp_value);
13093                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
13094                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13095                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13096                     }
13097                   else
13098                     {
13099                       /* 64 bit form.  */
13100                       Elf64_External_RegInfo * ereg;
13101                       Elf64_Internal_RegInfo reginfo;
13102
13103                       ereg = (Elf64_External_RegInfo *) (option + 1);
13104                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
13105                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13106                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13107                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13108                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13109                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
13110
13111                       printf ("GPR %08lx  GP 0x",
13112                               reginfo.ri_gprmask);
13113                       printf_vma (reginfo.ri_gp_value);
13114                       printf ("\n");
13115
13116                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
13117                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13118                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13119                     }
13120                   ++option;
13121                   continue;
13122                 case ODK_EXCEPTIONS:
13123                   fputs (" EXCEPTIONS fpe_min(", stdout);
13124                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13125                   fputs (") fpe_max(", stdout);
13126                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13127                   fputs (")", stdout);
13128
13129                   if (option->info & OEX_PAGE0)
13130                     fputs (" PAGE0", stdout);
13131                   if (option->info & OEX_SMM)
13132                     fputs (" SMM", stdout);
13133                   if (option->info & OEX_FPDBUG)
13134                     fputs (" FPDBUG", stdout);
13135                   if (option->info & OEX_DISMISS)
13136                     fputs (" DISMISS", stdout);
13137                   break;
13138                 case ODK_PAD:
13139                   fputs (" PAD       ", stdout);
13140                   if (option->info & OPAD_PREFIX)
13141                     fputs (" PREFIX", stdout);
13142                   if (option->info & OPAD_POSTFIX)
13143                     fputs (" POSTFIX", stdout);
13144                   if (option->info & OPAD_SYMBOL)
13145                     fputs (" SYMBOL", stdout);
13146                   break;
13147                 case ODK_HWPATCH:
13148                   fputs (" HWPATCH   ", stdout);
13149                   if (option->info & OHW_R4KEOP)
13150                     fputs (" R4KEOP", stdout);
13151                   if (option->info & OHW_R8KPFETCH)
13152                     fputs (" R8KPFETCH", stdout);
13153                   if (option->info & OHW_R5KEOP)
13154                     fputs (" R5KEOP", stdout);
13155                   if (option->info & OHW_R5KCVTL)
13156                     fputs (" R5KCVTL", stdout);
13157                   break;
13158                 case ODK_FILL:
13159                   fputs (" FILL       ", stdout);
13160                   /* XXX Print content of info word?  */
13161                   break;
13162                 case ODK_TAGS:
13163                   fputs (" TAGS       ", stdout);
13164                   /* XXX Print content of info word?  */
13165                   break;
13166                 case ODK_HWAND:
13167                   fputs (" HWAND     ", stdout);
13168                   if (option->info & OHWA0_R4KEOP_CHECKED)
13169                     fputs (" R4KEOP_CHECKED", stdout);
13170                   if (option->info & OHWA0_R4KEOP_CLEAN)
13171                     fputs (" R4KEOP_CLEAN", stdout);
13172                   break;
13173                 case ODK_HWOR:
13174                   fputs (" HWOR      ", stdout);
13175                   if (option->info & OHWA0_R4KEOP_CHECKED)
13176                     fputs (" R4KEOP_CHECKED", stdout);
13177                   if (option->info & OHWA0_R4KEOP_CLEAN)
13178                     fputs (" R4KEOP_CLEAN", stdout);
13179                   break;
13180                 case ODK_GP_GROUP:
13181                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
13182                           option->info & OGP_GROUP,
13183                           (option->info & OGP_SELF) >> 16);
13184                   break;
13185                 case ODK_IDENT:
13186                   printf (" IDENT     %#06lx  self-contained %#06lx",
13187                           option->info & OGP_GROUP,
13188                           (option->info & OGP_SELF) >> 16);
13189                   break;
13190                 default:
13191                   /* This shouldn't happen.  */
13192                   printf (" %3d ???     %d %lx",
13193                           option->kind, option->section, option->info);
13194                   break;
13195                 }
13196
13197               len = sizeof (* eopt);
13198               while (len < option->size)
13199                 if (((char *) option)[len] >= ' '
13200                     && ((char *) option)[len] < 0x7f)
13201                   printf ("%c", ((char *) option)[len++]);
13202                 else
13203                   printf ("\\%03o", ((char *) option)[len++]);
13204
13205               fputs ("\n", stdout);
13206               ++option;
13207             }
13208
13209           free (eopt);
13210         }
13211     }
13212
13213   if (conflicts_offset != 0 && conflictsno != 0)
13214     {
13215       Elf32_Conflict * iconf;
13216       size_t cnt;
13217
13218       if (dynamic_symbols == NULL)
13219         {
13220           error (_("conflict list found without a dynamic symbol table\n"));
13221           return 0;
13222         }
13223
13224       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
13225       if (iconf == NULL)
13226         {
13227           error (_("Out of memory\n"));
13228           return 0;
13229         }
13230
13231       if (is_32bit_elf)
13232         {
13233           Elf32_External_Conflict * econf32;
13234
13235           econf32 = (Elf32_External_Conflict *)
13236               get_data (NULL, file, conflicts_offset, conflictsno,
13237                         sizeof (* econf32), _("conflict"));
13238           if (!econf32)
13239             return 0;
13240
13241           for (cnt = 0; cnt < conflictsno; ++cnt)
13242             iconf[cnt] = BYTE_GET (econf32[cnt]);
13243
13244           free (econf32);
13245         }
13246       else
13247         {
13248           Elf64_External_Conflict * econf64;
13249
13250           econf64 = (Elf64_External_Conflict *)
13251               get_data (NULL, file, conflicts_offset, conflictsno,
13252                         sizeof (* econf64), _("conflict"));
13253           if (!econf64)
13254             return 0;
13255
13256           for (cnt = 0; cnt < conflictsno; ++cnt)
13257             iconf[cnt] = BYTE_GET (econf64[cnt]);
13258
13259           free (econf64);
13260         }
13261
13262       printf (_("\nSection '.conflict' contains %lu entries:\n"),
13263               (unsigned long) conflictsno);
13264       puts (_("  Num:    Index       Value  Name"));
13265
13266       for (cnt = 0; cnt < conflictsno; ++cnt)
13267         {
13268           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
13269
13270           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
13271           print_vma (psym->st_value, FULL_HEX);
13272           putchar (' ');
13273           if (VALID_DYNAMIC_NAME (psym->st_name))
13274             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13275           else
13276             printf (_("<corrupt: %14ld>"), psym->st_name);
13277           putchar ('\n');
13278         }
13279
13280       free (iconf);
13281     }
13282
13283   if (pltgot != 0 && local_gotno != 0)
13284     {
13285       bfd_vma ent, local_end, global_end;
13286       size_t i, offset;
13287       unsigned char * data;
13288       int addr_size;
13289
13290       ent = pltgot;
13291       addr_size = (is_32bit_elf ? 4 : 8);
13292       local_end = pltgot + local_gotno * addr_size;
13293       global_end = local_end + (symtabno - gotsym) * addr_size;
13294
13295       offset = offset_from_vma (file, pltgot, global_end - pltgot);
13296       data = (unsigned char *) get_data (NULL, file, offset,
13297                                          global_end - pltgot, 1,
13298                                          _("Global Offset Table data"));
13299       if (data == NULL)
13300         return 0;
13301
13302       printf (_("\nPrimary GOT:\n"));
13303       printf (_(" Canonical gp value: "));
13304       print_vma (pltgot + 0x7ff0, LONG_HEX);
13305       printf ("\n\n");
13306
13307       printf (_(" Reserved entries:\n"));
13308       printf (_("  %*s %10s %*s Purpose\n"),
13309               addr_size * 2, _("Address"), _("Access"),
13310               addr_size * 2, _("Initial"));
13311       ent = print_mips_got_entry (data, pltgot, ent);
13312       printf (_(" Lazy resolver\n"));
13313       if (data
13314           && (byte_get (data + ent - pltgot, addr_size)
13315               >> (addr_size * 8 - 1)) != 0)
13316         {
13317           ent = print_mips_got_entry (data, pltgot, ent);
13318           printf (_(" Module pointer (GNU extension)\n"));
13319         }
13320       printf ("\n");
13321
13322       if (ent < local_end)
13323         {
13324           printf (_(" Local entries:\n"));
13325           printf ("  %*s %10s %*s\n",
13326                   addr_size * 2, _("Address"), _("Access"),
13327                   addr_size * 2, _("Initial"));
13328           while (ent < local_end)
13329             {
13330               ent = print_mips_got_entry (data, pltgot, ent);
13331               printf ("\n");
13332             }
13333           printf ("\n");
13334         }
13335
13336       if (gotsym < symtabno)
13337         {
13338           int sym_width;
13339
13340           printf (_(" Global entries:\n"));
13341           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
13342                   addr_size * 2, _("Address"),
13343                   _("Access"),
13344                   addr_size * 2, _("Initial"),
13345                   addr_size * 2, _("Sym.Val."),
13346                   _("Type"),
13347                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
13348                   _("Ndx"), _("Name"));
13349
13350           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13351           for (i = gotsym; i < symtabno; i++)
13352             {
13353               Elf_Internal_Sym * psym;
13354
13355               psym = dynamic_symbols + i;
13356               ent = print_mips_got_entry (data, pltgot, ent);
13357               printf (" ");
13358               print_vma (psym->st_value, LONG_HEX);
13359               printf (" %-7s %3s ",
13360                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13361                       get_symbol_index_type (psym->st_shndx));
13362               if (VALID_DYNAMIC_NAME (psym->st_name))
13363                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13364               else
13365                 printf (_("<corrupt: %14ld>"), psym->st_name);
13366               printf ("\n");
13367             }
13368           printf ("\n");
13369         }
13370
13371       if (data)
13372         free (data);
13373     }
13374
13375   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13376     {
13377       bfd_vma ent, end;
13378       size_t offset, rel_offset;
13379       unsigned long count, i;
13380       unsigned char * data;
13381       int addr_size, sym_width;
13382       Elf_Internal_Rela * rels;
13383
13384       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13385       if (pltrel == DT_RELA)
13386         {
13387           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13388             return 0;
13389         }
13390       else
13391         {
13392           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13393             return 0;
13394         }
13395
13396       ent = mips_pltgot;
13397       addr_size = (is_32bit_elf ? 4 : 8);
13398       end = mips_pltgot + (2 + count) * addr_size;
13399
13400       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
13401       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
13402                                          1, _("Procedure Linkage Table data"));
13403       if (data == NULL)
13404         return 0;
13405
13406       printf ("\nPLT GOT:\n\n");
13407       printf (_(" Reserved entries:\n"));
13408       printf (_("  %*s %*s Purpose\n"),
13409               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
13410       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13411       printf (_(" PLT lazy resolver\n"));
13412       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13413       printf (_(" Module pointer\n"));
13414       printf ("\n");
13415
13416       printf (_(" Entries:\n"));
13417       printf ("  %*s %*s %*s %-7s %3s %s\n",
13418               addr_size * 2, _("Address"),
13419               addr_size * 2, _("Initial"),
13420               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13421       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13422       for (i = 0; i < count; i++)
13423         {
13424           Elf_Internal_Sym * psym;
13425
13426           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
13427           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13428           printf (" ");
13429           print_vma (psym->st_value, LONG_HEX);
13430           printf (" %-7s %3s ",
13431                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13432                   get_symbol_index_type (psym->st_shndx));
13433           if (VALID_DYNAMIC_NAME (psym->st_name))
13434             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13435           else
13436             printf (_("<corrupt: %14ld>"), psym->st_name);
13437           printf ("\n");
13438         }
13439       printf ("\n");
13440
13441       if (data)
13442         free (data);
13443       free (rels);
13444     }
13445
13446   return 1;
13447 }
13448
13449 static int
13450 process_nds32_specific (FILE * file)
13451 {
13452   Elf_Internal_Shdr *sect = NULL;
13453
13454   sect = find_section (".nds32_e_flags");
13455   if (sect != NULL)
13456     {
13457       unsigned int *flag;
13458
13459       printf ("\nNDS32 elf flags section:\n");
13460       flag = get_data (NULL, file, sect->sh_offset, 1,
13461                        sect->sh_size, _("NDS32 elf flags section"));
13462
13463       switch ((*flag) & 0x3)
13464         {
13465         case 0:
13466           printf ("(VEC_SIZE):\tNo entry.\n");
13467           break;
13468         case 1:
13469           printf ("(VEC_SIZE):\t4 bytes\n");
13470           break;
13471         case 2:
13472           printf ("(VEC_SIZE):\t16 bytes\n");
13473           break;
13474         case 3:
13475           printf ("(VEC_SIZE):\treserved\n");
13476           break;
13477         }
13478     }
13479
13480   return TRUE;
13481 }
13482
13483 static int
13484 process_gnu_liblist (FILE * file)
13485 {
13486   Elf_Internal_Shdr * section;
13487   Elf_Internal_Shdr * string_sec;
13488   Elf32_External_Lib * elib;
13489   char * strtab;
13490   size_t strtab_size;
13491   size_t cnt;
13492   unsigned i;
13493
13494   if (! do_arch)
13495     return 0;
13496
13497   for (i = 0, section = section_headers;
13498        i < elf_header.e_shnum;
13499        i++, section++)
13500     {
13501       switch (section->sh_type)
13502         {
13503         case SHT_GNU_LIBLIST:
13504           if (section->sh_link >= elf_header.e_shnum)
13505             break;
13506
13507           elib = (Elf32_External_Lib *)
13508               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
13509                         _("liblist section data"));
13510
13511           if (elib == NULL)
13512             break;
13513           string_sec = section_headers + section->sh_link;
13514
13515           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13516                                       string_sec->sh_size,
13517                                       _("liblist string table"));
13518           if (strtab == NULL
13519               || section->sh_entsize != sizeof (Elf32_External_Lib))
13520             {
13521               free (elib);
13522               free (strtab);
13523               break;
13524             }
13525           strtab_size = string_sec->sh_size;
13526
13527           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13528                   SECTION_NAME (section),
13529                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
13530
13531           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
13532
13533           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13534                ++cnt)
13535             {
13536               Elf32_Lib liblist;
13537               time_t atime;
13538               char timebuf[20];
13539               struct tm * tmp;
13540
13541               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13542               atime = BYTE_GET (elib[cnt].l_time_stamp);
13543               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13544               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13545               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13546
13547               tmp = gmtime (&atime);
13548               snprintf (timebuf, sizeof (timebuf),
13549                         "%04u-%02u-%02uT%02u:%02u:%02u",
13550                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13551                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13552
13553               printf ("%3lu: ", (unsigned long) cnt);
13554               if (do_wide)
13555                 printf ("%-20s", liblist.l_name < strtab_size
13556                         ? strtab + liblist.l_name : _("<corrupt>"));
13557               else
13558                 printf ("%-20.20s", liblist.l_name < strtab_size
13559                         ? strtab + liblist.l_name : _("<corrupt>"));
13560               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13561                       liblist.l_version, liblist.l_flags);
13562             }
13563
13564           free (elib);
13565           free (strtab);
13566         }
13567     }
13568
13569   return 1;
13570 }
13571
13572 static const char *
13573 get_note_type (unsigned e_type)
13574 {
13575   static char buff[64];
13576
13577   if (elf_header.e_type == ET_CORE)
13578     switch (e_type)
13579       {
13580       case NT_AUXV:
13581         return _("NT_AUXV (auxiliary vector)");
13582       case NT_PRSTATUS:
13583         return _("NT_PRSTATUS (prstatus structure)");
13584       case NT_FPREGSET:
13585         return _("NT_FPREGSET (floating point registers)");
13586       case NT_PRPSINFO:
13587         return _("NT_PRPSINFO (prpsinfo structure)");
13588       case NT_TASKSTRUCT:
13589         return _("NT_TASKSTRUCT (task structure)");
13590       case NT_PRXFPREG:
13591         return _("NT_PRXFPREG (user_xfpregs structure)");
13592       case NT_PPC_VMX:
13593         return _("NT_PPC_VMX (ppc Altivec registers)");
13594       case NT_PPC_VSX:
13595         return _("NT_PPC_VSX (ppc VSX registers)");
13596       case NT_386_TLS:
13597         return _("NT_386_TLS (x86 TLS information)");
13598       case NT_386_IOPERM:
13599         return _("NT_386_IOPERM (x86 I/O permissions)");
13600       case NT_X86_XSTATE:
13601         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13602       case NT_S390_HIGH_GPRS:
13603         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13604       case NT_S390_TIMER:
13605         return _("NT_S390_TIMER (s390 timer register)");
13606       case NT_S390_TODCMP:
13607         return _("NT_S390_TODCMP (s390 TOD comparator register)");
13608       case NT_S390_TODPREG:
13609         return _("NT_S390_TODPREG (s390 TOD programmable register)");
13610       case NT_S390_CTRS:
13611         return _("NT_S390_CTRS (s390 control registers)");
13612       case NT_S390_PREFIX:
13613         return _("NT_S390_PREFIX (s390 prefix register)");
13614       case NT_S390_LAST_BREAK:
13615         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13616       case NT_S390_SYSTEM_CALL:
13617         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13618       case NT_S390_TDB:
13619         return _("NT_S390_TDB (s390 transaction diagnostic block)");
13620       case NT_ARM_VFP:
13621         return _("NT_ARM_VFP (arm VFP registers)");
13622       case NT_ARM_TLS:
13623         return _("NT_ARM_TLS (AArch TLS registers)");
13624       case NT_ARM_HW_BREAK:
13625         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13626       case NT_ARM_HW_WATCH:
13627         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13628       case NT_PSTATUS:
13629         return _("NT_PSTATUS (pstatus structure)");
13630       case NT_FPREGS:
13631         return _("NT_FPREGS (floating point registers)");
13632       case NT_PSINFO:
13633         return _("NT_PSINFO (psinfo structure)");
13634       case NT_LWPSTATUS:
13635         return _("NT_LWPSTATUS (lwpstatus_t structure)");
13636       case NT_LWPSINFO:
13637         return _("NT_LWPSINFO (lwpsinfo_t structure)");
13638       case NT_WIN32PSTATUS:
13639         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13640       case NT_SIGINFO:
13641         return _("NT_SIGINFO (siginfo_t data)");
13642       case NT_FILE:
13643         return _("NT_FILE (mapped files)");
13644       default:
13645         break;
13646       }
13647   else
13648     switch (e_type)
13649       {
13650       case NT_VERSION:
13651         return _("NT_VERSION (version)");
13652       case NT_ARCH:
13653         return _("NT_ARCH (architecture)");
13654       default:
13655         break;
13656       }
13657
13658   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13659   return buff;
13660 }
13661
13662 static int
13663 print_core_note (Elf_Internal_Note *pnote)
13664 {
13665   unsigned int addr_size = is_32bit_elf ? 4 : 8;
13666   bfd_vma count, page_size;
13667   unsigned char *descdata, *filenames, *descend;
13668
13669   if (pnote->type != NT_FILE)
13670     return 1;
13671
13672 #ifndef BFD64
13673   if (!is_32bit_elf)
13674     {
13675       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
13676       /* Still "successful".  */
13677       return 1;
13678     }
13679 #endif
13680
13681   if (pnote->descsz < 2 * addr_size)
13682     {
13683       printf (_("    Malformed note - too short for header\n"));
13684       return 0;
13685     }
13686
13687   descdata = (unsigned char *) pnote->descdata;
13688   descend = descdata + pnote->descsz;
13689
13690   if (descdata[pnote->descsz - 1] != '\0')
13691     {
13692       printf (_("    Malformed note - does not end with \\0\n"));
13693       return 0;
13694     }
13695
13696   count = byte_get (descdata, addr_size);
13697   descdata += addr_size;
13698
13699   page_size = byte_get (descdata, addr_size);
13700   descdata += addr_size;
13701
13702   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13703     {
13704       printf (_("    Malformed note - too short for supplied file count\n"));
13705       return 0;
13706     }
13707
13708   printf (_("    Page size: "));
13709   print_vma (page_size, DEC);
13710   printf ("\n");
13711
13712   printf (_("    %*s%*s%*s\n"),
13713           (int) (2 + 2 * addr_size), _("Start"),
13714           (int) (4 + 2 * addr_size), _("End"),
13715           (int) (4 + 2 * addr_size), _("Page Offset"));
13716   filenames = descdata + count * 3 * addr_size;
13717   while (--count > 0)
13718     {
13719       bfd_vma start, end, file_ofs;
13720
13721       if (filenames == descend)
13722         {
13723           printf (_("    Malformed note - filenames end too early\n"));
13724           return 0;
13725         }
13726
13727       start = byte_get (descdata, addr_size);
13728       descdata += addr_size;
13729       end = byte_get (descdata, addr_size);
13730       descdata += addr_size;
13731       file_ofs = byte_get (descdata, addr_size);
13732       descdata += addr_size;
13733
13734       printf ("    ");
13735       print_vma (start, FULL_HEX);
13736       printf ("  ");
13737       print_vma (end, FULL_HEX);
13738       printf ("  ");
13739       print_vma (file_ofs, FULL_HEX);
13740       printf ("\n        %s\n", filenames);
13741
13742       filenames += 1 + strlen ((char *) filenames);
13743     }
13744
13745   return 1;
13746 }
13747
13748 static const char *
13749 get_gnu_elf_note_type (unsigned e_type)
13750 {
13751   static char buff[64];
13752
13753   switch (e_type)
13754     {
13755     case NT_GNU_ABI_TAG:
13756       return _("NT_GNU_ABI_TAG (ABI version tag)");
13757     case NT_GNU_HWCAP:
13758       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13759     case NT_GNU_BUILD_ID:
13760       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13761     case NT_GNU_GOLD_VERSION:
13762       return _("NT_GNU_GOLD_VERSION (gold version)");
13763     default:
13764       break;
13765     }
13766
13767   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13768   return buff;
13769 }
13770
13771 static int
13772 print_gnu_note (Elf_Internal_Note *pnote)
13773 {
13774   switch (pnote->type)
13775     {
13776     case NT_GNU_BUILD_ID:
13777       {
13778         unsigned long i;
13779
13780         printf (_("    Build ID: "));
13781         for (i = 0; i < pnote->descsz; ++i)
13782           printf ("%02x", pnote->descdata[i] & 0xff);
13783         printf ("\n");
13784       }
13785       break;
13786
13787     case NT_GNU_ABI_TAG:
13788       {
13789         unsigned long os, major, minor, subminor;
13790         const char *osname;
13791
13792         os = byte_get ((unsigned char *) pnote->descdata, 4);
13793         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13794         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13795         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13796
13797         switch (os)
13798           {
13799           case GNU_ABI_TAG_LINUX:
13800             osname = "Linux";
13801             break;
13802           case GNU_ABI_TAG_HURD:
13803             osname = "Hurd";
13804             break;
13805           case GNU_ABI_TAG_SOLARIS:
13806             osname = "Solaris";
13807             break;
13808           case GNU_ABI_TAG_FREEBSD:
13809             osname = "FreeBSD";
13810             break;
13811           case GNU_ABI_TAG_NETBSD:
13812             osname = "NetBSD";
13813             break;
13814           default:
13815             osname = "Unknown";
13816             break;
13817           }
13818
13819         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13820                 major, minor, subminor);
13821       }
13822       break;
13823
13824     case NT_GNU_GOLD_VERSION:
13825       {
13826         unsigned long i;
13827
13828         printf (_("    Version: "));
13829         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
13830           printf ("%c", pnote->descdata[i]);
13831         printf ("\n");
13832       }
13833       break;
13834     }
13835
13836   return 1;
13837 }
13838
13839 static const char *
13840 get_netbsd_elfcore_note_type (unsigned e_type)
13841 {
13842   static char buff[64];
13843
13844   if (e_type == NT_NETBSDCORE_PROCINFO)
13845     {
13846       /* NetBSD core "procinfo" structure.  */
13847       return _("NetBSD procinfo structure");
13848     }
13849
13850   /* As of Jan 2002 there are no other machine-independent notes
13851      defined for NetBSD core files.  If the note type is less
13852      than the start of the machine-dependent note types, we don't
13853      understand it.  */
13854
13855   if (e_type < NT_NETBSDCORE_FIRSTMACH)
13856     {
13857       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13858       return buff;
13859     }
13860
13861   switch (elf_header.e_machine)
13862     {
13863     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13864        and PT_GETFPREGS == mach+2.  */
13865
13866     case EM_OLD_ALPHA:
13867     case EM_ALPHA:
13868     case EM_SPARC:
13869     case EM_SPARC32PLUS:
13870     case EM_SPARCV9:
13871       switch (e_type)
13872         {
13873         case NT_NETBSDCORE_FIRSTMACH + 0:
13874           return _("PT_GETREGS (reg structure)");
13875         case NT_NETBSDCORE_FIRSTMACH + 2:
13876           return _("PT_GETFPREGS (fpreg structure)");
13877         default:
13878           break;
13879         }
13880       break;
13881
13882     /* On all other arch's, PT_GETREGS == mach+1 and
13883        PT_GETFPREGS == mach+3.  */
13884     default:
13885       switch (e_type)
13886         {
13887         case NT_NETBSDCORE_FIRSTMACH + 1:
13888           return _("PT_GETREGS (reg structure)");
13889         case NT_NETBSDCORE_FIRSTMACH + 3:
13890           return _("PT_GETFPREGS (fpreg structure)");
13891         default:
13892           break;
13893         }
13894     }
13895
13896   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13897             e_type - NT_NETBSDCORE_FIRSTMACH);
13898   return buff;
13899 }
13900
13901 static const char *
13902 get_stapsdt_note_type (unsigned e_type)
13903 {
13904   static char buff[64];
13905
13906   switch (e_type)
13907     {
13908     case NT_STAPSDT:
13909       return _("NT_STAPSDT (SystemTap probe descriptors)");
13910
13911     default:
13912       break;
13913     }
13914
13915   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13916   return buff;
13917 }
13918
13919 static int
13920 print_stapsdt_note (Elf_Internal_Note *pnote)
13921 {
13922   int addr_size = is_32bit_elf ? 4 : 8;
13923   char *data = pnote->descdata;
13924   char *data_end = pnote->descdata + pnote->descsz;
13925   bfd_vma pc, base_addr, semaphore;
13926   char *provider, *probe, *arg_fmt;
13927
13928   pc = byte_get ((unsigned char *) data, addr_size);
13929   data += addr_size;
13930   base_addr = byte_get ((unsigned char *) data, addr_size);
13931   data += addr_size;
13932   semaphore = byte_get ((unsigned char *) data, addr_size);
13933   data += addr_size;
13934
13935   provider = data;
13936   data += strlen (data) + 1;
13937   probe = data;
13938   data += strlen (data) + 1;
13939   arg_fmt = data;
13940   data += strlen (data) + 1;
13941
13942   printf (_("    Provider: %s\n"), provider);
13943   printf (_("    Name: %s\n"), probe);
13944   printf (_("    Location: "));
13945   print_vma (pc, FULL_HEX);
13946   printf (_(", Base: "));
13947   print_vma (base_addr, FULL_HEX);
13948   printf (_(", Semaphore: "));
13949   print_vma (semaphore, FULL_HEX);
13950   printf ("\n");
13951   printf (_("    Arguments: %s\n"), arg_fmt);
13952
13953   return data == data_end;
13954 }
13955
13956 static const char *
13957 get_ia64_vms_note_type (unsigned e_type)
13958 {
13959   static char buff[64];
13960
13961   switch (e_type)
13962     {
13963     case NT_VMS_MHD:
13964       return _("NT_VMS_MHD (module header)");
13965     case NT_VMS_LNM:
13966       return _("NT_VMS_LNM (language name)");
13967     case NT_VMS_SRC:
13968       return _("NT_VMS_SRC (source files)");
13969     case NT_VMS_TITLE:
13970       return "NT_VMS_TITLE";
13971     case NT_VMS_EIDC:
13972       return _("NT_VMS_EIDC (consistency check)");
13973     case NT_VMS_FPMODE:
13974       return _("NT_VMS_FPMODE (FP mode)");
13975     case NT_VMS_LINKTIME:
13976       return "NT_VMS_LINKTIME";
13977     case NT_VMS_IMGNAM:
13978       return _("NT_VMS_IMGNAM (image name)");
13979     case NT_VMS_IMGID:
13980       return _("NT_VMS_IMGID (image id)");
13981     case NT_VMS_LINKID:
13982       return _("NT_VMS_LINKID (link id)");
13983     case NT_VMS_IMGBID:
13984       return _("NT_VMS_IMGBID (build id)");
13985     case NT_VMS_GSTNAM:
13986       return _("NT_VMS_GSTNAM (sym table name)");
13987     case NT_VMS_ORIG_DYN:
13988       return "NT_VMS_ORIG_DYN";
13989     case NT_VMS_PATCHTIME:
13990       return "NT_VMS_PATCHTIME";
13991     default:
13992       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13993       return buff;
13994     }
13995 }
13996
13997 static int
13998 print_ia64_vms_note (Elf_Internal_Note * pnote)
13999 {
14000   switch (pnote->type)
14001     {
14002     case NT_VMS_MHD:
14003       if (pnote->descsz > 36)
14004         {
14005           size_t l = strlen (pnote->descdata + 34);
14006           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
14007           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
14008           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
14009           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
14010         }
14011       else
14012         printf (_("    Invalid size\n"));
14013       break;
14014     case NT_VMS_LNM:
14015       printf (_("   Language: %s\n"), pnote->descdata);
14016       break;
14017 #ifdef BFD64
14018     case NT_VMS_FPMODE:
14019       printf (_("   Floating Point mode: "));
14020       printf ("0x%016" BFD_VMA_FMT "x\n",
14021               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14022       break;
14023     case NT_VMS_LINKTIME:
14024       printf (_("   Link time: "));
14025       print_vms_time
14026         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14027       printf ("\n");
14028       break;
14029     case NT_VMS_PATCHTIME:
14030       printf (_("   Patch time: "));
14031       print_vms_time
14032         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14033       printf ("\n");
14034       break;
14035     case NT_VMS_ORIG_DYN:
14036       printf (_("   Major id: %u,  minor id: %u\n"),
14037               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14038               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
14039       printf (_("   Last modified  : "));
14040       print_vms_time
14041         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
14042       printf (_("\n   Link flags  : "));
14043       printf ("0x%016" BFD_VMA_FMT "x\n",
14044               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14045       printf (_("   Header flags: 0x%08x\n"),
14046               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14047       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
14048       break;
14049 #endif
14050     case NT_VMS_IMGNAM:
14051       printf (_("    Image name: %s\n"), pnote->descdata);
14052       break;
14053     case NT_VMS_GSTNAM:
14054       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
14055       break;
14056     case NT_VMS_IMGID:
14057       printf (_("    Image id: %s\n"), pnote->descdata);
14058       break;
14059     case NT_VMS_LINKID:
14060       printf (_("    Linker id: %s\n"), pnote->descdata);
14061       break;
14062     default:
14063       break;
14064     }
14065   return 1;
14066 }
14067
14068 /* Note that by the ELF standard, the name field is already null byte
14069    terminated, and namesz includes the terminating null byte.
14070    I.E. the value of namesz for the name "FSF" is 4.
14071
14072    If the value of namesz is zero, there is no name present.  */
14073 static int
14074 process_note (Elf_Internal_Note * pnote)
14075 {
14076   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14077   const char * nt;
14078
14079   if (pnote->namesz == 0)
14080     /* If there is no note name, then use the default set of
14081        note type strings.  */
14082     nt = get_note_type (pnote->type);
14083
14084   else if (const_strneq (pnote->namedata, "GNU"))
14085     /* GNU-specific object file notes.  */
14086     nt = get_gnu_elf_note_type (pnote->type);
14087
14088   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
14089     /* NetBSD-specific core file notes.  */
14090     nt = get_netbsd_elfcore_note_type (pnote->type);
14091
14092   else if (strneq (pnote->namedata, "SPU/", 4))
14093     {
14094       /* SPU-specific core file notes.  */
14095       nt = pnote->namedata + 4;
14096       name = "SPU";
14097     }
14098
14099   else if (const_strneq (pnote->namedata, "IPF/VMS"))
14100     /* VMS/ia64-specific file notes.  */
14101     nt = get_ia64_vms_note_type (pnote->type);
14102
14103   else if (const_strneq (pnote->namedata, "stapsdt"))
14104     nt = get_stapsdt_note_type (pnote->type);
14105
14106   else
14107     /* Don't recognize this note name; just use the default set of
14108        note type strings.  */
14109     nt = get_note_type (pnote->type);
14110
14111   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
14112
14113   if (const_strneq (pnote->namedata, "IPF/VMS"))
14114     return print_ia64_vms_note (pnote);
14115   else if (const_strneq (pnote->namedata, "GNU"))
14116     return print_gnu_note (pnote);
14117   else if (const_strneq (pnote->namedata, "stapsdt"))
14118     return print_stapsdt_note (pnote);
14119   else if (const_strneq (pnote->namedata, "CORE"))
14120     return print_core_note (pnote);
14121   else
14122     return 1;
14123 }
14124
14125
14126 static int
14127 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
14128 {
14129   Elf_External_Note * pnotes;
14130   Elf_External_Note * external;
14131   int res = 1;
14132
14133   if (length <= 0)
14134     return 0;
14135
14136   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
14137                                            _("notes"));
14138   if (pnotes == NULL)
14139     return 0;
14140
14141   external = pnotes;
14142
14143   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14144           (unsigned long) offset, (unsigned long) length);
14145   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14146
14147   while ((char *) external < (char *) pnotes + length)
14148     {
14149       Elf_Internal_Note inote;
14150       size_t min_notesz;
14151       char *next;
14152       char * temp = NULL;
14153       size_t data_remaining = ((char *) pnotes + length) - (char *) external;
14154
14155       if (!is_ia64_vms ())
14156         {
14157           /* PR binutils/15191
14158              Make sure that there is enough data to read.  */
14159           min_notesz = offsetof (Elf_External_Note, name);
14160           if (data_remaining < min_notesz)
14161             {
14162               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14163                     (int) data_remaining);
14164               break;
14165             }
14166           inote.type     = BYTE_GET (external->type);
14167           inote.namesz   = BYTE_GET (external->namesz);
14168           inote.namedata = external->name;
14169           inote.descsz   = BYTE_GET (external->descsz);
14170           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14171           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
14172           next = inote.descdata + align_power (inote.descsz, 2);
14173         }
14174       else
14175         {
14176           Elf64_External_VMS_Note *vms_external;
14177
14178           /* PR binutils/15191
14179              Make sure that there is enough data to read.  */
14180           min_notesz = offsetof (Elf64_External_VMS_Note, name);
14181           if (data_remaining < min_notesz)
14182             {
14183               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14184                     (int) data_remaining);
14185               break;
14186             }
14187
14188           vms_external = (Elf64_External_VMS_Note *) external;
14189           inote.type     = BYTE_GET (vms_external->type);
14190           inote.namesz   = BYTE_GET (vms_external->namesz);
14191           inote.namedata = vms_external->name;
14192           inote.descsz   = BYTE_GET (vms_external->descsz);
14193           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14194           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
14195           next = inote.descdata + align_power (inote.descsz, 3);
14196         }
14197
14198       if (inote.descdata < (char *) external + min_notesz
14199           || next < (char *) external + min_notesz
14200           || data_remaining < (size_t)(next - (char *) external))
14201         {
14202           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14203                 (unsigned long) ((char *) external - (char *) pnotes));
14204           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14205                 inote.type, inote.namesz, inote.descsz);
14206           break;
14207         }
14208
14209       external = (Elf_External_Note *) next;
14210
14211       /* Verify that name is null terminated.  It appears that at least
14212          one version of Linux (RedHat 6.0) generates corefiles that don't
14213          comply with the ELF spec by failing to include the null byte in
14214          namesz.  */
14215       if (inote.namedata[inote.namesz - 1] != '\0')
14216         {
14217           temp = (char *) malloc (inote.namesz + 1);
14218
14219           if (temp == NULL)
14220             {
14221               error (_("Out of memory\n"));
14222               res = 0;
14223               break;
14224             }
14225
14226           strncpy (temp, inote.namedata, inote.namesz);
14227           temp[inote.namesz] = 0;
14228
14229           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
14230           inote.namedata = temp;
14231         }
14232
14233       res &= process_note (& inote);
14234
14235       if (temp != NULL)
14236         {
14237           free (temp);
14238           temp = NULL;
14239         }
14240     }
14241
14242   free (pnotes);
14243
14244   return res;
14245 }
14246
14247 static int
14248 process_corefile_note_segments (FILE * file)
14249 {
14250   Elf_Internal_Phdr * segment;
14251   unsigned int i;
14252   int res = 1;
14253
14254   if (! get_program_headers (file))
14255       return 0;
14256
14257   for (i = 0, segment = program_headers;
14258        i < elf_header.e_phnum;
14259        i++, segment++)
14260     {
14261       if (segment->p_type == PT_NOTE)
14262         res &= process_corefile_note_segment (file,
14263                                               (bfd_vma) segment->p_offset,
14264                                               (bfd_vma) segment->p_filesz);
14265     }
14266
14267   return res;
14268 }
14269
14270 static int
14271 process_note_sections (FILE * file)
14272 {
14273   Elf_Internal_Shdr * section;
14274   unsigned long i;
14275   int n = 0;
14276   int res = 1;
14277
14278   for (i = 0, section = section_headers;
14279        i < elf_header.e_shnum && section != NULL;
14280        i++, section++)
14281     if (section->sh_type == SHT_NOTE)
14282       {
14283         res &= process_corefile_note_segment (file,
14284                                               (bfd_vma) section->sh_offset,
14285                                               (bfd_vma) section->sh_size);
14286         n++;
14287       }
14288
14289   if (n == 0)
14290     /* Try processing NOTE segments instead.  */
14291     return process_corefile_note_segments (file);
14292
14293   return res;
14294 }
14295
14296 static int
14297 process_notes (FILE * file)
14298 {
14299   /* If we have not been asked to display the notes then do nothing.  */
14300   if (! do_notes)
14301     return 1;
14302
14303   if (elf_header.e_type != ET_CORE)
14304     return process_note_sections (file);
14305
14306   /* No program headers means no NOTE segment.  */
14307   if (elf_header.e_phnum > 0)
14308     return process_corefile_note_segments (file);
14309
14310   printf (_("No note segments present in the core file.\n"));
14311   return 1;
14312 }
14313
14314 static int
14315 process_arch_specific (FILE * file)
14316 {
14317   if (! do_arch)
14318     return 1;
14319
14320   switch (elf_header.e_machine)
14321     {
14322     case EM_ARM:
14323       return process_arm_specific (file);
14324     case EM_MIPS:
14325     case EM_MIPS_RS3_LE:
14326       return process_mips_specific (file);
14327       break;
14328     case EM_NDS32:
14329       return process_nds32_specific (file);
14330       break;
14331     case EM_PPC:
14332       return process_power_specific (file);
14333       break;
14334     case EM_SPARC:
14335     case EM_SPARC32PLUS:
14336     case EM_SPARCV9:
14337       return process_sparc_specific (file);
14338       break;
14339     case EM_TI_C6000:
14340       return process_tic6x_specific (file);
14341       break;
14342     case EM_MSP430:
14343       return process_msp430x_specific (file);
14344     default:
14345       break;
14346     }
14347   return 1;
14348 }
14349
14350 static int
14351 get_file_header (FILE * file)
14352 {
14353   /* Read in the identity array.  */
14354   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
14355     return 0;
14356
14357   /* Determine how to read the rest of the header.  */
14358   switch (elf_header.e_ident[EI_DATA])
14359     {
14360     default: /* fall through */
14361     case ELFDATANONE: /* fall through */
14362     case ELFDATA2LSB:
14363       byte_get = byte_get_little_endian;
14364       byte_put = byte_put_little_endian;
14365       break;
14366     case ELFDATA2MSB:
14367       byte_get = byte_get_big_endian;
14368       byte_put = byte_put_big_endian;
14369       break;
14370     }
14371
14372   /* For now we only support 32 bit and 64 bit ELF files.  */
14373   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
14374
14375   /* Read in the rest of the header.  */
14376   if (is_32bit_elf)
14377     {
14378       Elf32_External_Ehdr ehdr32;
14379
14380       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14381         return 0;
14382
14383       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
14384       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
14385       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
14386       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
14387       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
14388       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
14389       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
14390       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
14391       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14392       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
14393       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14394       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
14395       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
14396     }
14397   else
14398     {
14399       Elf64_External_Ehdr ehdr64;
14400
14401       /* If we have been compiled with sizeof (bfd_vma) == 4, then
14402          we will not be able to cope with the 64bit data found in
14403          64 ELF files.  Detect this now and abort before we start
14404          overwriting things.  */
14405       if (sizeof (bfd_vma) < 8)
14406         {
14407           error (_("This instance of readelf has been built without support for a\n\
14408 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14409           return 0;
14410         }
14411
14412       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14413         return 0;
14414
14415       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
14416       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
14417       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
14418       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
14419       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
14420       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
14421       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
14422       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
14423       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14424       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
14425       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14426       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
14427       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
14428     }
14429
14430   if (elf_header.e_shoff)
14431     {
14432       /* There may be some extensions in the first section header.  Don't
14433          bomb if we can't read it.  */
14434       if (is_32bit_elf)
14435         get_32bit_section_headers (file, 1);
14436       else
14437         get_64bit_section_headers (file, 1);
14438     }
14439
14440   return 1;
14441 }
14442
14443 /* Process one ELF object file according to the command line options.
14444    This file may actually be stored in an archive.  The file is
14445    positioned at the start of the ELF object.  */
14446
14447 static int
14448 process_object (char * file_name, FILE * file)
14449 {
14450   unsigned int i;
14451
14452   if (! get_file_header (file))
14453     {
14454       error (_("%s: Failed to read file header\n"), file_name);
14455       return 1;
14456     }
14457
14458   /* Initialise per file variables.  */
14459   for (i = ARRAY_SIZE (version_info); i--;)
14460     version_info[i] = 0;
14461
14462   for (i = ARRAY_SIZE (dynamic_info); i--;)
14463     dynamic_info[i] = 0;
14464   dynamic_info_DT_GNU_HASH = 0;
14465
14466   /* Process the file.  */
14467   if (show_name)
14468     printf (_("\nFile: %s\n"), file_name);
14469
14470   /* Initialise the dump_sects array from the cmdline_dump_sects array.
14471      Note we do this even if cmdline_dump_sects is empty because we
14472      must make sure that the dump_sets array is zeroed out before each
14473      object file is processed.  */
14474   if (num_dump_sects > num_cmdline_dump_sects)
14475     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
14476
14477   if (num_cmdline_dump_sects > 0)
14478     {
14479       if (num_dump_sects == 0)
14480         /* A sneaky way of allocating the dump_sects array.  */
14481         request_dump_bynumber (num_cmdline_dump_sects, 0);
14482
14483       assert (num_dump_sects >= num_cmdline_dump_sects);
14484       memcpy (dump_sects, cmdline_dump_sects,
14485               num_cmdline_dump_sects * sizeof (* dump_sects));
14486     }
14487
14488   if (! process_file_header ())
14489     return 1;
14490
14491   if (! process_section_headers (file))
14492     {
14493       /* Without loaded section headers we cannot process lots of
14494          things.  */
14495       do_unwind = do_version = do_dump = do_arch = 0;
14496
14497       if (! do_using_dynamic)
14498         do_syms = do_dyn_syms = do_reloc = 0;
14499     }
14500
14501   if (! process_section_groups (file))
14502     {
14503       /* Without loaded section groups we cannot process unwind.  */
14504       do_unwind = 0;
14505     }
14506
14507   if (process_program_headers (file))
14508     process_dynamic_section (file);
14509
14510   process_relocs (file);
14511
14512   process_unwind (file);
14513
14514   process_symbol_table (file);
14515
14516   process_syminfo (file);
14517
14518   process_version_sections (file);
14519
14520   process_section_contents (file);
14521
14522   process_notes (file);
14523
14524   process_gnu_liblist (file);
14525
14526   process_arch_specific (file);
14527
14528   if (program_headers)
14529     {
14530       free (program_headers);
14531       program_headers = NULL;
14532     }
14533
14534   if (section_headers)
14535     {
14536       free (section_headers);
14537       section_headers = NULL;
14538     }
14539
14540   if (string_table)
14541     {
14542       free (string_table);
14543       string_table = NULL;
14544       string_table_length = 0;
14545     }
14546
14547   if (dynamic_strings)
14548     {
14549       free (dynamic_strings);
14550       dynamic_strings = NULL;
14551       dynamic_strings_length = 0;
14552     }
14553
14554   if (dynamic_symbols)
14555     {
14556       free (dynamic_symbols);
14557       dynamic_symbols = NULL;
14558       num_dynamic_syms = 0;
14559     }
14560
14561   if (dynamic_syminfo)
14562     {
14563       free (dynamic_syminfo);
14564       dynamic_syminfo = NULL;
14565     }
14566
14567   if (dynamic_section)
14568     {
14569       free (dynamic_section);
14570       dynamic_section = NULL;
14571     }
14572
14573   if (section_headers_groups)
14574     {
14575       free (section_headers_groups);
14576       section_headers_groups = NULL;
14577     }
14578
14579   if (section_groups)
14580     {
14581       struct group_list * g;
14582       struct group_list * next;
14583
14584       for (i = 0; i < group_count; i++)
14585         {
14586           for (g = section_groups [i].root; g != NULL; g = next)
14587             {
14588               next = g->next;
14589               free (g);
14590             }
14591         }
14592
14593       free (section_groups);
14594       section_groups = NULL;
14595     }
14596
14597   free_debug_memory ();
14598
14599   return 0;
14600 }
14601
14602 /* Process an ELF archive.
14603    On entry the file is positioned just after the ARMAG string.  */
14604
14605 static int
14606 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14607 {
14608   struct archive_info arch;
14609   struct archive_info nested_arch;
14610   size_t got;
14611   int ret;
14612
14613   show_name = 1;
14614
14615   /* The ARCH structure is used to hold information about this archive.  */
14616   arch.file_name = NULL;
14617   arch.file = NULL;
14618   arch.index_array = NULL;
14619   arch.sym_table = NULL;
14620   arch.longnames = NULL;
14621
14622   /* The NESTED_ARCH structure is used as a single-item cache of information
14623      about a nested archive (when members of a thin archive reside within
14624      another regular archive file).  */
14625   nested_arch.file_name = NULL;
14626   nested_arch.file = NULL;
14627   nested_arch.index_array = NULL;
14628   nested_arch.sym_table = NULL;
14629   nested_arch.longnames = NULL;
14630
14631   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14632     {
14633       ret = 1;
14634       goto out;
14635     }
14636
14637   if (do_archive_index)
14638     {
14639       if (arch.sym_table == NULL)
14640         error (_("%s: unable to dump the index as none was found\n"), file_name);
14641       else
14642         {
14643           unsigned int i, l;
14644           unsigned long current_pos;
14645
14646           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14647                   file_name, (long) arch.index_num, arch.sym_size);
14648           current_pos = ftell (file);
14649
14650           for (i = l = 0; i < arch.index_num; i++)
14651             {
14652               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14653                 {
14654                   char * member_name;
14655
14656                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14657
14658                   if (member_name != NULL)
14659                     {
14660                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14661
14662                       if (qualified_name != NULL)
14663                         {
14664                           printf (_("Contents of binary %s at offset "), qualified_name);
14665                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
14666                           putchar ('\n');
14667                           free (qualified_name);
14668                         }
14669                     }
14670                 }
14671
14672               if (l >= arch.sym_size)
14673                 {
14674                   error (_("%s: end of the symbol table reached before the end of the index\n"),
14675                          file_name);
14676                   break;
14677                 }
14678               printf ("\t%s\n", arch.sym_table + l);
14679               l += strlen (arch.sym_table + l) + 1;
14680             }
14681
14682           if (arch.uses_64bit_indicies)
14683             l = (l + 7) & ~ 7;
14684           else
14685             l += l & 1;
14686
14687           if (l < arch.sym_size)
14688             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14689                    file_name, arch.sym_size - l);
14690
14691           if (fseek (file, current_pos, SEEK_SET) != 0)
14692             {
14693               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
14694               ret = 1;
14695               goto out;
14696             }
14697         }
14698
14699       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14700           && !do_segments && !do_header && !do_dump && !do_version
14701           && !do_histogram && !do_debugging && !do_arch && !do_notes
14702           && !do_section_groups && !do_dyn_syms)
14703         {
14704           ret = 0; /* Archive index only.  */
14705           goto out;
14706         }
14707     }
14708
14709   ret = 0;
14710
14711   while (1)
14712     {
14713       char * name;
14714       size_t namelen;
14715       char * qualified_name;
14716
14717       /* Read the next archive header.  */
14718       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14719         {
14720           error (_("%s: failed to seek to next archive header\n"), file_name);
14721           return 1;
14722         }
14723       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14724       if (got != sizeof arch.arhdr)
14725         {
14726           if (got == 0)
14727             break;
14728           error (_("%s: failed to read archive header\n"), file_name);
14729           ret = 1;
14730           break;
14731         }
14732       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14733         {
14734           error (_("%s: did not find a valid archive header\n"), arch.file_name);
14735           ret = 1;
14736           break;
14737         }
14738
14739       arch.next_arhdr_offset += sizeof arch.arhdr;
14740
14741       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14742       if (archive_file_size & 01)
14743         ++archive_file_size;
14744
14745       name = get_archive_member_name (&arch, &nested_arch);
14746       if (name == NULL)
14747         {
14748           error (_("%s: bad archive file name\n"), file_name);
14749           ret = 1;
14750           break;
14751         }
14752       namelen = strlen (name);
14753
14754       qualified_name = make_qualified_name (&arch, &nested_arch, name);
14755       if (qualified_name == NULL)
14756         {
14757           error (_("%s: bad archive file name\n"), file_name);
14758           ret = 1;
14759           break;
14760         }
14761
14762       if (is_thin_archive && arch.nested_member_origin == 0)
14763         {
14764           /* This is a proxy for an external member of a thin archive.  */
14765           FILE * member_file;
14766           char * member_file_name = adjust_relative_path (file_name, name, namelen);
14767           if (member_file_name == NULL)
14768             {
14769               ret = 1;
14770               break;
14771             }
14772
14773           member_file = fopen (member_file_name, "rb");
14774           if (member_file == NULL)
14775             {
14776               error (_("Input file '%s' is not readable.\n"), member_file_name);
14777               free (member_file_name);
14778               ret = 1;
14779               break;
14780             }
14781
14782           archive_file_offset = arch.nested_member_origin;
14783
14784           ret |= process_object (qualified_name, member_file);
14785
14786           fclose (member_file);
14787           free (member_file_name);
14788         }
14789       else if (is_thin_archive)
14790         {
14791           /* PR 15140: Allow for corrupt thin archives.  */
14792           if (nested_arch.file == NULL)
14793             {
14794               error (_("%s: contains corrupt thin archive: %s\n"),
14795                      file_name, name);
14796               ret = 1;
14797               break;
14798             }
14799
14800           /* This is a proxy for a member of a nested archive.  */
14801           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14802
14803           /* The nested archive file will have been opened and setup by
14804              get_archive_member_name.  */
14805           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14806             {
14807               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14808               ret = 1;
14809               break;
14810             }
14811
14812           ret |= process_object (qualified_name, nested_arch.file);
14813         }
14814       else
14815         {
14816           archive_file_offset = arch.next_arhdr_offset;
14817           arch.next_arhdr_offset += archive_file_size;
14818
14819           ret |= process_object (qualified_name, file);
14820         }
14821
14822       if (dump_sects != NULL)
14823         {
14824           free (dump_sects);
14825           dump_sects = NULL;
14826           num_dump_sects = 0;
14827         }
14828
14829       free (qualified_name);
14830     }
14831
14832  out:
14833   if (nested_arch.file != NULL)
14834     fclose (nested_arch.file);
14835   release_archive (&nested_arch);
14836   release_archive (&arch);
14837
14838   return ret;
14839 }
14840
14841 static int
14842 process_file (char * file_name)
14843 {
14844   FILE * file;
14845   struct stat statbuf;
14846   char armag[SARMAG];
14847   int ret;
14848
14849   if (stat (file_name, &statbuf) < 0)
14850     {
14851       if (errno == ENOENT)
14852         error (_("'%s': No such file\n"), file_name);
14853       else
14854         error (_("Could not locate '%s'.  System error message: %s\n"),
14855                file_name, strerror (errno));
14856       return 1;
14857     }
14858
14859   if (! S_ISREG (statbuf.st_mode))
14860     {
14861       error (_("'%s' is not an ordinary file\n"), file_name);
14862       return 1;
14863     }
14864
14865   file = fopen (file_name, "rb");
14866   if (file == NULL)
14867     {
14868       error (_("Input file '%s' is not readable.\n"), file_name);
14869       return 1;
14870     }
14871
14872   if (fread (armag, SARMAG, 1, file) != 1)
14873     {
14874       error (_("%s: Failed to read file's magic number\n"), file_name);
14875       fclose (file);
14876       return 1;
14877     }
14878
14879   if (memcmp (armag, ARMAG, SARMAG) == 0)
14880     ret = process_archive (file_name, file, FALSE);
14881   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14882     ret = process_archive (file_name, file, TRUE);
14883   else
14884     {
14885       if (do_archive_index)
14886         error (_("File %s is not an archive so its index cannot be displayed.\n"),
14887                file_name);
14888
14889       rewind (file);
14890       archive_file_size = archive_file_offset = 0;
14891       ret = process_object (file_name, file);
14892     }
14893
14894   fclose (file);
14895
14896   return ret;
14897 }
14898
14899 #ifdef SUPPORT_DISASSEMBLY
14900 /* Needed by the i386 disassembler.  For extra credit, someone could
14901    fix this so that we insert symbolic addresses here, esp for GOT/PLT
14902    symbols.  */
14903
14904 void
14905 print_address (unsigned int addr, FILE * outfile)
14906 {
14907   fprintf (outfile,"0x%8.8x", addr);
14908 }
14909
14910 /* Needed by the i386 disassembler.  */
14911 void
14912 db_task_printsym (unsigned int addr)
14913 {
14914   print_address (addr, stderr);
14915 }
14916 #endif
14917
14918 int
14919 main (int argc, char ** argv)
14920 {
14921   int err;
14922
14923 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14924   setlocale (LC_MESSAGES, "");
14925 #endif
14926 #if defined (HAVE_SETLOCALE)
14927   setlocale (LC_CTYPE, "");
14928 #endif
14929   bindtextdomain (PACKAGE, LOCALEDIR);
14930   textdomain (PACKAGE);
14931
14932   expandargv (&argc, &argv);
14933
14934   parse_args (argc, argv);
14935
14936   if (num_dump_sects > 0)
14937     {
14938       /* Make a copy of the dump_sects array.  */
14939       cmdline_dump_sects = (dump_type *)
14940           malloc (num_dump_sects * sizeof (* dump_sects));
14941       if (cmdline_dump_sects == NULL)
14942         error (_("Out of memory allocating dump request table.\n"));
14943       else
14944         {
14945           memcpy (cmdline_dump_sects, dump_sects,
14946                   num_dump_sects * sizeof (* dump_sects));
14947           num_cmdline_dump_sects = num_dump_sects;
14948         }
14949     }
14950
14951   if (optind < (argc - 1))
14952     show_name = 1;
14953
14954   err = 0;
14955   while (optind < argc)
14956     err |= process_file (argv[optind++]);
14957
14958   if (dump_sects != NULL)
14959     free (dump_sects);
14960   if (cmdline_dump_sects != NULL)
14961     free (cmdline_dump_sects);
14962
14963   return err;
14964 }