]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame_incremental - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
gold/
[thirdparty/binutils-gdb.git] / binutils / readelf.c
... / ...
CommitLineData
1/* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010, 2011, 2012, 2013
4 Free Software Foundation, Inc.
5
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
7 Modifications by Nick Clifton <nickc@redhat.com>
8
9 This file is part of GNU Binutils.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 02110-1301, USA. */
25\f
26/* The difference between readelf and objdump:
27
28 Both programs are capable of displaying the contents of ELF format files,
29 so why does the binutils project have two file dumpers ?
30
31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
37
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
40
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
44\f
45#include "sysdep.h"
46#include <assert.h>
47#include <time.h>
48#ifdef HAVE_ZLIB_H
49#include <zlib.h>
50#endif
51#ifdef HAVE_WCHAR_H
52#include <wchar.h>
53#endif
54
55#if __GNUC__ >= 2
56/* Define BFD64 here, even if our default architecture is 32 bit ELF
57 as this will allow us to read in and parse 64bit and 32bit ELF files.
58 Only do this if we believe that the compiler can support a 64 bit
59 data type. For now we only rely on GCC being able to do this. */
60#define BFD64
61#endif
62
63#include "bfd.h"
64#include "bucomm.h"
65#include "elfcomm.h"
66#include "dwarf.h"
67
68#include "elf/common.h"
69#include "elf/external.h"
70#include "elf/internal.h"
71
72
73/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
74 we can obtain the H8 reloc numbers. We need these for the
75 get_reloc_size() function. We include h8.h again after defining
76 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77
78#include "elf/h8.h"
79#undef _ELF_H8_H
80
81/* Undo the effects of #including reloc-macros.h. */
82
83#undef START_RELOC_NUMBERS
84#undef RELOC_NUMBER
85#undef FAKE_RELOC
86#undef EMPTY_RELOC
87#undef END_RELOC_NUMBERS
88#undef _RELOC_MACROS_H
89
90/* The following headers use the elf/reloc-macros.h file to
91 automatically generate relocation recognition functions
92 such as elf_mips_reloc_type() */
93
94#define RELOC_MACROS_GEN_FUNC
95
96#include "elf/aarch64.h"
97#include "elf/alpha.h"
98#include "elf/arc.h"
99#include "elf/arm.h"
100#include "elf/avr.h"
101#include "elf/bfin.h"
102#include "elf/cr16.h"
103#include "elf/cris.h"
104#include "elf/crx.h"
105#include "elf/d10v.h"
106#include "elf/d30v.h"
107#include "elf/dlx.h"
108#include "elf/epiphany.h"
109#include "elf/fr30.h"
110#include "elf/frv.h"
111#include "elf/h8.h"
112#include "elf/hppa.h"
113#include "elf/i386.h"
114#include "elf/i370.h"
115#include "elf/i860.h"
116#include "elf/i960.h"
117#include "elf/ia64.h"
118#include "elf/ip2k.h"
119#include "elf/lm32.h"
120#include "elf/iq2000.h"
121#include "elf/m32c.h"
122#include "elf/m32r.h"
123#include "elf/m68k.h"
124#include "elf/m68hc11.h"
125#include "elf/mcore.h"
126#include "elf/mep.h"
127#include "elf/metag.h"
128#include "elf/microblaze.h"
129#include "elf/mips.h"
130#include "elf/mmix.h"
131#include "elf/mn10200.h"
132#include "elf/mn10300.h"
133#include "elf/moxie.h"
134#include "elf/mt.h"
135#include "elf/msp430.h"
136#include "elf/or32.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
163char * program_name = "readelf";
164static long archive_file_offset;
165static unsigned long archive_file_size;
166static unsigned long dynamic_addr;
167static bfd_size_type dynamic_size;
168static unsigned int dynamic_nent;
169static char * dynamic_strings;
170static unsigned long dynamic_strings_length;
171static char * string_table;
172static unsigned long string_table_length;
173static unsigned long num_dynamic_syms;
174static Elf_Internal_Sym * dynamic_symbols;
175static Elf_Internal_Syminfo * dynamic_syminfo;
176static unsigned long dynamic_syminfo_offset;
177static unsigned int dynamic_syminfo_nent;
178static char program_interpreter[PATH_MAX];
179static bfd_vma dynamic_info[DT_ENCODING];
180static bfd_vma dynamic_info_DT_GNU_HASH;
181static bfd_vma version_info[16];
182static Elf_Internal_Ehdr elf_header;
183static Elf_Internal_Shdr * section_headers;
184static Elf_Internal_Phdr * program_headers;
185static Elf_Internal_Dyn * dynamic_section;
186static Elf_Internal_Shdr * symtab_shndx_hdr;
187static int show_name;
188static int do_dynamic;
189static int do_syms;
190static int do_dyn_syms;
191static int do_reloc;
192static int do_sections;
193static int do_section_groups;
194static int do_section_details;
195static int do_segments;
196static int do_unwind;
197static int do_using_dynamic;
198static int do_header;
199static int do_dump;
200static int do_version;
201static int do_histogram;
202static int do_debugging;
203static int do_arch;
204static int do_notes;
205static int do_archive_index;
206static int is_32bit_elf;
207
208struct group_list
209{
210 struct group_list * next;
211 unsigned int section_index;
212};
213
214struct group
215{
216 struct group_list * root;
217 unsigned int group_index;
218};
219
220static size_t group_count;
221static struct group * section_groups;
222static struct group ** section_headers_groups;
223
224
225/* Flag bits indicating particular types of dump. */
226#define HEX_DUMP (1 << 0) /* The -x command line switch. */
227#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
228#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
229#define STRING_DUMP (1 << 3) /* The -p command line switch. */
230#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
231
232typedef unsigned char dump_type;
233
234/* A linked list of the section names for which dumps were requested. */
235struct dump_list_entry
236{
237 char * name;
238 dump_type type;
239 struct dump_list_entry * next;
240};
241static struct dump_list_entry * dump_sects_byname;
242
243/* A dynamic array of flags indicating for which sections a dump
244 has been requested via command line switches. */
245static dump_type * cmdline_dump_sects = NULL;
246static unsigned int num_cmdline_dump_sects = 0;
247
248/* A dynamic array of flags indicating for which sections a dump of
249 some kind has been requested. It is reset on a per-object file
250 basis and then initialised from the cmdline_dump_sects array,
251 the results of interpreting the -w switch, and the
252 dump_sects_byname list. */
253static dump_type * dump_sects = NULL;
254static unsigned int num_dump_sects = 0;
255
256
257/* How to print a vma value. */
258typedef enum print_mode
259{
260 HEX,
261 DEC,
262 DEC_5,
263 UNSIGNED,
264 PREFIX_HEX,
265 FULL_HEX,
266 LONG_HEX
267}
268print_mode;
269
270#define UNKNOWN -1
271
272#define SECTION_NAME(X) \
273 ((X) == NULL ? _("<none>") \
274 : string_table == NULL ? _("<no-name>") \
275 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
276 : string_table + (X)->sh_name))
277
278#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
279
280#define GET_ELF_SYMBOLS(file, section, sym_count) \
281 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
282 : get_64bit_elf_symbols (file, section, sym_count))
283
284#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
285/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
286 already been called and verified that the string exists. */
287#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
288
289#define REMOVE_ARCH_BITS(ADDR) \
290 do \
291 { \
292 if (elf_header.e_machine == EM_ARM) \
293 (ADDR) &= ~1; \
294 } \
295 while (0)
296\f
297/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
298 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
299 using malloc and fill that. In either case return the pointer to the start of
300 the retrieved data or NULL if something went wrong. If something does go wrong
301 emit an error message using REASON as part of the context. */
302
303static void *
304get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
305 const char * reason)
306{
307 void * mvar;
308
309 if (size == 0 || nmemb == 0)
310 return NULL;
311
312 if (fseek (file, archive_file_offset + offset, SEEK_SET))
313 {
314 error (_("Unable to seek to 0x%lx for %s\n"),
315 (unsigned long) archive_file_offset + offset, reason);
316 return NULL;
317 }
318
319 mvar = var;
320 if (mvar == NULL)
321 {
322 /* Check for overflow. */
323 if (nmemb < (~(size_t) 0 - 1) / size)
324 /* + 1 so that we can '\0' terminate invalid string table sections. */
325 mvar = malloc (size * nmemb + 1);
326
327 if (mvar == NULL)
328 {
329 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
330 (unsigned long)(size * nmemb), reason);
331 return NULL;
332 }
333
334 ((char *) mvar)[size * nmemb] = '\0';
335 }
336
337 if (fread (mvar, size, nmemb, file) != nmemb)
338 {
339 error (_("Unable to read in 0x%lx bytes of %s\n"),
340 (unsigned long)(size * nmemb), reason);
341 if (mvar != var)
342 free (mvar);
343 return NULL;
344 }
345
346 return mvar;
347}
348
349/* Print a VMA value. */
350
351static int
352print_vma (bfd_vma vma, print_mode mode)
353{
354 int nc = 0;
355
356 switch (mode)
357 {
358 case FULL_HEX:
359 nc = printf ("0x");
360 /* Drop through. */
361
362 case LONG_HEX:
363#ifdef BFD64
364 if (is_32bit_elf)
365 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
366#endif
367 printf_vma (vma);
368 return nc + 16;
369
370 case DEC_5:
371 if (vma <= 99999)
372 return printf ("%5" BFD_VMA_FMT "d", vma);
373 /* Drop through. */
374
375 case PREFIX_HEX:
376 nc = printf ("0x");
377 /* Drop through. */
378
379 case HEX:
380 return nc + printf ("%" BFD_VMA_FMT "x", vma);
381
382 case DEC:
383 return printf ("%" BFD_VMA_FMT "d", vma);
384
385 case UNSIGNED:
386 return printf ("%" BFD_VMA_FMT "u", vma);
387 }
388 return 0;
389}
390
391/* Display a symbol on stdout. Handles the display of control characters and
392 multibye characters (assuming the host environment supports them).
393
394 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
395
396 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
397 padding as necessary.
398
399 Returns the number of emitted characters. */
400
401static unsigned int
402print_symbol (int width, const char *symbol)
403{
404 bfd_boolean extra_padding = FALSE;
405 int num_printed = 0;
406#ifdef HAVE_MBSTATE_T
407 mbstate_t state;
408#endif
409 int width_remaining;
410
411 if (width < 0)
412 {
413 /* Keep the width positive. This also helps. */
414 width = - width;
415 extra_padding = TRUE;
416 }
417
418 if (do_wide)
419 /* Set the remaining width to a very large value.
420 This simplifies the code below. */
421 width_remaining = INT_MAX;
422 else
423 width_remaining = width;
424
425#ifdef HAVE_MBSTATE_T
426 /* Initialise the multibyte conversion state. */
427 memset (& state, 0, sizeof (state));
428#endif
429
430 while (width_remaining)
431 {
432 size_t n;
433 const char c = *symbol++;
434
435 if (c == 0)
436 break;
437
438 /* Do not print control characters directly as they can affect terminal
439 settings. Such characters usually appear in the names generated
440 by the assembler for local labels. */
441 if (ISCNTRL (c))
442 {
443 if (width_remaining < 2)
444 break;
445
446 printf ("^%c", c + 0x40);
447 width_remaining -= 2;
448 num_printed += 2;
449 }
450 else if (ISPRINT (c))
451 {
452 putchar (c);
453 width_remaining --;
454 num_printed ++;
455 }
456 else
457 {
458#ifdef HAVE_MBSTATE_T
459 wchar_t w;
460#endif
461 /* Let printf do the hard work of displaying multibyte characters. */
462 printf ("%.1s", symbol - 1);
463 width_remaining --;
464 num_printed ++;
465
466#ifdef HAVE_MBSTATE_T
467 /* Try to find out how many bytes made up the character that was
468 just printed. Advance the symbol pointer past the bytes that
469 were displayed. */
470 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
471#else
472 n = 1;
473#endif
474 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
475 symbol += (n - 1);
476 }
477 }
478
479 if (extra_padding && num_printed < width)
480 {
481 /* Fill in the remaining spaces. */
482 printf ("%-*s", width - num_printed, " ");
483 num_printed = width;
484 }
485
486 return num_printed;
487}
488
489/* Return a pointer to section NAME, or NULL if no such section exists. */
490
491static Elf_Internal_Shdr *
492find_section (const char * name)
493{
494 unsigned int i;
495
496 for (i = 0; i < elf_header.e_shnum; i++)
497 if (streq (SECTION_NAME (section_headers + i), name))
498 return section_headers + i;
499
500 return NULL;
501}
502
503/* Return a pointer to a section containing ADDR, or NULL if no such
504 section exists. */
505
506static Elf_Internal_Shdr *
507find_section_by_address (bfd_vma addr)
508{
509 unsigned int i;
510
511 for (i = 0; i < elf_header.e_shnum; i++)
512 {
513 Elf_Internal_Shdr *sec = section_headers + i;
514 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
515 return sec;
516 }
517
518 return NULL;
519}
520
521/* Return a pointer to section NAME, or NULL if no such section exists,
522 restricted to the list of sections given in SET. */
523
524static Elf_Internal_Shdr *
525find_section_in_set (const char * name, unsigned int * set)
526{
527 unsigned int i;
528
529 if (set != NULL)
530 {
531 while ((i = *set++) > 0)
532 if (streq (SECTION_NAME (section_headers + i), name))
533 return section_headers + i;
534 }
535
536 return find_section (name);
537}
538
539/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
540 bytes read. */
541
542static unsigned long
543read_uleb128 (unsigned char *data, unsigned int *length_return)
544{
545 return read_leb128 (data, length_return, 0);
546}
547
548/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
549 This OS has so many departures from the ELF standard that we test it at
550 many places. */
551
552static inline int
553is_ia64_vms (void)
554{
555 return elf_header.e_machine == EM_IA_64
556 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
557}
558
559/* Guess the relocation size commonly used by the specific machines. */
560
561static int
562guess_is_rela (unsigned int e_machine)
563{
564 switch (e_machine)
565 {
566 /* Targets that use REL relocations. */
567 case EM_386:
568 case EM_486:
569 case EM_960:
570 case EM_ARM:
571 case EM_D10V:
572 case EM_CYGNUS_D10V:
573 case EM_DLX:
574 case EM_MIPS:
575 case EM_MIPS_RS3_LE:
576 case EM_CYGNUS_M32R:
577 case EM_OPENRISC:
578 case EM_OR32:
579 case EM_SCORE:
580 case EM_XGATE:
581 return FALSE;
582
583 /* Targets that use RELA relocations. */
584 case EM_68K:
585 case EM_860:
586 case EM_AARCH64:
587 case EM_ADAPTEVA_EPIPHANY:
588 case EM_ALPHA:
589 case EM_ALTERA_NIOS2:
590 case EM_AVR:
591 case EM_AVR_OLD:
592 case EM_BLACKFIN:
593 case EM_CR16:
594 case EM_CRIS:
595 case EM_CRX:
596 case EM_D30V:
597 case EM_CYGNUS_D30V:
598 case EM_FR30:
599 case EM_CYGNUS_FR30:
600 case EM_CYGNUS_FRV:
601 case EM_H8S:
602 case EM_H8_300:
603 case EM_H8_300H:
604 case EM_IA_64:
605 case EM_IP2K:
606 case EM_IP2K_OLD:
607 case EM_IQ2000:
608 case EM_LATTICEMICO32:
609 case EM_M32C_OLD:
610 case EM_M32C:
611 case EM_M32R:
612 case EM_MCORE:
613 case EM_CYGNUS_MEP:
614 case EM_METAG:
615 case EM_MMIX:
616 case EM_MN10200:
617 case EM_CYGNUS_MN10200:
618 case EM_MN10300:
619 case EM_CYGNUS_MN10300:
620 case EM_MOXIE:
621 case EM_MSP430:
622 case EM_MSP430_OLD:
623 case EM_MT:
624 case EM_NIOS32:
625 case EM_PPC64:
626 case EM_PPC:
627 case EM_RL78:
628 case EM_RX:
629 case EM_S390:
630 case EM_S390_OLD:
631 case EM_SH:
632 case EM_SPARC:
633 case EM_SPARC32PLUS:
634 case EM_SPARCV9:
635 case EM_SPU:
636 case EM_TI_C6000:
637 case EM_TILEGX:
638 case EM_TILEPRO:
639 case EM_V800:
640 case EM_V850:
641 case EM_CYGNUS_V850:
642 case EM_VAX:
643 case EM_X86_64:
644 case EM_L1OM:
645 case EM_K1OM:
646 case EM_XSTORMY16:
647 case EM_XTENSA:
648 case EM_XTENSA_OLD:
649 case EM_MICROBLAZE:
650 case EM_MICROBLAZE_OLD:
651 return TRUE;
652
653 case EM_68HC05:
654 case EM_68HC08:
655 case EM_68HC11:
656 case EM_68HC16:
657 case EM_FX66:
658 case EM_ME16:
659 case EM_MMA:
660 case EM_NCPU:
661 case EM_NDR1:
662 case EM_PCP:
663 case EM_ST100:
664 case EM_ST19:
665 case EM_ST7:
666 case EM_ST9PLUS:
667 case EM_STARCORE:
668 case EM_SVX:
669 case EM_TINYJ:
670 default:
671 warn (_("Don't know about relocations on this machine architecture\n"));
672 return FALSE;
673 }
674}
675
676static int
677slurp_rela_relocs (FILE * file,
678 unsigned long rel_offset,
679 unsigned long rel_size,
680 Elf_Internal_Rela ** relasp,
681 unsigned long * nrelasp)
682{
683 Elf_Internal_Rela * relas;
684 unsigned long nrelas;
685 unsigned int i;
686
687 if (is_32bit_elf)
688 {
689 Elf32_External_Rela * erelas;
690
691 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
692 rel_size, _("32-bit relocation data"));
693 if (!erelas)
694 return 0;
695
696 nrelas = rel_size / sizeof (Elf32_External_Rela);
697
698 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
699 sizeof (Elf_Internal_Rela));
700
701 if (relas == NULL)
702 {
703 free (erelas);
704 error (_("out of memory parsing relocs\n"));
705 return 0;
706 }
707
708 for (i = 0; i < nrelas; i++)
709 {
710 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
711 relas[i].r_info = BYTE_GET (erelas[i].r_info);
712 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
713 }
714
715 free (erelas);
716 }
717 else
718 {
719 Elf64_External_Rela * erelas;
720
721 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
722 rel_size, _("64-bit relocation data"));
723 if (!erelas)
724 return 0;
725
726 nrelas = rel_size / sizeof (Elf64_External_Rela);
727
728 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
729 sizeof (Elf_Internal_Rela));
730
731 if (relas == NULL)
732 {
733 free (erelas);
734 error (_("out of memory parsing relocs\n"));
735 return 0;
736 }
737
738 for (i = 0; i < nrelas; i++)
739 {
740 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
741 relas[i].r_info = BYTE_GET (erelas[i].r_info);
742 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
743
744 /* The #ifdef BFD64 below is to prevent a compile time
745 warning. We know that if we do not have a 64 bit data
746 type that we will never execute this code anyway. */
747#ifdef BFD64
748 if (elf_header.e_machine == EM_MIPS
749 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
750 {
751 /* In little-endian objects, r_info isn't really a
752 64-bit little-endian value: it has a 32-bit
753 little-endian symbol index followed by four
754 individual byte fields. Reorder INFO
755 accordingly. */
756 bfd_vma inf = relas[i].r_info;
757 inf = (((inf & 0xffffffff) << 32)
758 | ((inf >> 56) & 0xff)
759 | ((inf >> 40) & 0xff00)
760 | ((inf >> 24) & 0xff0000)
761 | ((inf >> 8) & 0xff000000));
762 relas[i].r_info = inf;
763 }
764#endif /* BFD64 */
765 }
766
767 free (erelas);
768 }
769 *relasp = relas;
770 *nrelasp = nrelas;
771 return 1;
772}
773
774static int
775slurp_rel_relocs (FILE * file,
776 unsigned long rel_offset,
777 unsigned long rel_size,
778 Elf_Internal_Rela ** relsp,
779 unsigned long * nrelsp)
780{
781 Elf_Internal_Rela * rels;
782 unsigned long nrels;
783 unsigned int i;
784
785 if (is_32bit_elf)
786 {
787 Elf32_External_Rel * erels;
788
789 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
790 rel_size, _("32-bit relocation data"));
791 if (!erels)
792 return 0;
793
794 nrels = rel_size / sizeof (Elf32_External_Rel);
795
796 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
797
798 if (rels == NULL)
799 {
800 free (erels);
801 error (_("out of memory parsing relocs\n"));
802 return 0;
803 }
804
805 for (i = 0; i < nrels; i++)
806 {
807 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
808 rels[i].r_info = BYTE_GET (erels[i].r_info);
809 rels[i].r_addend = 0;
810 }
811
812 free (erels);
813 }
814 else
815 {
816 Elf64_External_Rel * erels;
817
818 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
819 rel_size, _("64-bit relocation data"));
820 if (!erels)
821 return 0;
822
823 nrels = rel_size / sizeof (Elf64_External_Rel);
824
825 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
826
827 if (rels == NULL)
828 {
829 free (erels);
830 error (_("out of memory parsing relocs\n"));
831 return 0;
832 }
833
834 for (i = 0; i < nrels; i++)
835 {
836 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
837 rels[i].r_info = BYTE_GET (erels[i].r_info);
838 rels[i].r_addend = 0;
839
840 /* The #ifdef BFD64 below is to prevent a compile time
841 warning. We know that if we do not have a 64 bit data
842 type that we will never execute this code anyway. */
843#ifdef BFD64
844 if (elf_header.e_machine == EM_MIPS
845 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
846 {
847 /* In little-endian objects, r_info isn't really a
848 64-bit little-endian value: it has a 32-bit
849 little-endian symbol index followed by four
850 individual byte fields. Reorder INFO
851 accordingly. */
852 bfd_vma inf = rels[i].r_info;
853 inf = (((inf & 0xffffffff) << 32)
854 | ((inf >> 56) & 0xff)
855 | ((inf >> 40) & 0xff00)
856 | ((inf >> 24) & 0xff0000)
857 | ((inf >> 8) & 0xff000000));
858 rels[i].r_info = inf;
859 }
860#endif /* BFD64 */
861 }
862
863 free (erels);
864 }
865 *relsp = rels;
866 *nrelsp = nrels;
867 return 1;
868}
869
870/* Returns the reloc type extracted from the reloc info field. */
871
872static unsigned int
873get_reloc_type (bfd_vma reloc_info)
874{
875 if (is_32bit_elf)
876 return ELF32_R_TYPE (reloc_info);
877
878 switch (elf_header.e_machine)
879 {
880 case EM_MIPS:
881 /* Note: We assume that reloc_info has already been adjusted for us. */
882 return ELF64_MIPS_R_TYPE (reloc_info);
883
884 case EM_SPARCV9:
885 return ELF64_R_TYPE_ID (reloc_info);
886
887 default:
888 return ELF64_R_TYPE (reloc_info);
889 }
890}
891
892/* Return the symbol index extracted from the reloc info field. */
893
894static bfd_vma
895get_reloc_symindex (bfd_vma reloc_info)
896{
897 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
898}
899
900/* Display the contents of the relocation data found at the specified
901 offset. */
902
903static void
904dump_relocations (FILE * file,
905 unsigned long rel_offset,
906 unsigned long rel_size,
907 Elf_Internal_Sym * symtab,
908 unsigned long nsyms,
909 char * strtab,
910 unsigned long strtablen,
911 int is_rela)
912{
913 unsigned int i;
914 Elf_Internal_Rela * rels;
915
916 if (is_rela == UNKNOWN)
917 is_rela = guess_is_rela (elf_header.e_machine);
918
919 if (is_rela)
920 {
921 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
922 return;
923 }
924 else
925 {
926 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
927 return;
928 }
929
930 if (is_32bit_elf)
931 {
932 if (is_rela)
933 {
934 if (do_wide)
935 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
936 else
937 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
938 }
939 else
940 {
941 if (do_wide)
942 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
943 else
944 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
945 }
946 }
947 else
948 {
949 if (is_rela)
950 {
951 if (do_wide)
952 printf (_(" Offset Info Type Symbol's 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 Symbol's Value Symbol's Name\n"));
960 else
961 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
962 }
963 }
964
965 for (i = 0; i < rel_size; i++)
966 {
967 const char * rtype;
968 bfd_vma offset;
969 bfd_vma inf;
970 bfd_vma symtab_index;
971 bfd_vma type;
972
973 offset = rels[i].r_offset;
974 inf = rels[i].r_info;
975
976 type = get_reloc_type (inf);
977 symtab_index = get_reloc_symindex (inf);
978
979 if (is_32bit_elf)
980 {
981 printf ("%8.8lx %8.8lx ",
982 (unsigned long) offset & 0xffffffff,
983 (unsigned long) inf & 0xffffffff);
984 }
985 else
986 {
987#if BFD_HOST_64BIT_LONG
988 printf (do_wide
989 ? "%16.16lx %16.16lx "
990 : "%12.12lx %12.12lx ",
991 offset, inf);
992#elif BFD_HOST_64BIT_LONG_LONG
993#ifndef __MSVCRT__
994 printf (do_wide
995 ? "%16.16llx %16.16llx "
996 : "%12.12llx %12.12llx ",
997 offset, inf);
998#else
999 printf (do_wide
1000 ? "%16.16I64x %16.16I64x "
1001 : "%12.12I64x %12.12I64x ",
1002 offset, inf);
1003#endif
1004#else
1005 printf (do_wide
1006 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1007 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1008 _bfd_int64_high (offset),
1009 _bfd_int64_low (offset),
1010 _bfd_int64_high (inf),
1011 _bfd_int64_low (inf));
1012#endif
1013 }
1014
1015 switch (elf_header.e_machine)
1016 {
1017 default:
1018 rtype = NULL;
1019 break;
1020
1021 case EM_AARCH64:
1022 rtype = elf_aarch64_reloc_type (type);
1023 break;
1024
1025 case EM_M32R:
1026 case EM_CYGNUS_M32R:
1027 rtype = elf_m32r_reloc_type (type);
1028 break;
1029
1030 case EM_386:
1031 case EM_486:
1032 rtype = elf_i386_reloc_type (type);
1033 break;
1034
1035 case EM_68HC11:
1036 case EM_68HC12:
1037 rtype = elf_m68hc11_reloc_type (type);
1038 break;
1039
1040 case EM_68K:
1041 rtype = elf_m68k_reloc_type (type);
1042 break;
1043
1044 case EM_960:
1045 rtype = elf_i960_reloc_type (type);
1046 break;
1047
1048 case EM_AVR:
1049 case EM_AVR_OLD:
1050 rtype = elf_avr_reloc_type (type);
1051 break;
1052
1053 case EM_OLD_SPARCV9:
1054 case EM_SPARC32PLUS:
1055 case EM_SPARCV9:
1056 case EM_SPARC:
1057 rtype = elf_sparc_reloc_type (type);
1058 break;
1059
1060 case EM_SPU:
1061 rtype = elf_spu_reloc_type (type);
1062 break;
1063
1064 case EM_V800:
1065 rtype = v800_reloc_type (type);
1066 break;
1067 case EM_V850:
1068 case EM_CYGNUS_V850:
1069 rtype = v850_reloc_type (type);
1070 break;
1071
1072 case EM_D10V:
1073 case EM_CYGNUS_D10V:
1074 rtype = elf_d10v_reloc_type (type);
1075 break;
1076
1077 case EM_D30V:
1078 case EM_CYGNUS_D30V:
1079 rtype = elf_d30v_reloc_type (type);
1080 break;
1081
1082 case EM_DLX:
1083 rtype = elf_dlx_reloc_type (type);
1084 break;
1085
1086 case EM_SH:
1087 rtype = elf_sh_reloc_type (type);
1088 break;
1089
1090 case EM_MN10300:
1091 case EM_CYGNUS_MN10300:
1092 rtype = elf_mn10300_reloc_type (type);
1093 break;
1094
1095 case EM_MN10200:
1096 case EM_CYGNUS_MN10200:
1097 rtype = elf_mn10200_reloc_type (type);
1098 break;
1099
1100 case EM_FR30:
1101 case EM_CYGNUS_FR30:
1102 rtype = elf_fr30_reloc_type (type);
1103 break;
1104
1105 case EM_CYGNUS_FRV:
1106 rtype = elf_frv_reloc_type (type);
1107 break;
1108
1109 case EM_MCORE:
1110 rtype = elf_mcore_reloc_type (type);
1111 break;
1112
1113 case EM_MMIX:
1114 rtype = elf_mmix_reloc_type (type);
1115 break;
1116
1117 case EM_MOXIE:
1118 rtype = elf_moxie_reloc_type (type);
1119 break;
1120
1121 case EM_MSP430:
1122 case EM_MSP430_OLD:
1123 rtype = elf_msp430_reloc_type (type);
1124 break;
1125
1126 case EM_PPC:
1127 rtype = elf_ppc_reloc_type (type);
1128 break;
1129
1130 case EM_PPC64:
1131 rtype = elf_ppc64_reloc_type (type);
1132 break;
1133
1134 case EM_MIPS:
1135 case EM_MIPS_RS3_LE:
1136 rtype = elf_mips_reloc_type (type);
1137 break;
1138
1139 case EM_ALPHA:
1140 rtype = elf_alpha_reloc_type (type);
1141 break;
1142
1143 case EM_ARM:
1144 rtype = elf_arm_reloc_type (type);
1145 break;
1146
1147 case EM_ARC:
1148 rtype = elf_arc_reloc_type (type);
1149 break;
1150
1151 case EM_PARISC:
1152 rtype = elf_hppa_reloc_type (type);
1153 break;
1154
1155 case EM_H8_300:
1156 case EM_H8_300H:
1157 case EM_H8S:
1158 rtype = elf_h8_reloc_type (type);
1159 break;
1160
1161 case EM_OPENRISC:
1162 case EM_OR32:
1163 rtype = elf_or32_reloc_type (type);
1164 break;
1165
1166 case EM_PJ:
1167 case EM_PJ_OLD:
1168 rtype = elf_pj_reloc_type (type);
1169 break;
1170 case EM_IA_64:
1171 rtype = elf_ia64_reloc_type (type);
1172 break;
1173
1174 case EM_CRIS:
1175 rtype = elf_cris_reloc_type (type);
1176 break;
1177
1178 case EM_860:
1179 rtype = elf_i860_reloc_type (type);
1180 break;
1181
1182 case EM_X86_64:
1183 case EM_L1OM:
1184 case EM_K1OM:
1185 rtype = elf_x86_64_reloc_type (type);
1186 break;
1187
1188 case EM_S370:
1189 rtype = i370_reloc_type (type);
1190 break;
1191
1192 case EM_S390_OLD:
1193 case EM_S390:
1194 rtype = elf_s390_reloc_type (type);
1195 break;
1196
1197 case EM_SCORE:
1198 rtype = elf_score_reloc_type (type);
1199 break;
1200
1201 case EM_XSTORMY16:
1202 rtype = elf_xstormy16_reloc_type (type);
1203 break;
1204
1205 case EM_CRX:
1206 rtype = elf_crx_reloc_type (type);
1207 break;
1208
1209 case EM_VAX:
1210 rtype = elf_vax_reloc_type (type);
1211 break;
1212
1213 case EM_ADAPTEVA_EPIPHANY:
1214 rtype = elf_epiphany_reloc_type (type);
1215 break;
1216
1217 case EM_IP2K:
1218 case EM_IP2K_OLD:
1219 rtype = elf_ip2k_reloc_type (type);
1220 break;
1221
1222 case EM_IQ2000:
1223 rtype = elf_iq2000_reloc_type (type);
1224 break;
1225
1226 case EM_XTENSA_OLD:
1227 case EM_XTENSA:
1228 rtype = elf_xtensa_reloc_type (type);
1229 break;
1230
1231 case EM_LATTICEMICO32:
1232 rtype = elf_lm32_reloc_type (type);
1233 break;
1234
1235 case EM_M32C_OLD:
1236 case EM_M32C:
1237 rtype = elf_m32c_reloc_type (type);
1238 break;
1239
1240 case EM_MT:
1241 rtype = elf_mt_reloc_type (type);
1242 break;
1243
1244 case EM_BLACKFIN:
1245 rtype = elf_bfin_reloc_type (type);
1246 break;
1247
1248 case EM_CYGNUS_MEP:
1249 rtype = elf_mep_reloc_type (type);
1250 break;
1251
1252 case EM_CR16:
1253 rtype = elf_cr16_reloc_type (type);
1254 break;
1255
1256 case EM_MICROBLAZE:
1257 case EM_MICROBLAZE_OLD:
1258 rtype = elf_microblaze_reloc_type (type);
1259 break;
1260
1261 case EM_RL78:
1262 rtype = elf_rl78_reloc_type (type);
1263 break;
1264
1265 case EM_RX:
1266 rtype = elf_rx_reloc_type (type);
1267 break;
1268
1269 case EM_METAG:
1270 rtype = elf_metag_reloc_type (type);
1271 break;
1272
1273 case EM_XC16X:
1274 case EM_C166:
1275 rtype = elf_xc16x_reloc_type (type);
1276 break;
1277
1278 case EM_TI_C6000:
1279 rtype = elf_tic6x_reloc_type (type);
1280 break;
1281
1282 case EM_TILEGX:
1283 rtype = elf_tilegx_reloc_type (type);
1284 break;
1285
1286 case EM_TILEPRO:
1287 rtype = elf_tilepro_reloc_type (type);
1288 break;
1289
1290 case EM_XGATE:
1291 rtype = elf_xgate_reloc_type (type);
1292 break;
1293 }
1294
1295 if (rtype == NULL)
1296 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1297 else
1298 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1299
1300 if (elf_header.e_machine == EM_ALPHA
1301 && rtype != NULL
1302 && streq (rtype, "R_ALPHA_LITUSE")
1303 && is_rela)
1304 {
1305 switch (rels[i].r_addend)
1306 {
1307 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1308 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1309 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1310 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1311 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1312 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1313 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1314 default: rtype = NULL;
1315 }
1316 if (rtype)
1317 printf (" (%s)", rtype);
1318 else
1319 {
1320 putchar (' ');
1321 printf (_("<unknown addend: %lx>"),
1322 (unsigned long) rels[i].r_addend);
1323 }
1324 }
1325 else if (symtab_index)
1326 {
1327 if (symtab == NULL || symtab_index >= nsyms)
1328 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1329 else
1330 {
1331 Elf_Internal_Sym * psym;
1332
1333 psym = symtab + symtab_index;
1334
1335 printf (" ");
1336
1337 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1338 {
1339 const char * name;
1340 unsigned int len;
1341 unsigned int width = is_32bit_elf ? 8 : 14;
1342
1343 /* Relocations against GNU_IFUNC symbols do not use the value
1344 of the symbol as the address to relocate against. Instead
1345 they invoke the function named by the symbol and use its
1346 result as the address for relocation.
1347
1348 To indicate this to the user, do not display the value of
1349 the symbol in the "Symbols's Value" field. Instead show
1350 its name followed by () as a hint that the symbol is
1351 invoked. */
1352
1353 if (strtab == NULL
1354 || psym->st_name == 0
1355 || psym->st_name >= strtablen)
1356 name = "??";
1357 else
1358 name = strtab + psym->st_name;
1359
1360 len = print_symbol (width, name);
1361 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1362 }
1363 else
1364 {
1365 print_vma (psym->st_value, LONG_HEX);
1366
1367 printf (is_32bit_elf ? " " : " ");
1368 }
1369
1370 if (psym->st_name == 0)
1371 {
1372 const char * sec_name = "<null>";
1373 char name_buf[40];
1374
1375 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1376 {
1377 if (psym->st_shndx < elf_header.e_shnum)
1378 sec_name
1379 = SECTION_NAME (section_headers + psym->st_shndx);
1380 else if (psym->st_shndx == SHN_ABS)
1381 sec_name = "ABS";
1382 else if (psym->st_shndx == SHN_COMMON)
1383 sec_name = "COMMON";
1384 else if ((elf_header.e_machine == EM_MIPS
1385 && psym->st_shndx == SHN_MIPS_SCOMMON)
1386 || (elf_header.e_machine == EM_TI_C6000
1387 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1388 sec_name = "SCOMMON";
1389 else if (elf_header.e_machine == EM_MIPS
1390 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1391 sec_name = "SUNDEF";
1392 else if ((elf_header.e_machine == EM_X86_64
1393 || elf_header.e_machine == EM_L1OM
1394 || elf_header.e_machine == EM_K1OM)
1395 && psym->st_shndx == SHN_X86_64_LCOMMON)
1396 sec_name = "LARGE_COMMON";
1397 else if (elf_header.e_machine == EM_IA_64
1398 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1399 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1400 sec_name = "ANSI_COM";
1401 else if (is_ia64_vms ()
1402 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1403 sec_name = "VMS_SYMVEC";
1404 else
1405 {
1406 sprintf (name_buf, "<section 0x%x>",
1407 (unsigned int) psym->st_shndx);
1408 sec_name = name_buf;
1409 }
1410 }
1411 print_symbol (22, sec_name);
1412 }
1413 else if (strtab == NULL)
1414 printf (_("<string table index: %3ld>"), psym->st_name);
1415 else if (psym->st_name >= strtablen)
1416 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1417 else
1418 print_symbol (22, strtab + psym->st_name);
1419
1420 if (is_rela)
1421 {
1422 bfd_signed_vma off = rels[i].r_addend;
1423
1424 if (off < 0)
1425 printf (" - %" BFD_VMA_FMT "x", - off);
1426 else
1427 printf (" + %" BFD_VMA_FMT "x", off);
1428 }
1429 }
1430 }
1431 else if (is_rela)
1432 {
1433 bfd_signed_vma off = rels[i].r_addend;
1434
1435 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1436 if (off < 0)
1437 printf ("-%" BFD_VMA_FMT "x", - off);
1438 else
1439 printf ("%" BFD_VMA_FMT "x", off);
1440 }
1441
1442 if (elf_header.e_machine == EM_SPARCV9
1443 && rtype != NULL
1444 && streq (rtype, "R_SPARC_OLO10"))
1445 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1446
1447 putchar ('\n');
1448
1449#ifdef BFD64
1450 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1451 {
1452 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1453 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1454 const char * rtype2 = elf_mips_reloc_type (type2);
1455 const char * rtype3 = elf_mips_reloc_type (type3);
1456
1457 printf (" Type2: ");
1458
1459 if (rtype2 == NULL)
1460 printf (_("unrecognized: %-7lx"),
1461 (unsigned long) type2 & 0xffffffff);
1462 else
1463 printf ("%-17.17s", rtype2);
1464
1465 printf ("\n Type3: ");
1466
1467 if (rtype3 == NULL)
1468 printf (_("unrecognized: %-7lx"),
1469 (unsigned long) type3 & 0xffffffff);
1470 else
1471 printf ("%-17.17s", rtype3);
1472
1473 putchar ('\n');
1474 }
1475#endif /* BFD64 */
1476 }
1477
1478 free (rels);
1479}
1480
1481static const char *
1482get_mips_dynamic_type (unsigned long type)
1483{
1484 switch (type)
1485 {
1486 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1487 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1488 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1489 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1490 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1491 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1492 case DT_MIPS_MSYM: return "MIPS_MSYM";
1493 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1494 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1495 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1496 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1497 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1498 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1499 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1500 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1501 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1502 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1503 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1504 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1505 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1506 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1507 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1508 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1509 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1510 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1511 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1512 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1513 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1514 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1515 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1516 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1517 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1518 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1519 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1520 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1521 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1522 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1523 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1524 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1525 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1526 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1527 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1528 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1529 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1530 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1531 default:
1532 return NULL;
1533 }
1534}
1535
1536static const char *
1537get_sparc64_dynamic_type (unsigned long type)
1538{
1539 switch (type)
1540 {
1541 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1542 default:
1543 return NULL;
1544 }
1545}
1546
1547static const char *
1548get_ppc_dynamic_type (unsigned long type)
1549{
1550 switch (type)
1551 {
1552 case DT_PPC_GOT: return "PPC_GOT";
1553 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1554 default:
1555 return NULL;
1556 }
1557}
1558
1559static const char *
1560get_ppc64_dynamic_type (unsigned long type)
1561{
1562 switch (type)
1563 {
1564 case DT_PPC64_GLINK: return "PPC64_GLINK";
1565 case DT_PPC64_OPD: return "PPC64_OPD";
1566 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1567 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1568 default:
1569 return NULL;
1570 }
1571}
1572
1573static const char *
1574get_parisc_dynamic_type (unsigned long type)
1575{
1576 switch (type)
1577 {
1578 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1579 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1580 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1581 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1582 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1583 case DT_HP_PREINIT: return "HP_PREINIT";
1584 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1585 case DT_HP_NEEDED: return "HP_NEEDED";
1586 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1587 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1588 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1589 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1590 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1591 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1592 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1593 case DT_HP_FILTERED: return "HP_FILTERED";
1594 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1595 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1596 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1597 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1598 case DT_PLT: return "PLT";
1599 case DT_PLT_SIZE: return "PLT_SIZE";
1600 case DT_DLT: return "DLT";
1601 case DT_DLT_SIZE: return "DLT_SIZE";
1602 default:
1603 return NULL;
1604 }
1605}
1606
1607static const char *
1608get_ia64_dynamic_type (unsigned long type)
1609{
1610 switch (type)
1611 {
1612 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1613 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1614 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1615 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1616 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1617 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1618 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1619 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1620 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1621 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1622 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1623 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1624 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1625 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1626 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1627 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1628 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1629 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1630 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1631 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1632 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1633 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1634 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1635 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1636 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1637 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1638 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1639 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1640 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1641 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1642 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1643 default:
1644 return NULL;
1645 }
1646}
1647
1648static const char *
1649get_alpha_dynamic_type (unsigned long type)
1650{
1651 switch (type)
1652 {
1653 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1654 default:
1655 return NULL;
1656 }
1657}
1658
1659static const char *
1660get_score_dynamic_type (unsigned long type)
1661{
1662 switch (type)
1663 {
1664 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1665 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1666 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1667 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1668 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1669 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1670 default:
1671 return NULL;
1672 }
1673}
1674
1675static const char *
1676get_tic6x_dynamic_type (unsigned long type)
1677{
1678 switch (type)
1679 {
1680 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1681 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1682 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1683 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1684 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1685 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1686 default:
1687 return NULL;
1688 }
1689}
1690
1691static const char *
1692get_dynamic_type (unsigned long type)
1693{
1694 static char buff[64];
1695
1696 switch (type)
1697 {
1698 case DT_NULL: return "NULL";
1699 case DT_NEEDED: return "NEEDED";
1700 case DT_PLTRELSZ: return "PLTRELSZ";
1701 case DT_PLTGOT: return "PLTGOT";
1702 case DT_HASH: return "HASH";
1703 case DT_STRTAB: return "STRTAB";
1704 case DT_SYMTAB: return "SYMTAB";
1705 case DT_RELA: return "RELA";
1706 case DT_RELASZ: return "RELASZ";
1707 case DT_RELAENT: return "RELAENT";
1708 case DT_STRSZ: return "STRSZ";
1709 case DT_SYMENT: return "SYMENT";
1710 case DT_INIT: return "INIT";
1711 case DT_FINI: return "FINI";
1712 case DT_SONAME: return "SONAME";
1713 case DT_RPATH: return "RPATH";
1714 case DT_SYMBOLIC: return "SYMBOLIC";
1715 case DT_REL: return "REL";
1716 case DT_RELSZ: return "RELSZ";
1717 case DT_RELENT: return "RELENT";
1718 case DT_PLTREL: return "PLTREL";
1719 case DT_DEBUG: return "DEBUG";
1720 case DT_TEXTREL: return "TEXTREL";
1721 case DT_JMPREL: return "JMPREL";
1722 case DT_BIND_NOW: return "BIND_NOW";
1723 case DT_INIT_ARRAY: return "INIT_ARRAY";
1724 case DT_FINI_ARRAY: return "FINI_ARRAY";
1725 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1726 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1727 case DT_RUNPATH: return "RUNPATH";
1728 case DT_FLAGS: return "FLAGS";
1729
1730 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1731 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1732
1733 case DT_CHECKSUM: return "CHECKSUM";
1734 case DT_PLTPADSZ: return "PLTPADSZ";
1735 case DT_MOVEENT: return "MOVEENT";
1736 case DT_MOVESZ: return "MOVESZ";
1737 case DT_FEATURE: return "FEATURE";
1738 case DT_POSFLAG_1: return "POSFLAG_1";
1739 case DT_SYMINSZ: return "SYMINSZ";
1740 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1741
1742 case DT_ADDRRNGLO: return "ADDRRNGLO";
1743 case DT_CONFIG: return "CONFIG";
1744 case DT_DEPAUDIT: return "DEPAUDIT";
1745 case DT_AUDIT: return "AUDIT";
1746 case DT_PLTPAD: return "PLTPAD";
1747 case DT_MOVETAB: return "MOVETAB";
1748 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1749
1750 case DT_VERSYM: return "VERSYM";
1751
1752 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1753 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1754 case DT_RELACOUNT: return "RELACOUNT";
1755 case DT_RELCOUNT: return "RELCOUNT";
1756 case DT_FLAGS_1: return "FLAGS_1";
1757 case DT_VERDEF: return "VERDEF";
1758 case DT_VERDEFNUM: return "VERDEFNUM";
1759 case DT_VERNEED: return "VERNEED";
1760 case DT_VERNEEDNUM: return "VERNEEDNUM";
1761
1762 case DT_AUXILIARY: return "AUXILIARY";
1763 case DT_USED: return "USED";
1764 case DT_FILTER: return "FILTER";
1765
1766 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1767 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1768 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1769 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1770 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1771 case DT_GNU_HASH: return "GNU_HASH";
1772
1773 default:
1774 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1775 {
1776 const char * result;
1777
1778 switch (elf_header.e_machine)
1779 {
1780 case EM_MIPS:
1781 case EM_MIPS_RS3_LE:
1782 result = get_mips_dynamic_type (type);
1783 break;
1784 case EM_SPARCV9:
1785 result = get_sparc64_dynamic_type (type);
1786 break;
1787 case EM_PPC:
1788 result = get_ppc_dynamic_type (type);
1789 break;
1790 case EM_PPC64:
1791 result = get_ppc64_dynamic_type (type);
1792 break;
1793 case EM_IA_64:
1794 result = get_ia64_dynamic_type (type);
1795 break;
1796 case EM_ALPHA:
1797 result = get_alpha_dynamic_type (type);
1798 break;
1799 case EM_SCORE:
1800 result = get_score_dynamic_type (type);
1801 break;
1802 case EM_TI_C6000:
1803 result = get_tic6x_dynamic_type (type);
1804 break;
1805 default:
1806 result = NULL;
1807 break;
1808 }
1809
1810 if (result != NULL)
1811 return result;
1812
1813 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1814 }
1815 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1816 || (elf_header.e_machine == EM_PARISC
1817 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1818 {
1819 const char * result;
1820
1821 switch (elf_header.e_machine)
1822 {
1823 case EM_PARISC:
1824 result = get_parisc_dynamic_type (type);
1825 break;
1826 case EM_IA_64:
1827 result = get_ia64_dynamic_type (type);
1828 break;
1829 default:
1830 result = NULL;
1831 break;
1832 }
1833
1834 if (result != NULL)
1835 return result;
1836
1837 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1838 type);
1839 }
1840 else
1841 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1842
1843 return buff;
1844 }
1845}
1846
1847static char *
1848get_file_type (unsigned e_type)
1849{
1850 static char buff[32];
1851
1852 switch (e_type)
1853 {
1854 case ET_NONE: return _("NONE (None)");
1855 case ET_REL: return _("REL (Relocatable file)");
1856 case ET_EXEC: return _("EXEC (Executable file)");
1857 case ET_DYN: return _("DYN (Shared object file)");
1858 case ET_CORE: return _("CORE (Core file)");
1859
1860 default:
1861 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1862 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1863 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1864 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1865 else
1866 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1867 return buff;
1868 }
1869}
1870
1871static char *
1872get_machine_name (unsigned e_machine)
1873{
1874 static char buff[64]; /* XXX */
1875
1876 switch (e_machine)
1877 {
1878 case EM_NONE: return _("None");
1879 case EM_AARCH64: return "AArch64";
1880 case EM_M32: return "WE32100";
1881 case EM_SPARC: return "Sparc";
1882 case EM_SPU: return "SPU";
1883 case EM_386: return "Intel 80386";
1884 case EM_68K: return "MC68000";
1885 case EM_88K: return "MC88000";
1886 case EM_486: return "Intel 80486";
1887 case EM_860: return "Intel 80860";
1888 case EM_MIPS: return "MIPS R3000";
1889 case EM_S370: return "IBM System/370";
1890 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1891 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1892 case EM_PARISC: return "HPPA";
1893 case EM_PPC_OLD: return "Power PC (old)";
1894 case EM_SPARC32PLUS: return "Sparc v8+" ;
1895 case EM_960: return "Intel 90860";
1896 case EM_PPC: return "PowerPC";
1897 case EM_PPC64: return "PowerPC64";
1898 case EM_FR20: return "Fujitsu FR20";
1899 case EM_RH32: return "TRW RH32";
1900 case EM_MCORE: return "MCORE";
1901 case EM_ARM: return "ARM";
1902 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1903 case EM_SH: return "Renesas / SuperH SH";
1904 case EM_SPARCV9: return "Sparc v9";
1905 case EM_TRICORE: return "Siemens Tricore";
1906 case EM_ARC: return "ARC";
1907 case EM_H8_300: return "Renesas H8/300";
1908 case EM_H8_300H: return "Renesas H8/300H";
1909 case EM_H8S: return "Renesas H8S";
1910 case EM_H8_500: return "Renesas H8/500";
1911 case EM_IA_64: return "Intel IA-64";
1912 case EM_MIPS_X: return "Stanford MIPS-X";
1913 case EM_COLDFIRE: return "Motorola Coldfire";
1914 case EM_ALPHA: return "Alpha";
1915 case EM_CYGNUS_D10V:
1916 case EM_D10V: return "d10v";
1917 case EM_CYGNUS_D30V:
1918 case EM_D30V: return "d30v";
1919 case EM_CYGNUS_M32R:
1920 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1921 case EM_CYGNUS_V850:
1922 case EM_V800: return "Renesas V850 (using RH850 ABI)";
1923 case EM_V850: return "Renesas V850";
1924 case EM_CYGNUS_MN10300:
1925 case EM_MN10300: return "mn10300";
1926 case EM_CYGNUS_MN10200:
1927 case EM_MN10200: return "mn10200";
1928 case EM_MOXIE: return "Moxie";
1929 case EM_CYGNUS_FR30:
1930 case EM_FR30: return "Fujitsu FR30";
1931 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1932 case EM_PJ_OLD:
1933 case EM_PJ: return "picoJava";
1934 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1935 case EM_PCP: return "Siemens PCP";
1936 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1937 case EM_NDR1: return "Denso NDR1 microprocesspr";
1938 case EM_STARCORE: return "Motorola Star*Core processor";
1939 case EM_ME16: return "Toyota ME16 processor";
1940 case EM_ST100: return "STMicroelectronics ST100 processor";
1941 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1942 case EM_PDSP: return "Sony DSP processor";
1943 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1944 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
1945 case EM_FX66: return "Siemens FX66 microcontroller";
1946 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1947 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1948 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1949 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
1950 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1951 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1952 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1953 case EM_SVX: return "Silicon Graphics SVx";
1954 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1955 case EM_VAX: return "Digital VAX";
1956 case EM_AVR_OLD:
1957 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1958 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1959 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1960 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1961 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1962 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1963 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1964 case EM_PRISM: return "Vitesse Prism";
1965 case EM_X86_64: return "Advanced Micro Devices X86-64";
1966 case EM_L1OM: return "Intel L1OM";
1967 case EM_K1OM: return "Intel K1OM";
1968 case EM_S390_OLD:
1969 case EM_S390: return "IBM S/390";
1970 case EM_SCORE: return "SUNPLUS S+Core";
1971 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
1972 case EM_OPENRISC:
1973 case EM_OR32: return "OpenRISC";
1974 case EM_ARC_A5: return "ARC International ARCompact processor";
1975 case EM_CRX: return "National Semiconductor CRX microprocessor";
1976 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
1977 case EM_DLX: return "OpenDLX";
1978 case EM_IP2K_OLD:
1979 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1980 case EM_IQ2000: return "Vitesse IQ2000";
1981 case EM_XTENSA_OLD:
1982 case EM_XTENSA: return "Tensilica Xtensa Processor";
1983 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1984 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1985 case EM_NS32K: return "National Semiconductor 32000 series";
1986 case EM_TPC: return "Tenor Network TPC processor";
1987 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1988 case EM_MAX: return "MAX Processor";
1989 case EM_CR: return "National Semiconductor CompactRISC";
1990 case EM_F2MC16: return "Fujitsu F2MC16";
1991 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
1992 case EM_LATTICEMICO32: return "Lattice Mico32";
1993 case EM_M32C_OLD:
1994 case EM_M32C: return "Renesas M32c";
1995 case EM_MT: return "Morpho Techologies MT processor";
1996 case EM_BLACKFIN: return "Analog Devices Blackfin";
1997 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1998 case EM_SEP: return "Sharp embedded microprocessor";
1999 case EM_ARCA: return "Arca RISC microprocessor";
2000 case EM_UNICORE: return "Unicore";
2001 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2002 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2003 case EM_NIOS32: return "Altera Nios";
2004 case EM_ALTERA_NIOS2: return "Altera Nios II";
2005 case EM_C166:
2006 case EM_XC16X: return "Infineon Technologies xc16x";
2007 case EM_M16C: return "Renesas M16C series microprocessors";
2008 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2009 case EM_CE: return "Freescale Communication Engine RISC core";
2010 case EM_TSK3000: return "Altium TSK3000 core";
2011 case EM_RS08: return "Freescale RS08 embedded processor";
2012 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2013 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2014 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2015 case EM_SE_C17: return "Seiko Epson C17 family";
2016 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2017 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2018 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2019 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2020 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2021 case EM_R32C: return "Renesas R32C series microprocessors";
2022 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2023 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2024 case EM_8051: return "Intel 8051 and variants";
2025 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2026 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2027 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2028 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2029 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2030 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2031 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2032 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2033 case EM_CR16:
2034 case EM_MICROBLAZE:
2035 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2036 case EM_RL78: return "Renesas RL78";
2037 case EM_RX: return "Renesas RX";
2038 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2039 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2040 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2041 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2042 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2043 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2044 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2045 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2046 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2047 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2048 case EM_CUDA: return "NVIDIA CUDA architecture";
2049 case EM_XGATE: return "Motorola XGATE embedded processor";
2050 default:
2051 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2052 return buff;
2053 }
2054}
2055
2056static void
2057decode_ARM_machine_flags (unsigned e_flags, char buf[])
2058{
2059 unsigned eabi;
2060 int unknown = 0;
2061
2062 eabi = EF_ARM_EABI_VERSION (e_flags);
2063 e_flags &= ~ EF_ARM_EABIMASK;
2064
2065 /* Handle "generic" ARM flags. */
2066 if (e_flags & EF_ARM_RELEXEC)
2067 {
2068 strcat (buf, ", relocatable executable");
2069 e_flags &= ~ EF_ARM_RELEXEC;
2070 }
2071
2072 if (e_flags & EF_ARM_HASENTRY)
2073 {
2074 strcat (buf, ", has entry point");
2075 e_flags &= ~ EF_ARM_HASENTRY;
2076 }
2077
2078 /* Now handle EABI specific flags. */
2079 switch (eabi)
2080 {
2081 default:
2082 strcat (buf, ", <unrecognized EABI>");
2083 if (e_flags)
2084 unknown = 1;
2085 break;
2086
2087 case EF_ARM_EABI_VER1:
2088 strcat (buf, ", Version1 EABI");
2089 while (e_flags)
2090 {
2091 unsigned flag;
2092
2093 /* Process flags one bit at a time. */
2094 flag = e_flags & - e_flags;
2095 e_flags &= ~ flag;
2096
2097 switch (flag)
2098 {
2099 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2100 strcat (buf, ", sorted symbol tables");
2101 break;
2102
2103 default:
2104 unknown = 1;
2105 break;
2106 }
2107 }
2108 break;
2109
2110 case EF_ARM_EABI_VER2:
2111 strcat (buf, ", Version2 EABI");
2112 while (e_flags)
2113 {
2114 unsigned flag;
2115
2116 /* Process flags one bit at a time. */
2117 flag = e_flags & - e_flags;
2118 e_flags &= ~ flag;
2119
2120 switch (flag)
2121 {
2122 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2123 strcat (buf, ", sorted symbol tables");
2124 break;
2125
2126 case EF_ARM_DYNSYMSUSESEGIDX:
2127 strcat (buf, ", dynamic symbols use segment index");
2128 break;
2129
2130 case EF_ARM_MAPSYMSFIRST:
2131 strcat (buf, ", mapping symbols precede others");
2132 break;
2133
2134 default:
2135 unknown = 1;
2136 break;
2137 }
2138 }
2139 break;
2140
2141 case EF_ARM_EABI_VER3:
2142 strcat (buf, ", Version3 EABI");
2143 break;
2144
2145 case EF_ARM_EABI_VER4:
2146 strcat (buf, ", Version4 EABI");
2147 while (e_flags)
2148 {
2149 unsigned flag;
2150
2151 /* Process flags one bit at a time. */
2152 flag = e_flags & - e_flags;
2153 e_flags &= ~ flag;
2154
2155 switch (flag)
2156 {
2157 case EF_ARM_BE8:
2158 strcat (buf, ", BE8");
2159 break;
2160
2161 case EF_ARM_LE8:
2162 strcat (buf, ", LE8");
2163 break;
2164
2165 default:
2166 unknown = 1;
2167 break;
2168 }
2169 break;
2170 }
2171 break;
2172
2173 case EF_ARM_EABI_VER5:
2174 strcat (buf, ", Version5 EABI");
2175 while (e_flags)
2176 {
2177 unsigned flag;
2178
2179 /* Process flags one bit at a time. */
2180 flag = e_flags & - e_flags;
2181 e_flags &= ~ flag;
2182
2183 switch (flag)
2184 {
2185 case EF_ARM_BE8:
2186 strcat (buf, ", BE8");
2187 break;
2188
2189 case EF_ARM_LE8:
2190 strcat (buf, ", LE8");
2191 break;
2192
2193 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2194 strcat (buf, ", soft-float ABI");
2195 break;
2196
2197 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2198 strcat (buf, ", hard-float ABI");
2199 break;
2200
2201 default:
2202 unknown = 1;
2203 break;
2204 }
2205 }
2206 break;
2207
2208 case EF_ARM_EABI_UNKNOWN:
2209 strcat (buf, ", GNU EABI");
2210 while (e_flags)
2211 {
2212 unsigned flag;
2213
2214 /* Process flags one bit at a time. */
2215 flag = e_flags & - e_flags;
2216 e_flags &= ~ flag;
2217
2218 switch (flag)
2219 {
2220 case EF_ARM_INTERWORK:
2221 strcat (buf, ", interworking enabled");
2222 break;
2223
2224 case EF_ARM_APCS_26:
2225 strcat (buf, ", uses APCS/26");
2226 break;
2227
2228 case EF_ARM_APCS_FLOAT:
2229 strcat (buf, ", uses APCS/float");
2230 break;
2231
2232 case EF_ARM_PIC:
2233 strcat (buf, ", position independent");
2234 break;
2235
2236 case EF_ARM_ALIGN8:
2237 strcat (buf, ", 8 bit structure alignment");
2238 break;
2239
2240 case EF_ARM_NEW_ABI:
2241 strcat (buf, ", uses new ABI");
2242 break;
2243
2244 case EF_ARM_OLD_ABI:
2245 strcat (buf, ", uses old ABI");
2246 break;
2247
2248 case EF_ARM_SOFT_FLOAT:
2249 strcat (buf, ", software FP");
2250 break;
2251
2252 case EF_ARM_VFP_FLOAT:
2253 strcat (buf, ", VFP");
2254 break;
2255
2256 case EF_ARM_MAVERICK_FLOAT:
2257 strcat (buf, ", Maverick FP");
2258 break;
2259
2260 default:
2261 unknown = 1;
2262 break;
2263 }
2264 }
2265 }
2266
2267 if (unknown)
2268 strcat (buf,_(", <unknown>"));
2269}
2270
2271static char *
2272get_machine_flags (unsigned e_flags, unsigned e_machine)
2273{
2274 static char buf[1024];
2275
2276 buf[0] = '\0';
2277
2278 if (e_flags)
2279 {
2280 switch (e_machine)
2281 {
2282 default:
2283 break;
2284
2285 case EM_ARM:
2286 decode_ARM_machine_flags (e_flags, buf);
2287 break;
2288
2289 case EM_BLACKFIN:
2290 if (e_flags & EF_BFIN_PIC)
2291 strcat (buf, ", PIC");
2292
2293 if (e_flags & EF_BFIN_FDPIC)
2294 strcat (buf, ", FDPIC");
2295
2296 if (e_flags & EF_BFIN_CODE_IN_L1)
2297 strcat (buf, ", code in L1");
2298
2299 if (e_flags & EF_BFIN_DATA_IN_L1)
2300 strcat (buf, ", data in L1");
2301
2302 break;
2303
2304 case EM_CYGNUS_FRV:
2305 switch (e_flags & EF_FRV_CPU_MASK)
2306 {
2307 case EF_FRV_CPU_GENERIC:
2308 break;
2309
2310 default:
2311 strcat (buf, ", fr???");
2312 break;
2313
2314 case EF_FRV_CPU_FR300:
2315 strcat (buf, ", fr300");
2316 break;
2317
2318 case EF_FRV_CPU_FR400:
2319 strcat (buf, ", fr400");
2320 break;
2321 case EF_FRV_CPU_FR405:
2322 strcat (buf, ", fr405");
2323 break;
2324
2325 case EF_FRV_CPU_FR450:
2326 strcat (buf, ", fr450");
2327 break;
2328
2329 case EF_FRV_CPU_FR500:
2330 strcat (buf, ", fr500");
2331 break;
2332 case EF_FRV_CPU_FR550:
2333 strcat (buf, ", fr550");
2334 break;
2335
2336 case EF_FRV_CPU_SIMPLE:
2337 strcat (buf, ", simple");
2338 break;
2339 case EF_FRV_CPU_TOMCAT:
2340 strcat (buf, ", tomcat");
2341 break;
2342 }
2343 break;
2344
2345 case EM_68K:
2346 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2347 strcat (buf, ", m68000");
2348 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2349 strcat (buf, ", cpu32");
2350 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2351 strcat (buf, ", fido_a");
2352 else
2353 {
2354 char const * isa = _("unknown");
2355 char const * mac = _("unknown mac");
2356 char const * additional = NULL;
2357
2358 switch (e_flags & EF_M68K_CF_ISA_MASK)
2359 {
2360 case EF_M68K_CF_ISA_A_NODIV:
2361 isa = "A";
2362 additional = ", nodiv";
2363 break;
2364 case EF_M68K_CF_ISA_A:
2365 isa = "A";
2366 break;
2367 case EF_M68K_CF_ISA_A_PLUS:
2368 isa = "A+";
2369 break;
2370 case EF_M68K_CF_ISA_B_NOUSP:
2371 isa = "B";
2372 additional = ", nousp";
2373 break;
2374 case EF_M68K_CF_ISA_B:
2375 isa = "B";
2376 break;
2377 case EF_M68K_CF_ISA_C:
2378 isa = "C";
2379 break;
2380 case EF_M68K_CF_ISA_C_NODIV:
2381 isa = "C";
2382 additional = ", nodiv";
2383 break;
2384 }
2385 strcat (buf, ", cf, isa ");
2386 strcat (buf, isa);
2387 if (additional)
2388 strcat (buf, additional);
2389 if (e_flags & EF_M68K_CF_FLOAT)
2390 strcat (buf, ", float");
2391 switch (e_flags & EF_M68K_CF_MAC_MASK)
2392 {
2393 case 0:
2394 mac = NULL;
2395 break;
2396 case EF_M68K_CF_MAC:
2397 mac = "mac";
2398 break;
2399 case EF_M68K_CF_EMAC:
2400 mac = "emac";
2401 break;
2402 case EF_M68K_CF_EMAC_B:
2403 mac = "emac_b";
2404 break;
2405 }
2406 if (mac)
2407 {
2408 strcat (buf, ", ");
2409 strcat (buf, mac);
2410 }
2411 }
2412 break;
2413
2414 case EM_PPC:
2415 if (e_flags & EF_PPC_EMB)
2416 strcat (buf, ", emb");
2417
2418 if (e_flags & EF_PPC_RELOCATABLE)
2419 strcat (buf, _(", relocatable"));
2420
2421 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2422 strcat (buf, _(", relocatable-lib"));
2423 break;
2424
2425 case EM_V800:
2426 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2427 strcat (buf, ", RH850 ABI");
2428
2429 if (e_flags & EF_V800_850E3)
2430 strcat (buf, ", V3 architecture");
2431
2432 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2433 strcat (buf, ", FPU not used");
2434
2435 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2436 strcat (buf, ", regmode: COMMON");
2437
2438 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2439 strcat (buf, ", r4 not used");
2440
2441 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2442 strcat (buf, ", r30 not used");
2443
2444 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2445 strcat (buf, ", r5 not used");
2446
2447 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2448 strcat (buf, ", r2 not used");
2449
2450 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2451 {
2452 switch (e_flags & - e_flags)
2453 {
2454 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2455 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2456 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2457 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2458 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2459 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2460 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2461 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2462 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2463 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2464 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2465 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2466 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2467 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2468 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2469 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2470 default: break;
2471 }
2472 }
2473 break;
2474
2475 case EM_V850:
2476 case EM_CYGNUS_V850:
2477 switch (e_flags & EF_V850_ARCH)
2478 {
2479 case E_V850E3V5_ARCH:
2480 strcat (buf, ", v850e3v5");
2481 break;
2482 case E_V850E2V3_ARCH:
2483 strcat (buf, ", v850e2v3");
2484 break;
2485 case E_V850E2_ARCH:
2486 strcat (buf, ", v850e2");
2487 break;
2488 case E_V850E1_ARCH:
2489 strcat (buf, ", v850e1");
2490 break;
2491 case E_V850E_ARCH:
2492 strcat (buf, ", v850e");
2493 break;
2494 case E_V850_ARCH:
2495 strcat (buf, ", v850");
2496 break;
2497 default:
2498 strcat (buf, _(", unknown v850 architecture variant"));
2499 break;
2500 }
2501 break;
2502
2503 case EM_M32R:
2504 case EM_CYGNUS_M32R:
2505 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2506 strcat (buf, ", m32r");
2507 break;
2508
2509 case EM_MIPS:
2510 case EM_MIPS_RS3_LE:
2511 if (e_flags & EF_MIPS_NOREORDER)
2512 strcat (buf, ", noreorder");
2513
2514 if (e_flags & EF_MIPS_PIC)
2515 strcat (buf, ", pic");
2516
2517 if (e_flags & EF_MIPS_CPIC)
2518 strcat (buf, ", cpic");
2519
2520 if (e_flags & EF_MIPS_UCODE)
2521 strcat (buf, ", ugen_reserved");
2522
2523 if (e_flags & EF_MIPS_ABI2)
2524 strcat (buf, ", abi2");
2525
2526 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2527 strcat (buf, ", odk first");
2528
2529 if (e_flags & EF_MIPS_32BITMODE)
2530 strcat (buf, ", 32bitmode");
2531
2532 switch ((e_flags & EF_MIPS_MACH))
2533 {
2534 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2535 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2536 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2537 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2538 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2539 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2540 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2541 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2542 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2543 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2544 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2545 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2546 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2547 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2548 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2549 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2550 case 0:
2551 /* We simply ignore the field in this case to avoid confusion:
2552 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2553 extension. */
2554 break;
2555 default: strcat (buf, _(", unknown CPU")); break;
2556 }
2557
2558 switch ((e_flags & EF_MIPS_ABI))
2559 {
2560 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2561 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2562 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2563 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2564 case 0:
2565 /* We simply ignore the field in this case to avoid confusion:
2566 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2567 This means it is likely to be an o32 file, but not for
2568 sure. */
2569 break;
2570 default: strcat (buf, _(", unknown ABI")); break;
2571 }
2572
2573 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2574 strcat (buf, ", mdmx");
2575
2576 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2577 strcat (buf, ", mips16");
2578
2579 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2580 strcat (buf, ", micromips");
2581
2582 switch ((e_flags & EF_MIPS_ARCH))
2583 {
2584 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2585 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2586 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2587 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2588 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2589 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2590 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2591 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2592 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2593 default: strcat (buf, _(", unknown ISA")); break;
2594 }
2595 break;
2596
2597 case EM_SH:
2598 switch ((e_flags & EF_SH_MACH_MASK))
2599 {
2600 case EF_SH1: strcat (buf, ", sh1"); break;
2601 case EF_SH2: strcat (buf, ", sh2"); break;
2602 case EF_SH3: strcat (buf, ", sh3"); break;
2603 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2604 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2605 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2606 case EF_SH3E: strcat (buf, ", sh3e"); break;
2607 case EF_SH4: strcat (buf, ", sh4"); break;
2608 case EF_SH5: strcat (buf, ", sh5"); break;
2609 case EF_SH2E: strcat (buf, ", sh2e"); break;
2610 case EF_SH4A: strcat (buf, ", sh4a"); break;
2611 case EF_SH2A: strcat (buf, ", sh2a"); break;
2612 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2613 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2614 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2615 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2616 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2617 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2618 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2619 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2620 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2621 default: strcat (buf, _(", unknown ISA")); break;
2622 }
2623
2624 if (e_flags & EF_SH_PIC)
2625 strcat (buf, ", pic");
2626
2627 if (e_flags & EF_SH_FDPIC)
2628 strcat (buf, ", fdpic");
2629 break;
2630
2631 case EM_SPARCV9:
2632 if (e_flags & EF_SPARC_32PLUS)
2633 strcat (buf, ", v8+");
2634
2635 if (e_flags & EF_SPARC_SUN_US1)
2636 strcat (buf, ", ultrasparcI");
2637
2638 if (e_flags & EF_SPARC_SUN_US3)
2639 strcat (buf, ", ultrasparcIII");
2640
2641 if (e_flags & EF_SPARC_HAL_R1)
2642 strcat (buf, ", halr1");
2643
2644 if (e_flags & EF_SPARC_LEDATA)
2645 strcat (buf, ", ledata");
2646
2647 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2648 strcat (buf, ", tso");
2649
2650 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2651 strcat (buf, ", pso");
2652
2653 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2654 strcat (buf, ", rmo");
2655 break;
2656
2657 case EM_PARISC:
2658 switch (e_flags & EF_PARISC_ARCH)
2659 {
2660 case EFA_PARISC_1_0:
2661 strcpy (buf, ", PA-RISC 1.0");
2662 break;
2663 case EFA_PARISC_1_1:
2664 strcpy (buf, ", PA-RISC 1.1");
2665 break;
2666 case EFA_PARISC_2_0:
2667 strcpy (buf, ", PA-RISC 2.0");
2668 break;
2669 default:
2670 break;
2671 }
2672 if (e_flags & EF_PARISC_TRAPNIL)
2673 strcat (buf, ", trapnil");
2674 if (e_flags & EF_PARISC_EXT)
2675 strcat (buf, ", ext");
2676 if (e_flags & EF_PARISC_LSB)
2677 strcat (buf, ", lsb");
2678 if (e_flags & EF_PARISC_WIDE)
2679 strcat (buf, ", wide");
2680 if (e_flags & EF_PARISC_NO_KABP)
2681 strcat (buf, ", no kabp");
2682 if (e_flags & EF_PARISC_LAZYSWAP)
2683 strcat (buf, ", lazyswap");
2684 break;
2685
2686 case EM_PJ:
2687 case EM_PJ_OLD:
2688 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2689 strcat (buf, ", new calling convention");
2690
2691 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2692 strcat (buf, ", gnu calling convention");
2693 break;
2694
2695 case EM_IA_64:
2696 if ((e_flags & EF_IA_64_ABI64))
2697 strcat (buf, ", 64-bit");
2698 else
2699 strcat (buf, ", 32-bit");
2700 if ((e_flags & EF_IA_64_REDUCEDFP))
2701 strcat (buf, ", reduced fp model");
2702 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2703 strcat (buf, ", no function descriptors, constant gp");
2704 else if ((e_flags & EF_IA_64_CONS_GP))
2705 strcat (buf, ", constant gp");
2706 if ((e_flags & EF_IA_64_ABSOLUTE))
2707 strcat (buf, ", absolute");
2708 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2709 {
2710 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2711 strcat (buf, ", vms_linkages");
2712 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2713 {
2714 case EF_IA_64_VMS_COMCOD_SUCCESS:
2715 break;
2716 case EF_IA_64_VMS_COMCOD_WARNING:
2717 strcat (buf, ", warning");
2718 break;
2719 case EF_IA_64_VMS_COMCOD_ERROR:
2720 strcat (buf, ", error");
2721 break;
2722 case EF_IA_64_VMS_COMCOD_ABORT:
2723 strcat (buf, ", abort");
2724 break;
2725 default:
2726 abort ();
2727 }
2728 }
2729 break;
2730
2731 case EM_VAX:
2732 if ((e_flags & EF_VAX_NONPIC))
2733 strcat (buf, ", non-PIC");
2734 if ((e_flags & EF_VAX_DFLOAT))
2735 strcat (buf, ", D-Float");
2736 if ((e_flags & EF_VAX_GFLOAT))
2737 strcat (buf, ", G-Float");
2738 break;
2739
2740 case EM_RX:
2741 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2742 strcat (buf, ", 64-bit doubles");
2743 if (e_flags & E_FLAG_RX_DSP)
2744 strcat (buf, ", dsp");
2745 if (e_flags & E_FLAG_RX_PID)
2746 strcat (buf, ", pid");
2747 if (e_flags & E_FLAG_RX_ABI)
2748 strcat (buf, ", RX ABI");
2749 break;
2750
2751 case EM_S390:
2752 if (e_flags & EF_S390_HIGH_GPRS)
2753 strcat (buf, ", highgprs");
2754 break;
2755
2756 case EM_TI_C6000:
2757 if ((e_flags & EF_C6000_REL))
2758 strcat (buf, ", relocatable module");
2759 break;
2760 }
2761 }
2762
2763 return buf;
2764}
2765
2766static const char *
2767get_osabi_name (unsigned int osabi)
2768{
2769 static char buff[32];
2770
2771 switch (osabi)
2772 {
2773 case ELFOSABI_NONE: return "UNIX - System V";
2774 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2775 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2776 case ELFOSABI_GNU: return "UNIX - GNU";
2777 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2778 case ELFOSABI_AIX: return "UNIX - AIX";
2779 case ELFOSABI_IRIX: return "UNIX - IRIX";
2780 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2781 case ELFOSABI_TRU64: return "UNIX - TRU64";
2782 case ELFOSABI_MODESTO: return "Novell - Modesto";
2783 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2784 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2785 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2786 case ELFOSABI_AROS: return "AROS";
2787 case ELFOSABI_FENIXOS: return "FenixOS";
2788 default:
2789 if (osabi >= 64)
2790 switch (elf_header.e_machine)
2791 {
2792 case EM_ARM:
2793 switch (osabi)
2794 {
2795 case ELFOSABI_ARM: return "ARM";
2796 default:
2797 break;
2798 }
2799 break;
2800
2801 case EM_MSP430:
2802 case EM_MSP430_OLD:
2803 switch (osabi)
2804 {
2805 case ELFOSABI_STANDALONE: return _("Standalone App");
2806 default:
2807 break;
2808 }
2809 break;
2810
2811 case EM_TI_C6000:
2812 switch (osabi)
2813 {
2814 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2815 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2816 default:
2817 break;
2818 }
2819 break;
2820
2821 default:
2822 break;
2823 }
2824 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2825 return buff;
2826 }
2827}
2828
2829static const char *
2830get_aarch64_segment_type (unsigned long type)
2831{
2832 switch (type)
2833 {
2834 case PT_AARCH64_ARCHEXT:
2835 return "AARCH64_ARCHEXT";
2836 default:
2837 break;
2838 }
2839
2840 return NULL;
2841}
2842
2843static const char *
2844get_arm_segment_type (unsigned long type)
2845{
2846 switch (type)
2847 {
2848 case PT_ARM_EXIDX:
2849 return "EXIDX";
2850 default:
2851 break;
2852 }
2853
2854 return NULL;
2855}
2856
2857static const char *
2858get_mips_segment_type (unsigned long type)
2859{
2860 switch (type)
2861 {
2862 case PT_MIPS_REGINFO:
2863 return "REGINFO";
2864 case PT_MIPS_RTPROC:
2865 return "RTPROC";
2866 case PT_MIPS_OPTIONS:
2867 return "OPTIONS";
2868 default:
2869 break;
2870 }
2871
2872 return NULL;
2873}
2874
2875static const char *
2876get_parisc_segment_type (unsigned long type)
2877{
2878 switch (type)
2879 {
2880 case PT_HP_TLS: return "HP_TLS";
2881 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2882 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2883 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2884 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2885 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2886 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2887 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2888 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2889 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2890 case PT_HP_PARALLEL: return "HP_PARALLEL";
2891 case PT_HP_FASTBIND: return "HP_FASTBIND";
2892 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2893 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2894 case PT_HP_STACK: return "HP_STACK";
2895 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2896 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2897 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2898 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2899 default:
2900 break;
2901 }
2902
2903 return NULL;
2904}
2905
2906static const char *
2907get_ia64_segment_type (unsigned long type)
2908{
2909 switch (type)
2910 {
2911 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2912 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2913 case PT_HP_TLS: return "HP_TLS";
2914 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2915 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2916 case PT_IA_64_HP_STACK: return "HP_STACK";
2917 default:
2918 break;
2919 }
2920
2921 return NULL;
2922}
2923
2924static const char *
2925get_tic6x_segment_type (unsigned long type)
2926{
2927 switch (type)
2928 {
2929 case PT_C6000_PHATTR: return "C6000_PHATTR";
2930 default:
2931 break;
2932 }
2933
2934 return NULL;
2935}
2936
2937static const char *
2938get_segment_type (unsigned long p_type)
2939{
2940 static char buff[32];
2941
2942 switch (p_type)
2943 {
2944 case PT_NULL: return "NULL";
2945 case PT_LOAD: return "LOAD";
2946 case PT_DYNAMIC: return "DYNAMIC";
2947 case PT_INTERP: return "INTERP";
2948 case PT_NOTE: return "NOTE";
2949 case PT_SHLIB: return "SHLIB";
2950 case PT_PHDR: return "PHDR";
2951 case PT_TLS: return "TLS";
2952
2953 case PT_GNU_EH_FRAME:
2954 return "GNU_EH_FRAME";
2955 case PT_GNU_STACK: return "GNU_STACK";
2956 case PT_GNU_RELRO: return "GNU_RELRO";
2957
2958 default:
2959 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2960 {
2961 const char * result;
2962
2963 switch (elf_header.e_machine)
2964 {
2965 case EM_AARCH64:
2966 result = get_aarch64_segment_type (p_type);
2967 break;
2968 case EM_ARM:
2969 result = get_arm_segment_type (p_type);
2970 break;
2971 case EM_MIPS:
2972 case EM_MIPS_RS3_LE:
2973 result = get_mips_segment_type (p_type);
2974 break;
2975 case EM_PARISC:
2976 result = get_parisc_segment_type (p_type);
2977 break;
2978 case EM_IA_64:
2979 result = get_ia64_segment_type (p_type);
2980 break;
2981 case EM_TI_C6000:
2982 result = get_tic6x_segment_type (p_type);
2983 break;
2984 default:
2985 result = NULL;
2986 break;
2987 }
2988
2989 if (result != NULL)
2990 return result;
2991
2992 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2993 }
2994 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2995 {
2996 const char * result;
2997
2998 switch (elf_header.e_machine)
2999 {
3000 case EM_PARISC:
3001 result = get_parisc_segment_type (p_type);
3002 break;
3003 case EM_IA_64:
3004 result = get_ia64_segment_type (p_type);
3005 break;
3006 default:
3007 result = NULL;
3008 break;
3009 }
3010
3011 if (result != NULL)
3012 return result;
3013
3014 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3015 }
3016 else
3017 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3018
3019 return buff;
3020 }
3021}
3022
3023static const char *
3024get_mips_section_type_name (unsigned int sh_type)
3025{
3026 switch (sh_type)
3027 {
3028 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3029 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3030 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3031 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3032 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3033 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3034 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3035 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3036 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3037 case SHT_MIPS_RELD: return "MIPS_RELD";
3038 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3039 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3040 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3041 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3042 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3043 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3044 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3045 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3046 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3047 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3048 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3049 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3050 case SHT_MIPS_LINE: return "MIPS_LINE";
3051 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3052 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3053 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3054 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3055 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3056 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3057 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3058 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3059 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3060 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3061 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3062 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3063 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3064 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3065 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3066 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3067 default:
3068 break;
3069 }
3070 return NULL;
3071}
3072
3073static const char *
3074get_parisc_section_type_name (unsigned int sh_type)
3075{
3076 switch (sh_type)
3077 {
3078 case SHT_PARISC_EXT: return "PARISC_EXT";
3079 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3080 case SHT_PARISC_DOC: return "PARISC_DOC";
3081 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3082 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3083 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3084 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3085 default:
3086 break;
3087 }
3088 return NULL;
3089}
3090
3091static const char *
3092get_ia64_section_type_name (unsigned int sh_type)
3093{
3094 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3095 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3096 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3097
3098 switch (sh_type)
3099 {
3100 case SHT_IA_64_EXT: return "IA_64_EXT";
3101 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3102 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3103 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3104 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3105 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3106 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3107 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3108 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3109 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3110 default:
3111 break;
3112 }
3113 return NULL;
3114}
3115
3116static const char *
3117get_x86_64_section_type_name (unsigned int sh_type)
3118{
3119 switch (sh_type)
3120 {
3121 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3122 default:
3123 break;
3124 }
3125 return NULL;
3126}
3127
3128static const char *
3129get_aarch64_section_type_name (unsigned int sh_type)
3130{
3131 switch (sh_type)
3132 {
3133 case SHT_AARCH64_ATTRIBUTES:
3134 return "AARCH64_ATTRIBUTES";
3135 default:
3136 break;
3137 }
3138 return NULL;
3139}
3140
3141static const char *
3142get_arm_section_type_name (unsigned int sh_type)
3143{
3144 switch (sh_type)
3145 {
3146 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3147 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3148 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3149 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3150 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3151 default:
3152 break;
3153 }
3154 return NULL;
3155}
3156
3157static const char *
3158get_tic6x_section_type_name (unsigned int sh_type)
3159{
3160 switch (sh_type)
3161 {
3162 case SHT_C6000_UNWIND:
3163 return "C6000_UNWIND";
3164 case SHT_C6000_PREEMPTMAP:
3165 return "C6000_PREEMPTMAP";
3166 case SHT_C6000_ATTRIBUTES:
3167 return "C6000_ATTRIBUTES";
3168 case SHT_TI_ICODE:
3169 return "TI_ICODE";
3170 case SHT_TI_XREF:
3171 return "TI_XREF";
3172 case SHT_TI_HANDLER:
3173 return "TI_HANDLER";
3174 case SHT_TI_INITINFO:
3175 return "TI_INITINFO";
3176 case SHT_TI_PHATTRS:
3177 return "TI_PHATTRS";
3178 default:
3179 break;
3180 }
3181 return NULL;
3182}
3183
3184static const char *
3185get_section_type_name (unsigned int sh_type)
3186{
3187 static char buff[32];
3188
3189 switch (sh_type)
3190 {
3191 case SHT_NULL: return "NULL";
3192 case SHT_PROGBITS: return "PROGBITS";
3193 case SHT_SYMTAB: return "SYMTAB";
3194 case SHT_STRTAB: return "STRTAB";
3195 case SHT_RELA: return "RELA";
3196 case SHT_HASH: return "HASH";
3197 case SHT_DYNAMIC: return "DYNAMIC";
3198 case SHT_NOTE: return "NOTE";
3199 case SHT_NOBITS: return "NOBITS";
3200 case SHT_REL: return "REL";
3201 case SHT_SHLIB: return "SHLIB";
3202 case SHT_DYNSYM: return "DYNSYM";
3203 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3204 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3205 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3206 case SHT_GNU_HASH: return "GNU_HASH";
3207 case SHT_GROUP: return "GROUP";
3208 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3209 case SHT_GNU_verdef: return "VERDEF";
3210 case SHT_GNU_verneed: return "VERNEED";
3211 case SHT_GNU_versym: return "VERSYM";
3212 case 0x6ffffff0: return "VERSYM";
3213 case 0x6ffffffc: return "VERDEF";
3214 case 0x7ffffffd: return "AUXILIARY";
3215 case 0x7fffffff: return "FILTER";
3216 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3217
3218 default:
3219 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3220 {
3221 const char * result;
3222
3223 switch (elf_header.e_machine)
3224 {
3225 case EM_MIPS:
3226 case EM_MIPS_RS3_LE:
3227 result = get_mips_section_type_name (sh_type);
3228 break;
3229 case EM_PARISC:
3230 result = get_parisc_section_type_name (sh_type);
3231 break;
3232 case EM_IA_64:
3233 result = get_ia64_section_type_name (sh_type);
3234 break;
3235 case EM_X86_64:
3236 case EM_L1OM:
3237 case EM_K1OM:
3238 result = get_x86_64_section_type_name (sh_type);
3239 break;
3240 case EM_AARCH64:
3241 result = get_aarch64_section_type_name (sh_type);
3242 break;
3243 case EM_ARM:
3244 result = get_arm_section_type_name (sh_type);
3245 break;
3246 case EM_TI_C6000:
3247 result = get_tic6x_section_type_name (sh_type);
3248 break;
3249 default:
3250 result = NULL;
3251 break;
3252 }
3253
3254 if (result != NULL)
3255 return result;
3256
3257 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3258 }
3259 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3260 {
3261 const char * result;
3262
3263 switch (elf_header.e_machine)
3264 {
3265 case EM_IA_64:
3266 result = get_ia64_section_type_name (sh_type);
3267 break;
3268 default:
3269 result = NULL;
3270 break;
3271 }
3272
3273 if (result != NULL)
3274 return result;
3275
3276 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3277 }
3278 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3279 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3280 else
3281 /* This message is probably going to be displayed in a 15
3282 character wide field, so put the hex value first. */
3283 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3284
3285 return buff;
3286 }
3287}
3288
3289#define OPTION_DEBUG_DUMP 512
3290#define OPTION_DYN_SYMS 513
3291#define OPTION_DWARF_DEPTH 514
3292#define OPTION_DWARF_START 515
3293#define OPTION_DWARF_CHECK 516
3294
3295static struct option options[] =
3296{
3297 {"all", no_argument, 0, 'a'},
3298 {"file-header", no_argument, 0, 'h'},
3299 {"program-headers", no_argument, 0, 'l'},
3300 {"headers", no_argument, 0, 'e'},
3301 {"histogram", no_argument, 0, 'I'},
3302 {"segments", no_argument, 0, 'l'},
3303 {"sections", no_argument, 0, 'S'},
3304 {"section-headers", no_argument, 0, 'S'},
3305 {"section-groups", no_argument, 0, 'g'},
3306 {"section-details", no_argument, 0, 't'},
3307 {"full-section-name",no_argument, 0, 'N'},
3308 {"symbols", no_argument, 0, 's'},
3309 {"syms", no_argument, 0, 's'},
3310 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3311 {"relocs", no_argument, 0, 'r'},
3312 {"notes", no_argument, 0, 'n'},
3313 {"dynamic", no_argument, 0, 'd'},
3314 {"arch-specific", no_argument, 0, 'A'},
3315 {"version-info", no_argument, 0, 'V'},
3316 {"use-dynamic", no_argument, 0, 'D'},
3317 {"unwind", no_argument, 0, 'u'},
3318 {"archive-index", no_argument, 0, 'c'},
3319 {"hex-dump", required_argument, 0, 'x'},
3320 {"relocated-dump", required_argument, 0, 'R'},
3321 {"string-dump", required_argument, 0, 'p'},
3322#ifdef SUPPORT_DISASSEMBLY
3323 {"instruction-dump", required_argument, 0, 'i'},
3324#endif
3325 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3326
3327 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3328 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3329 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
3330
3331 {"version", no_argument, 0, 'v'},
3332 {"wide", no_argument, 0, 'W'},
3333 {"help", no_argument, 0, 'H'},
3334 {0, no_argument, 0, 0}
3335};
3336
3337static void
3338usage (FILE * stream)
3339{
3340 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3341 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3342 fprintf (stream, _(" Options are:\n\
3343 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3344 -h --file-header Display the ELF file header\n\
3345 -l --program-headers Display the program headers\n\
3346 --segments An alias for --program-headers\n\
3347 -S --section-headers Display the sections' header\n\
3348 --sections An alias for --section-headers\n\
3349 -g --section-groups Display the section groups\n\
3350 -t --section-details Display the section details\n\
3351 -e --headers Equivalent to: -h -l -S\n\
3352 -s --syms Display the symbol table\n\
3353 --symbols An alias for --syms\n\
3354 --dyn-syms Display the dynamic symbol table\n\
3355 -n --notes Display the core notes (if present)\n\
3356 -r --relocs Display the relocations (if present)\n\
3357 -u --unwind Display the unwind info (if present)\n\
3358 -d --dynamic Display the dynamic section (if present)\n\
3359 -V --version-info Display the version sections (if present)\n\
3360 -A --arch-specific Display architecture specific information (if any)\n\
3361 -c --archive-index Display the symbol/file index in an archive\n\
3362 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3363 -x --hex-dump=<number|name>\n\
3364 Dump the contents of section <number|name> as bytes\n\
3365 -p --string-dump=<number|name>\n\
3366 Dump the contents of section <number|name> as strings\n\
3367 -R --relocated-dump=<number|name>\n\
3368 Dump the contents of section <number|name> as relocated bytes\n\
3369 -w[lLiaprmfFsoRt] or\n\
3370 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3371 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3372 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3373 =addr,=cu_index]\n\
3374 Display the contents of DWARF2 debug sections\n"));
3375 fprintf (stream, _("\
3376 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3377 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3378 or deeper\n"));
3379#ifdef SUPPORT_DISASSEMBLY
3380 fprintf (stream, _("\
3381 -i --instruction-dump=<number|name>\n\
3382 Disassemble the contents of section <number|name>\n"));
3383#endif
3384 fprintf (stream, _("\
3385 -I --histogram Display histogram of bucket list lengths\n\
3386 -W --wide Allow output width to exceed 80 characters\n\
3387 @<file> Read options from <file>\n\
3388 -H --help Display this information\n\
3389 -v --version Display the version number of readelf\n"));
3390
3391 if (REPORT_BUGS_TO[0] && stream == stdout)
3392 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3393
3394 exit (stream == stdout ? 0 : 1);
3395}
3396
3397/* Record the fact that the user wants the contents of section number
3398 SECTION to be displayed using the method(s) encoded as flags bits
3399 in TYPE. Note, TYPE can be zero if we are creating the array for
3400 the first time. */
3401
3402static void
3403request_dump_bynumber (unsigned int section, dump_type type)
3404{
3405 if (section >= num_dump_sects)
3406 {
3407 dump_type * new_dump_sects;
3408
3409 new_dump_sects = (dump_type *) calloc (section + 1,
3410 sizeof (* dump_sects));
3411
3412 if (new_dump_sects == NULL)
3413 error (_("Out of memory allocating dump request table.\n"));
3414 else
3415 {
3416 /* Copy current flag settings. */
3417 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3418
3419 free (dump_sects);
3420
3421 dump_sects = new_dump_sects;
3422 num_dump_sects = section + 1;
3423 }
3424 }
3425
3426 if (dump_sects)
3427 dump_sects[section] |= type;
3428
3429 return;
3430}
3431
3432/* Request a dump by section name. */
3433
3434static void
3435request_dump_byname (const char * section, dump_type type)
3436{
3437 struct dump_list_entry * new_request;
3438
3439 new_request = (struct dump_list_entry *)
3440 malloc (sizeof (struct dump_list_entry));
3441 if (!new_request)
3442 error (_("Out of memory allocating dump request table.\n"));
3443
3444 new_request->name = strdup (section);
3445 if (!new_request->name)
3446 error (_("Out of memory allocating dump request table.\n"));
3447
3448 new_request->type = type;
3449
3450 new_request->next = dump_sects_byname;
3451 dump_sects_byname = new_request;
3452}
3453
3454static inline void
3455request_dump (dump_type type)
3456{
3457 int section;
3458 char * cp;
3459
3460 do_dump++;
3461 section = strtoul (optarg, & cp, 0);
3462
3463 if (! *cp && section >= 0)
3464 request_dump_bynumber (section, type);
3465 else
3466 request_dump_byname (optarg, type);
3467}
3468
3469
3470static void
3471parse_args (int argc, char ** argv)
3472{
3473 int c;
3474
3475 if (argc < 2)
3476 usage (stderr);
3477
3478 while ((c = getopt_long
3479 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3480 {
3481 switch (c)
3482 {
3483 case 0:
3484 /* Long options. */
3485 break;
3486 case 'H':
3487 usage (stdout);
3488 break;
3489
3490 case 'a':
3491 do_syms++;
3492 do_reloc++;
3493 do_unwind++;
3494 do_dynamic++;
3495 do_header++;
3496 do_sections++;
3497 do_section_groups++;
3498 do_segments++;
3499 do_version++;
3500 do_histogram++;
3501 do_arch++;
3502 do_notes++;
3503 break;
3504 case 'g':
3505 do_section_groups++;
3506 break;
3507 case 't':
3508 case 'N':
3509 do_sections++;
3510 do_section_details++;
3511 break;
3512 case 'e':
3513 do_header++;
3514 do_sections++;
3515 do_segments++;
3516 break;
3517 case 'A':
3518 do_arch++;
3519 break;
3520 case 'D':
3521 do_using_dynamic++;
3522 break;
3523 case 'r':
3524 do_reloc++;
3525 break;
3526 case 'u':
3527 do_unwind++;
3528 break;
3529 case 'h':
3530 do_header++;
3531 break;
3532 case 'l':
3533 do_segments++;
3534 break;
3535 case 's':
3536 do_syms++;
3537 break;
3538 case 'S':
3539 do_sections++;
3540 break;
3541 case 'd':
3542 do_dynamic++;
3543 break;
3544 case 'I':
3545 do_histogram++;
3546 break;
3547 case 'n':
3548 do_notes++;
3549 break;
3550 case 'c':
3551 do_archive_index++;
3552 break;
3553 case 'x':
3554 request_dump (HEX_DUMP);
3555 break;
3556 case 'p':
3557 request_dump (STRING_DUMP);
3558 break;
3559 case 'R':
3560 request_dump (RELOC_DUMP);
3561 break;
3562 case 'w':
3563 do_dump++;
3564 if (optarg == 0)
3565 {
3566 do_debugging = 1;
3567 dwarf_select_sections_all ();
3568 }
3569 else
3570 {
3571 do_debugging = 0;
3572 dwarf_select_sections_by_letters (optarg);
3573 }
3574 break;
3575 case OPTION_DEBUG_DUMP:
3576 do_dump++;
3577 if (optarg == 0)
3578 do_debugging = 1;
3579 else
3580 {
3581 do_debugging = 0;
3582 dwarf_select_sections_by_names (optarg);
3583 }
3584 break;
3585 case OPTION_DWARF_DEPTH:
3586 {
3587 char *cp;
3588
3589 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3590 }
3591 break;
3592 case OPTION_DWARF_START:
3593 {
3594 char *cp;
3595
3596 dwarf_start_die = strtoul (optarg, & cp, 0);
3597 }
3598 break;
3599 case OPTION_DWARF_CHECK:
3600 dwarf_check = 1;
3601 break;
3602 case OPTION_DYN_SYMS:
3603 do_dyn_syms++;
3604 break;
3605#ifdef SUPPORT_DISASSEMBLY
3606 case 'i':
3607 request_dump (DISASS_DUMP);
3608 break;
3609#endif
3610 case 'v':
3611 print_version (program_name);
3612 break;
3613 case 'V':
3614 do_version++;
3615 break;
3616 case 'W':
3617 do_wide++;
3618 break;
3619 default:
3620 /* xgettext:c-format */
3621 error (_("Invalid option '-%c'\n"), c);
3622 /* Drop through. */
3623 case '?':
3624 usage (stderr);
3625 }
3626 }
3627
3628 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3629 && !do_segments && !do_header && !do_dump && !do_version
3630 && !do_histogram && !do_debugging && !do_arch && !do_notes
3631 && !do_section_groups && !do_archive_index
3632 && !do_dyn_syms)
3633 usage (stderr);
3634 else if (argc < 3)
3635 {
3636 warn (_("Nothing to do.\n"));
3637 usage (stderr);
3638 }
3639}
3640
3641static const char *
3642get_elf_class (unsigned int elf_class)
3643{
3644 static char buff[32];
3645
3646 switch (elf_class)
3647 {
3648 case ELFCLASSNONE: return _("none");
3649 case ELFCLASS32: return "ELF32";
3650 case ELFCLASS64: return "ELF64";
3651 default:
3652 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3653 return buff;
3654 }
3655}
3656
3657static const char *
3658get_data_encoding (unsigned int encoding)
3659{
3660 static char buff[32];
3661
3662 switch (encoding)
3663 {
3664 case ELFDATANONE: return _("none");
3665 case ELFDATA2LSB: return _("2's complement, little endian");
3666 case ELFDATA2MSB: return _("2's complement, big endian");
3667 default:
3668 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3669 return buff;
3670 }
3671}
3672
3673/* Decode the data held in 'elf_header'. */
3674
3675static int
3676process_file_header (void)
3677{
3678 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3679 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3680 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3681 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3682 {
3683 error
3684 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3685 return 0;
3686 }
3687
3688 init_dwarf_regnames (elf_header.e_machine);
3689
3690 if (do_header)
3691 {
3692 int i;
3693
3694 printf (_("ELF Header:\n"));
3695 printf (_(" Magic: "));
3696 for (i = 0; i < EI_NIDENT; i++)
3697 printf ("%2.2x ", elf_header.e_ident[i]);
3698 printf ("\n");
3699 printf (_(" Class: %s\n"),
3700 get_elf_class (elf_header.e_ident[EI_CLASS]));
3701 printf (_(" Data: %s\n"),
3702 get_data_encoding (elf_header.e_ident[EI_DATA]));
3703 printf (_(" Version: %d %s\n"),
3704 elf_header.e_ident[EI_VERSION],
3705 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3706 ? "(current)"
3707 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3708 ? _("<unknown: %lx>")
3709 : "")));
3710 printf (_(" OS/ABI: %s\n"),
3711 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3712 printf (_(" ABI Version: %d\n"),
3713 elf_header.e_ident[EI_ABIVERSION]);
3714 printf (_(" Type: %s\n"),
3715 get_file_type (elf_header.e_type));
3716 printf (_(" Machine: %s\n"),
3717 get_machine_name (elf_header.e_machine));
3718 printf (_(" Version: 0x%lx\n"),
3719 (unsigned long) elf_header.e_version);
3720
3721 printf (_(" Entry point address: "));
3722 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3723 printf (_("\n Start of program headers: "));
3724 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3725 printf (_(" (bytes into file)\n Start of section headers: "));
3726 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3727 printf (_(" (bytes into file)\n"));
3728
3729 printf (_(" Flags: 0x%lx%s\n"),
3730 (unsigned long) elf_header.e_flags,
3731 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3732 printf (_(" Size of this header: %ld (bytes)\n"),
3733 (long) elf_header.e_ehsize);
3734 printf (_(" Size of program headers: %ld (bytes)\n"),
3735 (long) elf_header.e_phentsize);
3736 printf (_(" Number of program headers: %ld"),
3737 (long) elf_header.e_phnum);
3738 if (section_headers != NULL
3739 && elf_header.e_phnum == PN_XNUM
3740 && section_headers[0].sh_info != 0)
3741 printf (" (%ld)", (long) section_headers[0].sh_info);
3742 putc ('\n', stdout);
3743 printf (_(" Size of section headers: %ld (bytes)\n"),
3744 (long) elf_header.e_shentsize);
3745 printf (_(" Number of section headers: %ld"),
3746 (long) elf_header.e_shnum);
3747 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3748 printf (" (%ld)", (long) section_headers[0].sh_size);
3749 putc ('\n', stdout);
3750 printf (_(" Section header string table index: %ld"),
3751 (long) elf_header.e_shstrndx);
3752 if (section_headers != NULL
3753 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3754 printf (" (%u)", section_headers[0].sh_link);
3755 else if (elf_header.e_shstrndx != SHN_UNDEF
3756 && elf_header.e_shstrndx >= elf_header.e_shnum)
3757 printf (_(" <corrupt: out of range>"));
3758 putc ('\n', stdout);
3759 }
3760
3761 if (section_headers != NULL)
3762 {
3763 if (elf_header.e_phnum == PN_XNUM
3764 && section_headers[0].sh_info != 0)
3765 elf_header.e_phnum = section_headers[0].sh_info;
3766 if (elf_header.e_shnum == SHN_UNDEF)
3767 elf_header.e_shnum = section_headers[0].sh_size;
3768 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3769 elf_header.e_shstrndx = section_headers[0].sh_link;
3770 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3771 elf_header.e_shstrndx = SHN_UNDEF;
3772 free (section_headers);
3773 section_headers = NULL;
3774 }
3775
3776 return 1;
3777}
3778
3779
3780static int
3781get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3782{
3783 Elf32_External_Phdr * phdrs;
3784 Elf32_External_Phdr * external;
3785 Elf_Internal_Phdr * internal;
3786 unsigned int i;
3787
3788 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3789 elf_header.e_phentsize,
3790 elf_header.e_phnum,
3791 _("program headers"));
3792 if (!phdrs)
3793 return 0;
3794
3795 for (i = 0, internal = pheaders, external = phdrs;
3796 i < elf_header.e_phnum;
3797 i++, internal++, external++)
3798 {
3799 internal->p_type = BYTE_GET (external->p_type);
3800 internal->p_offset = BYTE_GET (external->p_offset);
3801 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3802 internal->p_paddr = BYTE_GET (external->p_paddr);
3803 internal->p_filesz = BYTE_GET (external->p_filesz);
3804 internal->p_memsz = BYTE_GET (external->p_memsz);
3805 internal->p_flags = BYTE_GET (external->p_flags);
3806 internal->p_align = BYTE_GET (external->p_align);
3807 }
3808
3809 free (phdrs);
3810
3811 return 1;
3812}
3813
3814static int
3815get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3816{
3817 Elf64_External_Phdr * phdrs;
3818 Elf64_External_Phdr * external;
3819 Elf_Internal_Phdr * internal;
3820 unsigned int i;
3821
3822 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3823 elf_header.e_phentsize,
3824 elf_header.e_phnum,
3825 _("program headers"));
3826 if (!phdrs)
3827 return 0;
3828
3829 for (i = 0, internal = pheaders, external = phdrs;
3830 i < elf_header.e_phnum;
3831 i++, internal++, external++)
3832 {
3833 internal->p_type = BYTE_GET (external->p_type);
3834 internal->p_flags = BYTE_GET (external->p_flags);
3835 internal->p_offset = BYTE_GET (external->p_offset);
3836 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3837 internal->p_paddr = BYTE_GET (external->p_paddr);
3838 internal->p_filesz = BYTE_GET (external->p_filesz);
3839 internal->p_memsz = BYTE_GET (external->p_memsz);
3840 internal->p_align = BYTE_GET (external->p_align);
3841 }
3842
3843 free (phdrs);
3844
3845 return 1;
3846}
3847
3848/* Returns 1 if the program headers were read into `program_headers'. */
3849
3850static int
3851get_program_headers (FILE * file)
3852{
3853 Elf_Internal_Phdr * phdrs;
3854
3855 /* Check cache of prior read. */
3856 if (program_headers != NULL)
3857 return 1;
3858
3859 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3860 sizeof (Elf_Internal_Phdr));
3861
3862 if (phdrs == NULL)
3863 {
3864 error (_("Out of memory\n"));
3865 return 0;
3866 }
3867
3868 if (is_32bit_elf
3869 ? get_32bit_program_headers (file, phdrs)
3870 : get_64bit_program_headers (file, phdrs))
3871 {
3872 program_headers = phdrs;
3873 return 1;
3874 }
3875
3876 free (phdrs);
3877 return 0;
3878}
3879
3880/* Returns 1 if the program headers were loaded. */
3881
3882static int
3883process_program_headers (FILE * file)
3884{
3885 Elf_Internal_Phdr * segment;
3886 unsigned int i;
3887
3888 if (elf_header.e_phnum == 0)
3889 {
3890 /* PR binutils/12467. */
3891 if (elf_header.e_phoff != 0)
3892 warn (_("possibly corrupt ELF header - it has a non-zero program"
3893 " header offset, but no program headers"));
3894 else if (do_segments)
3895 printf (_("\nThere are no program headers in this file.\n"));
3896 return 0;
3897 }
3898
3899 if (do_segments && !do_header)
3900 {
3901 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3902 printf (_("Entry point "));
3903 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3904 printf (_("\nThere are %d program headers, starting at offset "),
3905 elf_header.e_phnum);
3906 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3907 printf ("\n");
3908 }
3909
3910 if (! get_program_headers (file))
3911 return 0;
3912
3913 if (do_segments)
3914 {
3915 if (elf_header.e_phnum > 1)
3916 printf (_("\nProgram Headers:\n"));
3917 else
3918 printf (_("\nProgram Headers:\n"));
3919
3920 if (is_32bit_elf)
3921 printf
3922 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3923 else if (do_wide)
3924 printf
3925 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3926 else
3927 {
3928 printf
3929 (_(" Type Offset VirtAddr PhysAddr\n"));
3930 printf
3931 (_(" FileSiz MemSiz Flags Align\n"));
3932 }
3933 }
3934
3935 dynamic_addr = 0;
3936 dynamic_size = 0;
3937
3938 for (i = 0, segment = program_headers;
3939 i < elf_header.e_phnum;
3940 i++, segment++)
3941 {
3942 if (do_segments)
3943 {
3944 printf (" %-14.14s ", get_segment_type (segment->p_type));
3945
3946 if (is_32bit_elf)
3947 {
3948 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3949 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3950 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3951 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3952 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3953 printf ("%c%c%c ",
3954 (segment->p_flags & PF_R ? 'R' : ' '),
3955 (segment->p_flags & PF_W ? 'W' : ' '),
3956 (segment->p_flags & PF_X ? 'E' : ' '));
3957 printf ("%#lx", (unsigned long) segment->p_align);
3958 }
3959 else if (do_wide)
3960 {
3961 if ((unsigned long) segment->p_offset == segment->p_offset)
3962 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3963 else
3964 {
3965 print_vma (segment->p_offset, FULL_HEX);
3966 putchar (' ');
3967 }
3968
3969 print_vma (segment->p_vaddr, FULL_HEX);
3970 putchar (' ');
3971 print_vma (segment->p_paddr, FULL_HEX);
3972 putchar (' ');
3973
3974 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3975 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3976 else
3977 {
3978 print_vma (segment->p_filesz, FULL_HEX);
3979 putchar (' ');
3980 }
3981
3982 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3983 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3984 else
3985 {
3986 print_vma (segment->p_memsz, FULL_HEX);
3987 }
3988
3989 printf (" %c%c%c ",
3990 (segment->p_flags & PF_R ? 'R' : ' '),
3991 (segment->p_flags & PF_W ? 'W' : ' '),
3992 (segment->p_flags & PF_X ? 'E' : ' '));
3993
3994 if ((unsigned long) segment->p_align == segment->p_align)
3995 printf ("%#lx", (unsigned long) segment->p_align);
3996 else
3997 {
3998 print_vma (segment->p_align, PREFIX_HEX);
3999 }
4000 }
4001 else
4002 {
4003 print_vma (segment->p_offset, FULL_HEX);
4004 putchar (' ');
4005 print_vma (segment->p_vaddr, FULL_HEX);
4006 putchar (' ');
4007 print_vma (segment->p_paddr, FULL_HEX);
4008 printf ("\n ");
4009 print_vma (segment->p_filesz, FULL_HEX);
4010 putchar (' ');
4011 print_vma (segment->p_memsz, FULL_HEX);
4012 printf (" %c%c%c ",
4013 (segment->p_flags & PF_R ? 'R' : ' '),
4014 (segment->p_flags & PF_W ? 'W' : ' '),
4015 (segment->p_flags & PF_X ? 'E' : ' '));
4016 print_vma (segment->p_align, HEX);
4017 }
4018 }
4019
4020 switch (segment->p_type)
4021 {
4022 case PT_DYNAMIC:
4023 if (dynamic_addr)
4024 error (_("more than one dynamic segment\n"));
4025
4026 /* By default, assume that the .dynamic section is the first
4027 section in the DYNAMIC segment. */
4028 dynamic_addr = segment->p_offset;
4029 dynamic_size = segment->p_filesz;
4030
4031 /* Try to locate the .dynamic section. If there is
4032 a section header table, we can easily locate it. */
4033 if (section_headers != NULL)
4034 {
4035 Elf_Internal_Shdr * sec;
4036
4037 sec = find_section (".dynamic");
4038 if (sec == NULL || sec->sh_size == 0)
4039 {
4040 /* A corresponding .dynamic section is expected, but on
4041 IA-64/OpenVMS it is OK for it to be missing. */
4042 if (!is_ia64_vms ())
4043 error (_("no .dynamic section in the dynamic segment\n"));
4044 break;
4045 }
4046
4047 if (sec->sh_type == SHT_NOBITS)
4048 {
4049 dynamic_size = 0;
4050 break;
4051 }
4052
4053 dynamic_addr = sec->sh_offset;
4054 dynamic_size = sec->sh_size;
4055
4056 if (dynamic_addr < segment->p_offset
4057 || dynamic_addr > segment->p_offset + segment->p_filesz)
4058 warn (_("the .dynamic section is not contained"
4059 " within the dynamic segment\n"));
4060 else if (dynamic_addr > segment->p_offset)
4061 warn (_("the .dynamic section is not the first section"
4062 " in the dynamic segment.\n"));
4063 }
4064 break;
4065
4066 case PT_INTERP:
4067 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4068 SEEK_SET))
4069 error (_("Unable to find program interpreter name\n"));
4070 else
4071 {
4072 char fmt [32];
4073 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4074
4075 if (ret >= (int) sizeof (fmt) || ret < 0)
4076 error (_("Internal error: failed to create format string to display program interpreter\n"));
4077
4078 program_interpreter[0] = 0;
4079 if (fscanf (file, fmt, program_interpreter) <= 0)
4080 error (_("Unable to read program interpreter name\n"));
4081
4082 if (do_segments)
4083 printf (_("\n [Requesting program interpreter: %s]"),
4084 program_interpreter);
4085 }
4086 break;
4087 }
4088
4089 if (do_segments)
4090 putc ('\n', stdout);
4091 }
4092
4093 if (do_segments && section_headers != NULL && string_table != NULL)
4094 {
4095 printf (_("\n Section to Segment mapping:\n"));
4096 printf (_(" Segment Sections...\n"));
4097
4098 for (i = 0; i < elf_header.e_phnum; i++)
4099 {
4100 unsigned int j;
4101 Elf_Internal_Shdr * section;
4102
4103 segment = program_headers + i;
4104 section = section_headers + 1;
4105
4106 printf (" %2.2d ", i);
4107
4108 for (j = 1; j < elf_header.e_shnum; j++, section++)
4109 {
4110 if (!ELF_TBSS_SPECIAL (section, segment)
4111 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4112 printf ("%s ", SECTION_NAME (section));
4113 }
4114
4115 putc ('\n',stdout);
4116 }
4117 }
4118
4119 return 1;
4120}
4121
4122
4123/* Find the file offset corresponding to VMA by using the program headers. */
4124
4125static long
4126offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4127{
4128 Elf_Internal_Phdr * seg;
4129
4130 if (! get_program_headers (file))
4131 {
4132 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4133 return (long) vma;
4134 }
4135
4136 for (seg = program_headers;
4137 seg < program_headers + elf_header.e_phnum;
4138 ++seg)
4139 {
4140 if (seg->p_type != PT_LOAD)
4141 continue;
4142
4143 if (vma >= (seg->p_vaddr & -seg->p_align)
4144 && vma + size <= seg->p_vaddr + seg->p_filesz)
4145 return vma - seg->p_vaddr + seg->p_offset;
4146 }
4147
4148 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4149 (unsigned long) vma);
4150 return (long) vma;
4151}
4152
4153
4154static int
4155get_32bit_section_headers (FILE * file, unsigned int num)
4156{
4157 Elf32_External_Shdr * shdrs;
4158 Elf_Internal_Shdr * internal;
4159 unsigned int i;
4160
4161 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4162 elf_header.e_shentsize, num,
4163 _("section headers"));
4164 if (!shdrs)
4165 return 0;
4166
4167 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4168 sizeof (Elf_Internal_Shdr));
4169
4170 if (section_headers == NULL)
4171 {
4172 error (_("Out of memory\n"));
4173 return 0;
4174 }
4175
4176 for (i = 0, internal = section_headers;
4177 i < num;
4178 i++, internal++)
4179 {
4180 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4181 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4182 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4183 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4184 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4185 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4186 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4187 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4188 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4189 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4190 }
4191
4192 free (shdrs);
4193
4194 return 1;
4195}
4196
4197static int
4198get_64bit_section_headers (FILE * file, unsigned int num)
4199{
4200 Elf64_External_Shdr * shdrs;
4201 Elf_Internal_Shdr * internal;
4202 unsigned int i;
4203
4204 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4205 elf_header.e_shentsize, num,
4206 _("section headers"));
4207 if (!shdrs)
4208 return 0;
4209
4210 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4211 sizeof (Elf_Internal_Shdr));
4212
4213 if (section_headers == NULL)
4214 {
4215 error (_("Out of memory\n"));
4216 return 0;
4217 }
4218
4219 for (i = 0, internal = section_headers;
4220 i < num;
4221 i++, internal++)
4222 {
4223 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4224 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4225 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4226 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4227 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4228 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4229 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4230 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4231 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4232 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4233 }
4234
4235 free (shdrs);
4236
4237 return 1;
4238}
4239
4240static Elf_Internal_Sym *
4241get_32bit_elf_symbols (FILE * file,
4242 Elf_Internal_Shdr * section,
4243 unsigned long * num_syms_return)
4244{
4245 unsigned long number = 0;
4246 Elf32_External_Sym * esyms = NULL;
4247 Elf_External_Sym_Shndx * shndx = NULL;
4248 Elf_Internal_Sym * isyms = NULL;
4249 Elf_Internal_Sym * psym;
4250 unsigned int j;
4251
4252 /* Run some sanity checks first. */
4253 if (section->sh_entsize == 0)
4254 {
4255 error (_("sh_entsize is zero\n"));
4256 goto exit_point;
4257 }
4258
4259 number = section->sh_size / section->sh_entsize;
4260
4261 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4262 {
4263 error (_("Invalid sh_entsize\n"));
4264 goto exit_point;
4265 }
4266
4267 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4268 section->sh_size, _("symbols"));
4269 if (esyms == NULL)
4270 goto exit_point;
4271
4272 shndx = NULL;
4273 if (symtab_shndx_hdr != NULL
4274 && (symtab_shndx_hdr->sh_link
4275 == (unsigned long) (section - section_headers)))
4276 {
4277 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4278 symtab_shndx_hdr->sh_offset,
4279 1, symtab_shndx_hdr->sh_size,
4280 _("symbol table section indicies"));
4281 if (shndx == NULL)
4282 goto exit_point;
4283 }
4284
4285 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4286
4287 if (isyms == NULL)
4288 {
4289 error (_("Out of memory\n"));
4290 goto exit_point;
4291 }
4292
4293 for (j = 0, psym = isyms; j < number; j++, psym++)
4294 {
4295 psym->st_name = BYTE_GET (esyms[j].st_name);
4296 psym->st_value = BYTE_GET (esyms[j].st_value);
4297 psym->st_size = BYTE_GET (esyms[j].st_size);
4298 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4299 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4300 psym->st_shndx
4301 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4302 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4303 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4304 psym->st_info = BYTE_GET (esyms[j].st_info);
4305 psym->st_other = BYTE_GET (esyms[j].st_other);
4306 }
4307
4308 exit_point:
4309 if (shndx != NULL)
4310 free (shndx);
4311 if (esyms != NULL)
4312 free (esyms);
4313
4314 if (num_syms_return != NULL)
4315 * num_syms_return = isyms == NULL ? 0 : number;
4316
4317 return isyms;
4318}
4319
4320static Elf_Internal_Sym *
4321get_64bit_elf_symbols (FILE * file,
4322 Elf_Internal_Shdr * section,
4323 unsigned long * num_syms_return)
4324{
4325 unsigned long number = 0;
4326 Elf64_External_Sym * esyms = NULL;
4327 Elf_External_Sym_Shndx * shndx = NULL;
4328 Elf_Internal_Sym * isyms = NULL;
4329 Elf_Internal_Sym * psym;
4330 unsigned int j;
4331
4332 /* Run some sanity checks first. */
4333 if (section->sh_entsize == 0)
4334 {
4335 error (_("sh_entsize is zero\n"));
4336 goto exit_point;
4337 }
4338
4339 number = section->sh_size / section->sh_entsize;
4340
4341 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4342 {
4343 error (_("Invalid sh_entsize\n"));
4344 goto exit_point;
4345 }
4346
4347 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4348 section->sh_size, _("symbols"));
4349 if (!esyms)
4350 goto exit_point;
4351
4352 if (symtab_shndx_hdr != NULL
4353 && (symtab_shndx_hdr->sh_link
4354 == (unsigned long) (section - section_headers)))
4355 {
4356 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4357 symtab_shndx_hdr->sh_offset,
4358 1, symtab_shndx_hdr->sh_size,
4359 _("symbol table section indicies"));
4360 if (shndx == NULL)
4361 goto exit_point;
4362 }
4363
4364 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4365
4366 if (isyms == NULL)
4367 {
4368 error (_("Out of memory\n"));
4369 goto exit_point;
4370 }
4371
4372 for (j = 0, psym = isyms; j < number; j++, psym++)
4373 {
4374 psym->st_name = BYTE_GET (esyms[j].st_name);
4375 psym->st_info = BYTE_GET (esyms[j].st_info);
4376 psym->st_other = BYTE_GET (esyms[j].st_other);
4377 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4378
4379 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4380 psym->st_shndx
4381 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4382 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4383 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4384
4385 psym->st_value = BYTE_GET (esyms[j].st_value);
4386 psym->st_size = BYTE_GET (esyms[j].st_size);
4387 }
4388
4389 exit_point:
4390 if (shndx != NULL)
4391 free (shndx);
4392 if (esyms != NULL)
4393 free (esyms);
4394
4395 if (num_syms_return != NULL)
4396 * num_syms_return = isyms == NULL ? 0 : number;
4397
4398 return isyms;
4399}
4400
4401static const char *
4402get_elf_section_flags (bfd_vma sh_flags)
4403{
4404 static char buff[1024];
4405 char * p = buff;
4406 int field_size = is_32bit_elf ? 8 : 16;
4407 int sindex;
4408 int size = sizeof (buff) - (field_size + 4 + 1);
4409 bfd_vma os_flags = 0;
4410 bfd_vma proc_flags = 0;
4411 bfd_vma unknown_flags = 0;
4412 static const struct
4413 {
4414 const char * str;
4415 int len;
4416 }
4417 flags [] =
4418 {
4419 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4420 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4421 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4422 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4423 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4424 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4425 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4426 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4427 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4428 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4429 /* IA-64 specific. */
4430 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4431 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4432 /* IA-64 OpenVMS specific. */
4433 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4434 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4435 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4436 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4437 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4438 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4439 /* Generic. */
4440 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4441 /* SPARC specific. */
4442 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4443 };
4444
4445 if (do_section_details)
4446 {
4447 sprintf (buff, "[%*.*lx]: ",
4448 field_size, field_size, (unsigned long) sh_flags);
4449 p += field_size + 4;
4450 }
4451
4452 while (sh_flags)
4453 {
4454 bfd_vma flag;
4455
4456 flag = sh_flags & - sh_flags;
4457 sh_flags &= ~ flag;
4458
4459 if (do_section_details)
4460 {
4461 switch (flag)
4462 {
4463 case SHF_WRITE: sindex = 0; break;
4464 case SHF_ALLOC: sindex = 1; break;
4465 case SHF_EXECINSTR: sindex = 2; break;
4466 case SHF_MERGE: sindex = 3; break;
4467 case SHF_STRINGS: sindex = 4; break;
4468 case SHF_INFO_LINK: sindex = 5; break;
4469 case SHF_LINK_ORDER: sindex = 6; break;
4470 case SHF_OS_NONCONFORMING: sindex = 7; break;
4471 case SHF_GROUP: sindex = 8; break;
4472 case SHF_TLS: sindex = 9; break;
4473 case SHF_EXCLUDE: sindex = 18; break;
4474
4475 default:
4476 sindex = -1;
4477 switch (elf_header.e_machine)
4478 {
4479 case EM_IA_64:
4480 if (flag == SHF_IA_64_SHORT)
4481 sindex = 10;
4482 else if (flag == SHF_IA_64_NORECOV)
4483 sindex = 11;
4484#ifdef BFD64
4485 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4486 switch (flag)
4487 {
4488 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4489 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4490 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4491 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4492 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4493 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4494 default: break;
4495 }
4496#endif
4497 break;
4498
4499 case EM_386:
4500 case EM_486:
4501 case EM_X86_64:
4502 case EM_L1OM:
4503 case EM_K1OM:
4504 case EM_OLD_SPARCV9:
4505 case EM_SPARC32PLUS:
4506 case EM_SPARCV9:
4507 case EM_SPARC:
4508 if (flag == SHF_ORDERED)
4509 sindex = 19;
4510 break;
4511 default:
4512 break;
4513 }
4514 }
4515
4516 if (sindex != -1)
4517 {
4518 if (p != buff + field_size + 4)
4519 {
4520 if (size < (10 + 2))
4521 abort ();
4522 size -= 2;
4523 *p++ = ',';
4524 *p++ = ' ';
4525 }
4526
4527 size -= flags [sindex].len;
4528 p = stpcpy (p, flags [sindex].str);
4529 }
4530 else if (flag & SHF_MASKOS)
4531 os_flags |= flag;
4532 else if (flag & SHF_MASKPROC)
4533 proc_flags |= flag;
4534 else
4535 unknown_flags |= flag;
4536 }
4537 else
4538 {
4539 switch (flag)
4540 {
4541 case SHF_WRITE: *p = 'W'; break;
4542 case SHF_ALLOC: *p = 'A'; break;
4543 case SHF_EXECINSTR: *p = 'X'; break;
4544 case SHF_MERGE: *p = 'M'; break;
4545 case SHF_STRINGS: *p = 'S'; break;
4546 case SHF_INFO_LINK: *p = 'I'; break;
4547 case SHF_LINK_ORDER: *p = 'L'; break;
4548 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4549 case SHF_GROUP: *p = 'G'; break;
4550 case SHF_TLS: *p = 'T'; break;
4551 case SHF_EXCLUDE: *p = 'E'; break;
4552
4553 default:
4554 if ((elf_header.e_machine == EM_X86_64
4555 || elf_header.e_machine == EM_L1OM
4556 || elf_header.e_machine == EM_K1OM)
4557 && flag == SHF_X86_64_LARGE)
4558 *p = 'l';
4559 else if (flag & SHF_MASKOS)
4560 {
4561 *p = 'o';
4562 sh_flags &= ~ SHF_MASKOS;
4563 }
4564 else if (flag & SHF_MASKPROC)
4565 {
4566 *p = 'p';
4567 sh_flags &= ~ SHF_MASKPROC;
4568 }
4569 else
4570 *p = 'x';
4571 break;
4572 }
4573 p++;
4574 }
4575 }
4576
4577 if (do_section_details)
4578 {
4579 if (os_flags)
4580 {
4581 size -= 5 + field_size;
4582 if (p != buff + field_size + 4)
4583 {
4584 if (size < (2 + 1))
4585 abort ();
4586 size -= 2;
4587 *p++ = ',';
4588 *p++ = ' ';
4589 }
4590 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4591 (unsigned long) os_flags);
4592 p += 5 + field_size;
4593 }
4594 if (proc_flags)
4595 {
4596 size -= 7 + field_size;
4597 if (p != buff + field_size + 4)
4598 {
4599 if (size < (2 + 1))
4600 abort ();
4601 size -= 2;
4602 *p++ = ',';
4603 *p++ = ' ';
4604 }
4605 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4606 (unsigned long) proc_flags);
4607 p += 7 + field_size;
4608 }
4609 if (unknown_flags)
4610 {
4611 size -= 10 + field_size;
4612 if (p != buff + field_size + 4)
4613 {
4614 if (size < (2 + 1))
4615 abort ();
4616 size -= 2;
4617 *p++ = ',';
4618 *p++ = ' ';
4619 }
4620 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4621 (unsigned long) unknown_flags);
4622 p += 10 + field_size;
4623 }
4624 }
4625
4626 *p = '\0';
4627 return buff;
4628}
4629
4630static int
4631process_section_headers (FILE * file)
4632{
4633 Elf_Internal_Shdr * section;
4634 unsigned int i;
4635
4636 section_headers = NULL;
4637
4638 if (elf_header.e_shnum == 0)
4639 {
4640 /* PR binutils/12467. */
4641 if (elf_header.e_shoff != 0)
4642 warn (_("possibly corrupt ELF file header - it has a non-zero"
4643 " section header offset, but no section headers\n"));
4644 else if (do_sections)
4645 printf (_("\nThere are no sections in this file.\n"));
4646
4647 return 1;
4648 }
4649
4650 if (do_sections && !do_header)
4651 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4652 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4653
4654 if (is_32bit_elf)
4655 {
4656 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4657 return 0;
4658 }
4659 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4660 return 0;
4661
4662 /* Read in the string table, so that we have names to display. */
4663 if (elf_header.e_shstrndx != SHN_UNDEF
4664 && elf_header.e_shstrndx < elf_header.e_shnum)
4665 {
4666 section = section_headers + elf_header.e_shstrndx;
4667
4668 if (section->sh_size != 0)
4669 {
4670 string_table = (char *) get_data (NULL, file, section->sh_offset,
4671 1, section->sh_size,
4672 _("string table"));
4673
4674 string_table_length = string_table != NULL ? section->sh_size : 0;
4675 }
4676 }
4677
4678 /* Scan the sections for the dynamic symbol table
4679 and dynamic string table and debug sections. */
4680 dynamic_symbols = NULL;
4681 dynamic_strings = NULL;
4682 dynamic_syminfo = NULL;
4683 symtab_shndx_hdr = NULL;
4684
4685 eh_addr_size = is_32bit_elf ? 4 : 8;
4686 switch (elf_header.e_machine)
4687 {
4688 case EM_MIPS:
4689 case EM_MIPS_RS3_LE:
4690 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4691 FDE addresses. However, the ABI also has a semi-official ILP32
4692 variant for which the normal FDE address size rules apply.
4693
4694 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4695 section, where XX is the size of longs in bits. Unfortunately,
4696 earlier compilers provided no way of distinguishing ILP32 objects
4697 from LP64 objects, so if there's any doubt, we should assume that
4698 the official LP64 form is being used. */
4699 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4700 && find_section (".gcc_compiled_long32") == NULL)
4701 eh_addr_size = 8;
4702 break;
4703
4704 case EM_H8_300:
4705 case EM_H8_300H:
4706 switch (elf_header.e_flags & EF_H8_MACH)
4707 {
4708 case E_H8_MACH_H8300:
4709 case E_H8_MACH_H8300HN:
4710 case E_H8_MACH_H8300SN:
4711 case E_H8_MACH_H8300SXN:
4712 eh_addr_size = 2;
4713 break;
4714 case E_H8_MACH_H8300H:
4715 case E_H8_MACH_H8300S:
4716 case E_H8_MACH_H8300SX:
4717 eh_addr_size = 4;
4718 break;
4719 }
4720 break;
4721
4722 case EM_M32C_OLD:
4723 case EM_M32C:
4724 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4725 {
4726 case EF_M32C_CPU_M16C:
4727 eh_addr_size = 2;
4728 break;
4729 }
4730 break;
4731 }
4732
4733#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4734 do \
4735 { \
4736 size_t expected_entsize \
4737 = is_32bit_elf ? size32 : size64; \
4738 if (section->sh_entsize != expected_entsize) \
4739 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4740 i, (unsigned long int) section->sh_entsize, \
4741 (unsigned long int) expected_entsize); \
4742 section->sh_entsize = expected_entsize; \
4743 } \
4744 while (0)
4745#define CHECK_ENTSIZE(section, i, type) \
4746 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4747 sizeof (Elf64_External_##type))
4748
4749 for (i = 0, section = section_headers;
4750 i < elf_header.e_shnum;
4751 i++, section++)
4752 {
4753 char * name = SECTION_NAME (section);
4754
4755 if (section->sh_type == SHT_DYNSYM)
4756 {
4757 if (dynamic_symbols != NULL)
4758 {
4759 error (_("File contains multiple dynamic symbol tables\n"));
4760 continue;
4761 }
4762
4763 CHECK_ENTSIZE (section, i, Sym);
4764 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
4765 }
4766 else if (section->sh_type == SHT_STRTAB
4767 && streq (name, ".dynstr"))
4768 {
4769 if (dynamic_strings != NULL)
4770 {
4771 error (_("File contains multiple dynamic string tables\n"));
4772 continue;
4773 }
4774
4775 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4776 1, section->sh_size,
4777 _("dynamic strings"));
4778 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4779 }
4780 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4781 {
4782 if (symtab_shndx_hdr != NULL)
4783 {
4784 error (_("File contains multiple symtab shndx tables\n"));
4785 continue;
4786 }
4787 symtab_shndx_hdr = section;
4788 }
4789 else if (section->sh_type == SHT_SYMTAB)
4790 CHECK_ENTSIZE (section, i, Sym);
4791 else if (section->sh_type == SHT_GROUP)
4792 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4793 else if (section->sh_type == SHT_REL)
4794 CHECK_ENTSIZE (section, i, Rel);
4795 else if (section->sh_type == SHT_RELA)
4796 CHECK_ENTSIZE (section, i, Rela);
4797 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4798 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4799 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4800 || do_debug_str || do_debug_loc || do_debug_ranges
4801 || do_debug_addr || do_debug_cu_index)
4802 && (const_strneq (name, ".debug_")
4803 || const_strneq (name, ".zdebug_")))
4804 {
4805 if (name[1] == 'z')
4806 name += sizeof (".zdebug_") - 1;
4807 else
4808 name += sizeof (".debug_") - 1;
4809
4810 if (do_debugging
4811 || (do_debug_info && const_strneq (name, "info"))
4812 || (do_debug_info && const_strneq (name, "types"))
4813 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
4814 || (do_debug_lines && const_strneq (name, "line"))
4815 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4816 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4817 || (do_debug_aranges && const_strneq (name, "aranges"))
4818 || (do_debug_ranges && const_strneq (name, "ranges"))
4819 || (do_debug_frames && const_strneq (name, "frame"))
4820 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4821 || (do_debug_macinfo && const_strneq (name, "macro"))
4822 || (do_debug_str && const_strneq (name, "str"))
4823 || (do_debug_loc && const_strneq (name, "loc"))
4824 || (do_debug_addr && const_strneq (name, "addr"))
4825 || (do_debug_cu_index && const_strneq (name, "cu_index"))
4826 || (do_debug_cu_index && const_strneq (name, "tu_index"))
4827 )
4828 request_dump_bynumber (i, DEBUG_DUMP);
4829 }
4830 /* Linkonce section to be combined with .debug_info at link time. */
4831 else if ((do_debugging || do_debug_info)
4832 && const_strneq (name, ".gnu.linkonce.wi."))
4833 request_dump_bynumber (i, DEBUG_DUMP);
4834 else if (do_debug_frames && streq (name, ".eh_frame"))
4835 request_dump_bynumber (i, DEBUG_DUMP);
4836 else if (do_gdb_index && streq (name, ".gdb_index"))
4837 request_dump_bynumber (i, DEBUG_DUMP);
4838 /* Trace sections for Itanium VMS. */
4839 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4840 || do_trace_aranges)
4841 && const_strneq (name, ".trace_"))
4842 {
4843 name += sizeof (".trace_") - 1;
4844
4845 if (do_debugging
4846 || (do_trace_info && streq (name, "info"))
4847 || (do_trace_abbrevs && streq (name, "abbrev"))
4848 || (do_trace_aranges && streq (name, "aranges"))
4849 )
4850 request_dump_bynumber (i, DEBUG_DUMP);
4851 }
4852
4853 }
4854
4855 if (! do_sections)
4856 return 1;
4857
4858 if (elf_header.e_shnum > 1)
4859 printf (_("\nSection Headers:\n"));
4860 else
4861 printf (_("\nSection Header:\n"));
4862
4863 if (is_32bit_elf)
4864 {
4865 if (do_section_details)
4866 {
4867 printf (_(" [Nr] Name\n"));
4868 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4869 }
4870 else
4871 printf
4872 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4873 }
4874 else if (do_wide)
4875 {
4876 if (do_section_details)
4877 {
4878 printf (_(" [Nr] Name\n"));
4879 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4880 }
4881 else
4882 printf
4883 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4884 }
4885 else
4886 {
4887 if (do_section_details)
4888 {
4889 printf (_(" [Nr] Name\n"));
4890 printf (_(" Type Address Offset Link\n"));
4891 printf (_(" Size EntSize Info Align\n"));
4892 }
4893 else
4894 {
4895 printf (_(" [Nr] Name Type Address Offset\n"));
4896 printf (_(" Size EntSize Flags Link Info Align\n"));
4897 }
4898 }
4899
4900 if (do_section_details)
4901 printf (_(" Flags\n"));
4902
4903 for (i = 0, section = section_headers;
4904 i < elf_header.e_shnum;
4905 i++, section++)
4906 {
4907 printf (" [%2u] ", i);
4908 if (do_section_details)
4909 {
4910 print_symbol (INT_MAX, SECTION_NAME (section));
4911 printf ("\n ");
4912 }
4913 else
4914 {
4915 print_symbol (-17, SECTION_NAME (section));
4916 }
4917
4918 printf (do_wide ? " %-15s " : " %-15.15s ",
4919 get_section_type_name (section->sh_type));
4920
4921 if (is_32bit_elf)
4922 {
4923 const char * link_too_big = NULL;
4924
4925 print_vma (section->sh_addr, LONG_HEX);
4926
4927 printf ( " %6.6lx %6.6lx %2.2lx",
4928 (unsigned long) section->sh_offset,
4929 (unsigned long) section->sh_size,
4930 (unsigned long) section->sh_entsize);
4931
4932 if (do_section_details)
4933 fputs (" ", stdout);
4934 else
4935 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4936
4937 if (section->sh_link >= elf_header.e_shnum)
4938 {
4939 link_too_big = "";
4940 /* The sh_link value is out of range. Normally this indicates
4941 an error but it can have special values in Solaris binaries. */
4942 switch (elf_header.e_machine)
4943 {
4944 case EM_386:
4945 case EM_486:
4946 case EM_X86_64:
4947 case EM_L1OM:
4948 case EM_K1OM:
4949 case EM_OLD_SPARCV9:
4950 case EM_SPARC32PLUS:
4951 case EM_SPARCV9:
4952 case EM_SPARC:
4953 if (section->sh_link == (SHN_BEFORE & 0xffff))
4954 link_too_big = "BEFORE";
4955 else if (section->sh_link == (SHN_AFTER & 0xffff))
4956 link_too_big = "AFTER";
4957 break;
4958 default:
4959 break;
4960 }
4961 }
4962
4963 if (do_section_details)
4964 {
4965 if (link_too_big != NULL && * link_too_big)
4966 printf ("<%s> ", link_too_big);
4967 else
4968 printf ("%2u ", section->sh_link);
4969 printf ("%3u %2lu\n", section->sh_info,
4970 (unsigned long) section->sh_addralign);
4971 }
4972 else
4973 printf ("%2u %3u %2lu\n",
4974 section->sh_link,
4975 section->sh_info,
4976 (unsigned long) section->sh_addralign);
4977
4978 if (link_too_big && ! * link_too_big)
4979 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4980 i, section->sh_link);
4981 }
4982 else if (do_wide)
4983 {
4984 print_vma (section->sh_addr, LONG_HEX);
4985
4986 if ((long) section->sh_offset == section->sh_offset)
4987 printf (" %6.6lx", (unsigned long) section->sh_offset);
4988 else
4989 {
4990 putchar (' ');
4991 print_vma (section->sh_offset, LONG_HEX);
4992 }
4993
4994 if ((unsigned long) section->sh_size == section->sh_size)
4995 printf (" %6.6lx", (unsigned long) section->sh_size);
4996 else
4997 {
4998 putchar (' ');
4999 print_vma (section->sh_size, LONG_HEX);
5000 }
5001
5002 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5003 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5004 else
5005 {
5006 putchar (' ');
5007 print_vma (section->sh_entsize, LONG_HEX);
5008 }
5009
5010 if (do_section_details)
5011 fputs (" ", stdout);
5012 else
5013 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5014
5015 printf ("%2u %3u ", section->sh_link, section->sh_info);
5016
5017 if ((unsigned long) section->sh_addralign == section->sh_addralign)
5018 printf ("%2lu\n", (unsigned long) section->sh_addralign);
5019 else
5020 {
5021 print_vma (section->sh_addralign, DEC);
5022 putchar ('\n');
5023 }
5024 }
5025 else if (do_section_details)
5026 {
5027 printf (" %-15.15s ",
5028 get_section_type_name (section->sh_type));
5029 print_vma (section->sh_addr, LONG_HEX);
5030 if ((long) section->sh_offset == section->sh_offset)
5031 printf (" %16.16lx", (unsigned long) section->sh_offset);
5032 else
5033 {
5034 printf (" ");
5035 print_vma (section->sh_offset, LONG_HEX);
5036 }
5037 printf (" %u\n ", section->sh_link);
5038 print_vma (section->sh_size, LONG_HEX);
5039 putchar (' ');
5040 print_vma (section->sh_entsize, LONG_HEX);
5041
5042 printf (" %-16u %lu\n",
5043 section->sh_info,
5044 (unsigned long) section->sh_addralign);
5045 }
5046 else
5047 {
5048 putchar (' ');
5049 print_vma (section->sh_addr, LONG_HEX);
5050 if ((long) section->sh_offset == section->sh_offset)
5051 printf (" %8.8lx", (unsigned long) section->sh_offset);
5052 else
5053 {
5054 printf (" ");
5055 print_vma (section->sh_offset, LONG_HEX);
5056 }
5057 printf ("\n ");
5058 print_vma (section->sh_size, LONG_HEX);
5059 printf (" ");
5060 print_vma (section->sh_entsize, LONG_HEX);
5061
5062 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5063
5064 printf (" %2u %3u %lu\n",
5065 section->sh_link,
5066 section->sh_info,
5067 (unsigned long) section->sh_addralign);
5068 }
5069
5070 if (do_section_details)
5071 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5072 }
5073
5074 if (!do_section_details)
5075 {
5076 if (elf_header.e_machine == EM_X86_64
5077 || elf_header.e_machine == EM_L1OM
5078 || elf_header.e_machine == EM_K1OM)
5079 printf (_("Key to Flags:\n\
5080 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5081 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5082 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5083 else
5084 printf (_("Key to Flags:\n\
5085 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5086 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5087 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5088 }
5089
5090 return 1;
5091}
5092
5093static const char *
5094get_group_flags (unsigned int flags)
5095{
5096 static char buff[32];
5097 switch (flags)
5098 {
5099 case 0:
5100 return "";
5101
5102 case GRP_COMDAT:
5103 return "COMDAT ";
5104
5105 default:
5106 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5107 break;
5108 }
5109 return buff;
5110}
5111
5112static int
5113process_section_groups (FILE * file)
5114{
5115 Elf_Internal_Shdr * section;
5116 unsigned int i;
5117 struct group * group;
5118 Elf_Internal_Shdr * symtab_sec;
5119 Elf_Internal_Shdr * strtab_sec;
5120 Elf_Internal_Sym * symtab;
5121 unsigned long num_syms;
5122 char * strtab;
5123 size_t strtab_size;
5124
5125 /* Don't process section groups unless needed. */
5126 if (!do_unwind && !do_section_groups)
5127 return 1;
5128
5129 if (elf_header.e_shnum == 0)
5130 {
5131 if (do_section_groups)
5132 printf (_("\nThere are no sections to group in this file.\n"));
5133
5134 return 1;
5135 }
5136
5137 if (section_headers == NULL)
5138 {
5139 error (_("Section headers are not available!\n"));
5140 /* PR 13622: This can happen with a corrupt ELF header. */
5141 return 0;
5142 }
5143
5144 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5145 sizeof (struct group *));
5146
5147 if (section_headers_groups == NULL)
5148 {
5149 error (_("Out of memory\n"));
5150 return 0;
5151 }
5152
5153 /* Scan the sections for the group section. */
5154 group_count = 0;
5155 for (i = 0, section = section_headers;
5156 i < elf_header.e_shnum;
5157 i++, section++)
5158 if (section->sh_type == SHT_GROUP)
5159 group_count++;
5160
5161 if (group_count == 0)
5162 {
5163 if (do_section_groups)
5164 printf (_("\nThere are no section groups in this file.\n"));
5165
5166 return 1;
5167 }
5168
5169 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5170
5171 if (section_groups == NULL)
5172 {
5173 error (_("Out of memory\n"));
5174 return 0;
5175 }
5176
5177 symtab_sec = NULL;
5178 strtab_sec = NULL;
5179 symtab = NULL;
5180 num_syms = 0;
5181 strtab = NULL;
5182 strtab_size = 0;
5183 for (i = 0, section = section_headers, group = section_groups;
5184 i < elf_header.e_shnum;
5185 i++, section++)
5186 {
5187 if (section->sh_type == SHT_GROUP)
5188 {
5189 char * name = SECTION_NAME (section);
5190 char * group_name;
5191 unsigned char * start;
5192 unsigned char * indices;
5193 unsigned int entry, j, size;
5194 Elf_Internal_Shdr * sec;
5195 Elf_Internal_Sym * sym;
5196
5197 /* Get the symbol table. */
5198 if (section->sh_link >= elf_header.e_shnum
5199 || ((sec = section_headers + section->sh_link)->sh_type
5200 != SHT_SYMTAB))
5201 {
5202 error (_("Bad sh_link in group section `%s'\n"), name);
5203 continue;
5204 }
5205
5206 if (symtab_sec != sec)
5207 {
5208 symtab_sec = sec;
5209 if (symtab)
5210 free (symtab);
5211 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5212 }
5213
5214 if (symtab == NULL)
5215 {
5216 error (_("Corrupt header in group section `%s'\n"), name);
5217 continue;
5218 }
5219
5220 if (section->sh_info >= num_syms)
5221 {
5222 error (_("Bad sh_info in group section `%s'\n"), name);
5223 continue;
5224 }
5225
5226 sym = symtab + section->sh_info;
5227
5228 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5229 {
5230 if (sym->st_shndx == 0
5231 || sym->st_shndx >= elf_header.e_shnum)
5232 {
5233 error (_("Bad sh_info in group section `%s'\n"), name);
5234 continue;
5235 }
5236
5237 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5238 strtab_sec = NULL;
5239 if (strtab)
5240 free (strtab);
5241 strtab = NULL;
5242 strtab_size = 0;
5243 }
5244 else
5245 {
5246 /* Get the string table. */
5247 if (symtab_sec->sh_link >= elf_header.e_shnum)
5248 {
5249 strtab_sec = NULL;
5250 if (strtab)
5251 free (strtab);
5252 strtab = NULL;
5253 strtab_size = 0;
5254 }
5255 else if (strtab_sec
5256 != (sec = section_headers + symtab_sec->sh_link))
5257 {
5258 strtab_sec = sec;
5259 if (strtab)
5260 free (strtab);
5261 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5262 1, strtab_sec->sh_size,
5263 _("string table"));
5264 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5265 }
5266 group_name = sym->st_name < strtab_size
5267 ? strtab + sym->st_name : _("<corrupt>");
5268 }
5269
5270 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5271 1, section->sh_size,
5272 _("section data"));
5273 if (start == NULL)
5274 continue;
5275
5276 indices = start;
5277 size = (section->sh_size / section->sh_entsize) - 1;
5278 entry = byte_get (indices, 4);
5279 indices += 4;
5280
5281 if (do_section_groups)
5282 {
5283 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5284 get_group_flags (entry), i, name, group_name, size);
5285
5286 printf (_(" [Index] Name\n"));
5287 }
5288
5289 group->group_index = i;
5290
5291 for (j = 0; j < size; j++)
5292 {
5293 struct group_list * g;
5294
5295 entry = byte_get (indices, 4);
5296 indices += 4;
5297
5298 if (entry >= elf_header.e_shnum)
5299 {
5300 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5301 entry, i, elf_header.e_shnum - 1);
5302 continue;
5303 }
5304
5305 if (section_headers_groups [entry] != NULL)
5306 {
5307 if (entry)
5308 {
5309 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5310 entry, i,
5311 section_headers_groups [entry]->group_index);
5312 continue;
5313 }
5314 else
5315 {
5316 /* Intel C/C++ compiler may put section 0 in a
5317 section group. We just warn it the first time
5318 and ignore it afterwards. */
5319 static int warned = 0;
5320 if (!warned)
5321 {
5322 error (_("section 0 in group section [%5u]\n"),
5323 section_headers_groups [entry]->group_index);
5324 warned++;
5325 }
5326 }
5327 }
5328
5329 section_headers_groups [entry] = group;
5330
5331 if (do_section_groups)
5332 {
5333 sec = section_headers + entry;
5334 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5335 }
5336
5337 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5338 g->section_index = entry;
5339 g->next = group->root;
5340 group->root = g;
5341 }
5342
5343 if (start)
5344 free (start);
5345
5346 group++;
5347 }
5348 }
5349
5350 if (symtab)
5351 free (symtab);
5352 if (strtab)
5353 free (strtab);
5354 return 1;
5355}
5356
5357/* Data used to display dynamic fixups. */
5358
5359struct ia64_vms_dynfixup
5360{
5361 bfd_vma needed_ident; /* Library ident number. */
5362 bfd_vma needed; /* Index in the dstrtab of the library name. */
5363 bfd_vma fixup_needed; /* Index of the library. */
5364 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5365 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5366};
5367
5368/* Data used to display dynamic relocations. */
5369
5370struct ia64_vms_dynimgrela
5371{
5372 bfd_vma img_rela_cnt; /* Number of relocations. */
5373 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5374};
5375
5376/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5377 library). */
5378
5379static void
5380dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5381 const char *strtab, unsigned int strtab_sz)
5382{
5383 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5384 long i;
5385 const char *lib_name;
5386
5387 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5388 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5389 _("dynamic section image fixups"));
5390 if (!imfs)
5391 return;
5392
5393 if (fixup->needed < strtab_sz)
5394 lib_name = strtab + fixup->needed;
5395 else
5396 {
5397 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5398 (unsigned long) fixup->needed);
5399 lib_name = "???";
5400 }
5401 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5402 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5403 printf
5404 (_("Seg Offset Type SymVec DataType\n"));
5405
5406 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5407 {
5408 unsigned int type;
5409 const char *rtype;
5410
5411 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5412 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5413 type = BYTE_GET (imfs [i].type);
5414 rtype = elf_ia64_reloc_type (type);
5415 if (rtype == NULL)
5416 printf (" 0x%08x ", type);
5417 else
5418 printf (" %-32s ", rtype);
5419 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5420 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5421 }
5422
5423 free (imfs);
5424}
5425
5426/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5427
5428static void
5429dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5430{
5431 Elf64_External_VMS_IMAGE_RELA *imrs;
5432 long i;
5433
5434 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5435 1, imgrela->img_rela_cnt * sizeof (*imrs),
5436 _("dynamic section image relocations"));
5437 if (!imrs)
5438 return;
5439
5440 printf (_("\nImage relocs\n"));
5441 printf
5442 (_("Seg Offset Type Addend Seg Sym Off\n"));
5443
5444 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5445 {
5446 unsigned int type;
5447 const char *rtype;
5448
5449 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5450 printf ("%08" BFD_VMA_FMT "x ",
5451 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5452 type = BYTE_GET (imrs [i].type);
5453 rtype = elf_ia64_reloc_type (type);
5454 if (rtype == NULL)
5455 printf ("0x%08x ", type);
5456 else
5457 printf ("%-31s ", rtype);
5458 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5459 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5460 printf ("%08" BFD_VMA_FMT "x\n",
5461 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5462 }
5463
5464 free (imrs);
5465}
5466
5467/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5468
5469static int
5470process_ia64_vms_dynamic_relocs (FILE *file)
5471{
5472 struct ia64_vms_dynfixup fixup;
5473 struct ia64_vms_dynimgrela imgrela;
5474 Elf_Internal_Dyn *entry;
5475 int res = 0;
5476 bfd_vma strtab_off = 0;
5477 bfd_vma strtab_sz = 0;
5478 char *strtab = NULL;
5479
5480 memset (&fixup, 0, sizeof (fixup));
5481 memset (&imgrela, 0, sizeof (imgrela));
5482
5483 /* Note: the order of the entries is specified by the OpenVMS specs. */
5484 for (entry = dynamic_section;
5485 entry < dynamic_section + dynamic_nent;
5486 entry++)
5487 {
5488 switch (entry->d_tag)
5489 {
5490 case DT_IA_64_VMS_STRTAB_OFFSET:
5491 strtab_off = entry->d_un.d_val;
5492 break;
5493 case DT_STRSZ:
5494 strtab_sz = entry->d_un.d_val;
5495 if (strtab == NULL)
5496 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5497 1, strtab_sz, _("dynamic string section"));
5498 break;
5499
5500 case DT_IA_64_VMS_NEEDED_IDENT:
5501 fixup.needed_ident = entry->d_un.d_val;
5502 break;
5503 case DT_NEEDED:
5504 fixup.needed = entry->d_un.d_val;
5505 break;
5506 case DT_IA_64_VMS_FIXUP_NEEDED:
5507 fixup.fixup_needed = entry->d_un.d_val;
5508 break;
5509 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5510 fixup.fixup_rela_cnt = entry->d_un.d_val;
5511 break;
5512 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5513 fixup.fixup_rela_off = entry->d_un.d_val;
5514 res++;
5515 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5516 break;
5517
5518 case DT_IA_64_VMS_IMG_RELA_CNT:
5519 imgrela.img_rela_cnt = entry->d_un.d_val;
5520 break;
5521 case DT_IA_64_VMS_IMG_RELA_OFF:
5522 imgrela.img_rela_off = entry->d_un.d_val;
5523 res++;
5524 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5525 break;
5526
5527 default:
5528 break;
5529 }
5530 }
5531
5532 if (strtab != NULL)
5533 free (strtab);
5534
5535 return res;
5536}
5537
5538static struct
5539{
5540 const char * name;
5541 int reloc;
5542 int size;
5543 int rela;
5544} dynamic_relocations [] =
5545{
5546 { "REL", DT_REL, DT_RELSZ, FALSE },
5547 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5548 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5549};
5550
5551/* Process the reloc section. */
5552
5553static int
5554process_relocs (FILE * file)
5555{
5556 unsigned long rel_size;
5557 unsigned long rel_offset;
5558
5559
5560 if (!do_reloc)
5561 return 1;
5562
5563 if (do_using_dynamic)
5564 {
5565 int is_rela;
5566 const char * name;
5567 int has_dynamic_reloc;
5568 unsigned int i;
5569
5570 has_dynamic_reloc = 0;
5571
5572 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5573 {
5574 is_rela = dynamic_relocations [i].rela;
5575 name = dynamic_relocations [i].name;
5576 rel_size = dynamic_info [dynamic_relocations [i].size];
5577 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5578
5579 has_dynamic_reloc |= rel_size;
5580
5581 if (is_rela == UNKNOWN)
5582 {
5583 if (dynamic_relocations [i].reloc == DT_JMPREL)
5584 switch (dynamic_info[DT_PLTREL])
5585 {
5586 case DT_REL:
5587 is_rela = FALSE;
5588 break;
5589 case DT_RELA:
5590 is_rela = TRUE;
5591 break;
5592 }
5593 }
5594
5595 if (rel_size)
5596 {
5597 printf
5598 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5599 name, rel_offset, rel_size);
5600
5601 dump_relocations (file,
5602 offset_from_vma (file, rel_offset, rel_size),
5603 rel_size,
5604 dynamic_symbols, num_dynamic_syms,
5605 dynamic_strings, dynamic_strings_length, is_rela);
5606 }
5607 }
5608
5609 if (is_ia64_vms ())
5610 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5611
5612 if (! has_dynamic_reloc)
5613 printf (_("\nThere are no dynamic relocations in this file.\n"));
5614 }
5615 else
5616 {
5617 Elf_Internal_Shdr * section;
5618 unsigned long i;
5619 int found = 0;
5620
5621 for (i = 0, section = section_headers;
5622 i < elf_header.e_shnum;
5623 i++, section++)
5624 {
5625 if ( section->sh_type != SHT_RELA
5626 && section->sh_type != SHT_REL)
5627 continue;
5628
5629 rel_offset = section->sh_offset;
5630 rel_size = section->sh_size;
5631
5632 if (rel_size)
5633 {
5634 Elf_Internal_Shdr * strsec;
5635 int is_rela;
5636
5637 printf (_("\nRelocation section "));
5638
5639 if (string_table == NULL)
5640 printf ("%d", section->sh_name);
5641 else
5642 printf ("'%s'", SECTION_NAME (section));
5643
5644 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5645 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5646
5647 is_rela = section->sh_type == SHT_RELA;
5648
5649 if (section->sh_link != 0
5650 && section->sh_link < elf_header.e_shnum)
5651 {
5652 Elf_Internal_Shdr * symsec;
5653 Elf_Internal_Sym * symtab;
5654 unsigned long nsyms;
5655 unsigned long strtablen = 0;
5656 char * strtab = NULL;
5657
5658 symsec = section_headers + section->sh_link;
5659 if (symsec->sh_type != SHT_SYMTAB
5660 && symsec->sh_type != SHT_DYNSYM)
5661 continue;
5662
5663 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5664
5665 if (symtab == NULL)
5666 continue;
5667
5668 if (symsec->sh_link != 0
5669 && symsec->sh_link < elf_header.e_shnum)
5670 {
5671 strsec = section_headers + symsec->sh_link;
5672
5673 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5674 1, strsec->sh_size,
5675 _("string table"));
5676 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5677 }
5678
5679 dump_relocations (file, rel_offset, rel_size,
5680 symtab, nsyms, strtab, strtablen, is_rela);
5681 if (strtab)
5682 free (strtab);
5683 free (symtab);
5684 }
5685 else
5686 dump_relocations (file, rel_offset, rel_size,
5687 NULL, 0, NULL, 0, is_rela);
5688
5689 found = 1;
5690 }
5691 }
5692
5693 if (! found)
5694 printf (_("\nThere are no relocations in this file.\n"));
5695 }
5696
5697 return 1;
5698}
5699
5700/* Process the unwind section. */
5701
5702#include "unwind-ia64.h"
5703
5704/* An absolute address consists of a section and an offset. If the
5705 section is NULL, the offset itself is the address, otherwise, the
5706 address equals to LOAD_ADDRESS(section) + offset. */
5707
5708struct absaddr
5709 {
5710 unsigned short section;
5711 bfd_vma offset;
5712 };
5713
5714#define ABSADDR(a) \
5715 ((a).section \
5716 ? section_headers [(a).section].sh_addr + (a).offset \
5717 : (a).offset)
5718
5719struct ia64_unw_table_entry
5720 {
5721 struct absaddr start;
5722 struct absaddr end;
5723 struct absaddr info;
5724 };
5725
5726struct ia64_unw_aux_info
5727 {
5728
5729 struct ia64_unw_table_entry *table; /* Unwind table. */
5730 unsigned long table_len; /* Length of unwind table. */
5731 unsigned char * info; /* Unwind info. */
5732 unsigned long info_size; /* Size of unwind info. */
5733 bfd_vma info_addr; /* starting address of unwind info. */
5734 bfd_vma seg_base; /* Starting address of segment. */
5735 Elf_Internal_Sym * symtab; /* The symbol table. */
5736 unsigned long nsyms; /* Number of symbols. */
5737 char * strtab; /* The string table. */
5738 unsigned long strtab_size; /* Size of string table. */
5739 };
5740
5741static void
5742find_symbol_for_address (Elf_Internal_Sym * symtab,
5743 unsigned long nsyms,
5744 const char * strtab,
5745 unsigned long strtab_size,
5746 struct absaddr addr,
5747 const char ** symname,
5748 bfd_vma * offset)
5749{
5750 bfd_vma dist = 0x100000;
5751 Elf_Internal_Sym * sym;
5752 Elf_Internal_Sym * best = NULL;
5753 unsigned long i;
5754
5755 REMOVE_ARCH_BITS (addr.offset);
5756
5757 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5758 {
5759 bfd_vma value = sym->st_value;
5760
5761 REMOVE_ARCH_BITS (value);
5762
5763 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5764 && sym->st_name != 0
5765 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5766 && addr.offset >= value
5767 && addr.offset - value < dist)
5768 {
5769 best = sym;
5770 dist = addr.offset - value;
5771 if (!dist)
5772 break;
5773 }
5774 }
5775
5776 if (best)
5777 {
5778 *symname = (best->st_name >= strtab_size
5779 ? _("<corrupt>") : strtab + best->st_name);
5780 *offset = dist;
5781 return;
5782 }
5783
5784 *symname = NULL;
5785 *offset = addr.offset;
5786}
5787
5788static void
5789dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5790{
5791 struct ia64_unw_table_entry * tp;
5792 int in_body;
5793
5794 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5795 {
5796 bfd_vma stamp;
5797 bfd_vma offset;
5798 const unsigned char * dp;
5799 const unsigned char * head;
5800 const char * procname;
5801
5802 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5803 aux->strtab_size, tp->start, &procname, &offset);
5804
5805 fputs ("\n<", stdout);
5806
5807 if (procname)
5808 {
5809 fputs (procname, stdout);
5810
5811 if (offset)
5812 printf ("+%lx", (unsigned long) offset);
5813 }
5814
5815 fputs (">: [", stdout);
5816 print_vma (tp->start.offset, PREFIX_HEX);
5817 fputc ('-', stdout);
5818 print_vma (tp->end.offset, PREFIX_HEX);
5819 printf ("], info at +0x%lx\n",
5820 (unsigned long) (tp->info.offset - aux->seg_base));
5821
5822 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5823 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5824
5825 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5826 (unsigned) UNW_VER (stamp),
5827 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5828 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5829 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5830 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5831
5832 if (UNW_VER (stamp) != 1)
5833 {
5834 printf (_("\tUnknown version.\n"));
5835 continue;
5836 }
5837
5838 in_body = 0;
5839 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5840 dp = unw_decode (dp, in_body, & in_body);
5841 }
5842}
5843
5844static int
5845slurp_ia64_unwind_table (FILE * file,
5846 struct ia64_unw_aux_info * aux,
5847 Elf_Internal_Shdr * sec)
5848{
5849 unsigned long size, nrelas, i;
5850 Elf_Internal_Phdr * seg;
5851 struct ia64_unw_table_entry * tep;
5852 Elf_Internal_Shdr * relsec;
5853 Elf_Internal_Rela * rela;
5854 Elf_Internal_Rela * rp;
5855 unsigned char * table;
5856 unsigned char * tp;
5857 Elf_Internal_Sym * sym;
5858 const char * relname;
5859
5860 /* First, find the starting address of the segment that includes
5861 this section: */
5862
5863 if (elf_header.e_phnum)
5864 {
5865 if (! get_program_headers (file))
5866 return 0;
5867
5868 for (seg = program_headers;
5869 seg < program_headers + elf_header.e_phnum;
5870 ++seg)
5871 {
5872 if (seg->p_type != PT_LOAD)
5873 continue;
5874
5875 if (sec->sh_addr >= seg->p_vaddr
5876 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5877 {
5878 aux->seg_base = seg->p_vaddr;
5879 break;
5880 }
5881 }
5882 }
5883
5884 /* Second, build the unwind table from the contents of the unwind section: */
5885 size = sec->sh_size;
5886 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5887 _("unwind table"));
5888 if (!table)
5889 return 0;
5890
5891 aux->table = (struct ia64_unw_table_entry *)
5892 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5893 tep = aux->table;
5894 for (tp = table; tp < table + size; ++tep)
5895 {
5896 tep->start.section = SHN_UNDEF;
5897 tep->end.section = SHN_UNDEF;
5898 tep->info.section = SHN_UNDEF;
5899 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5900 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5901 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5902 tep->start.offset += aux->seg_base;
5903 tep->end.offset += aux->seg_base;
5904 tep->info.offset += aux->seg_base;
5905 }
5906 free (table);
5907
5908 /* Third, apply any relocations to the unwind table: */
5909 for (relsec = section_headers;
5910 relsec < section_headers + elf_header.e_shnum;
5911 ++relsec)
5912 {
5913 if (relsec->sh_type != SHT_RELA
5914 || relsec->sh_info >= elf_header.e_shnum
5915 || section_headers + relsec->sh_info != sec)
5916 continue;
5917
5918 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5919 & rela, & nrelas))
5920 return 0;
5921
5922 for (rp = rela; rp < rela + nrelas; ++rp)
5923 {
5924 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5925 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5926
5927 if (! const_strneq (relname, "R_IA64_SEGREL"))
5928 {
5929 warn (_("Skipping unexpected relocation type %s\n"), relname);
5930 continue;
5931 }
5932
5933 i = rp->r_offset / (3 * eh_addr_size);
5934
5935 switch (rp->r_offset/eh_addr_size % 3)
5936 {
5937 case 0:
5938 aux->table[i].start.section = sym->st_shndx;
5939 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5940 break;
5941 case 1:
5942 aux->table[i].end.section = sym->st_shndx;
5943 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5944 break;
5945 case 2:
5946 aux->table[i].info.section = sym->st_shndx;
5947 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5948 break;
5949 default:
5950 break;
5951 }
5952 }
5953
5954 free (rela);
5955 }
5956
5957 aux->table_len = size / (3 * eh_addr_size);
5958 return 1;
5959}
5960
5961static void
5962ia64_process_unwind (FILE * file)
5963{
5964 Elf_Internal_Shdr * sec;
5965 Elf_Internal_Shdr * unwsec = NULL;
5966 Elf_Internal_Shdr * strsec;
5967 unsigned long i, unwcount = 0, unwstart = 0;
5968 struct ia64_unw_aux_info aux;
5969
5970 memset (& aux, 0, sizeof (aux));
5971
5972 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5973 {
5974 if (sec->sh_type == SHT_SYMTAB
5975 && sec->sh_link < elf_header.e_shnum)
5976 {
5977 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
5978
5979 strsec = section_headers + sec->sh_link;
5980 assert (aux.strtab == NULL);
5981 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5982 1, strsec->sh_size,
5983 _("string table"));
5984 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5985 }
5986 else if (sec->sh_type == SHT_IA_64_UNWIND)
5987 unwcount++;
5988 }
5989
5990 if (!unwcount)
5991 printf (_("\nThere are no unwind sections in this file.\n"));
5992
5993 while (unwcount-- > 0)
5994 {
5995 char * suffix;
5996 size_t len, len2;
5997
5998 for (i = unwstart, sec = section_headers + unwstart;
5999 i < elf_header.e_shnum; ++i, ++sec)
6000 if (sec->sh_type == SHT_IA_64_UNWIND)
6001 {
6002 unwsec = sec;
6003 break;
6004 }
6005
6006 unwstart = i + 1;
6007 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6008
6009 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6010 {
6011 /* We need to find which section group it is in. */
6012 struct group_list * g = section_headers_groups [i]->root;
6013
6014 for (; g != NULL; g = g->next)
6015 {
6016 sec = section_headers + g->section_index;
6017
6018 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6019 break;
6020 }
6021
6022 if (g == NULL)
6023 i = elf_header.e_shnum;
6024 }
6025 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6026 {
6027 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6028 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6029 suffix = SECTION_NAME (unwsec) + len;
6030 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6031 ++i, ++sec)
6032 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6033 && streq (SECTION_NAME (sec) + len2, suffix))
6034 break;
6035 }
6036 else
6037 {
6038 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6039 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6040 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6041 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6042 suffix = "";
6043 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6044 suffix = SECTION_NAME (unwsec) + len;
6045 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6046 ++i, ++sec)
6047 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6048 && streq (SECTION_NAME (sec) + len2, suffix))
6049 break;
6050 }
6051
6052 if (i == elf_header.e_shnum)
6053 {
6054 printf (_("\nCould not find unwind info section for "));
6055
6056 if (string_table == NULL)
6057 printf ("%d", unwsec->sh_name);
6058 else
6059 printf (_("'%s'"), SECTION_NAME (unwsec));
6060 }
6061 else
6062 {
6063 aux.info_addr = sec->sh_addr;
6064 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6065 sec->sh_size,
6066 _("unwind info"));
6067 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6068
6069 printf (_("\nUnwind section "));
6070
6071 if (string_table == NULL)
6072 printf ("%d", unwsec->sh_name);
6073 else
6074 printf (_("'%s'"), SECTION_NAME (unwsec));
6075
6076 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6077 (unsigned long) unwsec->sh_offset,
6078 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6079
6080 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6081
6082 if (aux.table_len > 0)
6083 dump_ia64_unwind (& aux);
6084
6085 if (aux.table)
6086 free ((char *) aux.table);
6087 if (aux.info)
6088 free ((char *) aux.info);
6089 aux.table = NULL;
6090 aux.info = NULL;
6091 }
6092 }
6093
6094 if (aux.symtab)
6095 free (aux.symtab);
6096 if (aux.strtab)
6097 free ((char *) aux.strtab);
6098}
6099
6100struct hppa_unw_table_entry
6101 {
6102 struct absaddr start;
6103 struct absaddr end;
6104 unsigned int Cannot_unwind:1; /* 0 */
6105 unsigned int Millicode:1; /* 1 */
6106 unsigned int Millicode_save_sr0:1; /* 2 */
6107 unsigned int Region_description:2; /* 3..4 */
6108 unsigned int reserved1:1; /* 5 */
6109 unsigned int Entry_SR:1; /* 6 */
6110 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6111 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6112 unsigned int Args_stored:1; /* 16 */
6113 unsigned int Variable_Frame:1; /* 17 */
6114 unsigned int Separate_Package_Body:1; /* 18 */
6115 unsigned int Frame_Extension_Millicode:1; /* 19 */
6116 unsigned int Stack_Overflow_Check:1; /* 20 */
6117 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6118 unsigned int Ada_Region:1; /* 22 */
6119 unsigned int cxx_info:1; /* 23 */
6120 unsigned int cxx_try_catch:1; /* 24 */
6121 unsigned int sched_entry_seq:1; /* 25 */
6122 unsigned int reserved2:1; /* 26 */
6123 unsigned int Save_SP:1; /* 27 */
6124 unsigned int Save_RP:1; /* 28 */
6125 unsigned int Save_MRP_in_frame:1; /* 29 */
6126 unsigned int extn_ptr_defined:1; /* 30 */
6127 unsigned int Cleanup_defined:1; /* 31 */
6128
6129 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6130 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6131 unsigned int Large_frame:1; /* 2 */
6132 unsigned int Pseudo_SP_Set:1; /* 3 */
6133 unsigned int reserved4:1; /* 4 */
6134 unsigned int Total_frame_size:27; /* 5..31 */
6135 };
6136
6137struct hppa_unw_aux_info
6138 {
6139 struct hppa_unw_table_entry *table; /* Unwind table. */
6140 unsigned long table_len; /* Length of unwind table. */
6141 bfd_vma seg_base; /* Starting address of segment. */
6142 Elf_Internal_Sym * symtab; /* The symbol table. */
6143 unsigned long nsyms; /* Number of symbols. */
6144 char * strtab; /* The string table. */
6145 unsigned long strtab_size; /* Size of string table. */
6146 };
6147
6148static void
6149dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6150{
6151 struct hppa_unw_table_entry * tp;
6152
6153 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6154 {
6155 bfd_vma offset;
6156 const char * procname;
6157
6158 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6159 aux->strtab_size, tp->start, &procname,
6160 &offset);
6161
6162 fputs ("\n<", stdout);
6163
6164 if (procname)
6165 {
6166 fputs (procname, stdout);
6167
6168 if (offset)
6169 printf ("+%lx", (unsigned long) offset);
6170 }
6171
6172 fputs (">: [", stdout);
6173 print_vma (tp->start.offset, PREFIX_HEX);
6174 fputc ('-', stdout);
6175 print_vma (tp->end.offset, PREFIX_HEX);
6176 printf ("]\n\t");
6177
6178#define PF(_m) if (tp->_m) printf (#_m " ");
6179#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6180 PF(Cannot_unwind);
6181 PF(Millicode);
6182 PF(Millicode_save_sr0);
6183 /* PV(Region_description); */
6184 PF(Entry_SR);
6185 PV(Entry_FR);
6186 PV(Entry_GR);
6187 PF(Args_stored);
6188 PF(Variable_Frame);
6189 PF(Separate_Package_Body);
6190 PF(Frame_Extension_Millicode);
6191 PF(Stack_Overflow_Check);
6192 PF(Two_Instruction_SP_Increment);
6193 PF(Ada_Region);
6194 PF(cxx_info);
6195 PF(cxx_try_catch);
6196 PF(sched_entry_seq);
6197 PF(Save_SP);
6198 PF(Save_RP);
6199 PF(Save_MRP_in_frame);
6200 PF(extn_ptr_defined);
6201 PF(Cleanup_defined);
6202 PF(MPE_XL_interrupt_marker);
6203 PF(HP_UX_interrupt_marker);
6204 PF(Large_frame);
6205 PF(Pseudo_SP_Set);
6206 PV(Total_frame_size);
6207#undef PF
6208#undef PV
6209 }
6210
6211 printf ("\n");
6212}
6213
6214static int
6215slurp_hppa_unwind_table (FILE * file,
6216 struct hppa_unw_aux_info * aux,
6217 Elf_Internal_Shdr * sec)
6218{
6219 unsigned long size, unw_ent_size, nentries, nrelas, i;
6220 Elf_Internal_Phdr * seg;
6221 struct hppa_unw_table_entry * tep;
6222 Elf_Internal_Shdr * relsec;
6223 Elf_Internal_Rela * rela;
6224 Elf_Internal_Rela * rp;
6225 unsigned char * table;
6226 unsigned char * tp;
6227 Elf_Internal_Sym * sym;
6228 const char * relname;
6229
6230 /* First, find the starting address of the segment that includes
6231 this section. */
6232
6233 if (elf_header.e_phnum)
6234 {
6235 if (! get_program_headers (file))
6236 return 0;
6237
6238 for (seg = program_headers;
6239 seg < program_headers + elf_header.e_phnum;
6240 ++seg)
6241 {
6242 if (seg->p_type != PT_LOAD)
6243 continue;
6244
6245 if (sec->sh_addr >= seg->p_vaddr
6246 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6247 {
6248 aux->seg_base = seg->p_vaddr;
6249 break;
6250 }
6251 }
6252 }
6253
6254 /* Second, build the unwind table from the contents of the unwind
6255 section. */
6256 size = sec->sh_size;
6257 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6258 _("unwind table"));
6259 if (!table)
6260 return 0;
6261
6262 unw_ent_size = 16;
6263 nentries = size / unw_ent_size;
6264 size = unw_ent_size * nentries;
6265
6266 tep = aux->table = (struct hppa_unw_table_entry *)
6267 xcmalloc (nentries, sizeof (aux->table[0]));
6268
6269 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6270 {
6271 unsigned int tmp1, tmp2;
6272
6273 tep->start.section = SHN_UNDEF;
6274 tep->end.section = SHN_UNDEF;
6275
6276 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6277 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6278 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6279 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6280
6281 tep->start.offset += aux->seg_base;
6282 tep->end.offset += aux->seg_base;
6283
6284 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6285 tep->Millicode = (tmp1 >> 30) & 0x1;
6286 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6287 tep->Region_description = (tmp1 >> 27) & 0x3;
6288 tep->reserved1 = (tmp1 >> 26) & 0x1;
6289 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6290 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6291 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6292 tep->Args_stored = (tmp1 >> 15) & 0x1;
6293 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6294 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6295 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6296 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6297 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6298 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6299 tep->cxx_info = (tmp1 >> 8) & 0x1;
6300 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6301 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6302 tep->reserved2 = (tmp1 >> 5) & 0x1;
6303 tep->Save_SP = (tmp1 >> 4) & 0x1;
6304 tep->Save_RP = (tmp1 >> 3) & 0x1;
6305 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6306 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6307 tep->Cleanup_defined = tmp1 & 0x1;
6308
6309 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6310 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6311 tep->Large_frame = (tmp2 >> 29) & 0x1;
6312 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6313 tep->reserved4 = (tmp2 >> 27) & 0x1;
6314 tep->Total_frame_size = tmp2 & 0x7ffffff;
6315 }
6316 free (table);
6317
6318 /* Third, apply any relocations to the unwind table. */
6319 for (relsec = section_headers;
6320 relsec < section_headers + elf_header.e_shnum;
6321 ++relsec)
6322 {
6323 if (relsec->sh_type != SHT_RELA
6324 || relsec->sh_info >= elf_header.e_shnum
6325 || section_headers + relsec->sh_info != sec)
6326 continue;
6327
6328 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6329 & rela, & nrelas))
6330 return 0;
6331
6332 for (rp = rela; rp < rela + nrelas; ++rp)
6333 {
6334 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6335 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6336
6337 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6338 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6339 {
6340 warn (_("Skipping unexpected relocation type %s\n"), relname);
6341 continue;
6342 }
6343
6344 i = rp->r_offset / unw_ent_size;
6345
6346 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6347 {
6348 case 0:
6349 aux->table[i].start.section = sym->st_shndx;
6350 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6351 break;
6352 case 1:
6353 aux->table[i].end.section = sym->st_shndx;
6354 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6355 break;
6356 default:
6357 break;
6358 }
6359 }
6360
6361 free (rela);
6362 }
6363
6364 aux->table_len = nentries;
6365
6366 return 1;
6367}
6368
6369static void
6370hppa_process_unwind (FILE * file)
6371{
6372 struct hppa_unw_aux_info aux;
6373 Elf_Internal_Shdr * unwsec = NULL;
6374 Elf_Internal_Shdr * strsec;
6375 Elf_Internal_Shdr * sec;
6376 unsigned long i;
6377
6378 if (string_table == NULL)
6379 return;
6380
6381 memset (& aux, 0, sizeof (aux));
6382
6383 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6384 {
6385 if (sec->sh_type == SHT_SYMTAB
6386 && sec->sh_link < elf_header.e_shnum)
6387 {
6388 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6389
6390 strsec = section_headers + sec->sh_link;
6391 assert (aux.strtab == NULL);
6392 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6393 1, strsec->sh_size,
6394 _("string table"));
6395 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6396 }
6397 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6398 unwsec = sec;
6399 }
6400
6401 if (!unwsec)
6402 printf (_("\nThere are no unwind sections in this file.\n"));
6403
6404 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6405 {
6406 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6407 {
6408 printf (_("\nUnwind section "));
6409 printf (_("'%s'"), SECTION_NAME (sec));
6410
6411 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6412 (unsigned long) sec->sh_offset,
6413 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6414
6415 slurp_hppa_unwind_table (file, &aux, sec);
6416 if (aux.table_len > 0)
6417 dump_hppa_unwind (&aux);
6418
6419 if (aux.table)
6420 free ((char *) aux.table);
6421 aux.table = NULL;
6422 }
6423 }
6424
6425 if (aux.symtab)
6426 free (aux.symtab);
6427 if (aux.strtab)
6428 free ((char *) aux.strtab);
6429}
6430
6431struct arm_section
6432{
6433 unsigned char * data; /* The unwind data. */
6434 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6435 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6436 unsigned long nrelas; /* The number of relocations. */
6437 unsigned int rel_type; /* REL or RELA ? */
6438 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
6439};
6440
6441struct arm_unw_aux_info
6442{
6443 FILE * file; /* The file containing the unwind sections. */
6444 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6445 unsigned long nsyms; /* Number of symbols. */
6446 char * strtab; /* The file's string table. */
6447 unsigned long strtab_size; /* Size of string table. */
6448};
6449
6450static const char *
6451arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6452 bfd_vma fn, struct absaddr addr)
6453{
6454 const char *procname;
6455 bfd_vma sym_offset;
6456
6457 if (addr.section == SHN_UNDEF)
6458 addr.offset = fn;
6459
6460 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6461 aux->strtab_size, addr, &procname,
6462 &sym_offset);
6463
6464 print_vma (fn, PREFIX_HEX);
6465
6466 if (procname)
6467 {
6468 fputs (" <", stdout);
6469 fputs (procname, stdout);
6470
6471 if (sym_offset)
6472 printf ("+0x%lx", (unsigned long) sym_offset);
6473 fputc ('>', stdout);
6474 }
6475
6476 return procname;
6477}
6478
6479static void
6480arm_free_section (struct arm_section *arm_sec)
6481{
6482 if (arm_sec->data != NULL)
6483 free (arm_sec->data);
6484
6485 if (arm_sec->rela != NULL)
6486 free (arm_sec->rela);
6487}
6488
6489/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6490 cached section and install SEC instead.
6491 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6492 and return its valued in * WORDP, relocating if necessary.
6493 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6494 relocation's offset in ADDR.
6495 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6496 into the string table of the symbol associated with the reloc. If no
6497 reloc was applied store -1 there.
6498 5) Return TRUE upon success, FALSE otherwise. */
6499
6500static bfd_boolean
6501get_unwind_section_word (struct arm_unw_aux_info * aux,
6502 struct arm_section * arm_sec,
6503 Elf_Internal_Shdr * sec,
6504 bfd_vma word_offset,
6505 unsigned int * wordp,
6506 struct absaddr * addr,
6507 bfd_vma * sym_name)
6508{
6509 Elf_Internal_Rela *rp;
6510 Elf_Internal_Sym *sym;
6511 const char * relname;
6512 unsigned int word;
6513 bfd_boolean wrapped;
6514
6515 addr->section = SHN_UNDEF;
6516 addr->offset = 0;
6517
6518 if (sym_name != NULL)
6519 *sym_name = (bfd_vma) -1;
6520
6521 /* If necessary, update the section cache. */
6522 if (sec != arm_sec->sec)
6523 {
6524 Elf_Internal_Shdr *relsec;
6525
6526 arm_free_section (arm_sec);
6527
6528 arm_sec->sec = sec;
6529 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6530 sec->sh_size, _("unwind data"));
6531 arm_sec->rela = NULL;
6532 arm_sec->nrelas = 0;
6533
6534 for (relsec = section_headers;
6535 relsec < section_headers + elf_header.e_shnum;
6536 ++relsec)
6537 {
6538 if (relsec->sh_info >= elf_header.e_shnum
6539 || section_headers + relsec->sh_info != sec)
6540 continue;
6541
6542 arm_sec->rel_type = relsec->sh_type;
6543 if (relsec->sh_type == SHT_REL)
6544 {
6545 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6546 relsec->sh_size,
6547 & arm_sec->rela, & arm_sec->nrelas))
6548 return FALSE;
6549 break;
6550 }
6551 else if (relsec->sh_type == SHT_RELA)
6552 {
6553 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6554 relsec->sh_size,
6555 & arm_sec->rela, & arm_sec->nrelas))
6556 return FALSE;
6557 break;
6558 }
6559 else
6560 warn (_("unexpected relocation type (%d) for section %d"),
6561 relsec->sh_type, relsec->sh_info);
6562 }
6563
6564 arm_sec->next_rela = arm_sec->rela;
6565 }
6566
6567 /* If there is no unwind data we can do nothing. */
6568 if (arm_sec->data == NULL)
6569 return FALSE;
6570
6571 /* Get the word at the required offset. */
6572 word = byte_get (arm_sec->data + word_offset, 4);
6573
6574 /* Look through the relocs to find the one that applies to the provided offset. */
6575 wrapped = FALSE;
6576 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6577 {
6578 bfd_vma prelval, offset;
6579
6580 if (rp->r_offset > word_offset && !wrapped)
6581 {
6582 rp = arm_sec->rela;
6583 wrapped = TRUE;
6584 }
6585 if (rp->r_offset > word_offset)
6586 break;
6587
6588 if (rp->r_offset & 3)
6589 {
6590 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6591 (unsigned long) rp->r_offset);
6592 continue;
6593 }
6594
6595 if (rp->r_offset < word_offset)
6596 continue;
6597
6598 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6599
6600 if (arm_sec->rel_type == SHT_REL)
6601 {
6602 offset = word & 0x7fffffff;
6603 if (offset & 0x40000000)
6604 offset |= ~ (bfd_vma) 0x7fffffff;
6605 }
6606 else if (arm_sec->rel_type == SHT_RELA)
6607 offset = rp->r_addend;
6608 else
6609 abort ();
6610
6611 offset += sym->st_value;
6612 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6613
6614 /* Check that we are processing the expected reloc type. */
6615 if (elf_header.e_machine == EM_ARM)
6616 {
6617 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6618
6619 if (streq (relname, "R_ARM_NONE"))
6620 continue;
6621
6622 if (! streq (relname, "R_ARM_PREL31"))
6623 {
6624 warn (_("Skipping unexpected relocation type %s\n"), relname);
6625 continue;
6626 }
6627 }
6628 else if (elf_header.e_machine == EM_TI_C6000)
6629 {
6630 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6631
6632 if (streq (relname, "R_C6000_NONE"))
6633 continue;
6634
6635 if (! streq (relname, "R_C6000_PREL31"))
6636 {
6637 warn (_("Skipping unexpected relocation type %s\n"), relname);
6638 continue;
6639 }
6640
6641 prelval >>= 1;
6642 }
6643 else
6644 /* This function currently only supports ARM and TI unwinders. */
6645 abort ();
6646
6647 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6648 addr->section = sym->st_shndx;
6649 addr->offset = offset;
6650 if (sym_name)
6651 * sym_name = sym->st_name;
6652 break;
6653 }
6654
6655 *wordp = word;
6656 arm_sec->next_rela = rp;
6657
6658 return TRUE;
6659}
6660
6661static const char *tic6x_unwind_regnames[16] =
6662{
6663 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6664 "A14", "A13", "A12", "A11", "A10",
6665 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6666};
6667
6668static void
6669decode_tic6x_unwind_regmask (unsigned int mask)
6670{
6671 int i;
6672
6673 for (i = 12; mask; mask >>= 1, i--)
6674 {
6675 if (mask & 1)
6676 {
6677 fputs (tic6x_unwind_regnames[i], stdout);
6678 if (mask > 1)
6679 fputs (", ", stdout);
6680 }
6681 }
6682}
6683
6684#define ADVANCE \
6685 if (remaining == 0 && more_words) \
6686 { \
6687 data_offset += 4; \
6688 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6689 data_offset, & word, & addr, NULL)) \
6690 return; \
6691 remaining = 4; \
6692 more_words--; \
6693 } \
6694
6695#define GET_OP(OP) \
6696 ADVANCE; \
6697 if (remaining) \
6698 { \
6699 remaining--; \
6700 (OP) = word >> 24; \
6701 word <<= 8; \
6702 } \
6703 else \
6704 { \
6705 printf (_("[Truncated opcode]\n")); \
6706 return; \
6707 } \
6708 printf ("0x%02x ", OP)
6709
6710static void
6711decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6712 unsigned int word, unsigned int remaining,
6713 unsigned int more_words,
6714 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6715 struct arm_section *data_arm_sec)
6716{
6717 struct absaddr addr;
6718
6719 /* Decode the unwinding instructions. */
6720 while (1)
6721 {
6722 unsigned int op, op2;
6723
6724 ADVANCE;
6725 if (remaining == 0)
6726 break;
6727 remaining--;
6728 op = word >> 24;
6729 word <<= 8;
6730
6731 printf (" 0x%02x ", op);
6732
6733 if ((op & 0xc0) == 0x00)
6734 {
6735 int offset = ((op & 0x3f) << 2) + 4;
6736
6737 printf (" vsp = vsp + %d", offset);
6738 }
6739 else if ((op & 0xc0) == 0x40)
6740 {
6741 int offset = ((op & 0x3f) << 2) + 4;
6742
6743 printf (" vsp = vsp - %d", offset);
6744 }
6745 else if ((op & 0xf0) == 0x80)
6746 {
6747 GET_OP (op2);
6748 if (op == 0x80 && op2 == 0)
6749 printf (_("Refuse to unwind"));
6750 else
6751 {
6752 unsigned int mask = ((op & 0x0f) << 8) | op2;
6753 int first = 1;
6754 int i;
6755
6756 printf ("pop {");
6757 for (i = 0; i < 12; i++)
6758 if (mask & (1 << i))
6759 {
6760 if (first)
6761 first = 0;
6762 else
6763 printf (", ");
6764 printf ("r%d", 4 + i);
6765 }
6766 printf ("}");
6767 }
6768 }
6769 else if ((op & 0xf0) == 0x90)
6770 {
6771 if (op == 0x9d || op == 0x9f)
6772 printf (_(" [Reserved]"));
6773 else
6774 printf (" vsp = r%d", op & 0x0f);
6775 }
6776 else if ((op & 0xf0) == 0xa0)
6777 {
6778 int end = 4 + (op & 0x07);
6779 int first = 1;
6780 int i;
6781
6782 printf (" pop {");
6783 for (i = 4; i <= end; i++)
6784 {
6785 if (first)
6786 first = 0;
6787 else
6788 printf (", ");
6789 printf ("r%d", i);
6790 }
6791 if (op & 0x08)
6792 {
6793 if (!first)
6794 printf (", ");
6795 printf ("r14");
6796 }
6797 printf ("}");
6798 }
6799 else if (op == 0xb0)
6800 printf (_(" finish"));
6801 else if (op == 0xb1)
6802 {
6803 GET_OP (op2);
6804 if (op2 == 0 || (op2 & 0xf0) != 0)
6805 printf (_("[Spare]"));
6806 else
6807 {
6808 unsigned int mask = op2 & 0x0f;
6809 int first = 1;
6810 int i;
6811
6812 printf ("pop {");
6813 for (i = 0; i < 12; i++)
6814 if (mask & (1 << i))
6815 {
6816 if (first)
6817 first = 0;
6818 else
6819 printf (", ");
6820 printf ("r%d", i);
6821 }
6822 printf ("}");
6823 }
6824 }
6825 else if (op == 0xb2)
6826 {
6827 unsigned char buf[9];
6828 unsigned int i, len;
6829 unsigned long offset;
6830
6831 for (i = 0; i < sizeof (buf); i++)
6832 {
6833 GET_OP (buf[i]);
6834 if ((buf[i] & 0x80) == 0)
6835 break;
6836 }
6837 assert (i < sizeof (buf));
6838 offset = read_uleb128 (buf, &len);
6839 assert (len == i + 1);
6840 offset = offset * 4 + 0x204;
6841 printf ("vsp = vsp + %ld", offset);
6842 }
6843 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6844 {
6845 unsigned int first, last;
6846
6847 GET_OP (op2);
6848 first = op2 >> 4;
6849 last = op2 & 0x0f;
6850 if (op == 0xc8)
6851 first = first + 16;
6852 printf ("pop {D%d", first);
6853 if (last)
6854 printf ("-D%d", first + last);
6855 printf ("}");
6856 }
6857 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6858 {
6859 unsigned int count = op & 0x07;
6860
6861 printf ("pop {D8");
6862 if (count)
6863 printf ("-D%d", 8 + count);
6864 printf ("}");
6865 }
6866 else if (op >= 0xc0 && op <= 0xc5)
6867 {
6868 unsigned int count = op & 0x07;
6869
6870 printf (" pop {wR10");
6871 if (count)
6872 printf ("-wR%d", 10 + count);
6873 printf ("}");
6874 }
6875 else if (op == 0xc6)
6876 {
6877 unsigned int first, last;
6878
6879 GET_OP (op2);
6880 first = op2 >> 4;
6881 last = op2 & 0x0f;
6882 printf ("pop {wR%d", first);
6883 if (last)
6884 printf ("-wR%d", first + last);
6885 printf ("}");
6886 }
6887 else if (op == 0xc7)
6888 {
6889 GET_OP (op2);
6890 if (op2 == 0 || (op2 & 0xf0) != 0)
6891 printf (_("[Spare]"));
6892 else
6893 {
6894 unsigned int mask = op2 & 0x0f;
6895 int first = 1;
6896 int i;
6897
6898 printf ("pop {");
6899 for (i = 0; i < 4; i++)
6900 if (mask & (1 << i))
6901 {
6902 if (first)
6903 first = 0;
6904 else
6905 printf (", ");
6906 printf ("wCGR%d", i);
6907 }
6908 printf ("}");
6909 }
6910 }
6911 else
6912 printf (_(" [unsupported opcode]"));
6913 printf ("\n");
6914 }
6915}
6916
6917static void
6918decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6919 unsigned int word, unsigned int remaining,
6920 unsigned int more_words,
6921 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6922 struct arm_section *data_arm_sec)
6923{
6924 struct absaddr addr;
6925
6926 /* Decode the unwinding instructions. */
6927 while (1)
6928 {
6929 unsigned int op, op2;
6930
6931 ADVANCE;
6932 if (remaining == 0)
6933 break;
6934 remaining--;
6935 op = word >> 24;
6936 word <<= 8;
6937
6938 printf (" 0x%02x ", op);
6939
6940 if ((op & 0xc0) == 0x00)
6941 {
6942 int offset = ((op & 0x3f) << 3) + 8;
6943 printf (" sp = sp + %d", offset);
6944 }
6945 else if ((op & 0xc0) == 0x80)
6946 {
6947 GET_OP (op2);
6948 if (op == 0x80 && op2 == 0)
6949 printf (_("Refuse to unwind"));
6950 else
6951 {
6952 unsigned int mask = ((op & 0x1f) << 8) | op2;
6953 if (op & 0x20)
6954 printf ("pop compact {");
6955 else
6956 printf ("pop {");
6957
6958 decode_tic6x_unwind_regmask (mask);
6959 printf("}");
6960 }
6961 }
6962 else if ((op & 0xf0) == 0xc0)
6963 {
6964 unsigned int reg;
6965 unsigned int nregs;
6966 unsigned int i;
6967 const char *name;
6968 struct
6969 {
6970 unsigned int offset;
6971 unsigned int reg;
6972 } regpos[16];
6973
6974 /* Scan entire instruction first so that GET_OP output is not
6975 interleaved with disassembly. */
6976 nregs = 0;
6977 for (i = 0; nregs < (op & 0xf); i++)
6978 {
6979 GET_OP (op2);
6980 reg = op2 >> 4;
6981 if (reg != 0xf)
6982 {
6983 regpos[nregs].offset = i * 2;
6984 regpos[nregs].reg = reg;
6985 nregs++;
6986 }
6987
6988 reg = op2 & 0xf;
6989 if (reg != 0xf)
6990 {
6991 regpos[nregs].offset = i * 2 + 1;
6992 regpos[nregs].reg = reg;
6993 nregs++;
6994 }
6995 }
6996
6997 printf (_("pop frame {"));
6998 reg = nregs - 1;
6999 for (i = i * 2; i > 0; i--)
7000 {
7001 if (regpos[reg].offset == i - 1)
7002 {
7003 name = tic6x_unwind_regnames[regpos[reg].reg];
7004 if (reg > 0)
7005 reg--;
7006 }
7007 else
7008 name = _("[pad]");
7009
7010 fputs (name, stdout);
7011 if (i > 1)
7012 printf (", ");
7013 }
7014
7015 printf ("}");
7016 }
7017 else if (op == 0xd0)
7018 printf (" MOV FP, SP");
7019 else if (op == 0xd1)
7020 printf (" __c6xabi_pop_rts");
7021 else if (op == 0xd2)
7022 {
7023 unsigned char buf[9];
7024 unsigned int i, len;
7025 unsigned long offset;
7026
7027 for (i = 0; i < sizeof (buf); i++)
7028 {
7029 GET_OP (buf[i]);
7030 if ((buf[i] & 0x80) == 0)
7031 break;
7032 }
7033 assert (i < sizeof (buf));
7034 offset = read_uleb128 (buf, &len);
7035 assert (len == i + 1);
7036 offset = offset * 8 + 0x408;
7037 printf (_("sp = sp + %ld"), offset);
7038 }
7039 else if ((op & 0xf0) == 0xe0)
7040 {
7041 if ((op & 0x0f) == 7)
7042 printf (" RETURN");
7043 else
7044 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7045 }
7046 else
7047 {
7048 printf (_(" [unsupported opcode]"));
7049 }
7050 putchar ('\n');
7051 }
7052}
7053
7054static bfd_vma
7055arm_expand_prel31 (bfd_vma word, bfd_vma where)
7056{
7057 bfd_vma offset;
7058
7059 offset = word & 0x7fffffff;
7060 if (offset & 0x40000000)
7061 offset |= ~ (bfd_vma) 0x7fffffff;
7062
7063 if (elf_header.e_machine == EM_TI_C6000)
7064 offset <<= 1;
7065
7066 return offset + where;
7067}
7068
7069static void
7070decode_arm_unwind (struct arm_unw_aux_info * aux,
7071 unsigned int word,
7072 unsigned int remaining,
7073 bfd_vma data_offset,
7074 Elf_Internal_Shdr * data_sec,
7075 struct arm_section * data_arm_sec)
7076{
7077 int per_index;
7078 unsigned int more_words = 0;
7079 struct absaddr addr;
7080 bfd_vma sym_name = (bfd_vma) -1;
7081
7082 if (remaining == 0)
7083 {
7084 /* Fetch the first word.
7085 Note - when decoding an object file the address extracted
7086 here will always be 0. So we also pass in the sym_name
7087 parameter so that we can find the symbol associated with
7088 the personality routine. */
7089 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7090 & word, & addr, & sym_name))
7091 return;
7092
7093 remaining = 4;
7094 }
7095
7096 if ((word & 0x80000000) == 0)
7097 {
7098 /* Expand prel31 for personality routine. */
7099 bfd_vma fn;
7100 const char *procname;
7101
7102 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7103 printf (_(" Personality routine: "));
7104 if (fn == 0
7105 && addr.section == SHN_UNDEF && addr.offset == 0
7106 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7107 {
7108 procname = aux->strtab + sym_name;
7109 print_vma (fn, PREFIX_HEX);
7110 if (procname)
7111 {
7112 fputs (" <", stdout);
7113 fputs (procname, stdout);
7114 fputc ('>', stdout);
7115 }
7116 }
7117 else
7118 procname = arm_print_vma_and_name (aux, fn, addr);
7119 fputc ('\n', stdout);
7120
7121 /* The GCC personality routines use the standard compact
7122 encoding, starting with one byte giving the number of
7123 words. */
7124 if (procname != NULL
7125 && (const_strneq (procname, "__gcc_personality_v0")
7126 || const_strneq (procname, "__gxx_personality_v0")
7127 || const_strneq (procname, "__gcj_personality_v0")
7128 || const_strneq (procname, "__gnu_objc_personality_v0")))
7129 {
7130 remaining = 0;
7131 more_words = 1;
7132 ADVANCE;
7133 if (!remaining)
7134 {
7135 printf (_(" [Truncated data]\n"));
7136 return;
7137 }
7138 more_words = word >> 24;
7139 word <<= 8;
7140 remaining--;
7141 per_index = -1;
7142 }
7143 else
7144 return;
7145 }
7146 else
7147 {
7148 /* ARM EHABI Section 6.3:
7149
7150 An exception-handling table entry for the compact model looks like:
7151
7152 31 30-28 27-24 23-0
7153 -- ----- ----- ----
7154 1 0 index Data for personalityRoutine[index] */
7155
7156 if (elf_header.e_machine == EM_ARM
7157 && (word & 0x70000000))
7158 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7159
7160 per_index = (word >> 24) & 0x7f;
7161 printf (_(" Compact model index: %d\n"), per_index);
7162 if (per_index == 0)
7163 {
7164 more_words = 0;
7165 word <<= 8;
7166 remaining--;
7167 }
7168 else if (per_index < 3)
7169 {
7170 more_words = (word >> 16) & 0xff;
7171 word <<= 16;
7172 remaining -= 2;
7173 }
7174 }
7175
7176 switch (elf_header.e_machine)
7177 {
7178 case EM_ARM:
7179 if (per_index < 3)
7180 {
7181 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7182 data_offset, data_sec, data_arm_sec);
7183 }
7184 else
7185 {
7186 warn (_("Unknown ARM compact model index encountered\n"));
7187 printf (_(" [reserved]\n"));
7188 }
7189 break;
7190
7191 case EM_TI_C6000:
7192 if (per_index < 3)
7193 {
7194 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7195 data_offset, data_sec, data_arm_sec);
7196 }
7197 else if (per_index < 5)
7198 {
7199 if (((word >> 17) & 0x7f) == 0x7f)
7200 printf (_(" Restore stack from frame pointer\n"));
7201 else
7202 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7203 printf (_(" Registers restored: "));
7204 if (per_index == 4)
7205 printf (" (compact) ");
7206 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7207 putchar ('\n');
7208 printf (_(" Return register: %s\n"),
7209 tic6x_unwind_regnames[word & 0xf]);
7210 }
7211 else
7212 printf (_(" [reserved (%d)]\n"), per_index);
7213 break;
7214
7215 default:
7216 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7217 elf_header.e_machine);
7218 }
7219
7220 /* Decode the descriptors. Not implemented. */
7221}
7222
7223static void
7224dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7225{
7226 struct arm_section exidx_arm_sec, extab_arm_sec;
7227 unsigned int i, exidx_len;
7228
7229 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7230 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7231 exidx_len = exidx_sec->sh_size / 8;
7232
7233 for (i = 0; i < exidx_len; i++)
7234 {
7235 unsigned int exidx_fn, exidx_entry;
7236 struct absaddr fn_addr, entry_addr;
7237 bfd_vma fn;
7238
7239 fputc ('\n', stdout);
7240
7241 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7242 8 * i, & exidx_fn, & fn_addr, NULL)
7243 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7244 8 * i + 4, & exidx_entry, & entry_addr, NULL))
7245 {
7246 arm_free_section (& exidx_arm_sec);
7247 arm_free_section (& extab_arm_sec);
7248 return;
7249 }
7250
7251 /* ARM EHABI, Section 5:
7252 An index table entry consists of 2 words.
7253 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7254 if (exidx_fn & 0x80000000)
7255 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7256
7257 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7258
7259 arm_print_vma_and_name (aux, fn, fn_addr);
7260 fputs (": ", stdout);
7261
7262 if (exidx_entry == 1)
7263 {
7264 print_vma (exidx_entry, PREFIX_HEX);
7265 fputs (" [cantunwind]\n", stdout);
7266 }
7267 else if (exidx_entry & 0x80000000)
7268 {
7269 print_vma (exidx_entry, PREFIX_HEX);
7270 fputc ('\n', stdout);
7271 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7272 }
7273 else
7274 {
7275 bfd_vma table, table_offset = 0;
7276 Elf_Internal_Shdr *table_sec;
7277
7278 fputs ("@", stdout);
7279 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7280 print_vma (table, PREFIX_HEX);
7281 printf ("\n");
7282
7283 /* Locate the matching .ARM.extab. */
7284 if (entry_addr.section != SHN_UNDEF
7285 && entry_addr.section < elf_header.e_shnum)
7286 {
7287 table_sec = section_headers + entry_addr.section;
7288 table_offset = entry_addr.offset;
7289 }
7290 else
7291 {
7292 table_sec = find_section_by_address (table);
7293 if (table_sec != NULL)
7294 table_offset = table - table_sec->sh_addr;
7295 }
7296 if (table_sec == NULL)
7297 {
7298 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7299 (unsigned long) table);
7300 continue;
7301 }
7302 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7303 &extab_arm_sec);
7304 }
7305 }
7306
7307 printf ("\n");
7308
7309 arm_free_section (&exidx_arm_sec);
7310 arm_free_section (&extab_arm_sec);
7311}
7312
7313/* Used for both ARM and C6X unwinding tables. */
7314
7315static void
7316arm_process_unwind (FILE *file)
7317{
7318 struct arm_unw_aux_info aux;
7319 Elf_Internal_Shdr *unwsec = NULL;
7320 Elf_Internal_Shdr *strsec;
7321 Elf_Internal_Shdr *sec;
7322 unsigned long i;
7323 unsigned int sec_type;
7324
7325 switch (elf_header.e_machine)
7326 {
7327 case EM_ARM:
7328 sec_type = SHT_ARM_EXIDX;
7329 break;
7330
7331 case EM_TI_C6000:
7332 sec_type = SHT_C6000_UNWIND;
7333 break;
7334
7335 default:
7336 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7337 elf_header.e_machine);
7338 return;
7339 }
7340
7341 if (string_table == NULL)
7342 return;
7343
7344 memset (& aux, 0, sizeof (aux));
7345 aux.file = file;
7346
7347 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7348 {
7349 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7350 {
7351 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7352
7353 strsec = section_headers + sec->sh_link;
7354 assert (aux.strtab == NULL);
7355 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7356 1, strsec->sh_size, _("string table"));
7357 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7358 }
7359 else if (sec->sh_type == sec_type)
7360 unwsec = sec;
7361 }
7362
7363 if (unwsec == NULL)
7364 printf (_("\nThere are no unwind sections in this file.\n"));
7365 else
7366 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7367 {
7368 if (sec->sh_type == sec_type)
7369 {
7370 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7371 SECTION_NAME (sec),
7372 (unsigned long) sec->sh_offset,
7373 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7374
7375 dump_arm_unwind (&aux, sec);
7376 }
7377 }
7378
7379 if (aux.symtab)
7380 free (aux.symtab);
7381 if (aux.strtab)
7382 free ((char *) aux.strtab);
7383}
7384
7385static void
7386process_unwind (FILE * file)
7387{
7388 struct unwind_handler
7389 {
7390 int machtype;
7391 void (* handler)(FILE *);
7392 } handlers[] =
7393 {
7394 { EM_ARM, arm_process_unwind },
7395 { EM_IA_64, ia64_process_unwind },
7396 { EM_PARISC, hppa_process_unwind },
7397 { EM_TI_C6000, arm_process_unwind },
7398 { 0, 0 }
7399 };
7400 int i;
7401
7402 if (!do_unwind)
7403 return;
7404
7405 for (i = 0; handlers[i].handler != NULL; i++)
7406 if (elf_header.e_machine == handlers[i].machtype)
7407 return handlers[i].handler (file);
7408
7409 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7410 get_machine_name (elf_header.e_machine));
7411}
7412
7413static void
7414dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7415{
7416 switch (entry->d_tag)
7417 {
7418 case DT_MIPS_FLAGS:
7419 if (entry->d_un.d_val == 0)
7420 printf (_("NONE"));
7421 else
7422 {
7423 static const char * opts[] =
7424 {
7425 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7426 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7427 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7428 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7429 "RLD_ORDER_SAFE"
7430 };
7431 unsigned int cnt;
7432 int first = 1;
7433
7434 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7435 if (entry->d_un.d_val & (1 << cnt))
7436 {
7437 printf ("%s%s", first ? "" : " ", opts[cnt]);
7438 first = 0;
7439 }
7440 }
7441 break;
7442
7443 case DT_MIPS_IVERSION:
7444 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7445 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7446 else
7447 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7448 break;
7449
7450 case DT_MIPS_TIME_STAMP:
7451 {
7452 char timebuf[20];
7453 struct tm * tmp;
7454
7455 time_t atime = entry->d_un.d_val;
7456 tmp = gmtime (&atime);
7457 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7458 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7459 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7460 printf (_("Time Stamp: %s"), timebuf);
7461 }
7462 break;
7463
7464 case DT_MIPS_RLD_VERSION:
7465 case DT_MIPS_LOCAL_GOTNO:
7466 case DT_MIPS_CONFLICTNO:
7467 case DT_MIPS_LIBLISTNO:
7468 case DT_MIPS_SYMTABNO:
7469 case DT_MIPS_UNREFEXTNO:
7470 case DT_MIPS_HIPAGENO:
7471 case DT_MIPS_DELTA_CLASS_NO:
7472 case DT_MIPS_DELTA_INSTANCE_NO:
7473 case DT_MIPS_DELTA_RELOC_NO:
7474 case DT_MIPS_DELTA_SYM_NO:
7475 case DT_MIPS_DELTA_CLASSSYM_NO:
7476 case DT_MIPS_COMPACT_SIZE:
7477 print_vma (entry->d_un.d_ptr, DEC);
7478 break;
7479
7480 default:
7481 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7482 }
7483 putchar ('\n');
7484}
7485
7486static void
7487dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7488{
7489 switch (entry->d_tag)
7490 {
7491 case DT_HP_DLD_FLAGS:
7492 {
7493 static struct
7494 {
7495 long int bit;
7496 const char * str;
7497 }
7498 flags[] =
7499 {
7500 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7501 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7502 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7503 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7504 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7505 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7506 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7507 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7508 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7509 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7510 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7511 { DT_HP_GST, "HP_GST" },
7512 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7513 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7514 { DT_HP_NODELETE, "HP_NODELETE" },
7515 { DT_HP_GROUP, "HP_GROUP" },
7516 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7517 };
7518 int first = 1;
7519 size_t cnt;
7520 bfd_vma val = entry->d_un.d_val;
7521
7522 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7523 if (val & flags[cnt].bit)
7524 {
7525 if (! first)
7526 putchar (' ');
7527 fputs (flags[cnt].str, stdout);
7528 first = 0;
7529 val ^= flags[cnt].bit;
7530 }
7531
7532 if (val != 0 || first)
7533 {
7534 if (! first)
7535 putchar (' ');
7536 print_vma (val, HEX);
7537 }
7538 }
7539 break;
7540
7541 default:
7542 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7543 break;
7544 }
7545 putchar ('\n');
7546}
7547
7548#ifdef BFD64
7549
7550/* VMS vs Unix time offset and factor. */
7551
7552#define VMS_EPOCH_OFFSET 35067168000000000LL
7553#define VMS_GRANULARITY_FACTOR 10000000
7554
7555/* Display a VMS time in a human readable format. */
7556
7557static void
7558print_vms_time (bfd_int64_t vmstime)
7559{
7560 struct tm *tm;
7561 time_t unxtime;
7562
7563 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7564 tm = gmtime (&unxtime);
7565 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7566 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7567 tm->tm_hour, tm->tm_min, tm->tm_sec);
7568}
7569#endif /* BFD64 */
7570
7571static void
7572dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7573{
7574 switch (entry->d_tag)
7575 {
7576 case DT_IA_64_PLT_RESERVE:
7577 /* First 3 slots reserved. */
7578 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7579 printf (" -- ");
7580 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7581 break;
7582
7583 case DT_IA_64_VMS_LINKTIME:
7584#ifdef BFD64
7585 print_vms_time (entry->d_un.d_val);
7586#endif
7587 break;
7588
7589 case DT_IA_64_VMS_LNKFLAGS:
7590 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7591 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7592 printf (" CALL_DEBUG");
7593 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7594 printf (" NOP0BUFS");
7595 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7596 printf (" P0IMAGE");
7597 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7598 printf (" MKTHREADS");
7599 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7600 printf (" UPCALLS");
7601 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7602 printf (" IMGSTA");
7603 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7604 printf (" INITIALIZE");
7605 if (entry->d_un.d_val & VMS_LF_MAIN)
7606 printf (" MAIN");
7607 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7608 printf (" EXE_INIT");
7609 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7610 printf (" TBK_IN_IMG");
7611 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7612 printf (" DBG_IN_IMG");
7613 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7614 printf (" TBK_IN_DSF");
7615 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7616 printf (" DBG_IN_DSF");
7617 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7618 printf (" SIGNATURES");
7619 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7620 printf (" REL_SEG_OFF");
7621 break;
7622
7623 default:
7624 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7625 break;
7626 }
7627 putchar ('\n');
7628}
7629
7630static int
7631get_32bit_dynamic_section (FILE * file)
7632{
7633 Elf32_External_Dyn * edyn;
7634 Elf32_External_Dyn * ext;
7635 Elf_Internal_Dyn * entry;
7636
7637 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7638 dynamic_size, _("dynamic section"));
7639 if (!edyn)
7640 return 0;
7641
7642/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7643 might not have the luxury of section headers. Look for the DT_NULL
7644 terminator to determine the number of entries. */
7645 for (ext = edyn, dynamic_nent = 0;
7646 (char *) ext < (char *) edyn + dynamic_size;
7647 ext++)
7648 {
7649 dynamic_nent++;
7650 if (BYTE_GET (ext->d_tag) == DT_NULL)
7651 break;
7652 }
7653
7654 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7655 sizeof (* entry));
7656 if (dynamic_section == NULL)
7657 {
7658 error (_("Out of memory\n"));
7659 free (edyn);
7660 return 0;
7661 }
7662
7663 for (ext = edyn, entry = dynamic_section;
7664 entry < dynamic_section + dynamic_nent;
7665 ext++, entry++)
7666 {
7667 entry->d_tag = BYTE_GET (ext->d_tag);
7668 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7669 }
7670
7671 free (edyn);
7672
7673 return 1;
7674}
7675
7676static int
7677get_64bit_dynamic_section (FILE * file)
7678{
7679 Elf64_External_Dyn * edyn;
7680 Elf64_External_Dyn * ext;
7681 Elf_Internal_Dyn * entry;
7682
7683 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7684 dynamic_size, _("dynamic section"));
7685 if (!edyn)
7686 return 0;
7687
7688/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7689 might not have the luxury of section headers. Look for the DT_NULL
7690 terminator to determine the number of entries. */
7691 for (ext = edyn, dynamic_nent = 0;
7692 (char *) ext < (char *) edyn + dynamic_size;
7693 ext++)
7694 {
7695 dynamic_nent++;
7696 if (BYTE_GET (ext->d_tag) == DT_NULL)
7697 break;
7698 }
7699
7700 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7701 sizeof (* entry));
7702 if (dynamic_section == NULL)
7703 {
7704 error (_("Out of memory\n"));
7705 free (edyn);
7706 return 0;
7707 }
7708
7709 for (ext = edyn, entry = dynamic_section;
7710 entry < dynamic_section + dynamic_nent;
7711 ext++, entry++)
7712 {
7713 entry->d_tag = BYTE_GET (ext->d_tag);
7714 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7715 }
7716
7717 free (edyn);
7718
7719 return 1;
7720}
7721
7722static void
7723print_dynamic_flags (bfd_vma flags)
7724{
7725 int first = 1;
7726
7727 while (flags)
7728 {
7729 bfd_vma flag;
7730
7731 flag = flags & - flags;
7732 flags &= ~ flag;
7733
7734 if (first)
7735 first = 0;
7736 else
7737 putc (' ', stdout);
7738
7739 switch (flag)
7740 {
7741 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7742 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7743 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7744 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7745 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7746 default: fputs (_("unknown"), stdout); break;
7747 }
7748 }
7749 puts ("");
7750}
7751
7752/* Parse and display the contents of the dynamic section. */
7753
7754static int
7755process_dynamic_section (FILE * file)
7756{
7757 Elf_Internal_Dyn * entry;
7758
7759 if (dynamic_size == 0)
7760 {
7761 if (do_dynamic)
7762 printf (_("\nThere is no dynamic section in this file.\n"));
7763
7764 return 1;
7765 }
7766
7767 if (is_32bit_elf)
7768 {
7769 if (! get_32bit_dynamic_section (file))
7770 return 0;
7771 }
7772 else if (! get_64bit_dynamic_section (file))
7773 return 0;
7774
7775 /* Find the appropriate symbol table. */
7776 if (dynamic_symbols == NULL)
7777 {
7778 for (entry = dynamic_section;
7779 entry < dynamic_section + dynamic_nent;
7780 ++entry)
7781 {
7782 Elf_Internal_Shdr section;
7783
7784 if (entry->d_tag != DT_SYMTAB)
7785 continue;
7786
7787 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7788
7789 /* Since we do not know how big the symbol table is,
7790 we default to reading in the entire file (!) and
7791 processing that. This is overkill, I know, but it
7792 should work. */
7793 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7794
7795 if (archive_file_offset != 0)
7796 section.sh_size = archive_file_size - section.sh_offset;
7797 else
7798 {
7799 if (fseek (file, 0, SEEK_END))
7800 error (_("Unable to seek to end of file!\n"));
7801
7802 section.sh_size = ftell (file) - section.sh_offset;
7803 }
7804
7805 if (is_32bit_elf)
7806 section.sh_entsize = sizeof (Elf32_External_Sym);
7807 else
7808 section.sh_entsize = sizeof (Elf64_External_Sym);
7809
7810 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
7811 if (num_dynamic_syms < 1)
7812 {
7813 error (_("Unable to determine the number of symbols to load\n"));
7814 continue;
7815 }
7816 }
7817 }
7818
7819 /* Similarly find a string table. */
7820 if (dynamic_strings == NULL)
7821 {
7822 for (entry = dynamic_section;
7823 entry < dynamic_section + dynamic_nent;
7824 ++entry)
7825 {
7826 unsigned long offset;
7827 long str_tab_len;
7828
7829 if (entry->d_tag != DT_STRTAB)
7830 continue;
7831
7832 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7833
7834 /* Since we do not know how big the string table is,
7835 we default to reading in the entire file (!) and
7836 processing that. This is overkill, I know, but it
7837 should work. */
7838
7839 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7840
7841 if (archive_file_offset != 0)
7842 str_tab_len = archive_file_size - offset;
7843 else
7844 {
7845 if (fseek (file, 0, SEEK_END))
7846 error (_("Unable to seek to end of file\n"));
7847 str_tab_len = ftell (file) - offset;
7848 }
7849
7850 if (str_tab_len < 1)
7851 {
7852 error
7853 (_("Unable to determine the length of the dynamic string table\n"));
7854 continue;
7855 }
7856
7857 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7858 str_tab_len,
7859 _("dynamic string table"));
7860 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7861 break;
7862 }
7863 }
7864
7865 /* And find the syminfo section if available. */
7866 if (dynamic_syminfo == NULL)
7867 {
7868 unsigned long syminsz = 0;
7869
7870 for (entry = dynamic_section;
7871 entry < dynamic_section + dynamic_nent;
7872 ++entry)
7873 {
7874 if (entry->d_tag == DT_SYMINENT)
7875 {
7876 /* Note: these braces are necessary to avoid a syntax
7877 error from the SunOS4 C compiler. */
7878 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7879 }
7880 else if (entry->d_tag == DT_SYMINSZ)
7881 syminsz = entry->d_un.d_val;
7882 else if (entry->d_tag == DT_SYMINFO)
7883 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7884 syminsz);
7885 }
7886
7887 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7888 {
7889 Elf_External_Syminfo * extsyminfo;
7890 Elf_External_Syminfo * extsym;
7891 Elf_Internal_Syminfo * syminfo;
7892
7893 /* There is a syminfo section. Read the data. */
7894 extsyminfo = (Elf_External_Syminfo *)
7895 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7896 _("symbol information"));
7897 if (!extsyminfo)
7898 return 0;
7899
7900 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7901 if (dynamic_syminfo == NULL)
7902 {
7903 error (_("Out of memory\n"));
7904 return 0;
7905 }
7906
7907 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7908 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7909 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7910 ++syminfo, ++extsym)
7911 {
7912 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7913 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7914 }
7915
7916 free (extsyminfo);
7917 }
7918 }
7919
7920 if (do_dynamic && dynamic_addr)
7921 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7922 dynamic_addr, dynamic_nent);
7923 if (do_dynamic)
7924 printf (_(" Tag Type Name/Value\n"));
7925
7926 for (entry = dynamic_section;
7927 entry < dynamic_section + dynamic_nent;
7928 entry++)
7929 {
7930 if (do_dynamic)
7931 {
7932 const char * dtype;
7933
7934 putchar (' ');
7935 print_vma (entry->d_tag, FULL_HEX);
7936 dtype = get_dynamic_type (entry->d_tag);
7937 printf (" (%s)%*s", dtype,
7938 ((is_32bit_elf ? 27 : 19)
7939 - (int) strlen (dtype)),
7940 " ");
7941 }
7942
7943 switch (entry->d_tag)
7944 {
7945 case DT_FLAGS:
7946 if (do_dynamic)
7947 print_dynamic_flags (entry->d_un.d_val);
7948 break;
7949
7950 case DT_AUXILIARY:
7951 case DT_FILTER:
7952 case DT_CONFIG:
7953 case DT_DEPAUDIT:
7954 case DT_AUDIT:
7955 if (do_dynamic)
7956 {
7957 switch (entry->d_tag)
7958 {
7959 case DT_AUXILIARY:
7960 printf (_("Auxiliary library"));
7961 break;
7962
7963 case DT_FILTER:
7964 printf (_("Filter library"));
7965 break;
7966
7967 case DT_CONFIG:
7968 printf (_("Configuration file"));
7969 break;
7970
7971 case DT_DEPAUDIT:
7972 printf (_("Dependency audit library"));
7973 break;
7974
7975 case DT_AUDIT:
7976 printf (_("Audit library"));
7977 break;
7978 }
7979
7980 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7981 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7982 else
7983 {
7984 printf (": ");
7985 print_vma (entry->d_un.d_val, PREFIX_HEX);
7986 putchar ('\n');
7987 }
7988 }
7989 break;
7990
7991 case DT_FEATURE:
7992 if (do_dynamic)
7993 {
7994 printf (_("Flags:"));
7995
7996 if (entry->d_un.d_val == 0)
7997 printf (_(" None\n"));
7998 else
7999 {
8000 unsigned long int val = entry->d_un.d_val;
8001
8002 if (val & DTF_1_PARINIT)
8003 {
8004 printf (" PARINIT");
8005 val ^= DTF_1_PARINIT;
8006 }
8007 if (val & DTF_1_CONFEXP)
8008 {
8009 printf (" CONFEXP");
8010 val ^= DTF_1_CONFEXP;
8011 }
8012 if (val != 0)
8013 printf (" %lx", val);
8014 puts ("");
8015 }
8016 }
8017 break;
8018
8019 case DT_POSFLAG_1:
8020 if (do_dynamic)
8021 {
8022 printf (_("Flags:"));
8023
8024 if (entry->d_un.d_val == 0)
8025 printf (_(" None\n"));
8026 else
8027 {
8028 unsigned long int val = entry->d_un.d_val;
8029
8030 if (val & DF_P1_LAZYLOAD)
8031 {
8032 printf (" LAZYLOAD");
8033 val ^= DF_P1_LAZYLOAD;
8034 }
8035 if (val & DF_P1_GROUPPERM)
8036 {
8037 printf (" GROUPPERM");
8038 val ^= DF_P1_GROUPPERM;
8039 }
8040 if (val != 0)
8041 printf (" %lx", val);
8042 puts ("");
8043 }
8044 }
8045 break;
8046
8047 case DT_FLAGS_1:
8048 if (do_dynamic)
8049 {
8050 printf (_("Flags:"));
8051 if (entry->d_un.d_val == 0)
8052 printf (_(" None\n"));
8053 else
8054 {
8055 unsigned long int val = entry->d_un.d_val;
8056
8057 if (val & DF_1_NOW)
8058 {
8059 printf (" NOW");
8060 val ^= DF_1_NOW;
8061 }
8062 if (val & DF_1_GLOBAL)
8063 {
8064 printf (" GLOBAL");
8065 val ^= DF_1_GLOBAL;
8066 }
8067 if (val & DF_1_GROUP)
8068 {
8069 printf (" GROUP");
8070 val ^= DF_1_GROUP;
8071 }
8072 if (val & DF_1_NODELETE)
8073 {
8074 printf (" NODELETE");
8075 val ^= DF_1_NODELETE;
8076 }
8077 if (val & DF_1_LOADFLTR)
8078 {
8079 printf (" LOADFLTR");
8080 val ^= DF_1_LOADFLTR;
8081 }
8082 if (val & DF_1_INITFIRST)
8083 {
8084 printf (" INITFIRST");
8085 val ^= DF_1_INITFIRST;
8086 }
8087 if (val & DF_1_NOOPEN)
8088 {
8089 printf (" NOOPEN");
8090 val ^= DF_1_NOOPEN;
8091 }
8092 if (val & DF_1_ORIGIN)
8093 {
8094 printf (" ORIGIN");
8095 val ^= DF_1_ORIGIN;
8096 }
8097 if (val & DF_1_DIRECT)
8098 {
8099 printf (" DIRECT");
8100 val ^= DF_1_DIRECT;
8101 }
8102 if (val & DF_1_TRANS)
8103 {
8104 printf (" TRANS");
8105 val ^= DF_1_TRANS;
8106 }
8107 if (val & DF_1_INTERPOSE)
8108 {
8109 printf (" INTERPOSE");
8110 val ^= DF_1_INTERPOSE;
8111 }
8112 if (val & DF_1_NODEFLIB)
8113 {
8114 printf (" NODEFLIB");
8115 val ^= DF_1_NODEFLIB;
8116 }
8117 if (val & DF_1_NODUMP)
8118 {
8119 printf (" NODUMP");
8120 val ^= DF_1_NODUMP;
8121 }
8122 if (val & DF_1_CONFALT)
8123 {
8124 printf (" CONFALT");
8125 val ^= DF_1_CONFALT;
8126 }
8127 if (val & DF_1_ENDFILTEE)
8128 {
8129 printf (" ENDFILTEE");
8130 val ^= DF_1_ENDFILTEE;
8131 }
8132 if (val & DF_1_DISPRELDNE)
8133 {
8134 printf (" DISPRELDNE");
8135 val ^= DF_1_DISPRELDNE;
8136 }
8137 if (val & DF_1_DISPRELPND)
8138 {
8139 printf (" DISPRELPND");
8140 val ^= DF_1_DISPRELPND;
8141 }
8142 if (val & DF_1_NODIRECT)
8143 {
8144 printf (" NODIRECT");
8145 val ^= DF_1_NODIRECT;
8146 }
8147 if (val & DF_1_IGNMULDEF)
8148 {
8149 printf (" IGNMULDEF");
8150 val ^= DF_1_IGNMULDEF;
8151 }
8152 if (val & DF_1_NOKSYMS)
8153 {
8154 printf (" NOKSYMS");
8155 val ^= DF_1_NOKSYMS;
8156 }
8157 if (val & DF_1_NOHDR)
8158 {
8159 printf (" NOHDR");
8160 val ^= DF_1_NOHDR;
8161 }
8162 if (val & DF_1_EDITED)
8163 {
8164 printf (" EDITED");
8165 val ^= DF_1_EDITED;
8166 }
8167 if (val & DF_1_NORELOC)
8168 {
8169 printf (" NORELOC");
8170 val ^= DF_1_NORELOC;
8171 }
8172 if (val & DF_1_SYMINTPOSE)
8173 {
8174 printf (" SYMINTPOSE");
8175 val ^= DF_1_SYMINTPOSE;
8176 }
8177 if (val & DF_1_GLOBAUDIT)
8178 {
8179 printf (" GLOBAUDIT");
8180 val ^= DF_1_GLOBAUDIT;
8181 }
8182 if (val & DF_1_SINGLETON)
8183 {
8184 printf (" SINGLETON");
8185 val ^= DF_1_SINGLETON;
8186 }
8187 if (val != 0)
8188 printf (" %lx", val);
8189 puts ("");
8190 }
8191 }
8192 break;
8193
8194 case DT_PLTREL:
8195 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8196 if (do_dynamic)
8197 puts (get_dynamic_type (entry->d_un.d_val));
8198 break;
8199
8200 case DT_NULL :
8201 case DT_NEEDED :
8202 case DT_PLTGOT :
8203 case DT_HASH :
8204 case DT_STRTAB :
8205 case DT_SYMTAB :
8206 case DT_RELA :
8207 case DT_INIT :
8208 case DT_FINI :
8209 case DT_SONAME :
8210 case DT_RPATH :
8211 case DT_SYMBOLIC:
8212 case DT_REL :
8213 case DT_DEBUG :
8214 case DT_TEXTREL :
8215 case DT_JMPREL :
8216 case DT_RUNPATH :
8217 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8218
8219 if (do_dynamic)
8220 {
8221 char * name;
8222
8223 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8224 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8225 else
8226 name = NULL;
8227
8228 if (name)
8229 {
8230 switch (entry->d_tag)
8231 {
8232 case DT_NEEDED:
8233 printf (_("Shared library: [%s]"), name);
8234
8235 if (streq (name, program_interpreter))
8236 printf (_(" program interpreter"));
8237 break;
8238
8239 case DT_SONAME:
8240 printf (_("Library soname: [%s]"), name);
8241 break;
8242
8243 case DT_RPATH:
8244 printf (_("Library rpath: [%s]"), name);
8245 break;
8246
8247 case DT_RUNPATH:
8248 printf (_("Library runpath: [%s]"), name);
8249 break;
8250
8251 default:
8252 print_vma (entry->d_un.d_val, PREFIX_HEX);
8253 break;
8254 }
8255 }
8256 else
8257 print_vma (entry->d_un.d_val, PREFIX_HEX);
8258
8259 putchar ('\n');
8260 }
8261 break;
8262
8263 case DT_PLTRELSZ:
8264 case DT_RELASZ :
8265 case DT_STRSZ :
8266 case DT_RELSZ :
8267 case DT_RELAENT :
8268 case DT_SYMENT :
8269 case DT_RELENT :
8270 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8271 case DT_PLTPADSZ:
8272 case DT_MOVEENT :
8273 case DT_MOVESZ :
8274 case DT_INIT_ARRAYSZ:
8275 case DT_FINI_ARRAYSZ:
8276 case DT_GNU_CONFLICTSZ:
8277 case DT_GNU_LIBLISTSZ:
8278 if (do_dynamic)
8279 {
8280 print_vma (entry->d_un.d_val, UNSIGNED);
8281 printf (_(" (bytes)\n"));
8282 }
8283 break;
8284
8285 case DT_VERDEFNUM:
8286 case DT_VERNEEDNUM:
8287 case DT_RELACOUNT:
8288 case DT_RELCOUNT:
8289 if (do_dynamic)
8290 {
8291 print_vma (entry->d_un.d_val, UNSIGNED);
8292 putchar ('\n');
8293 }
8294 break;
8295
8296 case DT_SYMINSZ:
8297 case DT_SYMINENT:
8298 case DT_SYMINFO:
8299 case DT_USED:
8300 case DT_INIT_ARRAY:
8301 case DT_FINI_ARRAY:
8302 if (do_dynamic)
8303 {
8304 if (entry->d_tag == DT_USED
8305 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8306 {
8307 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8308
8309 if (*name)
8310 {
8311 printf (_("Not needed object: [%s]\n"), name);
8312 break;
8313 }
8314 }
8315
8316 print_vma (entry->d_un.d_val, PREFIX_HEX);
8317 putchar ('\n');
8318 }
8319 break;
8320
8321 case DT_BIND_NOW:
8322 /* The value of this entry is ignored. */
8323 if (do_dynamic)
8324 putchar ('\n');
8325 break;
8326
8327 case DT_GNU_PRELINKED:
8328 if (do_dynamic)
8329 {
8330 struct tm * tmp;
8331 time_t atime = entry->d_un.d_val;
8332
8333 tmp = gmtime (&atime);
8334 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8335 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8336 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8337
8338 }
8339 break;
8340
8341 case DT_GNU_HASH:
8342 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8343 if (do_dynamic)
8344 {
8345 print_vma (entry->d_un.d_val, PREFIX_HEX);
8346 putchar ('\n');
8347 }
8348 break;
8349
8350 default:
8351 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8352 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8353 entry->d_un.d_val;
8354
8355 if (do_dynamic)
8356 {
8357 switch (elf_header.e_machine)
8358 {
8359 case EM_MIPS:
8360 case EM_MIPS_RS3_LE:
8361 dynamic_section_mips_val (entry);
8362 break;
8363 case EM_PARISC:
8364 dynamic_section_parisc_val (entry);
8365 break;
8366 case EM_IA_64:
8367 dynamic_section_ia64_val (entry);
8368 break;
8369 default:
8370 print_vma (entry->d_un.d_val, PREFIX_HEX);
8371 putchar ('\n');
8372 }
8373 }
8374 break;
8375 }
8376 }
8377
8378 return 1;
8379}
8380
8381static char *
8382get_ver_flags (unsigned int flags)
8383{
8384 static char buff[32];
8385
8386 buff[0] = 0;
8387
8388 if (flags == 0)
8389 return _("none");
8390
8391 if (flags & VER_FLG_BASE)
8392 strcat (buff, "BASE ");
8393
8394 if (flags & VER_FLG_WEAK)
8395 {
8396 if (flags & VER_FLG_BASE)
8397 strcat (buff, "| ");
8398
8399 strcat (buff, "WEAK ");
8400 }
8401
8402 if (flags & VER_FLG_INFO)
8403 {
8404 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8405 strcat (buff, "| ");
8406
8407 strcat (buff, "INFO ");
8408 }
8409
8410 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8411 strcat (buff, _("| <unknown>"));
8412
8413 return buff;
8414}
8415
8416/* Display the contents of the version sections. */
8417
8418static int
8419process_version_sections (FILE * file)
8420{
8421 Elf_Internal_Shdr * section;
8422 unsigned i;
8423 int found = 0;
8424
8425 if (! do_version)
8426 return 1;
8427
8428 for (i = 0, section = section_headers;
8429 i < elf_header.e_shnum;
8430 i++, section++)
8431 {
8432 switch (section->sh_type)
8433 {
8434 case SHT_GNU_verdef:
8435 {
8436 Elf_External_Verdef * edefs;
8437 unsigned int idx;
8438 unsigned int cnt;
8439 char * endbuf;
8440
8441 found = 1;
8442
8443 printf
8444 (_("\nVersion definition section '%s' contains %u entries:\n"),
8445 SECTION_NAME (section), section->sh_info);
8446
8447 printf (_(" Addr: 0x"));
8448 printf_vma (section->sh_addr);
8449 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8450 (unsigned long) section->sh_offset, section->sh_link,
8451 section->sh_link < elf_header.e_shnum
8452 ? SECTION_NAME (section_headers + section->sh_link)
8453 : _("<corrupt>"));
8454
8455 edefs = (Elf_External_Verdef *)
8456 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8457 _("version definition section"));
8458 if (!edefs)
8459 break;
8460 endbuf = (char *) edefs + section->sh_size;
8461
8462 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8463 {
8464 char * vstart;
8465 Elf_External_Verdef * edef;
8466 Elf_Internal_Verdef ent;
8467 Elf_External_Verdaux * eaux;
8468 Elf_Internal_Verdaux aux;
8469 int j;
8470 int isum;
8471
8472 /* Check for negative or very large indicies. */
8473 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8474 break;
8475
8476 vstart = ((char *) edefs) + idx;
8477 if (vstart + sizeof (*edef) > endbuf)
8478 break;
8479
8480 edef = (Elf_External_Verdef *) vstart;
8481
8482 ent.vd_version = BYTE_GET (edef->vd_version);
8483 ent.vd_flags = BYTE_GET (edef->vd_flags);
8484 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8485 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8486 ent.vd_hash = BYTE_GET (edef->vd_hash);
8487 ent.vd_aux = BYTE_GET (edef->vd_aux);
8488 ent.vd_next = BYTE_GET (edef->vd_next);
8489
8490 printf (_(" %#06x: Rev: %d Flags: %s"),
8491 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8492
8493 printf (_(" Index: %d Cnt: %d "),
8494 ent.vd_ndx, ent.vd_cnt);
8495
8496 /* Check for overflow. */
8497 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8498 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8499 break;
8500
8501 vstart += ent.vd_aux;
8502
8503 eaux = (Elf_External_Verdaux *) vstart;
8504
8505 aux.vda_name = BYTE_GET (eaux->vda_name);
8506 aux.vda_next = BYTE_GET (eaux->vda_next);
8507
8508 if (VALID_DYNAMIC_NAME (aux.vda_name))
8509 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8510 else
8511 printf (_("Name index: %ld\n"), aux.vda_name);
8512
8513 isum = idx + ent.vd_aux;
8514
8515 for (j = 1; j < ent.vd_cnt; j++)
8516 {
8517 /* Check for overflow. */
8518 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8519 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8520 break;
8521
8522 isum += aux.vda_next;
8523 vstart += aux.vda_next;
8524
8525 eaux = (Elf_External_Verdaux *) vstart;
8526 if (vstart + sizeof (*eaux) > endbuf)
8527 break;
8528
8529 aux.vda_name = BYTE_GET (eaux->vda_name);
8530 aux.vda_next = BYTE_GET (eaux->vda_next);
8531
8532 if (VALID_DYNAMIC_NAME (aux.vda_name))
8533 printf (_(" %#06x: Parent %d: %s\n"),
8534 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8535 else
8536 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8537 isum, j, aux.vda_name);
8538 }
8539
8540 if (j < ent.vd_cnt)
8541 printf (_(" Version def aux past end of section\n"));
8542
8543 idx += ent.vd_next;
8544 }
8545
8546 if (cnt < section->sh_info)
8547 printf (_(" Version definition past end of section\n"));
8548
8549 free (edefs);
8550 }
8551 break;
8552
8553 case SHT_GNU_verneed:
8554 {
8555 Elf_External_Verneed * eneed;
8556 unsigned int idx;
8557 unsigned int cnt;
8558 char * endbuf;
8559
8560 found = 1;
8561
8562 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8563 SECTION_NAME (section), section->sh_info);
8564
8565 printf (_(" Addr: 0x"));
8566 printf_vma (section->sh_addr);
8567 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8568 (unsigned long) section->sh_offset, section->sh_link,
8569 section->sh_link < elf_header.e_shnum
8570 ? SECTION_NAME (section_headers + section->sh_link)
8571 : _("<corrupt>"));
8572
8573 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8574 section->sh_offset, 1,
8575 section->sh_size,
8576 _("Version Needs section"));
8577 if (!eneed)
8578 break;
8579 endbuf = (char *) eneed + section->sh_size;
8580
8581 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8582 {
8583 Elf_External_Verneed * entry;
8584 Elf_Internal_Verneed ent;
8585 int j;
8586 int isum;
8587 char * vstart;
8588
8589 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8590 break;
8591
8592 vstart = ((char *) eneed) + idx;
8593 if (vstart + sizeof (*entry) > endbuf)
8594 break;
8595
8596 entry = (Elf_External_Verneed *) vstart;
8597
8598 ent.vn_version = BYTE_GET (entry->vn_version);
8599 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8600 ent.vn_file = BYTE_GET (entry->vn_file);
8601 ent.vn_aux = BYTE_GET (entry->vn_aux);
8602 ent.vn_next = BYTE_GET (entry->vn_next);
8603
8604 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8605
8606 if (VALID_DYNAMIC_NAME (ent.vn_file))
8607 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8608 else
8609 printf (_(" File: %lx"), ent.vn_file);
8610
8611 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8612
8613 /* Check for overflow. */
8614 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8615 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8616 break;
8617
8618 vstart += ent.vn_aux;
8619
8620 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8621 {
8622 Elf_External_Vernaux * eaux;
8623 Elf_Internal_Vernaux aux;
8624
8625 if (vstart + sizeof (*eaux) > endbuf)
8626 break;
8627 eaux = (Elf_External_Vernaux *) vstart;
8628
8629 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8630 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8631 aux.vna_other = BYTE_GET (eaux->vna_other);
8632 aux.vna_name = BYTE_GET (eaux->vna_name);
8633 aux.vna_next = BYTE_GET (eaux->vna_next);
8634
8635 if (VALID_DYNAMIC_NAME (aux.vna_name))
8636 printf (_(" %#06x: Name: %s"),
8637 isum, GET_DYNAMIC_NAME (aux.vna_name));
8638 else
8639 printf (_(" %#06x: Name index: %lx"),
8640 isum, aux.vna_name);
8641
8642 printf (_(" Flags: %s Version: %d\n"),
8643 get_ver_flags (aux.vna_flags), aux.vna_other);
8644
8645 /* Check for overflow. */
8646 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8647 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8648 break;
8649
8650 isum += aux.vna_next;
8651 vstart += aux.vna_next;
8652 }
8653
8654 if (j < ent.vn_cnt)
8655 warn (_("Missing Version Needs auxillary information\n"));
8656
8657 idx += ent.vn_next;
8658 }
8659
8660 if (cnt < section->sh_info)
8661 warn (_("Missing Version Needs information\n"));
8662
8663 free (eneed);
8664 }
8665 break;
8666
8667 case SHT_GNU_versym:
8668 {
8669 Elf_Internal_Shdr * link_section;
8670 int total;
8671 int cnt;
8672 unsigned char * edata;
8673 unsigned short * data;
8674 char * strtab;
8675 Elf_Internal_Sym * symbols;
8676 Elf_Internal_Shdr * string_sec;
8677 unsigned long num_syms;
8678 long off;
8679
8680 if (section->sh_link >= elf_header.e_shnum)
8681 break;
8682
8683 link_section = section_headers + section->sh_link;
8684 total = section->sh_size / sizeof (Elf_External_Versym);
8685
8686 if (link_section->sh_link >= elf_header.e_shnum)
8687 break;
8688
8689 found = 1;
8690
8691 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
8692 if (symbols == NULL)
8693 break;
8694
8695 string_sec = section_headers + link_section->sh_link;
8696
8697 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8698 string_sec->sh_size,
8699 _("version string table"));
8700 if (!strtab)
8701 {
8702 free (symbols);
8703 break;
8704 }
8705
8706 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8707 SECTION_NAME (section), total);
8708
8709 printf (_(" Addr: "));
8710 printf_vma (section->sh_addr);
8711 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8712 (unsigned long) section->sh_offset, section->sh_link,
8713 SECTION_NAME (link_section));
8714
8715 off = offset_from_vma (file,
8716 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8717 total * sizeof (short));
8718 edata = (unsigned char *) get_data (NULL, file, off, total,
8719 sizeof (short),
8720 _("version symbol data"));
8721 if (!edata)
8722 {
8723 free (strtab);
8724 free (symbols);
8725 break;
8726 }
8727
8728 data = (short unsigned int *) cmalloc (total, sizeof (short));
8729
8730 for (cnt = total; cnt --;)
8731 data[cnt] = byte_get (edata + cnt * sizeof (short),
8732 sizeof (short));
8733
8734 free (edata);
8735
8736 for (cnt = 0; cnt < total; cnt += 4)
8737 {
8738 int j, nn;
8739 int check_def, check_need;
8740 char * name;
8741
8742 printf (" %03x:", cnt);
8743
8744 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8745 switch (data[cnt + j])
8746 {
8747 case 0:
8748 fputs (_(" 0 (*local*) "), stdout);
8749 break;
8750
8751 case 1:
8752 fputs (_(" 1 (*global*) "), stdout);
8753 break;
8754
8755 default:
8756 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8757 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8758
8759 /* If this index value is greater than the size of the symbols
8760 array, break to avoid an out-of-bounds read. */
8761 if ((unsigned long)(cnt + j) >= num_syms)
8762 {
8763 warn (_("invalid index into symbol array\n"));
8764 break;
8765 }
8766
8767 check_def = 1;
8768 check_need = 1;
8769 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8770 || section_headers[symbols[cnt + j].st_shndx].sh_type
8771 != SHT_NOBITS)
8772 {
8773 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8774 check_def = 0;
8775 else
8776 check_need = 0;
8777 }
8778
8779 if (check_need
8780 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8781 {
8782 Elf_Internal_Verneed ivn;
8783 unsigned long offset;
8784
8785 offset = offset_from_vma
8786 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8787 sizeof (Elf_External_Verneed));
8788
8789 do
8790 {
8791 Elf_Internal_Vernaux ivna;
8792 Elf_External_Verneed evn;
8793 Elf_External_Vernaux evna;
8794 unsigned long a_off;
8795
8796 if (get_data (&evn, file, offset, sizeof (evn), 1,
8797 _("version need")) == NULL)
8798 break;
8799
8800 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8801 ivn.vn_next = BYTE_GET (evn.vn_next);
8802
8803 a_off = offset + ivn.vn_aux;
8804
8805 do
8806 {
8807 if (get_data (&evna, file, a_off, sizeof (evna),
8808 1, _("version need aux (2)")) == NULL)
8809 {
8810 ivna.vna_next = 0;
8811 ivna.vna_other = 0;
8812 }
8813 else
8814 {
8815 ivna.vna_next = BYTE_GET (evna.vna_next);
8816 ivna.vna_other = BYTE_GET (evna.vna_other);
8817 }
8818
8819 a_off += ivna.vna_next;
8820 }
8821 while (ivna.vna_other != data[cnt + j]
8822 && ivna.vna_next != 0);
8823
8824 if (ivna.vna_other == data[cnt + j])
8825 {
8826 ivna.vna_name = BYTE_GET (evna.vna_name);
8827
8828 if (ivna.vna_name >= string_sec->sh_size)
8829 name = _("*invalid*");
8830 else
8831 name = strtab + ivna.vna_name;
8832 nn += printf ("(%s%-*s",
8833 name,
8834 12 - (int) strlen (name),
8835 ")");
8836 check_def = 0;
8837 break;
8838 }
8839
8840 offset += ivn.vn_next;
8841 }
8842 while (ivn.vn_next);
8843 }
8844
8845 if (check_def && data[cnt + j] != 0x8001
8846 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8847 {
8848 Elf_Internal_Verdef ivd;
8849 Elf_External_Verdef evd;
8850 unsigned long offset;
8851
8852 offset = offset_from_vma
8853 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8854 sizeof evd);
8855
8856 do
8857 {
8858 if (get_data (&evd, file, offset, sizeof (evd), 1,
8859 _("version def")) == NULL)
8860 {
8861 ivd.vd_next = 0;
8862 ivd.vd_ndx = 0;
8863 }
8864 else
8865 {
8866 ivd.vd_next = BYTE_GET (evd.vd_next);
8867 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8868 }
8869
8870 offset += ivd.vd_next;
8871 }
8872 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8873 && ivd.vd_next != 0);
8874
8875 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8876 {
8877 Elf_External_Verdaux evda;
8878 Elf_Internal_Verdaux ivda;
8879
8880 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8881
8882 if (get_data (&evda, file,
8883 offset - ivd.vd_next + ivd.vd_aux,
8884 sizeof (evda), 1,
8885 _("version def aux")) == NULL)
8886 break;
8887
8888 ivda.vda_name = BYTE_GET (evda.vda_name);
8889
8890 if (ivda.vda_name >= string_sec->sh_size)
8891 name = _("*invalid*");
8892 else
8893 name = strtab + ivda.vda_name;
8894 nn += printf ("(%s%-*s",
8895 name,
8896 12 - (int) strlen (name),
8897 ")");
8898 }
8899 }
8900
8901 if (nn < 18)
8902 printf ("%*c", 18 - nn, ' ');
8903 }
8904
8905 putchar ('\n');
8906 }
8907
8908 free (data);
8909 free (strtab);
8910 free (symbols);
8911 }
8912 break;
8913
8914 default:
8915 break;
8916 }
8917 }
8918
8919 if (! found)
8920 printf (_("\nNo version information found in this file.\n"));
8921
8922 return 1;
8923}
8924
8925static const char *
8926get_symbol_binding (unsigned int binding)
8927{
8928 static char buff[32];
8929
8930 switch (binding)
8931 {
8932 case STB_LOCAL: return "LOCAL";
8933 case STB_GLOBAL: return "GLOBAL";
8934 case STB_WEAK: return "WEAK";
8935 default:
8936 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8937 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8938 binding);
8939 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8940 {
8941 if (binding == STB_GNU_UNIQUE
8942 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8943 /* GNU is still using the default value 0. */
8944 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8945 return "UNIQUE";
8946 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8947 }
8948 else
8949 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8950 return buff;
8951 }
8952}
8953
8954static const char *
8955get_symbol_type (unsigned int type)
8956{
8957 static char buff[32];
8958
8959 switch (type)
8960 {
8961 case STT_NOTYPE: return "NOTYPE";
8962 case STT_OBJECT: return "OBJECT";
8963 case STT_FUNC: return "FUNC";
8964 case STT_SECTION: return "SECTION";
8965 case STT_FILE: return "FILE";
8966 case STT_COMMON: return "COMMON";
8967 case STT_TLS: return "TLS";
8968 case STT_RELC: return "RELC";
8969 case STT_SRELC: return "SRELC";
8970 default:
8971 if (type >= STT_LOPROC && type <= STT_HIPROC)
8972 {
8973 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8974 return "THUMB_FUNC";
8975
8976 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8977 return "REGISTER";
8978
8979 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8980 return "PARISC_MILLI";
8981
8982 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8983 }
8984 else if (type >= STT_LOOS && type <= STT_HIOS)
8985 {
8986 if (elf_header.e_machine == EM_PARISC)
8987 {
8988 if (type == STT_HP_OPAQUE)
8989 return "HP_OPAQUE";
8990 if (type == STT_HP_STUB)
8991 return "HP_STUB";
8992 }
8993
8994 if (type == STT_GNU_IFUNC
8995 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8996 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
8997 /* GNU is still using the default value 0. */
8998 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8999 return "IFUNC";
9000
9001 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9002 }
9003 else
9004 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9005 return buff;
9006 }
9007}
9008
9009static const char *
9010get_symbol_visibility (unsigned int visibility)
9011{
9012 switch (visibility)
9013 {
9014 case STV_DEFAULT: return "DEFAULT";
9015 case STV_INTERNAL: return "INTERNAL";
9016 case STV_HIDDEN: return "HIDDEN";
9017 case STV_PROTECTED: return "PROTECTED";
9018 default: abort ();
9019 }
9020}
9021
9022static const char *
9023get_mips_symbol_other (unsigned int other)
9024{
9025 switch (other)
9026 {
9027 case STO_OPTIONAL:
9028 return "OPTIONAL";
9029 case STO_MIPS_PLT:
9030 return "MIPS PLT";
9031 case STO_MIPS_PIC:
9032 return "MIPS PIC";
9033 case STO_MICROMIPS:
9034 return "MICROMIPS";
9035 case STO_MICROMIPS | STO_MIPS_PIC:
9036 return "MICROMIPS, MIPS PIC";
9037 case STO_MIPS16:
9038 return "MIPS16";
9039 default:
9040 return NULL;
9041 }
9042}
9043
9044static const char *
9045get_ia64_symbol_other (unsigned int other)
9046{
9047 if (is_ia64_vms ())
9048 {
9049 static char res[32];
9050
9051 res[0] = 0;
9052
9053 /* Function types is for images and .STB files only. */
9054 switch (elf_header.e_type)
9055 {
9056 case ET_DYN:
9057 case ET_EXEC:
9058 switch (VMS_ST_FUNC_TYPE (other))
9059 {
9060 case VMS_SFT_CODE_ADDR:
9061 strcat (res, " CA");
9062 break;
9063 case VMS_SFT_SYMV_IDX:
9064 strcat (res, " VEC");
9065 break;
9066 case VMS_SFT_FD:
9067 strcat (res, " FD");
9068 break;
9069 case VMS_SFT_RESERVE:
9070 strcat (res, " RSV");
9071 break;
9072 default:
9073 abort ();
9074 }
9075 break;
9076 default:
9077 break;
9078 }
9079 switch (VMS_ST_LINKAGE (other))
9080 {
9081 case VMS_STL_IGNORE:
9082 strcat (res, " IGN");
9083 break;
9084 case VMS_STL_RESERVE:
9085 strcat (res, " RSV");
9086 break;
9087 case VMS_STL_STD:
9088 strcat (res, " STD");
9089 break;
9090 case VMS_STL_LNK:
9091 strcat (res, " LNK");
9092 break;
9093 default:
9094 abort ();
9095 }
9096
9097 if (res[0] != 0)
9098 return res + 1;
9099 else
9100 return res;
9101 }
9102 return NULL;
9103}
9104
9105static const char *
9106get_symbol_other (unsigned int other)
9107{
9108 const char * result = NULL;
9109 static char buff [32];
9110
9111 if (other == 0)
9112 return "";
9113
9114 switch (elf_header.e_machine)
9115 {
9116 case EM_MIPS:
9117 result = get_mips_symbol_other (other);
9118 break;
9119 case EM_IA_64:
9120 result = get_ia64_symbol_other (other);
9121 break;
9122 default:
9123 break;
9124 }
9125
9126 if (result)
9127 return result;
9128
9129 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9130 return buff;
9131}
9132
9133static const char *
9134get_symbol_index_type (unsigned int type)
9135{
9136 static char buff[32];
9137
9138 switch (type)
9139 {
9140 case SHN_UNDEF: return "UND";
9141 case SHN_ABS: return "ABS";
9142 case SHN_COMMON: return "COM";
9143 default:
9144 if (type == SHN_IA_64_ANSI_COMMON
9145 && elf_header.e_machine == EM_IA_64
9146 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9147 return "ANSI_COM";
9148 else if ((elf_header.e_machine == EM_X86_64
9149 || elf_header.e_machine == EM_L1OM
9150 || elf_header.e_machine == EM_K1OM)
9151 && type == SHN_X86_64_LCOMMON)
9152 return "LARGE_COM";
9153 else if ((type == SHN_MIPS_SCOMMON
9154 && elf_header.e_machine == EM_MIPS)
9155 || (type == SHN_TIC6X_SCOMMON
9156 && elf_header.e_machine == EM_TI_C6000))
9157 return "SCOM";
9158 else if (type == SHN_MIPS_SUNDEFINED
9159 && elf_header.e_machine == EM_MIPS)
9160 return "SUND";
9161 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9162 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9163 else if (type >= SHN_LOOS && type <= SHN_HIOS)
9164 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9165 else if (type >= SHN_LORESERVE)
9166 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9167 else if (type >= elf_header.e_shnum)
9168 sprintf (buff, "bad section index[%3d]", type);
9169 else
9170 sprintf (buff, "%3d", type);
9171 break;
9172 }
9173
9174 return buff;
9175}
9176
9177static bfd_vma *
9178get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9179{
9180 unsigned char * e_data;
9181 bfd_vma * i_data;
9182
9183 e_data = (unsigned char *) cmalloc (number, ent_size);
9184
9185 if (e_data == NULL)
9186 {
9187 error (_("Out of memory\n"));
9188 return NULL;
9189 }
9190
9191 if (fread (e_data, ent_size, number, file) != number)
9192 {
9193 error (_("Unable to read in dynamic data\n"));
9194 return NULL;
9195 }
9196
9197 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9198
9199 if (i_data == NULL)
9200 {
9201 error (_("Out of memory\n"));
9202 free (e_data);
9203 return NULL;
9204 }
9205
9206 while (number--)
9207 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9208
9209 free (e_data);
9210
9211 return i_data;
9212}
9213
9214static void
9215print_dynamic_symbol (bfd_vma si, unsigned long hn)
9216{
9217 Elf_Internal_Sym * psym;
9218 int n;
9219
9220 psym = dynamic_symbols + si;
9221
9222 n = print_vma (si, DEC_5);
9223 if (n < 5)
9224 fputs (" " + n, stdout);
9225 printf (" %3lu: ", hn);
9226 print_vma (psym->st_value, LONG_HEX);
9227 putchar (' ');
9228 print_vma (psym->st_size, DEC_5);
9229
9230 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9231 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9232 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9233 /* Check to see if any other bits in the st_other field are set.
9234 Note - displaying this information disrupts the layout of the
9235 table being generated, but for the moment this case is very
9236 rare. */
9237 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9238 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9239 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9240 if (VALID_DYNAMIC_NAME (psym->st_name))
9241 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9242 else
9243 printf (_(" <corrupt: %14ld>"), psym->st_name);
9244 putchar ('\n');
9245}
9246
9247/* Dump the symbol table. */
9248static int
9249process_symbol_table (FILE * file)
9250{
9251 Elf_Internal_Shdr * section;
9252 bfd_vma nbuckets = 0;
9253 bfd_vma nchains = 0;
9254 bfd_vma * buckets = NULL;
9255 bfd_vma * chains = NULL;
9256 bfd_vma ngnubuckets = 0;
9257 bfd_vma * gnubuckets = NULL;
9258 bfd_vma * gnuchains = NULL;
9259 bfd_vma gnusymidx = 0;
9260
9261 if (!do_syms && !do_dyn_syms && !do_histogram)
9262 return 1;
9263
9264 if (dynamic_info[DT_HASH]
9265 && (do_histogram
9266 || (do_using_dynamic
9267 && !do_dyn_syms
9268 && dynamic_strings != NULL)))
9269 {
9270 unsigned char nb[8];
9271 unsigned char nc[8];
9272 int hash_ent_size = 4;
9273
9274 if ((elf_header.e_machine == EM_ALPHA
9275 || elf_header.e_machine == EM_S390
9276 || elf_header.e_machine == EM_S390_OLD)
9277 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9278 hash_ent_size = 8;
9279
9280 if (fseek (file,
9281 (archive_file_offset
9282 + offset_from_vma (file, dynamic_info[DT_HASH],
9283 sizeof nb + sizeof nc)),
9284 SEEK_SET))
9285 {
9286 error (_("Unable to seek to start of dynamic information\n"));
9287 goto no_hash;
9288 }
9289
9290 if (fread (nb, hash_ent_size, 1, file) != 1)
9291 {
9292 error (_("Failed to read in number of buckets\n"));
9293 goto no_hash;
9294 }
9295
9296 if (fread (nc, hash_ent_size, 1, file) != 1)
9297 {
9298 error (_("Failed to read in number of chains\n"));
9299 goto no_hash;
9300 }
9301
9302 nbuckets = byte_get (nb, hash_ent_size);
9303 nchains = byte_get (nc, hash_ent_size);
9304
9305 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9306 chains = get_dynamic_data (file, nchains, hash_ent_size);
9307
9308 no_hash:
9309 if (buckets == NULL || chains == NULL)
9310 {
9311 if (do_using_dynamic)
9312 return 0;
9313 free (buckets);
9314 free (chains);
9315 buckets = NULL;
9316 chains = NULL;
9317 nbuckets = 0;
9318 nchains = 0;
9319 }
9320 }
9321
9322 if (dynamic_info_DT_GNU_HASH
9323 && (do_histogram
9324 || (do_using_dynamic
9325 && !do_dyn_syms
9326 && dynamic_strings != NULL)))
9327 {
9328 unsigned char nb[16];
9329 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9330 bfd_vma buckets_vma;
9331
9332 if (fseek (file,
9333 (archive_file_offset
9334 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9335 sizeof nb)),
9336 SEEK_SET))
9337 {
9338 error (_("Unable to seek to start of dynamic information\n"));
9339 goto no_gnu_hash;
9340 }
9341
9342 if (fread (nb, 16, 1, file) != 1)
9343 {
9344 error (_("Failed to read in number of buckets\n"));
9345 goto no_gnu_hash;
9346 }
9347
9348 ngnubuckets = byte_get (nb, 4);
9349 gnusymidx = byte_get (nb + 4, 4);
9350 bitmaskwords = byte_get (nb + 8, 4);
9351 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9352 if (is_32bit_elf)
9353 buckets_vma += bitmaskwords * 4;
9354 else
9355 buckets_vma += bitmaskwords * 8;
9356
9357 if (fseek (file,
9358 (archive_file_offset
9359 + offset_from_vma (file, buckets_vma, 4)),
9360 SEEK_SET))
9361 {
9362 error (_("Unable to seek to start of dynamic information\n"));
9363 goto no_gnu_hash;
9364 }
9365
9366 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9367
9368 if (gnubuckets == NULL)
9369 goto no_gnu_hash;
9370
9371 for (i = 0; i < ngnubuckets; i++)
9372 if (gnubuckets[i] != 0)
9373 {
9374 if (gnubuckets[i] < gnusymidx)
9375 return 0;
9376
9377 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9378 maxchain = gnubuckets[i];
9379 }
9380
9381 if (maxchain == 0xffffffff)
9382 goto no_gnu_hash;
9383
9384 maxchain -= gnusymidx;
9385
9386 if (fseek (file,
9387 (archive_file_offset
9388 + offset_from_vma (file, buckets_vma
9389 + 4 * (ngnubuckets + maxchain), 4)),
9390 SEEK_SET))
9391 {
9392 error (_("Unable to seek to start of dynamic information\n"));
9393 goto no_gnu_hash;
9394 }
9395
9396 do
9397 {
9398 if (fread (nb, 4, 1, file) != 1)
9399 {
9400 error (_("Failed to determine last chain length\n"));
9401 goto no_gnu_hash;
9402 }
9403
9404 if (maxchain + 1 == 0)
9405 goto no_gnu_hash;
9406
9407 ++maxchain;
9408 }
9409 while ((byte_get (nb, 4) & 1) == 0);
9410
9411 if (fseek (file,
9412 (archive_file_offset
9413 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9414 SEEK_SET))
9415 {
9416 error (_("Unable to seek to start of dynamic information\n"));
9417 goto no_gnu_hash;
9418 }
9419
9420 gnuchains = get_dynamic_data (file, maxchain, 4);
9421
9422 no_gnu_hash:
9423 if (gnuchains == NULL)
9424 {
9425 free (gnubuckets);
9426 gnubuckets = NULL;
9427 ngnubuckets = 0;
9428 if (do_using_dynamic)
9429 return 0;
9430 }
9431 }
9432
9433 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9434 && do_syms
9435 && do_using_dynamic
9436 && dynamic_strings != NULL)
9437 {
9438 unsigned long hn;
9439
9440 if (dynamic_info[DT_HASH])
9441 {
9442 bfd_vma si;
9443
9444 printf (_("\nSymbol table for image:\n"));
9445 if (is_32bit_elf)
9446 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9447 else
9448 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9449
9450 for (hn = 0; hn < nbuckets; hn++)
9451 {
9452 if (! buckets[hn])
9453 continue;
9454
9455 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9456 print_dynamic_symbol (si, hn);
9457 }
9458 }
9459
9460 if (dynamic_info_DT_GNU_HASH)
9461 {
9462 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9463 if (is_32bit_elf)
9464 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9465 else
9466 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9467
9468 for (hn = 0; hn < ngnubuckets; ++hn)
9469 if (gnubuckets[hn] != 0)
9470 {
9471 bfd_vma si = gnubuckets[hn];
9472 bfd_vma off = si - gnusymidx;
9473
9474 do
9475 {
9476 print_dynamic_symbol (si, hn);
9477 si++;
9478 }
9479 while ((gnuchains[off++] & 1) == 0);
9480 }
9481 }
9482 }
9483 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9484 {
9485 unsigned int i;
9486
9487 for (i = 0, section = section_headers;
9488 i < elf_header.e_shnum;
9489 i++, section++)
9490 {
9491 unsigned int si;
9492 char * strtab = NULL;
9493 unsigned long int strtab_size = 0;
9494 Elf_Internal_Sym * symtab;
9495 Elf_Internal_Sym * psym;
9496 unsigned long num_syms;
9497
9498 if ((section->sh_type != SHT_SYMTAB
9499 && section->sh_type != SHT_DYNSYM)
9500 || (!do_syms
9501 && section->sh_type == SHT_SYMTAB))
9502 continue;
9503
9504 if (section->sh_entsize == 0)
9505 {
9506 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9507 SECTION_NAME (section));
9508 continue;
9509 }
9510
9511 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9512 SECTION_NAME (section),
9513 (unsigned long) (section->sh_size / section->sh_entsize));
9514
9515 if (is_32bit_elf)
9516 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9517 else
9518 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9519
9520 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9521 if (symtab == NULL)
9522 continue;
9523
9524 if (section->sh_link == elf_header.e_shstrndx)
9525 {
9526 strtab = string_table;
9527 strtab_size = string_table_length;
9528 }
9529 else if (section->sh_link < elf_header.e_shnum)
9530 {
9531 Elf_Internal_Shdr * string_sec;
9532
9533 string_sec = section_headers + section->sh_link;
9534
9535 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9536 1, string_sec->sh_size,
9537 _("string table"));
9538 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9539 }
9540
9541 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9542 {
9543 printf ("%6d: ", si);
9544 print_vma (psym->st_value, LONG_HEX);
9545 putchar (' ');
9546 print_vma (psym->st_size, DEC_5);
9547 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9548 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9549 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9550 /* Check to see if any other bits in the st_other field are set.
9551 Note - displaying this information disrupts the layout of the
9552 table being generated, but for the moment this case is very rare. */
9553 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9554 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9555 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9556 print_symbol (25, psym->st_name < strtab_size
9557 ? strtab + psym->st_name : _("<corrupt>"));
9558
9559 if (section->sh_type == SHT_DYNSYM
9560 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9561 {
9562 unsigned char data[2];
9563 unsigned short vers_data;
9564 unsigned long offset;
9565 int is_nobits;
9566 int check_def;
9567
9568 offset = offset_from_vma
9569 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9570 sizeof data + si * sizeof (vers_data));
9571
9572 if (get_data (&data, file, offset + si * sizeof (vers_data),
9573 sizeof (data), 1, _("version data")) == NULL)
9574 break;
9575
9576 vers_data = byte_get (data, 2);
9577
9578 is_nobits = (psym->st_shndx < elf_header.e_shnum
9579 && section_headers[psym->st_shndx].sh_type
9580 == SHT_NOBITS);
9581
9582 check_def = (psym->st_shndx != SHN_UNDEF);
9583
9584 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9585 {
9586 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9587 && (is_nobits || ! check_def))
9588 {
9589 Elf_External_Verneed evn;
9590 Elf_Internal_Verneed ivn;
9591 Elf_Internal_Vernaux ivna;
9592
9593 /* We must test both. */
9594 offset = offset_from_vma
9595 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9596 sizeof evn);
9597
9598 do
9599 {
9600 unsigned long vna_off;
9601
9602 if (get_data (&evn, file, offset, sizeof (evn), 1,
9603 _("version need")) == NULL)
9604 {
9605 ivna.vna_next = 0;
9606 ivna.vna_other = 0;
9607 ivna.vna_name = 0;
9608 break;
9609 }
9610
9611 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9612 ivn.vn_next = BYTE_GET (evn.vn_next);
9613
9614 vna_off = offset + ivn.vn_aux;
9615
9616 do
9617 {
9618 Elf_External_Vernaux evna;
9619
9620 if (get_data (&evna, file, vna_off,
9621 sizeof (evna), 1,
9622 _("version need aux (3)")) == NULL)
9623 {
9624 ivna.vna_next = 0;
9625 ivna.vna_other = 0;
9626 ivna.vna_name = 0;
9627 }
9628 else
9629 {
9630 ivna.vna_other = BYTE_GET (evna.vna_other);
9631 ivna.vna_next = BYTE_GET (evna.vna_next);
9632 ivna.vna_name = BYTE_GET (evna.vna_name);
9633 }
9634
9635 vna_off += ivna.vna_next;
9636 }
9637 while (ivna.vna_other != vers_data
9638 && ivna.vna_next != 0);
9639
9640 if (ivna.vna_other == vers_data)
9641 break;
9642
9643 offset += ivn.vn_next;
9644 }
9645 while (ivn.vn_next != 0);
9646
9647 if (ivna.vna_other == vers_data)
9648 {
9649 printf ("@%s (%d)",
9650 ivna.vna_name < strtab_size
9651 ? strtab + ivna.vna_name : _("<corrupt>"),
9652 ivna.vna_other);
9653 check_def = 0;
9654 }
9655 else if (! is_nobits)
9656 error (_("bad dynamic symbol\n"));
9657 else
9658 check_def = 1;
9659 }
9660
9661 if (check_def)
9662 {
9663 if (vers_data != 0x8001
9664 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9665 {
9666 Elf_Internal_Verdef ivd;
9667 Elf_Internal_Verdaux ivda;
9668 Elf_External_Verdaux evda;
9669 unsigned long off;
9670
9671 off = offset_from_vma
9672 (file,
9673 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9674 sizeof (Elf_External_Verdef));
9675
9676 do
9677 {
9678 Elf_External_Verdef evd;
9679
9680 if (get_data (&evd, file, off, sizeof (evd),
9681 1, _("version def")) == NULL)
9682 {
9683 ivd.vd_ndx = 0;
9684 ivd.vd_aux = 0;
9685 ivd.vd_next = 0;
9686 }
9687 else
9688 {
9689 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9690 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9691 ivd.vd_next = BYTE_GET (evd.vd_next);
9692 }
9693
9694 off += ivd.vd_next;
9695 }
9696 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9697 && ivd.vd_next != 0);
9698
9699 off -= ivd.vd_next;
9700 off += ivd.vd_aux;
9701
9702 if (get_data (&evda, file, off, sizeof (evda),
9703 1, _("version def aux")) == NULL)
9704 break;
9705
9706 ivda.vda_name = BYTE_GET (evda.vda_name);
9707
9708 if (psym->st_name != ivda.vda_name)
9709 printf ((vers_data & VERSYM_HIDDEN)
9710 ? "@%s" : "@@%s",
9711 ivda.vda_name < strtab_size
9712 ? strtab + ivda.vda_name : _("<corrupt>"));
9713 }
9714 }
9715 }
9716 }
9717
9718 putchar ('\n');
9719 }
9720
9721 free (symtab);
9722 if (strtab != string_table)
9723 free (strtab);
9724 }
9725 }
9726 else if (do_syms)
9727 printf
9728 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9729
9730 if (do_histogram && buckets != NULL)
9731 {
9732 unsigned long * lengths;
9733 unsigned long * counts;
9734 unsigned long hn;
9735 bfd_vma si;
9736 unsigned long maxlength = 0;
9737 unsigned long nzero_counts = 0;
9738 unsigned long nsyms = 0;
9739
9740 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9741 (unsigned long) nbuckets);
9742 printf (_(" Length Number %% of total Coverage\n"));
9743
9744 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9745 if (lengths == NULL)
9746 {
9747 error (_("Out of memory\n"));
9748 return 0;
9749 }
9750 for (hn = 0; hn < nbuckets; ++hn)
9751 {
9752 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9753 {
9754 ++nsyms;
9755 if (maxlength < ++lengths[hn])
9756 ++maxlength;
9757 }
9758 }
9759
9760 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9761 if (counts == NULL)
9762 {
9763 error (_("Out of memory\n"));
9764 return 0;
9765 }
9766
9767 for (hn = 0; hn < nbuckets; ++hn)
9768 ++counts[lengths[hn]];
9769
9770 if (nbuckets > 0)
9771 {
9772 unsigned long i;
9773 printf (" 0 %-10lu (%5.1f%%)\n",
9774 counts[0], (counts[0] * 100.0) / nbuckets);
9775 for (i = 1; i <= maxlength; ++i)
9776 {
9777 nzero_counts += counts[i] * i;
9778 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9779 i, counts[i], (counts[i] * 100.0) / nbuckets,
9780 (nzero_counts * 100.0) / nsyms);
9781 }
9782 }
9783
9784 free (counts);
9785 free (lengths);
9786 }
9787
9788 if (buckets != NULL)
9789 {
9790 free (buckets);
9791 free (chains);
9792 }
9793
9794 if (do_histogram && gnubuckets != NULL)
9795 {
9796 unsigned long * lengths;
9797 unsigned long * counts;
9798 unsigned long hn;
9799 unsigned long maxlength = 0;
9800 unsigned long nzero_counts = 0;
9801 unsigned long nsyms = 0;
9802
9803 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9804 if (lengths == NULL)
9805 {
9806 error (_("Out of memory\n"));
9807 return 0;
9808 }
9809
9810 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9811 (unsigned long) ngnubuckets);
9812 printf (_(" Length Number %% of total Coverage\n"));
9813
9814 for (hn = 0; hn < ngnubuckets; ++hn)
9815 if (gnubuckets[hn] != 0)
9816 {
9817 bfd_vma off, length = 1;
9818
9819 for (off = gnubuckets[hn] - gnusymidx;
9820 (gnuchains[off] & 1) == 0; ++off)
9821 ++length;
9822 lengths[hn] = length;
9823 if (length > maxlength)
9824 maxlength = length;
9825 nsyms += length;
9826 }
9827
9828 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9829 if (counts == NULL)
9830 {
9831 error (_("Out of memory\n"));
9832 return 0;
9833 }
9834
9835 for (hn = 0; hn < ngnubuckets; ++hn)
9836 ++counts[lengths[hn]];
9837
9838 if (ngnubuckets > 0)
9839 {
9840 unsigned long j;
9841 printf (" 0 %-10lu (%5.1f%%)\n",
9842 counts[0], (counts[0] * 100.0) / ngnubuckets);
9843 for (j = 1; j <= maxlength; ++j)
9844 {
9845 nzero_counts += counts[j] * j;
9846 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9847 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9848 (nzero_counts * 100.0) / nsyms);
9849 }
9850 }
9851
9852 free (counts);
9853 free (lengths);
9854 free (gnubuckets);
9855 free (gnuchains);
9856 }
9857
9858 return 1;
9859}
9860
9861static int
9862process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9863{
9864 unsigned int i;
9865
9866 if (dynamic_syminfo == NULL
9867 || !do_dynamic)
9868 /* No syminfo, this is ok. */
9869 return 1;
9870
9871 /* There better should be a dynamic symbol section. */
9872 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9873 return 0;
9874
9875 if (dynamic_addr)
9876 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9877 dynamic_syminfo_offset, dynamic_syminfo_nent);
9878
9879 printf (_(" Num: Name BoundTo Flags\n"));
9880 for (i = 0; i < dynamic_syminfo_nent; ++i)
9881 {
9882 unsigned short int flags = dynamic_syminfo[i].si_flags;
9883
9884 printf ("%4d: ", i);
9885 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9886 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9887 else
9888 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9889 putchar (' ');
9890
9891 switch (dynamic_syminfo[i].si_boundto)
9892 {
9893 case SYMINFO_BT_SELF:
9894 fputs ("SELF ", stdout);
9895 break;
9896 case SYMINFO_BT_PARENT:
9897 fputs ("PARENT ", stdout);
9898 break;
9899 default:
9900 if (dynamic_syminfo[i].si_boundto > 0
9901 && dynamic_syminfo[i].si_boundto < dynamic_nent
9902 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9903 {
9904 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9905 putchar (' ' );
9906 }
9907 else
9908 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9909 break;
9910 }
9911
9912 if (flags & SYMINFO_FLG_DIRECT)
9913 printf (" DIRECT");
9914 if (flags & SYMINFO_FLG_PASSTHRU)
9915 printf (" PASSTHRU");
9916 if (flags & SYMINFO_FLG_COPY)
9917 printf (" COPY");
9918 if (flags & SYMINFO_FLG_LAZYLOAD)
9919 printf (" LAZYLOAD");
9920
9921 puts ("");
9922 }
9923
9924 return 1;
9925}
9926
9927/* Check to see if the given reloc needs to be handled in a target specific
9928 manner. If so then process the reloc and return TRUE otherwise return
9929 FALSE. */
9930
9931static bfd_boolean
9932target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9933 unsigned char * start,
9934 Elf_Internal_Sym * symtab)
9935{
9936 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9937
9938 switch (elf_header.e_machine)
9939 {
9940 case EM_MN10300:
9941 case EM_CYGNUS_MN10300:
9942 {
9943 static Elf_Internal_Sym * saved_sym = NULL;
9944
9945 switch (reloc_type)
9946 {
9947 case 34: /* R_MN10300_ALIGN */
9948 return TRUE;
9949 case 33: /* R_MN10300_SYM_DIFF */
9950 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9951 return TRUE;
9952 case 1: /* R_MN10300_32 */
9953 case 2: /* R_MN10300_16 */
9954 if (saved_sym != NULL)
9955 {
9956 bfd_vma value;
9957
9958 value = reloc->r_addend
9959 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9960 - saved_sym->st_value);
9961
9962 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9963
9964 saved_sym = NULL;
9965 return TRUE;
9966 }
9967 break;
9968 default:
9969 if (saved_sym != NULL)
9970 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9971 break;
9972 }
9973 break;
9974 }
9975 }
9976
9977 return FALSE;
9978}
9979
9980/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9981 DWARF debug sections. This is a target specific test. Note - we do not
9982 go through the whole including-target-headers-multiple-times route, (as
9983 we have already done with <elf/h8.h>) because this would become very
9984 messy and even then this function would have to contain target specific
9985 information (the names of the relocs instead of their numeric values).
9986 FIXME: This is not the correct way to solve this problem. The proper way
9987 is to have target specific reloc sizing and typing functions created by
9988 the reloc-macros.h header, in the same way that it already creates the
9989 reloc naming functions. */
9990
9991static bfd_boolean
9992is_32bit_abs_reloc (unsigned int reloc_type)
9993{
9994 switch (elf_header.e_machine)
9995 {
9996 case EM_386:
9997 case EM_486:
9998 return reloc_type == 1; /* R_386_32. */
9999 case EM_68K:
10000 return reloc_type == 1; /* R_68K_32. */
10001 case EM_860:
10002 return reloc_type == 1; /* R_860_32. */
10003 case EM_960:
10004 return reloc_type == 2; /* R_960_32. */
10005 case EM_AARCH64:
10006 return reloc_type == 258; /* R_AARCH64_ABS32 */
10007 case EM_ALPHA:
10008 return reloc_type == 1; /* R_ALPHA_REFLONG. */
10009 case EM_ARC:
10010 return reloc_type == 1; /* R_ARC_32. */
10011 case EM_ARM:
10012 return reloc_type == 2; /* R_ARM_ABS32 */
10013 case EM_AVR_OLD:
10014 case EM_AVR:
10015 return reloc_type == 1;
10016 case EM_ADAPTEVA_EPIPHANY:
10017 return reloc_type == 3;
10018 case EM_BLACKFIN:
10019 return reloc_type == 0x12; /* R_byte4_data. */
10020 case EM_CRIS:
10021 return reloc_type == 3; /* R_CRIS_32. */
10022 case EM_CR16:
10023 return reloc_type == 3; /* R_CR16_NUM32. */
10024 case EM_CRX:
10025 return reloc_type == 15; /* R_CRX_NUM32. */
10026 case EM_CYGNUS_FRV:
10027 return reloc_type == 1;
10028 case EM_CYGNUS_D10V:
10029 case EM_D10V:
10030 return reloc_type == 6; /* R_D10V_32. */
10031 case EM_CYGNUS_D30V:
10032 case EM_D30V:
10033 return reloc_type == 12; /* R_D30V_32_NORMAL. */
10034 case EM_DLX:
10035 return reloc_type == 3; /* R_DLX_RELOC_32. */
10036 case EM_CYGNUS_FR30:
10037 case EM_FR30:
10038 return reloc_type == 3; /* R_FR30_32. */
10039 case EM_H8S:
10040 case EM_H8_300:
10041 case EM_H8_300H:
10042 return reloc_type == 1; /* R_H8_DIR32. */
10043 case EM_IA_64:
10044 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
10045 case EM_IP2K_OLD:
10046 case EM_IP2K:
10047 return reloc_type == 2; /* R_IP2K_32. */
10048 case EM_IQ2000:
10049 return reloc_type == 2; /* R_IQ2000_32. */
10050 case EM_LATTICEMICO32:
10051 return reloc_type == 3; /* R_LM32_32. */
10052 case EM_M32C_OLD:
10053 case EM_M32C:
10054 return reloc_type == 3; /* R_M32C_32. */
10055 case EM_M32R:
10056 return reloc_type == 34; /* R_M32R_32_RELA. */
10057 case EM_MCORE:
10058 return reloc_type == 1; /* R_MCORE_ADDR32. */
10059 case EM_CYGNUS_MEP:
10060 return reloc_type == 4; /* R_MEP_32. */
10061 case EM_METAG:
10062 return reloc_type == 2; /* R_METAG_ADDR32. */
10063 case EM_MICROBLAZE:
10064 return reloc_type == 1; /* R_MICROBLAZE_32. */
10065 case EM_MIPS:
10066 return reloc_type == 2; /* R_MIPS_32. */
10067 case EM_MMIX:
10068 return reloc_type == 4; /* R_MMIX_32. */
10069 case EM_CYGNUS_MN10200:
10070 case EM_MN10200:
10071 return reloc_type == 1; /* R_MN10200_32. */
10072 case EM_CYGNUS_MN10300:
10073 case EM_MN10300:
10074 return reloc_type == 1; /* R_MN10300_32. */
10075 case EM_MOXIE:
10076 return reloc_type == 1; /* R_MOXIE_32. */
10077 case EM_MSP430_OLD:
10078 case EM_MSP430:
10079 return reloc_type == 1; /* R_MSP43_32. */
10080 case EM_MT:
10081 return reloc_type == 2; /* R_MT_32. */
10082 case EM_ALTERA_NIOS2:
10083 case EM_NIOS32:
10084 return reloc_type == 1; /* R_NIOS_32. */
10085 case EM_OPENRISC:
10086 case EM_OR32:
10087 return reloc_type == 1; /* R_OR32_32. */
10088 case EM_PARISC:
10089 return (reloc_type == 1 /* R_PARISC_DIR32. */
10090 || reloc_type == 41); /* R_PARISC_SECREL32. */
10091 case EM_PJ:
10092 case EM_PJ_OLD:
10093 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10094 case EM_PPC64:
10095 return reloc_type == 1; /* R_PPC64_ADDR32. */
10096 case EM_PPC:
10097 return reloc_type == 1; /* R_PPC_ADDR32. */
10098 case EM_RL78:
10099 return reloc_type == 1; /* R_RL78_DIR32. */
10100 case EM_RX:
10101 return reloc_type == 1; /* R_RX_DIR32. */
10102 case EM_S370:
10103 return reloc_type == 1; /* R_I370_ADDR31. */
10104 case EM_S390_OLD:
10105 case EM_S390:
10106 return reloc_type == 4; /* R_S390_32. */
10107 case EM_SCORE:
10108 return reloc_type == 8; /* R_SCORE_ABS32. */
10109 case EM_SH:
10110 return reloc_type == 1; /* R_SH_DIR32. */
10111 case EM_SPARC32PLUS:
10112 case EM_SPARCV9:
10113 case EM_SPARC:
10114 return reloc_type == 3 /* R_SPARC_32. */
10115 || reloc_type == 23; /* R_SPARC_UA32. */
10116 case EM_SPU:
10117 return reloc_type == 6; /* R_SPU_ADDR32 */
10118 case EM_TI_C6000:
10119 return reloc_type == 1; /* R_C6000_ABS32. */
10120 case EM_TILEGX:
10121 return reloc_type == 2; /* R_TILEGX_32. */
10122 case EM_TILEPRO:
10123 return reloc_type == 1; /* R_TILEPRO_32. */
10124 case EM_CYGNUS_V850:
10125 case EM_V850:
10126 return reloc_type == 6; /* R_V850_ABS32. */
10127 case EM_V800:
10128 return reloc_type == 0x33; /* R_V810_WORD. */
10129 case EM_VAX:
10130 return reloc_type == 1; /* R_VAX_32. */
10131 case EM_X86_64:
10132 case EM_L1OM:
10133 case EM_K1OM:
10134 return reloc_type == 10; /* R_X86_64_32. */
10135 case EM_XC16X:
10136 case EM_C166:
10137 return reloc_type == 3; /* R_XC16C_ABS_32. */
10138 case EM_XGATE:
10139 return reloc_type == 4; /* R_XGATE_32. */
10140 case EM_XSTORMY16:
10141 return reloc_type == 1; /* R_XSTROMY16_32. */
10142 case EM_XTENSA_OLD:
10143 case EM_XTENSA:
10144 return reloc_type == 1; /* R_XTENSA_32. */
10145 default:
10146 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10147 elf_header.e_machine);
10148 abort ();
10149 }
10150}
10151
10152/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10153 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10154
10155static bfd_boolean
10156is_32bit_pcrel_reloc (unsigned int reloc_type)
10157{
10158 switch (elf_header.e_machine)
10159 {
10160 case EM_386:
10161 case EM_486:
10162 return reloc_type == 2; /* R_386_PC32. */
10163 case EM_68K:
10164 return reloc_type == 4; /* R_68K_PC32. */
10165 case EM_AARCH64:
10166 return reloc_type == 261; /* R_AARCH64_PREL32 */
10167 case EM_ADAPTEVA_EPIPHANY:
10168 return reloc_type == 6;
10169 case EM_ALPHA:
10170 return reloc_type == 10; /* R_ALPHA_SREL32. */
10171 case EM_ARM:
10172 return reloc_type == 3; /* R_ARM_REL32 */
10173 case EM_MICROBLAZE:
10174 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
10175 case EM_PARISC:
10176 return reloc_type == 9; /* R_PARISC_PCREL32. */
10177 case EM_PPC:
10178 return reloc_type == 26; /* R_PPC_REL32. */
10179 case EM_PPC64:
10180 return reloc_type == 26; /* R_PPC64_REL32. */
10181 case EM_S390_OLD:
10182 case EM_S390:
10183 return reloc_type == 5; /* R_390_PC32. */
10184 case EM_SH:
10185 return reloc_type == 2; /* R_SH_REL32. */
10186 case EM_SPARC32PLUS:
10187 case EM_SPARCV9:
10188 case EM_SPARC:
10189 return reloc_type == 6; /* R_SPARC_DISP32. */
10190 case EM_SPU:
10191 return reloc_type == 13; /* R_SPU_REL32. */
10192 case EM_TILEGX:
10193 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10194 case EM_TILEPRO:
10195 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
10196 case EM_X86_64:
10197 case EM_L1OM:
10198 case EM_K1OM:
10199 return reloc_type == 2; /* R_X86_64_PC32. */
10200 case EM_XTENSA_OLD:
10201 case EM_XTENSA:
10202 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
10203 default:
10204 /* Do not abort or issue an error message here. Not all targets use
10205 pc-relative 32-bit relocs in their DWARF debug information and we
10206 have already tested for target coverage in is_32bit_abs_reloc. A
10207 more helpful warning message will be generated by apply_relocations
10208 anyway, so just return. */
10209 return FALSE;
10210 }
10211}
10212
10213/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10214 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10215
10216static bfd_boolean
10217is_64bit_abs_reloc (unsigned int reloc_type)
10218{
10219 switch (elf_header.e_machine)
10220 {
10221 case EM_AARCH64:
10222 return reloc_type == 257; /* R_AARCH64_ABS64. */
10223 case EM_ALPHA:
10224 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
10225 case EM_IA_64:
10226 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
10227 case EM_PARISC:
10228 return reloc_type == 80; /* R_PARISC_DIR64. */
10229 case EM_PPC64:
10230 return reloc_type == 38; /* R_PPC64_ADDR64. */
10231 case EM_SPARC32PLUS:
10232 case EM_SPARCV9:
10233 case EM_SPARC:
10234 return reloc_type == 54; /* R_SPARC_UA64. */
10235 case EM_X86_64:
10236 case EM_L1OM:
10237 case EM_K1OM:
10238 return reloc_type == 1; /* R_X86_64_64. */
10239 case EM_S390_OLD:
10240 case EM_S390:
10241 return reloc_type == 22; /* R_S390_64. */
10242 case EM_TILEGX:
10243 return reloc_type == 1; /* R_TILEGX_64. */
10244 case EM_MIPS:
10245 return reloc_type == 18; /* R_MIPS_64. */
10246 default:
10247 return FALSE;
10248 }
10249}
10250
10251/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10252 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10253
10254static bfd_boolean
10255is_64bit_pcrel_reloc (unsigned int reloc_type)
10256{
10257 switch (elf_header.e_machine)
10258 {
10259 case EM_AARCH64:
10260 return reloc_type == 260; /* R_AARCH64_PREL64. */
10261 case EM_ALPHA:
10262 return reloc_type == 11; /* R_ALPHA_SREL64. */
10263 case EM_IA_64:
10264 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
10265 case EM_PARISC:
10266 return reloc_type == 72; /* R_PARISC_PCREL64. */
10267 case EM_PPC64:
10268 return reloc_type == 44; /* R_PPC64_REL64. */
10269 case EM_SPARC32PLUS:
10270 case EM_SPARCV9:
10271 case EM_SPARC:
10272 return reloc_type == 46; /* R_SPARC_DISP64. */
10273 case EM_X86_64:
10274 case EM_L1OM:
10275 case EM_K1OM:
10276 return reloc_type == 24; /* R_X86_64_PC64. */
10277 case EM_S390_OLD:
10278 case EM_S390:
10279 return reloc_type == 23; /* R_S390_PC64. */
10280 case EM_TILEGX:
10281 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
10282 default:
10283 return FALSE;
10284 }
10285}
10286
10287/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10288 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10289
10290static bfd_boolean
10291is_24bit_abs_reloc (unsigned int reloc_type)
10292{
10293 switch (elf_header.e_machine)
10294 {
10295 case EM_CYGNUS_MN10200:
10296 case EM_MN10200:
10297 return reloc_type == 4; /* R_MN10200_24. */
10298 default:
10299 return FALSE;
10300 }
10301}
10302
10303/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10304 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10305
10306static bfd_boolean
10307is_16bit_abs_reloc (unsigned int reloc_type)
10308{
10309 switch (elf_header.e_machine)
10310 {
10311 case EM_AVR_OLD:
10312 case EM_AVR:
10313 return reloc_type == 4; /* R_AVR_16. */
10314 case EM_ADAPTEVA_EPIPHANY:
10315 return reloc_type == 5;
10316 case EM_CYGNUS_D10V:
10317 case EM_D10V:
10318 return reloc_type == 3; /* R_D10V_16. */
10319 case EM_H8S:
10320 case EM_H8_300:
10321 case EM_H8_300H:
10322 return reloc_type == R_H8_DIR16;
10323 case EM_IP2K_OLD:
10324 case EM_IP2K:
10325 return reloc_type == 1; /* R_IP2K_16. */
10326 case EM_M32C_OLD:
10327 case EM_M32C:
10328 return reloc_type == 1; /* R_M32C_16 */
10329 case EM_MSP430:
10330 case EM_MSP430_OLD:
10331 return reloc_type == 5; /* R_MSP430_16_BYTE. */
10332 case EM_ALTERA_NIOS2:
10333 case EM_NIOS32:
10334 return reloc_type == 9; /* R_NIOS_16. */
10335 case EM_TI_C6000:
10336 return reloc_type == 2; /* R_C6000_ABS16. */
10337 case EM_XC16X:
10338 case EM_C166:
10339 return reloc_type == 2; /* R_XC16C_ABS_16. */
10340 case EM_CYGNUS_MN10200:
10341 case EM_MN10200:
10342 return reloc_type == 2; /* R_MN10200_16. */
10343 case EM_CYGNUS_MN10300:
10344 case EM_MN10300:
10345 return reloc_type == 2; /* R_MN10300_16. */
10346 case EM_XGATE:
10347 return reloc_type == 3; /* R_XGATE_16. */
10348 default:
10349 return FALSE;
10350 }
10351}
10352
10353/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10354 relocation entries (possibly formerly used for SHT_GROUP sections). */
10355
10356static bfd_boolean
10357is_none_reloc (unsigned int reloc_type)
10358{
10359 switch (elf_header.e_machine)
10360 {
10361 case EM_68K: /* R_68K_NONE. */
10362 case EM_386: /* R_386_NONE. */
10363 case EM_SPARC32PLUS:
10364 case EM_SPARCV9:
10365 case EM_SPARC: /* R_SPARC_NONE. */
10366 case EM_MIPS: /* R_MIPS_NONE. */
10367 case EM_PARISC: /* R_PARISC_NONE. */
10368 case EM_ALPHA: /* R_ALPHA_NONE. */
10369 case EM_ADAPTEVA_EPIPHANY:
10370 case EM_PPC: /* R_PPC_NONE. */
10371 case EM_PPC64: /* R_PPC64_NONE. */
10372 case EM_ARM: /* R_ARM_NONE. */
10373 case EM_IA_64: /* R_IA64_NONE. */
10374 case EM_SH: /* R_SH_NONE. */
10375 case EM_S390_OLD:
10376 case EM_S390: /* R_390_NONE. */
10377 case EM_CRIS: /* R_CRIS_NONE. */
10378 case EM_X86_64: /* R_X86_64_NONE. */
10379 case EM_L1OM: /* R_X86_64_NONE. */
10380 case EM_K1OM: /* R_X86_64_NONE. */
10381 case EM_MN10300: /* R_MN10300_NONE. */
10382 case EM_MOXIE: /* R_MOXIE_NONE. */
10383 case EM_M32R: /* R_M32R_NONE. */
10384 case EM_TI_C6000:/* R_C6000_NONE. */
10385 case EM_TILEGX: /* R_TILEGX_NONE. */
10386 case EM_TILEPRO: /* R_TILEPRO_NONE. */
10387 case EM_XC16X:
10388 case EM_C166: /* R_XC16X_NONE. */
10389 return reloc_type == 0;
10390 case EM_AARCH64:
10391 return reloc_type == 0 || reloc_type == 256;
10392 case EM_XTENSA_OLD:
10393 case EM_XTENSA:
10394 return (reloc_type == 0 /* R_XTENSA_NONE. */
10395 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10396 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10397 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
10398 case EM_METAG:
10399 return reloc_type == 3; /* R_METAG_NONE. */
10400 }
10401 return FALSE;
10402}
10403
10404/* Apply relocations to a section.
10405 Note: So far support has been added only for those relocations
10406 which can be found in debug sections.
10407 FIXME: Add support for more relocations ? */
10408
10409static void
10410apply_relocations (void * file,
10411 Elf_Internal_Shdr * section,
10412 unsigned char * start)
10413{
10414 Elf_Internal_Shdr * relsec;
10415 unsigned char * end = start + section->sh_size;
10416
10417 if (elf_header.e_type != ET_REL)
10418 return;
10419
10420 /* Find the reloc section associated with the section. */
10421 for (relsec = section_headers;
10422 relsec < section_headers + elf_header.e_shnum;
10423 ++relsec)
10424 {
10425 bfd_boolean is_rela;
10426 unsigned long num_relocs;
10427 Elf_Internal_Rela * relocs;
10428 Elf_Internal_Rela * rp;
10429 Elf_Internal_Shdr * symsec;
10430 Elf_Internal_Sym * symtab;
10431 unsigned long num_syms;
10432 Elf_Internal_Sym * sym;
10433
10434 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10435 || relsec->sh_info >= elf_header.e_shnum
10436 || section_headers + relsec->sh_info != section
10437 || relsec->sh_size == 0
10438 || relsec->sh_link >= elf_header.e_shnum)
10439 continue;
10440
10441 is_rela = relsec->sh_type == SHT_RELA;
10442
10443 if (is_rela)
10444 {
10445 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10446 relsec->sh_size, & relocs, & num_relocs))
10447 return;
10448 }
10449 else
10450 {
10451 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10452 relsec->sh_size, & relocs, & num_relocs))
10453 return;
10454 }
10455
10456 /* SH uses RELA but uses in place value instead of the addend field. */
10457 if (elf_header.e_machine == EM_SH)
10458 is_rela = FALSE;
10459
10460 symsec = section_headers + relsec->sh_link;
10461 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10462
10463 for (rp = relocs; rp < relocs + num_relocs; ++rp)
10464 {
10465 bfd_vma addend;
10466 unsigned int reloc_type;
10467 unsigned int reloc_size;
10468 unsigned char * rloc;
10469 unsigned long sym_index;
10470
10471 reloc_type = get_reloc_type (rp->r_info);
10472
10473 if (target_specific_reloc_handling (rp, start, symtab))
10474 continue;
10475 else if (is_none_reloc (reloc_type))
10476 continue;
10477 else if (is_32bit_abs_reloc (reloc_type)
10478 || is_32bit_pcrel_reloc (reloc_type))
10479 reloc_size = 4;
10480 else if (is_64bit_abs_reloc (reloc_type)
10481 || is_64bit_pcrel_reloc (reloc_type))
10482 reloc_size = 8;
10483 else if (is_24bit_abs_reloc (reloc_type))
10484 reloc_size = 3;
10485 else if (is_16bit_abs_reloc (reloc_type))
10486 reloc_size = 2;
10487 else
10488 {
10489 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10490 reloc_type, SECTION_NAME (section));
10491 continue;
10492 }
10493
10494 rloc = start + rp->r_offset;
10495 if ((rloc + reloc_size) > end)
10496 {
10497 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10498 (unsigned long) rp->r_offset,
10499 SECTION_NAME (section));
10500 continue;
10501 }
10502
10503 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10504 if (sym_index >= num_syms)
10505 {
10506 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10507 sym_index, SECTION_NAME (section));
10508 continue;
10509 }
10510 sym = symtab + sym_index;
10511
10512 /* If the reloc has a symbol associated with it,
10513 make sure that it is of an appropriate type.
10514
10515 Relocations against symbols without type can happen.
10516 Gcc -feliminate-dwarf2-dups may generate symbols
10517 without type for debug info.
10518
10519 Icc generates relocations against function symbols
10520 instead of local labels.
10521
10522 Relocations against object symbols can happen, eg when
10523 referencing a global array. For an example of this see
10524 the _clz.o binary in libgcc.a. */
10525 if (sym != symtab
10526 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10527 {
10528 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10529 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10530 (long int)(rp - relocs),
10531 SECTION_NAME (relsec));
10532 continue;
10533 }
10534
10535 addend = 0;
10536 if (is_rela)
10537 addend += rp->r_addend;
10538 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10539 partial_inplace. */
10540 if (!is_rela
10541 || (elf_header.e_machine == EM_XTENSA
10542 && reloc_type == 1)
10543 || ((elf_header.e_machine == EM_PJ
10544 || elf_header.e_machine == EM_PJ_OLD)
10545 && reloc_type == 1)
10546 || ((elf_header.e_machine == EM_D30V
10547 || elf_header.e_machine == EM_CYGNUS_D30V)
10548 && reloc_type == 12))
10549 addend += byte_get (rloc, reloc_size);
10550
10551 if (is_32bit_pcrel_reloc (reloc_type)
10552 || is_64bit_pcrel_reloc (reloc_type))
10553 {
10554 /* On HPPA, all pc-relative relocations are biased by 8. */
10555 if (elf_header.e_machine == EM_PARISC)
10556 addend -= 8;
10557 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10558 reloc_size);
10559 }
10560 else
10561 byte_put (rloc, addend + sym->st_value, reloc_size);
10562 }
10563
10564 free (symtab);
10565 free (relocs);
10566 break;
10567 }
10568}
10569
10570#ifdef SUPPORT_DISASSEMBLY
10571static int
10572disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10573{
10574 printf (_("\nAssembly dump of section %s\n"),
10575 SECTION_NAME (section));
10576
10577 /* XXX -- to be done --- XXX */
10578
10579 return 1;
10580}
10581#endif
10582
10583/* Reads in the contents of SECTION from FILE, returning a pointer
10584 to a malloc'ed buffer or NULL if something went wrong. */
10585
10586static char *
10587get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10588{
10589 bfd_size_type num_bytes;
10590
10591 num_bytes = section->sh_size;
10592
10593 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10594 {
10595 printf (_("\nSection '%s' has no data to dump.\n"),
10596 SECTION_NAME (section));
10597 return NULL;
10598 }
10599
10600 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10601 _("section contents"));
10602}
10603
10604
10605static void
10606dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10607{
10608 Elf_Internal_Shdr * relsec;
10609 bfd_size_type num_bytes;
10610 char * data;
10611 char * end;
10612 char * start;
10613 char * name = SECTION_NAME (section);
10614 bfd_boolean some_strings_shown;
10615
10616 start = get_section_contents (section, file);
10617 if (start == NULL)
10618 return;
10619
10620 printf (_("\nString dump of section '%s':\n"), name);
10621
10622 /* If the section being dumped has relocations against it the user might
10623 be expecting these relocations to have been applied. Check for this
10624 case and issue a warning message in order to avoid confusion.
10625 FIXME: Maybe we ought to have an option that dumps a section with
10626 relocs applied ? */
10627 for (relsec = section_headers;
10628 relsec < section_headers + elf_header.e_shnum;
10629 ++relsec)
10630 {
10631 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10632 || relsec->sh_info >= elf_header.e_shnum
10633 || section_headers + relsec->sh_info != section
10634 || relsec->sh_size == 0
10635 || relsec->sh_link >= elf_header.e_shnum)
10636 continue;
10637
10638 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10639 break;
10640 }
10641
10642 num_bytes = section->sh_size;
10643 data = start;
10644 end = start + num_bytes;
10645 some_strings_shown = FALSE;
10646
10647 while (data < end)
10648 {
10649 while (!ISPRINT (* data))
10650 if (++ data >= end)
10651 break;
10652
10653 if (data < end)
10654 {
10655#ifndef __MSVCRT__
10656 /* PR 11128: Use two separate invocations in order to work
10657 around bugs in the Solaris 8 implementation of printf. */
10658 printf (" [%6tx] ", data - start);
10659 printf ("%s\n", data);
10660#else
10661 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10662#endif
10663 data += strlen (data);
10664 some_strings_shown = TRUE;
10665 }
10666 }
10667
10668 if (! some_strings_shown)
10669 printf (_(" No strings found in this section."));
10670
10671 free (start);
10672
10673 putchar ('\n');
10674}
10675
10676static void
10677dump_section_as_bytes (Elf_Internal_Shdr * section,
10678 FILE * file,
10679 bfd_boolean relocate)
10680{
10681 Elf_Internal_Shdr * relsec;
10682 bfd_size_type bytes;
10683 bfd_vma addr;
10684 unsigned char * data;
10685 unsigned char * start;
10686
10687 start = (unsigned char *) get_section_contents (section, file);
10688 if (start == NULL)
10689 return;
10690
10691 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10692
10693 if (relocate)
10694 {
10695 apply_relocations (file, section, start);
10696 }
10697 else
10698 {
10699 /* If the section being dumped has relocations against it the user might
10700 be expecting these relocations to have been applied. Check for this
10701 case and issue a warning message in order to avoid confusion.
10702 FIXME: Maybe we ought to have an option that dumps a section with
10703 relocs applied ? */
10704 for (relsec = section_headers;
10705 relsec < section_headers + elf_header.e_shnum;
10706 ++relsec)
10707 {
10708 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10709 || relsec->sh_info >= elf_header.e_shnum
10710 || section_headers + relsec->sh_info != section
10711 || relsec->sh_size == 0
10712 || relsec->sh_link >= elf_header.e_shnum)
10713 continue;
10714
10715 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10716 break;
10717 }
10718 }
10719
10720 addr = section->sh_addr;
10721 bytes = section->sh_size;
10722 data = start;
10723
10724 while (bytes)
10725 {
10726 int j;
10727 int k;
10728 int lbytes;
10729
10730 lbytes = (bytes > 16 ? 16 : bytes);
10731
10732 printf (" 0x%8.8lx ", (unsigned long) addr);
10733
10734 for (j = 0; j < 16; j++)
10735 {
10736 if (j < lbytes)
10737 printf ("%2.2x", data[j]);
10738 else
10739 printf (" ");
10740
10741 if ((j & 3) == 3)
10742 printf (" ");
10743 }
10744
10745 for (j = 0; j < lbytes; j++)
10746 {
10747 k = data[j];
10748 if (k >= ' ' && k < 0x7f)
10749 printf ("%c", k);
10750 else
10751 printf (".");
10752 }
10753
10754 putchar ('\n');
10755
10756 data += lbytes;
10757 addr += lbytes;
10758 bytes -= lbytes;
10759 }
10760
10761 free (start);
10762
10763 putchar ('\n');
10764}
10765
10766/* Uncompresses a section that was compressed using zlib, in place. */
10767
10768static int
10769uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10770 dwarf_size_type *size ATTRIBUTE_UNUSED)
10771{
10772#ifndef HAVE_ZLIB_H
10773 return FALSE;
10774#else
10775 dwarf_size_type compressed_size = *size;
10776 unsigned char * compressed_buffer = *buffer;
10777 dwarf_size_type uncompressed_size;
10778 unsigned char * uncompressed_buffer;
10779 z_stream strm;
10780 int rc;
10781 dwarf_size_type header_size = 12;
10782
10783 /* Read the zlib header. In this case, it should be "ZLIB" followed
10784 by the uncompressed section size, 8 bytes in big-endian order. */
10785 if (compressed_size < header_size
10786 || ! streq ((char *) compressed_buffer, "ZLIB"))
10787 return 0;
10788
10789 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10790 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10791 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10792 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10793 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10794 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10795 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10796 uncompressed_size += compressed_buffer[11];
10797
10798 /* It is possible the section consists of several compressed
10799 buffers concatenated together, so we uncompress in a loop. */
10800 strm.zalloc = NULL;
10801 strm.zfree = NULL;
10802 strm.opaque = NULL;
10803 strm.avail_in = compressed_size - header_size;
10804 strm.next_in = (Bytef *) compressed_buffer + header_size;
10805 strm.avail_out = uncompressed_size;
10806 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10807
10808 rc = inflateInit (& strm);
10809 while (strm.avail_in > 0)
10810 {
10811 if (rc != Z_OK)
10812 goto fail;
10813 strm.next_out = ((Bytef *) uncompressed_buffer
10814 + (uncompressed_size - strm.avail_out));
10815 rc = inflate (&strm, Z_FINISH);
10816 if (rc != Z_STREAM_END)
10817 goto fail;
10818 rc = inflateReset (& strm);
10819 }
10820 rc = inflateEnd (& strm);
10821 if (rc != Z_OK
10822 || strm.avail_out != 0)
10823 goto fail;
10824
10825 free (compressed_buffer);
10826 *buffer = uncompressed_buffer;
10827 *size = uncompressed_size;
10828 return 1;
10829
10830 fail:
10831 free (uncompressed_buffer);
10832 /* Indicate decompression failure. */
10833 *buffer = NULL;
10834 return 0;
10835#endif /* HAVE_ZLIB_H */
10836}
10837
10838static int
10839load_specific_debug_section (enum dwarf_section_display_enum debug,
10840 Elf_Internal_Shdr * sec, void * file)
10841{
10842 struct dwarf_section * section = &debug_displays [debug].section;
10843 char buf [64];
10844
10845 /* If it is already loaded, do nothing. */
10846 if (section->start != NULL)
10847 return 1;
10848
10849 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10850 section->address = sec->sh_addr;
10851 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10852 sec->sh_offset, 1,
10853 sec->sh_size, buf);
10854 if (section->start == NULL)
10855 section->size = 0;
10856 else
10857 {
10858 section->size = sec->sh_size;
10859 if (uncompress_section_contents (&section->start, &section->size))
10860 sec->sh_size = section->size;
10861 }
10862
10863 if (section->start == NULL)
10864 return 0;
10865
10866 if (debug_displays [debug].relocate)
10867 apply_relocations ((FILE *) file, sec, section->start);
10868
10869 return 1;
10870}
10871
10872/* If this is not NULL, load_debug_section will only look for sections
10873 within the list of sections given here. */
10874unsigned int *section_subset = NULL;
10875
10876int
10877load_debug_section (enum dwarf_section_display_enum debug, void * file)
10878{
10879 struct dwarf_section * section = &debug_displays [debug].section;
10880 Elf_Internal_Shdr * sec;
10881
10882 /* Locate the debug section. */
10883 sec = find_section_in_set (section->uncompressed_name, section_subset);
10884 if (sec != NULL)
10885 section->name = section->uncompressed_name;
10886 else
10887 {
10888 sec = find_section_in_set (section->compressed_name, section_subset);
10889 if (sec != NULL)
10890 section->name = section->compressed_name;
10891 }
10892 if (sec == NULL)
10893 return 0;
10894
10895 /* If we're loading from a subset of sections, and we've loaded
10896 a section matching this name before, it's likely that it's a
10897 different one. */
10898 if (section_subset != NULL)
10899 free_debug_section (debug);
10900
10901 return load_specific_debug_section (debug, sec, (FILE *) file);
10902}
10903
10904void
10905free_debug_section (enum dwarf_section_display_enum debug)
10906{
10907 struct dwarf_section * section = &debug_displays [debug].section;
10908
10909 if (section->start == NULL)
10910 return;
10911
10912 free ((char *) section->start);
10913 section->start = NULL;
10914 section->address = 0;
10915 section->size = 0;
10916}
10917
10918static int
10919display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
10920{
10921 char * name = SECTION_NAME (section);
10922 bfd_size_type length;
10923 int result = 1;
10924 int i;
10925
10926 length = section->sh_size;
10927 if (length == 0)
10928 {
10929 printf (_("\nSection '%s' has no debugging data.\n"), name);
10930 return 0;
10931 }
10932 if (section->sh_type == SHT_NOBITS)
10933 {
10934 /* There is no point in dumping the contents of a debugging section
10935 which has the NOBITS type - the bits in the file will be random.
10936 This can happen when a file containing a .eh_frame section is
10937 stripped with the --only-keep-debug command line option. */
10938 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10939 return 0;
10940 }
10941
10942 if (const_strneq (name, ".gnu.linkonce.wi."))
10943 name = ".debug_info";
10944
10945 /* See if we know how to display the contents of this section. */
10946 for (i = 0; i < max; i++)
10947 if (streq (debug_displays[i].section.uncompressed_name, name)
10948 || streq (debug_displays[i].section.compressed_name, name))
10949 {
10950 struct dwarf_section * sec = &debug_displays [i].section;
10951 int secondary = (section != find_section (name));
10952
10953 if (secondary)
10954 free_debug_section ((enum dwarf_section_display_enum) i);
10955
10956 if (streq (sec->uncompressed_name, name))
10957 sec->name = sec->uncompressed_name;
10958 else
10959 sec->name = sec->compressed_name;
10960 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10961 section, file))
10962 {
10963 /* If this debug section is part of a CU/TU set in a .dwp file,
10964 restrict load_debug_section to the sections in that set. */
10965 section_subset = find_cu_tu_set (file, shndx);
10966
10967 result &= debug_displays[i].display (sec, file);
10968
10969 section_subset = NULL;
10970
10971 if (secondary || (i != info && i != abbrev))
10972 free_debug_section ((enum dwarf_section_display_enum) i);
10973 }
10974
10975 break;
10976 }
10977
10978 if (i == max)
10979 {
10980 printf (_("Unrecognized debug section: %s\n"), name);
10981 result = 0;
10982 }
10983
10984 return result;
10985}
10986
10987/* Set DUMP_SECTS for all sections where dumps were requested
10988 based on section name. */
10989
10990static void
10991initialise_dumps_byname (void)
10992{
10993 struct dump_list_entry * cur;
10994
10995 for (cur = dump_sects_byname; cur; cur = cur->next)
10996 {
10997 unsigned int i;
10998 int any;
10999
11000 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11001 if (streq (SECTION_NAME (section_headers + i), cur->name))
11002 {
11003 request_dump_bynumber (i, cur->type);
11004 any = 1;
11005 }
11006
11007 if (!any)
11008 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11009 cur->name);
11010 }
11011}
11012
11013static void
11014process_section_contents (FILE * file)
11015{
11016 Elf_Internal_Shdr * section;
11017 unsigned int i;
11018
11019 if (! do_dump)
11020 return;
11021
11022 initialise_dumps_byname ();
11023
11024 for (i = 0, section = section_headers;
11025 i < elf_header.e_shnum && i < num_dump_sects;
11026 i++, section++)
11027 {
11028#ifdef SUPPORT_DISASSEMBLY
11029 if (dump_sects[i] & DISASS_DUMP)
11030 disassemble_section (section, file);
11031#endif
11032 if (dump_sects[i] & HEX_DUMP)
11033 dump_section_as_bytes (section, file, FALSE);
11034
11035 if (dump_sects[i] & RELOC_DUMP)
11036 dump_section_as_bytes (section, file, TRUE);
11037
11038 if (dump_sects[i] & STRING_DUMP)
11039 dump_section_as_strings (section, file);
11040
11041 if (dump_sects[i] & DEBUG_DUMP)
11042 display_debug_section (i, section, file);
11043 }
11044
11045 /* Check to see if the user requested a
11046 dump of a section that does not exist. */
11047 while (i++ < num_dump_sects)
11048 if (dump_sects[i])
11049 warn (_("Section %d was not dumped because it does not exist!\n"), i);
11050}
11051
11052static void
11053process_mips_fpe_exception (int mask)
11054{
11055 if (mask)
11056 {
11057 int first = 1;
11058 if (mask & OEX_FPU_INEX)
11059 fputs ("INEX", stdout), first = 0;
11060 if (mask & OEX_FPU_UFLO)
11061 printf ("%sUFLO", first ? "" : "|"), first = 0;
11062 if (mask & OEX_FPU_OFLO)
11063 printf ("%sOFLO", first ? "" : "|"), first = 0;
11064 if (mask & OEX_FPU_DIV0)
11065 printf ("%sDIV0", first ? "" : "|"), first = 0;
11066 if (mask & OEX_FPU_INVAL)
11067 printf ("%sINVAL", first ? "" : "|");
11068 }
11069 else
11070 fputs ("0", stdout);
11071}
11072
11073/* ARM EABI attributes section. */
11074typedef struct
11075{
11076 int tag;
11077 const char * name;
11078 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11079 int type;
11080 const char ** table;
11081} arm_attr_public_tag;
11082
11083static const char * arm_attr_tag_CPU_arch[] =
11084 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11085 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11086static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11087static const char * arm_attr_tag_THUMB_ISA_use[] =
11088 {"No", "Thumb-1", "Thumb-2"};
11089static const char * arm_attr_tag_FP_arch[] =
11090 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11091 "FP for ARMv8"};
11092static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11093static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11094 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11095static const char * arm_attr_tag_PCS_config[] =
11096 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11097 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11098static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11099 {"V6", "SB", "TLS", "Unused"};
11100static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11101 {"Absolute", "PC-relative", "SB-relative", "None"};
11102static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11103 {"Absolute", "PC-relative", "None"};
11104static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11105 {"None", "direct", "GOT-indirect"};
11106static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11107 {"None", "??? 1", "2", "??? 3", "4"};
11108static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11109static const char * arm_attr_tag_ABI_FP_denormal[] =
11110 {"Unused", "Needed", "Sign only"};
11111static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11112static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11113static const char * arm_attr_tag_ABI_FP_number_model[] =
11114 {"Unused", "Finite", "RTABI", "IEEE 754"};
11115static const char * arm_attr_tag_ABI_enum_size[] =
11116 {"Unused", "small", "int", "forced to int"};
11117static const char * arm_attr_tag_ABI_HardFP_use[] =
11118 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11119static const char * arm_attr_tag_ABI_VFP_args[] =
11120 {"AAPCS", "VFP registers", "custom"};
11121static const char * arm_attr_tag_ABI_WMMX_args[] =
11122 {"AAPCS", "WMMX registers", "custom"};
11123static const char * arm_attr_tag_ABI_optimization_goals[] =
11124 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11125 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11126static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11127 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11128 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11129static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11130static const char * arm_attr_tag_FP_HP_extension[] =
11131 {"Not Allowed", "Allowed"};
11132static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11133 {"None", "IEEE 754", "Alternative Format"};
11134static const char * arm_attr_tag_MPextension_use[] =
11135 {"Not Allowed", "Allowed"};
11136static const char * arm_attr_tag_DIV_use[] =
11137 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11138 "Allowed in v7-A with integer division extension"};
11139static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11140static const char * arm_attr_tag_Virtualization_use[] =
11141 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11142 "TrustZone and Virtualization Extensions"};
11143static const char * arm_attr_tag_MPextension_use_legacy[] =
11144 {"Not Allowed", "Allowed"};
11145
11146#define LOOKUP(id, name) \
11147 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11148static arm_attr_public_tag arm_attr_public_tags[] =
11149{
11150 {4, "CPU_raw_name", 1, NULL},
11151 {5, "CPU_name", 1, NULL},
11152 LOOKUP(6, CPU_arch),
11153 {7, "CPU_arch_profile", 0, NULL},
11154 LOOKUP(8, ARM_ISA_use),
11155 LOOKUP(9, THUMB_ISA_use),
11156 LOOKUP(10, FP_arch),
11157 LOOKUP(11, WMMX_arch),
11158 LOOKUP(12, Advanced_SIMD_arch),
11159 LOOKUP(13, PCS_config),
11160 LOOKUP(14, ABI_PCS_R9_use),
11161 LOOKUP(15, ABI_PCS_RW_data),
11162 LOOKUP(16, ABI_PCS_RO_data),
11163 LOOKUP(17, ABI_PCS_GOT_use),
11164 LOOKUP(18, ABI_PCS_wchar_t),
11165 LOOKUP(19, ABI_FP_rounding),
11166 LOOKUP(20, ABI_FP_denormal),
11167 LOOKUP(21, ABI_FP_exceptions),
11168 LOOKUP(22, ABI_FP_user_exceptions),
11169 LOOKUP(23, ABI_FP_number_model),
11170 {24, "ABI_align_needed", 0, NULL},
11171 {25, "ABI_align_preserved", 0, NULL},
11172 LOOKUP(26, ABI_enum_size),
11173 LOOKUP(27, ABI_HardFP_use),
11174 LOOKUP(28, ABI_VFP_args),
11175 LOOKUP(29, ABI_WMMX_args),
11176 LOOKUP(30, ABI_optimization_goals),
11177 LOOKUP(31, ABI_FP_optimization_goals),
11178 {32, "compatibility", 0, NULL},
11179 LOOKUP(34, CPU_unaligned_access),
11180 LOOKUP(36, FP_HP_extension),
11181 LOOKUP(38, ABI_FP_16bit_format),
11182 LOOKUP(42, MPextension_use),
11183 LOOKUP(44, DIV_use),
11184 {64, "nodefaults", 0, NULL},
11185 {65, "also_compatible_with", 0, NULL},
11186 LOOKUP(66, T2EE_use),
11187 {67, "conformance", 1, NULL},
11188 LOOKUP(68, Virtualization_use),
11189 LOOKUP(70, MPextension_use_legacy)
11190};
11191#undef LOOKUP
11192
11193static unsigned char *
11194display_arm_attribute (unsigned char * p)
11195{
11196 int tag;
11197 unsigned int len;
11198 int val;
11199 arm_attr_public_tag * attr;
11200 unsigned i;
11201 int type;
11202
11203 tag = read_uleb128 (p, &len);
11204 p += len;
11205 attr = NULL;
11206 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11207 {
11208 if (arm_attr_public_tags[i].tag == tag)
11209 {
11210 attr = &arm_attr_public_tags[i];
11211 break;
11212 }
11213 }
11214
11215 if (attr)
11216 {
11217 printf (" Tag_%s: ", attr->name);
11218 switch (attr->type)
11219 {
11220 case 0:
11221 switch (tag)
11222 {
11223 case 7: /* Tag_CPU_arch_profile. */
11224 val = read_uleb128 (p, &len);
11225 p += len;
11226 switch (val)
11227 {
11228 case 0: printf (_("None\n")); break;
11229 case 'A': printf (_("Application\n")); break;
11230 case 'R': printf (_("Realtime\n")); break;
11231 case 'M': printf (_("Microcontroller\n")); break;
11232 case 'S': printf (_("Application or Realtime\n")); break;
11233 default: printf ("??? (%d)\n", val); break;
11234 }
11235 break;
11236
11237 case 24: /* Tag_align_needed. */
11238 val = read_uleb128 (p, &len);
11239 p += len;
11240 switch (val)
11241 {
11242 case 0: printf (_("None\n")); break;
11243 case 1: printf (_("8-byte\n")); break;
11244 case 2: printf (_("4-byte\n")); break;
11245 case 3: printf ("??? 3\n"); break;
11246 default:
11247 if (val <= 12)
11248 printf (_("8-byte and up to %d-byte extended\n"),
11249 1 << val);
11250 else
11251 printf ("??? (%d)\n", val);
11252 break;
11253 }
11254 break;
11255
11256 case 25: /* Tag_align_preserved. */
11257 val = read_uleb128 (p, &len);
11258 p += len;
11259 switch (val)
11260 {
11261 case 0: printf (_("None\n")); break;
11262 case 1: printf (_("8-byte, except leaf SP\n")); break;
11263 case 2: printf (_("8-byte\n")); break;
11264 case 3: printf ("??? 3\n"); break;
11265 default:
11266 if (val <= 12)
11267 printf (_("8-byte and up to %d-byte extended\n"),
11268 1 << val);
11269 else
11270 printf ("??? (%d)\n", val);
11271 break;
11272 }
11273 break;
11274
11275 case 32: /* Tag_compatibility. */
11276 val = read_uleb128 (p, &len);
11277 p += len;
11278 printf (_("flag = %d, vendor = %s\n"), val, p);
11279 p += strlen ((char *) p) + 1;
11280 break;
11281
11282 case 64: /* Tag_nodefaults. */
11283 p++;
11284 printf (_("True\n"));
11285 break;
11286
11287 case 65: /* Tag_also_compatible_with. */
11288 val = read_uleb128 (p, &len);
11289 p += len;
11290 if (val == 6 /* Tag_CPU_arch. */)
11291 {
11292 val = read_uleb128 (p, &len);
11293 p += len;
11294 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11295 printf ("??? (%d)\n", val);
11296 else
11297 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11298 }
11299 else
11300 printf ("???\n");
11301 while (*(p++) != '\0' /* NUL terminator. */);
11302 break;
11303
11304 default:
11305 abort ();
11306 }
11307 return p;
11308
11309 case 1:
11310 case 2:
11311 type = attr->type;
11312 break;
11313
11314 default:
11315 assert (attr->type & 0x80);
11316 val = read_uleb128 (p, &len);
11317 p += len;
11318 type = attr->type & 0x7f;
11319 if (val >= type)
11320 printf ("??? (%d)\n", val);
11321 else
11322 printf ("%s\n", attr->table[val]);
11323 return p;
11324 }
11325 }
11326 else
11327 {
11328 if (tag & 1)
11329 type = 1; /* String. */
11330 else
11331 type = 2; /* uleb128. */
11332 printf (" Tag_unknown_%d: ", tag);
11333 }
11334
11335 if (type == 1)
11336 {
11337 printf ("\"%s\"\n", p);
11338 p += strlen ((char *) p) + 1;
11339 }
11340 else
11341 {
11342 val = read_uleb128 (p, &len);
11343 p += len;
11344 printf ("%d (0x%x)\n", val, val);
11345 }
11346
11347 return p;
11348}
11349
11350static unsigned char *
11351display_gnu_attribute (unsigned char * p,
11352 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11353{
11354 int tag;
11355 unsigned int len;
11356 int val;
11357 int type;
11358
11359 tag = read_uleb128 (p, &len);
11360 p += len;
11361
11362 /* Tag_compatibility is the only generic GNU attribute defined at
11363 present. */
11364 if (tag == 32)
11365 {
11366 val = read_uleb128 (p, &len);
11367 p += len;
11368 printf (_("flag = %d, vendor = %s\n"), val, p);
11369 p += strlen ((char *) p) + 1;
11370 return p;
11371 }
11372
11373 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11374 return display_proc_gnu_attribute (p, tag);
11375
11376 if (tag & 1)
11377 type = 1; /* String. */
11378 else
11379 type = 2; /* uleb128. */
11380 printf (" Tag_unknown_%d: ", tag);
11381
11382 if (type == 1)
11383 {
11384 printf ("\"%s\"\n", p);
11385 p += strlen ((char *) p) + 1;
11386 }
11387 else
11388 {
11389 val = read_uleb128 (p, &len);
11390 p += len;
11391 printf ("%d (0x%x)\n", val, val);
11392 }
11393
11394 return p;
11395}
11396
11397static unsigned char *
11398display_power_gnu_attribute (unsigned char * p, int tag)
11399{
11400 int type;
11401 unsigned int len;
11402 int val;
11403
11404 if (tag == Tag_GNU_Power_ABI_FP)
11405 {
11406 val = read_uleb128 (p, &len);
11407 p += len;
11408 printf (" Tag_GNU_Power_ABI_FP: ");
11409
11410 switch (val)
11411 {
11412 case 0:
11413 printf (_("Hard or soft float\n"));
11414 break;
11415 case 1:
11416 printf (_("Hard float\n"));
11417 break;
11418 case 2:
11419 printf (_("Soft float\n"));
11420 break;
11421 case 3:
11422 printf (_("Single-precision hard float\n"));
11423 break;
11424 default:
11425 printf ("??? (%d)\n", val);
11426 break;
11427 }
11428 return p;
11429 }
11430
11431 if (tag == Tag_GNU_Power_ABI_Vector)
11432 {
11433 val = read_uleb128 (p, &len);
11434 p += len;
11435 printf (" Tag_GNU_Power_ABI_Vector: ");
11436 switch (val)
11437 {
11438 case 0:
11439 printf (_("Any\n"));
11440 break;
11441 case 1:
11442 printf (_("Generic\n"));
11443 break;
11444 case 2:
11445 printf ("AltiVec\n");
11446 break;
11447 case 3:
11448 printf ("SPE\n");
11449 break;
11450 default:
11451 printf ("??? (%d)\n", val);
11452 break;
11453 }
11454 return p;
11455 }
11456
11457 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11458 {
11459 val = read_uleb128 (p, &len);
11460 p += len;
11461 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11462 switch (val)
11463 {
11464 case 0:
11465 printf (_("Any\n"));
11466 break;
11467 case 1:
11468 printf ("r3/r4\n");
11469 break;
11470 case 2:
11471 printf (_("Memory\n"));
11472 break;
11473 default:
11474 printf ("??? (%d)\n", val);
11475 break;
11476 }
11477 return p;
11478 }
11479
11480 if (tag & 1)
11481 type = 1; /* String. */
11482 else
11483 type = 2; /* uleb128. */
11484 printf (" Tag_unknown_%d: ", tag);
11485
11486 if (type == 1)
11487 {
11488 printf ("\"%s\"\n", p);
11489 p += strlen ((char *) p) + 1;
11490 }
11491 else
11492 {
11493 val = read_uleb128 (p, &len);
11494 p += len;
11495 printf ("%d (0x%x)\n", val, val);
11496 }
11497
11498 return p;
11499}
11500
11501static void
11502display_sparc_hwcaps (int mask)
11503{
11504 if (mask)
11505 {
11506 int first = 1;
11507 if (mask & ELF_SPARC_HWCAP_MUL32)
11508 fputs ("mul32", stdout), first = 0;
11509 if (mask & ELF_SPARC_HWCAP_DIV32)
11510 printf ("%sdiv32", first ? "" : "|"), first = 0;
11511 if (mask & ELF_SPARC_HWCAP_FSMULD)
11512 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11513 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11514 printf ("%sv8plus", first ? "" : "|"), first = 0;
11515 if (mask & ELF_SPARC_HWCAP_POPC)
11516 printf ("%spopc", first ? "" : "|"), first = 0;
11517 if (mask & ELF_SPARC_HWCAP_VIS)
11518 printf ("%svis", first ? "" : "|"), first = 0;
11519 if (mask & ELF_SPARC_HWCAP_VIS2)
11520 printf ("%svis2", first ? "" : "|"), first = 0;
11521 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11522 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11523 if (mask & ELF_SPARC_HWCAP_FMAF)
11524 printf ("%sfmaf", first ? "" : "|"), first = 0;
11525 if (mask & ELF_SPARC_HWCAP_VIS3)
11526 printf ("%svis3", first ? "" : "|"), first = 0;
11527 if (mask & ELF_SPARC_HWCAP_HPC)
11528 printf ("%shpc", first ? "" : "|"), first = 0;
11529 if (mask & ELF_SPARC_HWCAP_RANDOM)
11530 printf ("%srandom", first ? "" : "|"), first = 0;
11531 if (mask & ELF_SPARC_HWCAP_TRANS)
11532 printf ("%strans", first ? "" : "|"), first = 0;
11533 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11534 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11535 if (mask & ELF_SPARC_HWCAP_IMA)
11536 printf ("%sima", first ? "" : "|"), first = 0;
11537 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11538 printf ("%scspare", first ? "" : "|"), first = 0;
11539 }
11540 else
11541 fputc('0', stdout);
11542 fputc('\n', stdout);
11543}
11544
11545static unsigned char *
11546display_sparc_gnu_attribute (unsigned char * p, int tag)
11547{
11548 int type;
11549 unsigned int len;
11550 int val;
11551
11552 if (tag == Tag_GNU_Sparc_HWCAPS)
11553 {
11554 val = read_uleb128 (p, &len);
11555 p += len;
11556 printf (" Tag_GNU_Sparc_HWCAPS: ");
11557
11558 display_sparc_hwcaps (val);
11559 return p;
11560 }
11561
11562 if (tag & 1)
11563 type = 1; /* String. */
11564 else
11565 type = 2; /* uleb128. */
11566 printf (" Tag_unknown_%d: ", tag);
11567
11568 if (type == 1)
11569 {
11570 printf ("\"%s\"\n", p);
11571 p += strlen ((char *) p) + 1;
11572 }
11573 else
11574 {
11575 val = read_uleb128 (p, &len);
11576 p += len;
11577 printf ("%d (0x%x)\n", val, val);
11578 }
11579
11580 return p;
11581}
11582
11583static unsigned char *
11584display_mips_gnu_attribute (unsigned char * p, int tag)
11585{
11586 int type;
11587 unsigned int len;
11588 int val;
11589
11590 if (tag == Tag_GNU_MIPS_ABI_FP)
11591 {
11592 val = read_uleb128 (p, &len);
11593 p += len;
11594 printf (" Tag_GNU_MIPS_ABI_FP: ");
11595
11596 switch (val)
11597 {
11598 case 0:
11599 printf (_("Hard or soft float\n"));
11600 break;
11601 case 1:
11602 printf (_("Hard float (double precision)\n"));
11603 break;
11604 case 2:
11605 printf (_("Hard float (single precision)\n"));
11606 break;
11607 case 3:
11608 printf (_("Soft float\n"));
11609 break;
11610 case 4:
11611 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11612 break;
11613 default:
11614 printf ("??? (%d)\n", val);
11615 break;
11616 }
11617 return p;
11618 }
11619
11620 if (tag & 1)
11621 type = 1; /* String. */
11622 else
11623 type = 2; /* uleb128. */
11624 printf (" Tag_unknown_%d: ", tag);
11625
11626 if (type == 1)
11627 {
11628 printf ("\"%s\"\n", p);
11629 p += strlen ((char *) p) + 1;
11630 }
11631 else
11632 {
11633 val = read_uleb128 (p, &len);
11634 p += len;
11635 printf ("%d (0x%x)\n", val, val);
11636 }
11637
11638 return p;
11639}
11640
11641static unsigned char *
11642display_tic6x_attribute (unsigned char * p)
11643{
11644 int tag;
11645 unsigned int len;
11646 int val;
11647
11648 tag = read_uleb128 (p, &len);
11649 p += len;
11650
11651 switch (tag)
11652 {
11653 case Tag_ISA:
11654 val = read_uleb128 (p, &len);
11655 p += len;
11656 printf (" Tag_ISA: ");
11657
11658 switch (val)
11659 {
11660 case C6XABI_Tag_ISA_none:
11661 printf (_("None\n"));
11662 break;
11663 case C6XABI_Tag_ISA_C62X:
11664 printf ("C62x\n");
11665 break;
11666 case C6XABI_Tag_ISA_C67X:
11667 printf ("C67x\n");
11668 break;
11669 case C6XABI_Tag_ISA_C67XP:
11670 printf ("C67x+\n");
11671 break;
11672 case C6XABI_Tag_ISA_C64X:
11673 printf ("C64x\n");
11674 break;
11675 case C6XABI_Tag_ISA_C64XP:
11676 printf ("C64x+\n");
11677 break;
11678 case C6XABI_Tag_ISA_C674X:
11679 printf ("C674x\n");
11680 break;
11681 default:
11682 printf ("??? (%d)\n", val);
11683 break;
11684 }
11685 return p;
11686
11687 case Tag_ABI_wchar_t:
11688 val = read_uleb128 (p, &len);
11689 p += len;
11690 printf (" Tag_ABI_wchar_t: ");
11691 switch (val)
11692 {
11693 case 0:
11694 printf (_("Not used\n"));
11695 break;
11696 case 1:
11697 printf (_("2 bytes\n"));
11698 break;
11699 case 2:
11700 printf (_("4 bytes\n"));
11701 break;
11702 default:
11703 printf ("??? (%d)\n", val);
11704 break;
11705 }
11706 return p;
11707
11708 case Tag_ABI_stack_align_needed:
11709 val = read_uleb128 (p, &len);
11710 p += len;
11711 printf (" Tag_ABI_stack_align_needed: ");
11712 switch (val)
11713 {
11714 case 0:
11715 printf (_("8-byte\n"));
11716 break;
11717 case 1:
11718 printf (_("16-byte\n"));
11719 break;
11720 default:
11721 printf ("??? (%d)\n", val);
11722 break;
11723 }
11724 return p;
11725
11726 case Tag_ABI_stack_align_preserved:
11727 val = read_uleb128 (p, &len);
11728 p += len;
11729 printf (" Tag_ABI_stack_align_preserved: ");
11730 switch (val)
11731 {
11732 case 0:
11733 printf (_("8-byte\n"));
11734 break;
11735 case 1:
11736 printf (_("16-byte\n"));
11737 break;
11738 default:
11739 printf ("??? (%d)\n", val);
11740 break;
11741 }
11742 return p;
11743
11744 case Tag_ABI_DSBT:
11745 val = read_uleb128 (p, &len);
11746 p += len;
11747 printf (" Tag_ABI_DSBT: ");
11748 switch (val)
11749 {
11750 case 0:
11751 printf (_("DSBT addressing not used\n"));
11752 break;
11753 case 1:
11754 printf (_("DSBT addressing used\n"));
11755 break;
11756 default:
11757 printf ("??? (%d)\n", val);
11758 break;
11759 }
11760 return p;
11761
11762 case Tag_ABI_PID:
11763 val = read_uleb128 (p, &len);
11764 p += len;
11765 printf (" Tag_ABI_PID: ");
11766 switch (val)
11767 {
11768 case 0:
11769 printf (_("Data addressing position-dependent\n"));
11770 break;
11771 case 1:
11772 printf (_("Data addressing position-independent, GOT near DP\n"));
11773 break;
11774 case 2:
11775 printf (_("Data addressing position-independent, GOT far from DP\n"));
11776 break;
11777 default:
11778 printf ("??? (%d)\n", val);
11779 break;
11780 }
11781 return p;
11782
11783 case Tag_ABI_PIC:
11784 val = read_uleb128 (p, &len);
11785 p += len;
11786 printf (" Tag_ABI_PIC: ");
11787 switch (val)
11788 {
11789 case 0:
11790 printf (_("Code addressing position-dependent\n"));
11791 break;
11792 case 1:
11793 printf (_("Code addressing position-independent\n"));
11794 break;
11795 default:
11796 printf ("??? (%d)\n", val);
11797 break;
11798 }
11799 return p;
11800
11801 case Tag_ABI_array_object_alignment:
11802 val = read_uleb128 (p, &len);
11803 p += len;
11804 printf (" Tag_ABI_array_object_alignment: ");
11805 switch (val)
11806 {
11807 case 0:
11808 printf (_("8-byte\n"));
11809 break;
11810 case 1:
11811 printf (_("4-byte\n"));
11812 break;
11813 case 2:
11814 printf (_("16-byte\n"));
11815 break;
11816 default:
11817 printf ("??? (%d)\n", val);
11818 break;
11819 }
11820 return p;
11821
11822 case Tag_ABI_array_object_align_expected:
11823 val = read_uleb128 (p, &len);
11824 p += len;
11825 printf (" Tag_ABI_array_object_align_expected: ");
11826 switch (val)
11827 {
11828 case 0:
11829 printf (_("8-byte\n"));
11830 break;
11831 case 1:
11832 printf (_("4-byte\n"));
11833 break;
11834 case 2:
11835 printf (_("16-byte\n"));
11836 break;
11837 default:
11838 printf ("??? (%d)\n", val);
11839 break;
11840 }
11841 return p;
11842
11843 case Tag_ABI_compatibility:
11844 val = read_uleb128 (p, &len);
11845 p += len;
11846 printf (" Tag_ABI_compatibility: ");
11847 printf (_("flag = %d, vendor = %s\n"), val, p);
11848 p += strlen ((char *) p) + 1;
11849 return p;
11850
11851 case Tag_ABI_conformance:
11852 printf (" Tag_ABI_conformance: ");
11853 printf ("\"%s\"\n", p);
11854 p += strlen ((char *) p) + 1;
11855 return p;
11856 }
11857
11858 printf (" Tag_unknown_%d: ", tag);
11859
11860 if (tag & 1)
11861 {
11862 printf ("\"%s\"\n", p);
11863 p += strlen ((char *) p) + 1;
11864 }
11865 else
11866 {
11867 val = read_uleb128 (p, &len);
11868 p += len;
11869 printf ("%d (0x%x)\n", val, val);
11870 }
11871
11872 return p;
11873}
11874
11875static int
11876process_attributes (FILE * file,
11877 const char * public_name,
11878 unsigned int proc_type,
11879 unsigned char * (* display_pub_attribute) (unsigned char *),
11880 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11881{
11882 Elf_Internal_Shdr * sect;
11883 unsigned char * contents;
11884 unsigned char * p;
11885 unsigned char * end;
11886 bfd_vma section_len;
11887 bfd_vma len;
11888 unsigned i;
11889
11890 /* Find the section header so that we get the size. */
11891 for (i = 0, sect = section_headers;
11892 i < elf_header.e_shnum;
11893 i++, sect++)
11894 {
11895 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11896 continue;
11897
11898 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11899 sect->sh_size, _("attributes"));
11900 if (contents == NULL)
11901 continue;
11902
11903 p = contents;
11904 if (*p == 'A')
11905 {
11906 len = sect->sh_size - 1;
11907 p++;
11908
11909 while (len > 0)
11910 {
11911 int namelen;
11912 bfd_boolean public_section;
11913 bfd_boolean gnu_section;
11914
11915 section_len = byte_get (p, 4);
11916 p += 4;
11917
11918 if (section_len > len)
11919 {
11920 printf (_("ERROR: Bad section length (%d > %d)\n"),
11921 (int) section_len, (int) len);
11922 section_len = len;
11923 }
11924
11925 len -= section_len;
11926 printf (_("Attribute Section: %s\n"), p);
11927
11928 if (public_name && streq ((char *) p, public_name))
11929 public_section = TRUE;
11930 else
11931 public_section = FALSE;
11932
11933 if (streq ((char *) p, "gnu"))
11934 gnu_section = TRUE;
11935 else
11936 gnu_section = FALSE;
11937
11938 namelen = strlen ((char *) p) + 1;
11939 p += namelen;
11940 section_len -= namelen + 4;
11941
11942 while (section_len > 0)
11943 {
11944 int tag = *(p++);
11945 int val;
11946 bfd_vma size;
11947
11948 size = byte_get (p, 4);
11949 if (size > section_len)
11950 {
11951 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11952 (int) size, (int) section_len);
11953 size = section_len;
11954 }
11955
11956 section_len -= size;
11957 end = p + size - 1;
11958 p += 4;
11959
11960 switch (tag)
11961 {
11962 case 1:
11963 printf (_("File Attributes\n"));
11964 break;
11965 case 2:
11966 printf (_("Section Attributes:"));
11967 goto do_numlist;
11968 case 3:
11969 printf (_("Symbol Attributes:"));
11970 do_numlist:
11971 for (;;)
11972 {
11973 unsigned int j;
11974
11975 val = read_uleb128 (p, &j);
11976 p += j;
11977 if (val == 0)
11978 break;
11979 printf (" %d", val);
11980 }
11981 printf ("\n");
11982 break;
11983 default:
11984 printf (_("Unknown tag: %d\n"), tag);
11985 public_section = FALSE;
11986 break;
11987 }
11988
11989 if (public_section)
11990 {
11991 while (p < end)
11992 p = display_pub_attribute (p);
11993 }
11994 else if (gnu_section)
11995 {
11996 while (p < end)
11997 p = display_gnu_attribute (p,
11998 display_proc_gnu_attribute);
11999 }
12000 else
12001 {
12002 /* ??? Do something sensible, like dump hex. */
12003 printf (_(" Unknown section contexts\n"));
12004 p = end;
12005 }
12006 }
12007 }
12008 }
12009 else
12010 printf (_("Unknown format '%c'\n"), *p);
12011
12012 free (contents);
12013 }
12014 return 1;
12015}
12016
12017static int
12018process_arm_specific (FILE * file)
12019{
12020 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12021 display_arm_attribute, NULL);
12022}
12023
12024static int
12025process_power_specific (FILE * file)
12026{
12027 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12028 display_power_gnu_attribute);
12029}
12030
12031static int
12032process_sparc_specific (FILE * file)
12033{
12034 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12035 display_sparc_gnu_attribute);
12036}
12037
12038static int
12039process_tic6x_specific (FILE * file)
12040{
12041 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12042 display_tic6x_attribute, NULL);
12043}
12044
12045/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12046 Print the Address, Access and Initial fields of an entry at VMA ADDR
12047 and return the VMA of the next entry. */
12048
12049static bfd_vma
12050print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12051{
12052 printf (" ");
12053 print_vma (addr, LONG_HEX);
12054 printf (" ");
12055 if (addr < pltgot + 0xfff0)
12056 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12057 else
12058 printf ("%10s", "");
12059 printf (" ");
12060 if (data == NULL)
12061 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12062 else
12063 {
12064 bfd_vma entry;
12065
12066 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12067 print_vma (entry, LONG_HEX);
12068 }
12069 return addr + (is_32bit_elf ? 4 : 8);
12070}
12071
12072/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12073 PLTGOT. Print the Address and Initial fields of an entry at VMA
12074 ADDR and return the VMA of the next entry. */
12075
12076static bfd_vma
12077print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12078{
12079 printf (" ");
12080 print_vma (addr, LONG_HEX);
12081 printf (" ");
12082 if (data == NULL)
12083 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12084 else
12085 {
12086 bfd_vma entry;
12087
12088 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12089 print_vma (entry, LONG_HEX);
12090 }
12091 return addr + (is_32bit_elf ? 4 : 8);
12092}
12093
12094static int
12095process_mips_specific (FILE * file)
12096{
12097 Elf_Internal_Dyn * entry;
12098 size_t liblist_offset = 0;
12099 size_t liblistno = 0;
12100 size_t conflictsno = 0;
12101 size_t options_offset = 0;
12102 size_t conflicts_offset = 0;
12103 size_t pltrelsz = 0;
12104 size_t pltrel = 0;
12105 bfd_vma pltgot = 0;
12106 bfd_vma mips_pltgot = 0;
12107 bfd_vma jmprel = 0;
12108 bfd_vma local_gotno = 0;
12109 bfd_vma gotsym = 0;
12110 bfd_vma symtabno = 0;
12111
12112 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12113 display_mips_gnu_attribute);
12114
12115 /* We have a lot of special sections. Thanks SGI! */
12116 if (dynamic_section == NULL)
12117 /* No information available. */
12118 return 0;
12119
12120 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12121 switch (entry->d_tag)
12122 {
12123 case DT_MIPS_LIBLIST:
12124 liblist_offset
12125 = offset_from_vma (file, entry->d_un.d_val,
12126 liblistno * sizeof (Elf32_External_Lib));
12127 break;
12128 case DT_MIPS_LIBLISTNO:
12129 liblistno = entry->d_un.d_val;
12130 break;
12131 case DT_MIPS_OPTIONS:
12132 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12133 break;
12134 case DT_MIPS_CONFLICT:
12135 conflicts_offset
12136 = offset_from_vma (file, entry->d_un.d_val,
12137 conflictsno * sizeof (Elf32_External_Conflict));
12138 break;
12139 case DT_MIPS_CONFLICTNO:
12140 conflictsno = entry->d_un.d_val;
12141 break;
12142 case DT_PLTGOT:
12143 pltgot = entry->d_un.d_ptr;
12144 break;
12145 case DT_MIPS_LOCAL_GOTNO:
12146 local_gotno = entry->d_un.d_val;
12147 break;
12148 case DT_MIPS_GOTSYM:
12149 gotsym = entry->d_un.d_val;
12150 break;
12151 case DT_MIPS_SYMTABNO:
12152 symtabno = entry->d_un.d_val;
12153 break;
12154 case DT_MIPS_PLTGOT:
12155 mips_pltgot = entry->d_un.d_ptr;
12156 break;
12157 case DT_PLTREL:
12158 pltrel = entry->d_un.d_val;
12159 break;
12160 case DT_PLTRELSZ:
12161 pltrelsz = entry->d_un.d_val;
12162 break;
12163 case DT_JMPREL:
12164 jmprel = entry->d_un.d_ptr;
12165 break;
12166 default:
12167 break;
12168 }
12169
12170 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12171 {
12172 Elf32_External_Lib * elib;
12173 size_t cnt;
12174
12175 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12176 liblistno,
12177 sizeof (Elf32_External_Lib),
12178 _("liblist section data"));
12179 if (elib)
12180 {
12181 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12182 (unsigned long) liblistno);
12183 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12184 stdout);
12185
12186 for (cnt = 0; cnt < liblistno; ++cnt)
12187 {
12188 Elf32_Lib liblist;
12189 time_t atime;
12190 char timebuf[20];
12191 struct tm * tmp;
12192
12193 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12194 atime = BYTE_GET (elib[cnt].l_time_stamp);
12195 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12196 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12197 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12198
12199 tmp = gmtime (&atime);
12200 snprintf (timebuf, sizeof (timebuf),
12201 "%04u-%02u-%02uT%02u:%02u:%02u",
12202 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12203 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12204
12205 printf ("%3lu: ", (unsigned long) cnt);
12206 if (VALID_DYNAMIC_NAME (liblist.l_name))
12207 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12208 else
12209 printf (_("<corrupt: %9ld>"), liblist.l_name);
12210 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12211 liblist.l_version);
12212
12213 if (liblist.l_flags == 0)
12214 puts (_(" NONE"));
12215 else
12216 {
12217 static const struct
12218 {
12219 const char * name;
12220 int bit;
12221 }
12222 l_flags_vals[] =
12223 {
12224 { " EXACT_MATCH", LL_EXACT_MATCH },
12225 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12226 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12227 { " EXPORTS", LL_EXPORTS },
12228 { " DELAY_LOAD", LL_DELAY_LOAD },
12229 { " DELTA", LL_DELTA }
12230 };
12231 int flags = liblist.l_flags;
12232 size_t fcnt;
12233
12234 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12235 if ((flags & l_flags_vals[fcnt].bit) != 0)
12236 {
12237 fputs (l_flags_vals[fcnt].name, stdout);
12238 flags ^= l_flags_vals[fcnt].bit;
12239 }
12240 if (flags != 0)
12241 printf (" %#x", (unsigned int) flags);
12242
12243 puts ("");
12244 }
12245 }
12246
12247 free (elib);
12248 }
12249 }
12250
12251 if (options_offset != 0)
12252 {
12253 Elf_External_Options * eopt;
12254 Elf_Internal_Shdr * sect = section_headers;
12255 Elf_Internal_Options * iopt;
12256 Elf_Internal_Options * option;
12257 size_t offset;
12258 int cnt;
12259
12260 /* Find the section header so that we get the size. */
12261 while (sect->sh_type != SHT_MIPS_OPTIONS)
12262 ++sect;
12263
12264 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12265 sect->sh_size, _("options"));
12266 if (eopt)
12267 {
12268 iopt = (Elf_Internal_Options *)
12269 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12270 if (iopt == NULL)
12271 {
12272 error (_("Out of memory\n"));
12273 return 0;
12274 }
12275
12276 offset = cnt = 0;
12277 option = iopt;
12278
12279 while (offset < sect->sh_size)
12280 {
12281 Elf_External_Options * eoption;
12282
12283 eoption = (Elf_External_Options *) ((char *) eopt + offset);
12284
12285 option->kind = BYTE_GET (eoption->kind);
12286 option->size = BYTE_GET (eoption->size);
12287 option->section = BYTE_GET (eoption->section);
12288 option->info = BYTE_GET (eoption->info);
12289
12290 offset += option->size;
12291
12292 ++option;
12293 ++cnt;
12294 }
12295
12296 printf (_("\nSection '%s' contains %d entries:\n"),
12297 SECTION_NAME (sect), cnt);
12298
12299 option = iopt;
12300
12301 while (cnt-- > 0)
12302 {
12303 size_t len;
12304
12305 switch (option->kind)
12306 {
12307 case ODK_NULL:
12308 /* This shouldn't happen. */
12309 printf (" NULL %d %lx", option->section, option->info);
12310 break;
12311 case ODK_REGINFO:
12312 printf (" REGINFO ");
12313 if (elf_header.e_machine == EM_MIPS)
12314 {
12315 /* 32bit form. */
12316 Elf32_External_RegInfo * ereg;
12317 Elf32_RegInfo reginfo;
12318
12319 ereg = (Elf32_External_RegInfo *) (option + 1);
12320 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12321 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12322 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12323 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12324 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12325 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12326
12327 printf ("GPR %08lx GP 0x%lx\n",
12328 reginfo.ri_gprmask,
12329 (unsigned long) reginfo.ri_gp_value);
12330 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12331 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12332 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12333 }
12334 else
12335 {
12336 /* 64 bit form. */
12337 Elf64_External_RegInfo * ereg;
12338 Elf64_Internal_RegInfo reginfo;
12339
12340 ereg = (Elf64_External_RegInfo *) (option + 1);
12341 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12342 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12343 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12344 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12345 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12346 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12347
12348 printf ("GPR %08lx GP 0x",
12349 reginfo.ri_gprmask);
12350 printf_vma (reginfo.ri_gp_value);
12351 printf ("\n");
12352
12353 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12354 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12355 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12356 }
12357 ++option;
12358 continue;
12359 case ODK_EXCEPTIONS:
12360 fputs (" EXCEPTIONS fpe_min(", stdout);
12361 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12362 fputs (") fpe_max(", stdout);
12363 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12364 fputs (")", stdout);
12365
12366 if (option->info & OEX_PAGE0)
12367 fputs (" PAGE0", stdout);
12368 if (option->info & OEX_SMM)
12369 fputs (" SMM", stdout);
12370 if (option->info & OEX_FPDBUG)
12371 fputs (" FPDBUG", stdout);
12372 if (option->info & OEX_DISMISS)
12373 fputs (" DISMISS", stdout);
12374 break;
12375 case ODK_PAD:
12376 fputs (" PAD ", stdout);
12377 if (option->info & OPAD_PREFIX)
12378 fputs (" PREFIX", stdout);
12379 if (option->info & OPAD_POSTFIX)
12380 fputs (" POSTFIX", stdout);
12381 if (option->info & OPAD_SYMBOL)
12382 fputs (" SYMBOL", stdout);
12383 break;
12384 case ODK_HWPATCH:
12385 fputs (" HWPATCH ", stdout);
12386 if (option->info & OHW_R4KEOP)
12387 fputs (" R4KEOP", stdout);
12388 if (option->info & OHW_R8KPFETCH)
12389 fputs (" R8KPFETCH", stdout);
12390 if (option->info & OHW_R5KEOP)
12391 fputs (" R5KEOP", stdout);
12392 if (option->info & OHW_R5KCVTL)
12393 fputs (" R5KCVTL", stdout);
12394 break;
12395 case ODK_FILL:
12396 fputs (" FILL ", stdout);
12397 /* XXX Print content of info word? */
12398 break;
12399 case ODK_TAGS:
12400 fputs (" TAGS ", stdout);
12401 /* XXX Print content of info word? */
12402 break;
12403 case ODK_HWAND:
12404 fputs (" HWAND ", stdout);
12405 if (option->info & OHWA0_R4KEOP_CHECKED)
12406 fputs (" R4KEOP_CHECKED", stdout);
12407 if (option->info & OHWA0_R4KEOP_CLEAN)
12408 fputs (" R4KEOP_CLEAN", stdout);
12409 break;
12410 case ODK_HWOR:
12411 fputs (" HWOR ", stdout);
12412 if (option->info & OHWA0_R4KEOP_CHECKED)
12413 fputs (" R4KEOP_CHECKED", stdout);
12414 if (option->info & OHWA0_R4KEOP_CLEAN)
12415 fputs (" R4KEOP_CLEAN", stdout);
12416 break;
12417 case ODK_GP_GROUP:
12418 printf (" GP_GROUP %#06lx self-contained %#06lx",
12419 option->info & OGP_GROUP,
12420 (option->info & OGP_SELF) >> 16);
12421 break;
12422 case ODK_IDENT:
12423 printf (" IDENT %#06lx self-contained %#06lx",
12424 option->info & OGP_GROUP,
12425 (option->info & OGP_SELF) >> 16);
12426 break;
12427 default:
12428 /* This shouldn't happen. */
12429 printf (" %3d ??? %d %lx",
12430 option->kind, option->section, option->info);
12431 break;
12432 }
12433
12434 len = sizeof (* eopt);
12435 while (len < option->size)
12436 if (((char *) option)[len] >= ' '
12437 && ((char *) option)[len] < 0x7f)
12438 printf ("%c", ((char *) option)[len++]);
12439 else
12440 printf ("\\%03o", ((char *) option)[len++]);
12441
12442 fputs ("\n", stdout);
12443 ++option;
12444 }
12445
12446 free (eopt);
12447 }
12448 }
12449
12450 if (conflicts_offset != 0 && conflictsno != 0)
12451 {
12452 Elf32_Conflict * iconf;
12453 size_t cnt;
12454
12455 if (dynamic_symbols == NULL)
12456 {
12457 error (_("conflict list found without a dynamic symbol table\n"));
12458 return 0;
12459 }
12460
12461 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12462 if (iconf == NULL)
12463 {
12464 error (_("Out of memory\n"));
12465 return 0;
12466 }
12467
12468 if (is_32bit_elf)
12469 {
12470 Elf32_External_Conflict * econf32;
12471
12472 econf32 = (Elf32_External_Conflict *)
12473 get_data (NULL, file, conflicts_offset, conflictsno,
12474 sizeof (* econf32), _("conflict"));
12475 if (!econf32)
12476 return 0;
12477
12478 for (cnt = 0; cnt < conflictsno; ++cnt)
12479 iconf[cnt] = BYTE_GET (econf32[cnt]);
12480
12481 free (econf32);
12482 }
12483 else
12484 {
12485 Elf64_External_Conflict * econf64;
12486
12487 econf64 = (Elf64_External_Conflict *)
12488 get_data (NULL, file, conflicts_offset, conflictsno,
12489 sizeof (* econf64), _("conflict"));
12490 if (!econf64)
12491 return 0;
12492
12493 for (cnt = 0; cnt < conflictsno; ++cnt)
12494 iconf[cnt] = BYTE_GET (econf64[cnt]);
12495
12496 free (econf64);
12497 }
12498
12499 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12500 (unsigned long) conflictsno);
12501 puts (_(" Num: Index Value Name"));
12502
12503 for (cnt = 0; cnt < conflictsno; ++cnt)
12504 {
12505 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
12506
12507 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
12508 print_vma (psym->st_value, FULL_HEX);
12509 putchar (' ');
12510 if (VALID_DYNAMIC_NAME (psym->st_name))
12511 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12512 else
12513 printf (_("<corrupt: %14ld>"), psym->st_name);
12514 putchar ('\n');
12515 }
12516
12517 free (iconf);
12518 }
12519
12520 if (pltgot != 0 && local_gotno != 0)
12521 {
12522 bfd_vma ent, local_end, global_end;
12523 size_t i, offset;
12524 unsigned char * data;
12525 int addr_size;
12526
12527 ent = pltgot;
12528 addr_size = (is_32bit_elf ? 4 : 8);
12529 local_end = pltgot + local_gotno * addr_size;
12530 global_end = local_end + (symtabno - gotsym) * addr_size;
12531
12532 offset = offset_from_vma (file, pltgot, global_end - pltgot);
12533 data = (unsigned char *) get_data (NULL, file, offset,
12534 global_end - pltgot, 1,
12535 _("Global Offset Table data"));
12536 if (data == NULL)
12537 return 0;
12538
12539 printf (_("\nPrimary GOT:\n"));
12540 printf (_(" Canonical gp value: "));
12541 print_vma (pltgot + 0x7ff0, LONG_HEX);
12542 printf ("\n\n");
12543
12544 printf (_(" Reserved entries:\n"));
12545 printf (_(" %*s %10s %*s Purpose\n"),
12546 addr_size * 2, _("Address"), _("Access"),
12547 addr_size * 2, _("Initial"));
12548 ent = print_mips_got_entry (data, pltgot, ent);
12549 printf (_(" Lazy resolver\n"));
12550 if (data
12551 && (byte_get (data + ent - pltgot, addr_size)
12552 >> (addr_size * 8 - 1)) != 0)
12553 {
12554 ent = print_mips_got_entry (data, pltgot, ent);
12555 printf (_(" Module pointer (GNU extension)\n"));
12556 }
12557 printf ("\n");
12558
12559 if (ent < local_end)
12560 {
12561 printf (_(" Local entries:\n"));
12562 printf (" %*s %10s %*s\n",
12563 addr_size * 2, _("Address"), _("Access"),
12564 addr_size * 2, _("Initial"));
12565 while (ent < local_end)
12566 {
12567 ent = print_mips_got_entry (data, pltgot, ent);
12568 printf ("\n");
12569 }
12570 printf ("\n");
12571 }
12572
12573 if (gotsym < symtabno)
12574 {
12575 int sym_width;
12576
12577 printf (_(" Global entries:\n"));
12578 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12579 addr_size * 2, _("Address"),
12580 _("Access"),
12581 addr_size * 2, _("Initial"),
12582 addr_size * 2, _("Sym.Val."),
12583 _("Type"),
12584 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12585 _("Ndx"), _("Name"));
12586
12587 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12588 for (i = gotsym; i < symtabno; i++)
12589 {
12590 Elf_Internal_Sym * psym;
12591
12592 psym = dynamic_symbols + i;
12593 ent = print_mips_got_entry (data, pltgot, ent);
12594 printf (" ");
12595 print_vma (psym->st_value, LONG_HEX);
12596 printf (" %-7s %3s ",
12597 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12598 get_symbol_index_type (psym->st_shndx));
12599 if (VALID_DYNAMIC_NAME (psym->st_name))
12600 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12601 else
12602 printf (_("<corrupt: %14ld>"), psym->st_name);
12603 printf ("\n");
12604 }
12605 printf ("\n");
12606 }
12607
12608 if (data)
12609 free (data);
12610 }
12611
12612 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12613 {
12614 bfd_vma ent, end;
12615 size_t offset, rel_offset;
12616 unsigned long count, i;
12617 unsigned char * data;
12618 int addr_size, sym_width;
12619 Elf_Internal_Rela * rels;
12620
12621 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12622 if (pltrel == DT_RELA)
12623 {
12624 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12625 return 0;
12626 }
12627 else
12628 {
12629 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12630 return 0;
12631 }
12632
12633 ent = mips_pltgot;
12634 addr_size = (is_32bit_elf ? 4 : 8);
12635 end = mips_pltgot + (2 + count) * addr_size;
12636
12637 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12638 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12639 1, _("Procedure Linkage Table data"));
12640 if (data == NULL)
12641 return 0;
12642
12643 printf ("\nPLT GOT:\n\n");
12644 printf (_(" Reserved entries:\n"));
12645 printf (_(" %*s %*s Purpose\n"),
12646 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12647 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12648 printf (_(" PLT lazy resolver\n"));
12649 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12650 printf (_(" Module pointer\n"));
12651 printf ("\n");
12652
12653 printf (_(" Entries:\n"));
12654 printf (" %*s %*s %*s %-7s %3s %s\n",
12655 addr_size * 2, _("Address"),
12656 addr_size * 2, _("Initial"),
12657 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12658 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12659 for (i = 0; i < count; i++)
12660 {
12661 Elf_Internal_Sym * psym;
12662
12663 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12664 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12665 printf (" ");
12666 print_vma (psym->st_value, LONG_HEX);
12667 printf (" %-7s %3s ",
12668 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12669 get_symbol_index_type (psym->st_shndx));
12670 if (VALID_DYNAMIC_NAME (psym->st_name))
12671 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12672 else
12673 printf (_("<corrupt: %14ld>"), psym->st_name);
12674 printf ("\n");
12675 }
12676 printf ("\n");
12677
12678 if (data)
12679 free (data);
12680 free (rels);
12681 }
12682
12683 return 1;
12684}
12685
12686static int
12687process_gnu_liblist (FILE * file)
12688{
12689 Elf_Internal_Shdr * section;
12690 Elf_Internal_Shdr * string_sec;
12691 Elf32_External_Lib * elib;
12692 char * strtab;
12693 size_t strtab_size;
12694 size_t cnt;
12695 unsigned i;
12696
12697 if (! do_arch)
12698 return 0;
12699
12700 for (i = 0, section = section_headers;
12701 i < elf_header.e_shnum;
12702 i++, section++)
12703 {
12704 switch (section->sh_type)
12705 {
12706 case SHT_GNU_LIBLIST:
12707 if (section->sh_link >= elf_header.e_shnum)
12708 break;
12709
12710 elib = (Elf32_External_Lib *)
12711 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12712 _("liblist section data"));
12713
12714 if (elib == NULL)
12715 break;
12716 string_sec = section_headers + section->sh_link;
12717
12718 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12719 string_sec->sh_size,
12720 _("liblist string table"));
12721 if (strtab == NULL
12722 || section->sh_entsize != sizeof (Elf32_External_Lib))
12723 {
12724 free (elib);
12725 free (strtab);
12726 break;
12727 }
12728 strtab_size = string_sec->sh_size;
12729
12730 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12731 SECTION_NAME (section),
12732 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12733
12734 puts (_(" Library Time Stamp Checksum Version Flags"));
12735
12736 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12737 ++cnt)
12738 {
12739 Elf32_Lib liblist;
12740 time_t atime;
12741 char timebuf[20];
12742 struct tm * tmp;
12743
12744 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12745 atime = BYTE_GET (elib[cnt].l_time_stamp);
12746 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12747 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12748 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12749
12750 tmp = gmtime (&atime);
12751 snprintf (timebuf, sizeof (timebuf),
12752 "%04u-%02u-%02uT%02u:%02u:%02u",
12753 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12754 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12755
12756 printf ("%3lu: ", (unsigned long) cnt);
12757 if (do_wide)
12758 printf ("%-20s", liblist.l_name < strtab_size
12759 ? strtab + liblist.l_name : _("<corrupt>"));
12760 else
12761 printf ("%-20.20s", liblist.l_name < strtab_size
12762 ? strtab + liblist.l_name : _("<corrupt>"));
12763 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12764 liblist.l_version, liblist.l_flags);
12765 }
12766
12767 free (elib);
12768 free (strtab);
12769 }
12770 }
12771
12772 return 1;
12773}
12774
12775static const char *
12776get_note_type (unsigned e_type)
12777{
12778 static char buff[64];
12779
12780 if (elf_header.e_type == ET_CORE)
12781 switch (e_type)
12782 {
12783 case NT_AUXV:
12784 return _("NT_AUXV (auxiliary vector)");
12785 case NT_PRSTATUS:
12786 return _("NT_PRSTATUS (prstatus structure)");
12787 case NT_FPREGSET:
12788 return _("NT_FPREGSET (floating point registers)");
12789 case NT_PRPSINFO:
12790 return _("NT_PRPSINFO (prpsinfo structure)");
12791 case NT_TASKSTRUCT:
12792 return _("NT_TASKSTRUCT (task structure)");
12793 case NT_PRXFPREG:
12794 return _("NT_PRXFPREG (user_xfpregs structure)");
12795 case NT_PPC_VMX:
12796 return _("NT_PPC_VMX (ppc Altivec registers)");
12797 case NT_PPC_VSX:
12798 return _("NT_PPC_VSX (ppc VSX registers)");
12799 case NT_386_TLS:
12800 return _("NT_386_TLS (x86 TLS information)");
12801 case NT_386_IOPERM:
12802 return _("NT_386_IOPERM (x86 I/O permissions)");
12803 case NT_X86_XSTATE:
12804 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12805 case NT_S390_HIGH_GPRS:
12806 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12807 case NT_S390_TIMER:
12808 return _("NT_S390_TIMER (s390 timer register)");
12809 case NT_S390_TODCMP:
12810 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12811 case NT_S390_TODPREG:
12812 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12813 case NT_S390_CTRS:
12814 return _("NT_S390_CTRS (s390 control registers)");
12815 case NT_S390_PREFIX:
12816 return _("NT_S390_PREFIX (s390 prefix register)");
12817 case NT_S390_LAST_BREAK:
12818 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
12819 case NT_S390_SYSTEM_CALL:
12820 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
12821 case NT_ARM_VFP:
12822 return _("NT_ARM_VFP (arm VFP registers)");
12823 case NT_ARM_TLS:
12824 return _("NT_ARM_TLS (AArch TLS registers)");
12825 case NT_ARM_HW_BREAK:
12826 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12827 case NT_ARM_HW_WATCH:
12828 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
12829 case NT_PSTATUS:
12830 return _("NT_PSTATUS (pstatus structure)");
12831 case NT_FPREGS:
12832 return _("NT_FPREGS (floating point registers)");
12833 case NT_PSINFO:
12834 return _("NT_PSINFO (psinfo structure)");
12835 case NT_LWPSTATUS:
12836 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12837 case NT_LWPSINFO:
12838 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12839 case NT_WIN32PSTATUS:
12840 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12841 case NT_SIGINFO:
12842 return _("NT_SIGINFO (siginfo_t data)");
12843 case NT_FILE:
12844 return _("NT_FILE (mapped files)");
12845 default:
12846 break;
12847 }
12848 else
12849 switch (e_type)
12850 {
12851 case NT_VERSION:
12852 return _("NT_VERSION (version)");
12853 case NT_ARCH:
12854 return _("NT_ARCH (architecture)");
12855 default:
12856 break;
12857 }
12858
12859 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12860 return buff;
12861}
12862
12863static int
12864print_core_note (Elf_Internal_Note *pnote)
12865{
12866 unsigned int addr_size = is_32bit_elf ? 4 : 8;
12867 bfd_vma count, page_size;
12868 unsigned char *descdata, *filenames, *descend;
12869
12870 if (pnote->type != NT_FILE)
12871 return 1;
12872
12873#ifndef BFD64
12874 if (!is_32bit_elf)
12875 {
12876 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12877 /* Still "successful". */
12878 return 1;
12879 }
12880#endif
12881
12882 if (pnote->descsz < 2 * addr_size)
12883 {
12884 printf (_(" Malformed note - too short for header\n"));
12885 return 0;
12886 }
12887
12888 descdata = (unsigned char *) pnote->descdata;
12889 descend = descdata + pnote->descsz;
12890
12891 if (descdata[pnote->descsz - 1] != '\0')
12892 {
12893 printf (_(" Malformed note - does not end with \\0\n"));
12894 return 0;
12895 }
12896
12897 count = byte_get (descdata, addr_size);
12898 descdata += addr_size;
12899
12900 page_size = byte_get (descdata, addr_size);
12901 descdata += addr_size;
12902
12903 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
12904 {
12905 printf (_(" Malformed note - too short for supplied file count\n"));
12906 return 0;
12907 }
12908
12909 printf (_(" Page size: "));
12910 print_vma (page_size, DEC);
12911 printf ("\n");
12912
12913 printf (_(" %*s%*s%*s\n"),
12914 (int) (2 + 2 * addr_size), _("Start"),
12915 (int) (4 + 2 * addr_size), _("End"),
12916 (int) (4 + 2 * addr_size), _("Page Offset"));
12917 filenames = descdata + count * 3 * addr_size;
12918 while (--count > 0)
12919 {
12920 bfd_vma start, end, file_ofs;
12921
12922 if (filenames == descend)
12923 {
12924 printf (_(" Malformed note - filenames end too early\n"));
12925 return 0;
12926 }
12927
12928 start = byte_get (descdata, addr_size);
12929 descdata += addr_size;
12930 end = byte_get (descdata, addr_size);
12931 descdata += addr_size;
12932 file_ofs = byte_get (descdata, addr_size);
12933 descdata += addr_size;
12934
12935 printf (" ");
12936 print_vma (start, FULL_HEX);
12937 printf (" ");
12938 print_vma (end, FULL_HEX);
12939 printf (" ");
12940 print_vma (file_ofs, FULL_HEX);
12941 printf ("\n %s\n", filenames);
12942
12943 filenames += 1 + strlen ((char *) filenames);
12944 }
12945
12946 return 1;
12947}
12948
12949static const char *
12950get_gnu_elf_note_type (unsigned e_type)
12951{
12952 static char buff[64];
12953
12954 switch (e_type)
12955 {
12956 case NT_GNU_ABI_TAG:
12957 return _("NT_GNU_ABI_TAG (ABI version tag)");
12958 case NT_GNU_HWCAP:
12959 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12960 case NT_GNU_BUILD_ID:
12961 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12962 case NT_GNU_GOLD_VERSION:
12963 return _("NT_GNU_GOLD_VERSION (gold version)");
12964 default:
12965 break;
12966 }
12967
12968 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12969 return buff;
12970}
12971
12972static int
12973print_gnu_note (Elf_Internal_Note *pnote)
12974{
12975 switch (pnote->type)
12976 {
12977 case NT_GNU_BUILD_ID:
12978 {
12979 unsigned long i;
12980
12981 printf (_(" Build ID: "));
12982 for (i = 0; i < pnote->descsz; ++i)
12983 printf ("%02x", pnote->descdata[i] & 0xff);
12984 printf ("\n");
12985 }
12986 break;
12987
12988 case NT_GNU_ABI_TAG:
12989 {
12990 unsigned long os, major, minor, subminor;
12991 const char *osname;
12992
12993 os = byte_get ((unsigned char *) pnote->descdata, 4);
12994 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12995 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12996 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12997
12998 switch (os)
12999 {
13000 case GNU_ABI_TAG_LINUX:
13001 osname = "Linux";
13002 break;
13003 case GNU_ABI_TAG_HURD:
13004 osname = "Hurd";
13005 break;
13006 case GNU_ABI_TAG_SOLARIS:
13007 osname = "Solaris";
13008 break;
13009 case GNU_ABI_TAG_FREEBSD:
13010 osname = "FreeBSD";
13011 break;
13012 case GNU_ABI_TAG_NETBSD:
13013 osname = "NetBSD";
13014 break;
13015 default:
13016 osname = "Unknown";
13017 break;
13018 }
13019
13020 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13021 major, minor, subminor);
13022 }
13023 break;
13024 }
13025
13026 return 1;
13027}
13028
13029static const char *
13030get_netbsd_elfcore_note_type (unsigned e_type)
13031{
13032 static char buff[64];
13033
13034 if (e_type == NT_NETBSDCORE_PROCINFO)
13035 {
13036 /* NetBSD core "procinfo" structure. */
13037 return _("NetBSD procinfo structure");
13038 }
13039
13040 /* As of Jan 2002 there are no other machine-independent notes
13041 defined for NetBSD core files. If the note type is less
13042 than the start of the machine-dependent note types, we don't
13043 understand it. */
13044
13045 if (e_type < NT_NETBSDCORE_FIRSTMACH)
13046 {
13047 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13048 return buff;
13049 }
13050
13051 switch (elf_header.e_machine)
13052 {
13053 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13054 and PT_GETFPREGS == mach+2. */
13055
13056 case EM_OLD_ALPHA:
13057 case EM_ALPHA:
13058 case EM_SPARC:
13059 case EM_SPARC32PLUS:
13060 case EM_SPARCV9:
13061 switch (e_type)
13062 {
13063 case NT_NETBSDCORE_FIRSTMACH + 0:
13064 return _("PT_GETREGS (reg structure)");
13065 case NT_NETBSDCORE_FIRSTMACH + 2:
13066 return _("PT_GETFPREGS (fpreg structure)");
13067 default:
13068 break;
13069 }
13070 break;
13071
13072 /* On all other arch's, PT_GETREGS == mach+1 and
13073 PT_GETFPREGS == mach+3. */
13074 default:
13075 switch (e_type)
13076 {
13077 case NT_NETBSDCORE_FIRSTMACH + 1:
13078 return _("PT_GETREGS (reg structure)");
13079 case NT_NETBSDCORE_FIRSTMACH + 3:
13080 return _("PT_GETFPREGS (fpreg structure)");
13081 default:
13082 break;
13083 }
13084 }
13085
13086 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13087 e_type - NT_NETBSDCORE_FIRSTMACH);
13088 return buff;
13089}
13090
13091static const char *
13092get_stapsdt_note_type (unsigned e_type)
13093{
13094 static char buff[64];
13095
13096 switch (e_type)
13097 {
13098 case NT_STAPSDT:
13099 return _("NT_STAPSDT (SystemTap probe descriptors)");
13100
13101 default:
13102 break;
13103 }
13104
13105 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13106 return buff;
13107}
13108
13109static int
13110print_stapsdt_note (Elf_Internal_Note *pnote)
13111{
13112 int addr_size = is_32bit_elf ? 4 : 8;
13113 char *data = pnote->descdata;
13114 char *data_end = pnote->descdata + pnote->descsz;
13115 bfd_vma pc, base_addr, semaphore;
13116 char *provider, *probe, *arg_fmt;
13117
13118 pc = byte_get ((unsigned char *) data, addr_size);
13119 data += addr_size;
13120 base_addr = byte_get ((unsigned char *) data, addr_size);
13121 data += addr_size;
13122 semaphore = byte_get ((unsigned char *) data, addr_size);
13123 data += addr_size;
13124
13125 provider = data;
13126 data += strlen (data) + 1;
13127 probe = data;
13128 data += strlen (data) + 1;
13129 arg_fmt = data;
13130 data += strlen (data) + 1;
13131
13132 printf (_(" Provider: %s\n"), provider);
13133 printf (_(" Name: %s\n"), probe);
13134 printf (_(" Location: "));
13135 print_vma (pc, FULL_HEX);
13136 printf (_(", Base: "));
13137 print_vma (base_addr, FULL_HEX);
13138 printf (_(", Semaphore: "));
13139 print_vma (semaphore, FULL_HEX);
13140 printf ("\n");
13141 printf (_(" Arguments: %s\n"), arg_fmt);
13142
13143 return data == data_end;
13144}
13145
13146static const char *
13147get_ia64_vms_note_type (unsigned e_type)
13148{
13149 static char buff[64];
13150
13151 switch (e_type)
13152 {
13153 case NT_VMS_MHD:
13154 return _("NT_VMS_MHD (module header)");
13155 case NT_VMS_LNM:
13156 return _("NT_VMS_LNM (language name)");
13157 case NT_VMS_SRC:
13158 return _("NT_VMS_SRC (source files)");
13159 case NT_VMS_TITLE:
13160 return "NT_VMS_TITLE";
13161 case NT_VMS_EIDC:
13162 return _("NT_VMS_EIDC (consistency check)");
13163 case NT_VMS_FPMODE:
13164 return _("NT_VMS_FPMODE (FP mode)");
13165 case NT_VMS_LINKTIME:
13166 return "NT_VMS_LINKTIME";
13167 case NT_VMS_IMGNAM:
13168 return _("NT_VMS_IMGNAM (image name)");
13169 case NT_VMS_IMGID:
13170 return _("NT_VMS_IMGID (image id)");
13171 case NT_VMS_LINKID:
13172 return _("NT_VMS_LINKID (link id)");
13173 case NT_VMS_IMGBID:
13174 return _("NT_VMS_IMGBID (build id)");
13175 case NT_VMS_GSTNAM:
13176 return _("NT_VMS_GSTNAM (sym table name)");
13177 case NT_VMS_ORIG_DYN:
13178 return "NT_VMS_ORIG_DYN";
13179 case NT_VMS_PATCHTIME:
13180 return "NT_VMS_PATCHTIME";
13181 default:
13182 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13183 return buff;
13184 }
13185}
13186
13187static int
13188print_ia64_vms_note (Elf_Internal_Note * pnote)
13189{
13190 switch (pnote->type)
13191 {
13192 case NT_VMS_MHD:
13193 if (pnote->descsz > 36)
13194 {
13195 size_t l = strlen (pnote->descdata + 34);
13196 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13197 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13198 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13199 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13200 }
13201 else
13202 printf (_(" Invalid size\n"));
13203 break;
13204 case NT_VMS_LNM:
13205 printf (_(" Language: %s\n"), pnote->descdata);
13206 break;
13207#ifdef BFD64
13208 case NT_VMS_FPMODE:
13209 printf (_(" Floating Point mode: "));
13210 printf ("0x%016" BFD_VMA_FMT "x\n",
13211 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13212 break;
13213 case NT_VMS_LINKTIME:
13214 printf (_(" Link time: "));
13215 print_vms_time
13216 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13217 printf ("\n");
13218 break;
13219 case NT_VMS_PATCHTIME:
13220 printf (_(" Patch time: "));
13221 print_vms_time
13222 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13223 printf ("\n");
13224 break;
13225 case NT_VMS_ORIG_DYN:
13226 printf (_(" Major id: %u, minor id: %u\n"),
13227 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13228 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
13229 printf (_(" Last modified : "));
13230 print_vms_time
13231 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
13232 printf (_("\n Link flags : "));
13233 printf ("0x%016" BFD_VMA_FMT "x\n",
13234 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13235 printf (_(" Header flags: 0x%08x\n"),
13236 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13237 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13238 break;
13239#endif
13240 case NT_VMS_IMGNAM:
13241 printf (_(" Image name: %s\n"), pnote->descdata);
13242 break;
13243 case NT_VMS_GSTNAM:
13244 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13245 break;
13246 case NT_VMS_IMGID:
13247 printf (_(" Image id: %s\n"), pnote->descdata);
13248 break;
13249 case NT_VMS_LINKID:
13250 printf (_(" Linker id: %s\n"), pnote->descdata);
13251 break;
13252 default:
13253 break;
13254 }
13255 return 1;
13256}
13257
13258/* Note that by the ELF standard, the name field is already null byte
13259 terminated, and namesz includes the terminating null byte.
13260 I.E. the value of namesz for the name "FSF" is 4.
13261
13262 If the value of namesz is zero, there is no name present. */
13263static int
13264process_note (Elf_Internal_Note * pnote)
13265{
13266 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13267 const char * nt;
13268
13269 if (pnote->namesz == 0)
13270 /* If there is no note name, then use the default set of
13271 note type strings. */
13272 nt = get_note_type (pnote->type);
13273
13274 else if (const_strneq (pnote->namedata, "GNU"))
13275 /* GNU-specific object file notes. */
13276 nt = get_gnu_elf_note_type (pnote->type);
13277
13278 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
13279 /* NetBSD-specific core file notes. */
13280 nt = get_netbsd_elfcore_note_type (pnote->type);
13281
13282 else if (strneq (pnote->namedata, "SPU/", 4))
13283 {
13284 /* SPU-specific core file notes. */
13285 nt = pnote->namedata + 4;
13286 name = "SPU";
13287 }
13288
13289 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13290 /* VMS/ia64-specific file notes. */
13291 nt = get_ia64_vms_note_type (pnote->type);
13292
13293 else if (const_strneq (pnote->namedata, "stapsdt"))
13294 nt = get_stapsdt_note_type (pnote->type);
13295
13296 else
13297 /* Don't recognize this note name; just use the default set of
13298 note type strings. */
13299 nt = get_note_type (pnote->type);
13300
13301 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
13302
13303 if (const_strneq (pnote->namedata, "IPF/VMS"))
13304 return print_ia64_vms_note (pnote);
13305 else if (const_strneq (pnote->namedata, "GNU"))
13306 return print_gnu_note (pnote);
13307 else if (const_strneq (pnote->namedata, "stapsdt"))
13308 return print_stapsdt_note (pnote);
13309 else if (const_strneq (pnote->namedata, "CORE"))
13310 return print_core_note (pnote);
13311 else
13312 return 1;
13313}
13314
13315
13316static int
13317process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
13318{
13319 Elf_External_Note * pnotes;
13320 Elf_External_Note * external;
13321 int res = 1;
13322
13323 if (length <= 0)
13324 return 0;
13325
13326 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13327 _("notes"));
13328 if (pnotes == NULL)
13329 return 0;
13330
13331 external = pnotes;
13332
13333 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
13334 (unsigned long) offset, (unsigned long) length);
13335 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13336
13337 while (external < (Elf_External_Note *) ((char *) pnotes + length))
13338 {
13339 Elf_External_Note * next;
13340 Elf_Internal_Note inote;
13341 char * temp = NULL;
13342
13343 if (!is_ia64_vms ())
13344 {
13345 inote.type = BYTE_GET (external->type);
13346 inote.namesz = BYTE_GET (external->namesz);
13347 inote.namedata = external->name;
13348 inote.descsz = BYTE_GET (external->descsz);
13349 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13350 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13351
13352 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
13353 }
13354 else
13355 {
13356 Elf64_External_VMS_Note *vms_external;
13357
13358 vms_external = (Elf64_External_VMS_Note *)external;
13359 inote.type = BYTE_GET (vms_external->type);
13360 inote.namesz = BYTE_GET (vms_external->namesz);
13361 inote.namedata = vms_external->name;
13362 inote.descsz = BYTE_GET (vms_external->descsz);
13363 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13364 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13365
13366 next = (Elf_External_Note *)
13367 (inote.descdata + align_power (inote.descsz, 3));
13368 }
13369
13370 if ( ((char *) next > ((char *) pnotes) + length)
13371 || ((char *) next < (char *) pnotes))
13372 {
13373 warn (_("corrupt note found at offset %lx into core notes\n"),
13374 (unsigned long) ((char *) external - (char *) pnotes));
13375 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13376 inote.type, inote.namesz, inote.descsz);
13377 break;
13378 }
13379
13380 external = next;
13381
13382 /* Prevent out-of-bounds indexing. */
13383 if (inote.namedata + inote.namesz > (char *) pnotes + length
13384 || inote.namedata + inote.namesz < inote.namedata)
13385 {
13386 warn (_("corrupt note found at offset %lx into core notes\n"),
13387 (unsigned long) ((char *) external - (char *) pnotes));
13388 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13389 inote.type, inote.namesz, inote.descsz);
13390 break;
13391 }
13392
13393 /* Verify that name is null terminated. It appears that at least
13394 one version of Linux (RedHat 6.0) generates corefiles that don't
13395 comply with the ELF spec by failing to include the null byte in
13396 namesz. */
13397 if (inote.namedata[inote.namesz - 1] != '\0')
13398 {
13399 temp = (char *) malloc (inote.namesz + 1);
13400
13401 if (temp == NULL)
13402 {
13403 error (_("Out of memory\n"));
13404 res = 0;
13405 break;
13406 }
13407
13408 strncpy (temp, inote.namedata, inote.namesz);
13409 temp[inote.namesz] = 0;
13410
13411 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13412 inote.namedata = temp;
13413 }
13414
13415 res &= process_note (& inote);
13416
13417 if (temp != NULL)
13418 {
13419 free (temp);
13420 temp = NULL;
13421 }
13422 }
13423
13424 free (pnotes);
13425
13426 return res;
13427}
13428
13429static int
13430process_corefile_note_segments (FILE * file)
13431{
13432 Elf_Internal_Phdr * segment;
13433 unsigned int i;
13434 int res = 1;
13435
13436 if (! get_program_headers (file))
13437 return 0;
13438
13439 for (i = 0, segment = program_headers;
13440 i < elf_header.e_phnum;
13441 i++, segment++)
13442 {
13443 if (segment->p_type == PT_NOTE)
13444 res &= process_corefile_note_segment (file,
13445 (bfd_vma) segment->p_offset,
13446 (bfd_vma) segment->p_filesz);
13447 }
13448
13449 return res;
13450}
13451
13452static int
13453process_note_sections (FILE * file)
13454{
13455 Elf_Internal_Shdr * section;
13456 unsigned long i;
13457 int res = 1;
13458
13459 for (i = 0, section = section_headers;
13460 i < elf_header.e_shnum && section != NULL;
13461 i++, section++)
13462 if (section->sh_type == SHT_NOTE)
13463 res &= process_corefile_note_segment (file,
13464 (bfd_vma) section->sh_offset,
13465 (bfd_vma) section->sh_size);
13466
13467 return res;
13468}
13469
13470static int
13471process_notes (FILE * file)
13472{
13473 /* If we have not been asked to display the notes then do nothing. */
13474 if (! do_notes)
13475 return 1;
13476
13477 if (elf_header.e_type != ET_CORE)
13478 return process_note_sections (file);
13479
13480 /* No program headers means no NOTE segment. */
13481 if (elf_header.e_phnum > 0)
13482 return process_corefile_note_segments (file);
13483
13484 printf (_("No note segments present in the core file.\n"));
13485 return 1;
13486}
13487
13488static int
13489process_arch_specific (FILE * file)
13490{
13491 if (! do_arch)
13492 return 1;
13493
13494 switch (elf_header.e_machine)
13495 {
13496 case EM_ARM:
13497 return process_arm_specific (file);
13498 case EM_MIPS:
13499 case EM_MIPS_RS3_LE:
13500 return process_mips_specific (file);
13501 break;
13502 case EM_PPC:
13503 return process_power_specific (file);
13504 break;
13505 case EM_SPARC:
13506 case EM_SPARC32PLUS:
13507 case EM_SPARCV9:
13508 return process_sparc_specific (file);
13509 break;
13510 case EM_TI_C6000:
13511 return process_tic6x_specific (file);
13512 break;
13513 default:
13514 break;
13515 }
13516 return 1;
13517}
13518
13519static int
13520get_file_header (FILE * file)
13521{
13522 /* Read in the identity array. */
13523 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
13524 return 0;
13525
13526 /* Determine how to read the rest of the header. */
13527 switch (elf_header.e_ident[EI_DATA])
13528 {
13529 default: /* fall through */
13530 case ELFDATANONE: /* fall through */
13531 case ELFDATA2LSB:
13532 byte_get = byte_get_little_endian;
13533 byte_put = byte_put_little_endian;
13534 break;
13535 case ELFDATA2MSB:
13536 byte_get = byte_get_big_endian;
13537 byte_put = byte_put_big_endian;
13538 break;
13539 }
13540
13541 /* For now we only support 32 bit and 64 bit ELF files. */
13542 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
13543
13544 /* Read in the rest of the header. */
13545 if (is_32bit_elf)
13546 {
13547 Elf32_External_Ehdr ehdr32;
13548
13549 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13550 return 0;
13551
13552 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13553 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13554 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13555 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13556 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13557 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13558 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13559 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13560 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13561 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13562 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13563 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13564 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13565 }
13566 else
13567 {
13568 Elf64_External_Ehdr ehdr64;
13569
13570 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13571 we will not be able to cope with the 64bit data found in
13572 64 ELF files. Detect this now and abort before we start
13573 overwriting things. */
13574 if (sizeof (bfd_vma) < 8)
13575 {
13576 error (_("This instance of readelf has been built without support for a\n\
1357764 bit data type and so it cannot read 64 bit ELF files.\n"));
13578 return 0;
13579 }
13580
13581 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13582 return 0;
13583
13584 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13585 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13586 elf_header.e_version = BYTE_GET (ehdr64.e_version);
13587 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13588 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13589 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
13590 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13591 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13592 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13593 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13594 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13595 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13596 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13597 }
13598
13599 if (elf_header.e_shoff)
13600 {
13601 /* There may be some extensions in the first section header. Don't
13602 bomb if we can't read it. */
13603 if (is_32bit_elf)
13604 get_32bit_section_headers (file, 1);
13605 else
13606 get_64bit_section_headers (file, 1);
13607 }
13608
13609 return 1;
13610}
13611
13612/* Process one ELF object file according to the command line options.
13613 This file may actually be stored in an archive. The file is
13614 positioned at the start of the ELF object. */
13615
13616static int
13617process_object (char * file_name, FILE * file)
13618{
13619 unsigned int i;
13620
13621 if (! get_file_header (file))
13622 {
13623 error (_("%s: Failed to read file header\n"), file_name);
13624 return 1;
13625 }
13626
13627 /* Initialise per file variables. */
13628 for (i = ARRAY_SIZE (version_info); i--;)
13629 version_info[i] = 0;
13630
13631 for (i = ARRAY_SIZE (dynamic_info); i--;)
13632 dynamic_info[i] = 0;
13633 dynamic_info_DT_GNU_HASH = 0;
13634
13635 /* Process the file. */
13636 if (show_name)
13637 printf (_("\nFile: %s\n"), file_name);
13638
13639 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13640 Note we do this even if cmdline_dump_sects is empty because we
13641 must make sure that the dump_sets array is zeroed out before each
13642 object file is processed. */
13643 if (num_dump_sects > num_cmdline_dump_sects)
13644 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13645
13646 if (num_cmdline_dump_sects > 0)
13647 {
13648 if (num_dump_sects == 0)
13649 /* A sneaky way of allocating the dump_sects array. */
13650 request_dump_bynumber (num_cmdline_dump_sects, 0);
13651
13652 assert (num_dump_sects >= num_cmdline_dump_sects);
13653 memcpy (dump_sects, cmdline_dump_sects,
13654 num_cmdline_dump_sects * sizeof (* dump_sects));
13655 }
13656
13657 if (! process_file_header ())
13658 return 1;
13659
13660 if (! process_section_headers (file))
13661 {
13662 /* Without loaded section headers we cannot process lots of
13663 things. */
13664 do_unwind = do_version = do_dump = do_arch = 0;
13665
13666 if (! do_using_dynamic)
13667 do_syms = do_dyn_syms = do_reloc = 0;
13668 }
13669
13670 if (! process_section_groups (file))
13671 {
13672 /* Without loaded section groups we cannot process unwind. */
13673 do_unwind = 0;
13674 }
13675
13676 if (process_program_headers (file))
13677 process_dynamic_section (file);
13678
13679 process_relocs (file);
13680
13681 process_unwind (file);
13682
13683 process_symbol_table (file);
13684
13685 process_syminfo (file);
13686
13687 process_version_sections (file);
13688
13689 process_section_contents (file);
13690
13691 process_notes (file);
13692
13693 process_gnu_liblist (file);
13694
13695 process_arch_specific (file);
13696
13697 if (program_headers)
13698 {
13699 free (program_headers);
13700 program_headers = NULL;
13701 }
13702
13703 if (section_headers)
13704 {
13705 free (section_headers);
13706 section_headers = NULL;
13707 }
13708
13709 if (string_table)
13710 {
13711 free (string_table);
13712 string_table = NULL;
13713 string_table_length = 0;
13714 }
13715
13716 if (dynamic_strings)
13717 {
13718 free (dynamic_strings);
13719 dynamic_strings = NULL;
13720 dynamic_strings_length = 0;
13721 }
13722
13723 if (dynamic_symbols)
13724 {
13725 free (dynamic_symbols);
13726 dynamic_symbols = NULL;
13727 num_dynamic_syms = 0;
13728 }
13729
13730 if (dynamic_syminfo)
13731 {
13732 free (dynamic_syminfo);
13733 dynamic_syminfo = NULL;
13734 }
13735
13736 if (dynamic_section)
13737 {
13738 free (dynamic_section);
13739 dynamic_section = NULL;
13740 }
13741
13742 if (section_headers_groups)
13743 {
13744 free (section_headers_groups);
13745 section_headers_groups = NULL;
13746 }
13747
13748 if (section_groups)
13749 {
13750 struct group_list * g;
13751 struct group_list * next;
13752
13753 for (i = 0; i < group_count; i++)
13754 {
13755 for (g = section_groups [i].root; g != NULL; g = next)
13756 {
13757 next = g->next;
13758 free (g);
13759 }
13760 }
13761
13762 free (section_groups);
13763 section_groups = NULL;
13764 }
13765
13766 free_debug_memory ();
13767
13768 return 0;
13769}
13770
13771/* Process an ELF archive.
13772 On entry the file is positioned just after the ARMAG string. */
13773
13774static int
13775process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13776{
13777 struct archive_info arch;
13778 struct archive_info nested_arch;
13779 size_t got;
13780 int ret;
13781
13782 show_name = 1;
13783
13784 /* The ARCH structure is used to hold information about this archive. */
13785 arch.file_name = NULL;
13786 arch.file = NULL;
13787 arch.index_array = NULL;
13788 arch.sym_table = NULL;
13789 arch.longnames = NULL;
13790
13791 /* The NESTED_ARCH structure is used as a single-item cache of information
13792 about a nested archive (when members of a thin archive reside within
13793 another regular archive file). */
13794 nested_arch.file_name = NULL;
13795 nested_arch.file = NULL;
13796 nested_arch.index_array = NULL;
13797 nested_arch.sym_table = NULL;
13798 nested_arch.longnames = NULL;
13799
13800 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13801 {
13802 ret = 1;
13803 goto out;
13804 }
13805
13806 if (do_archive_index)
13807 {
13808 if (arch.sym_table == NULL)
13809 error (_("%s: unable to dump the index as none was found\n"), file_name);
13810 else
13811 {
13812 unsigned int i, l;
13813 unsigned long current_pos;
13814
13815 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13816 file_name, (long) arch.index_num, arch.sym_size);
13817 current_pos = ftell (file);
13818
13819 for (i = l = 0; i < arch.index_num; i++)
13820 {
13821 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13822 {
13823 char * member_name;
13824
13825 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13826
13827 if (member_name != NULL)
13828 {
13829 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13830
13831 if (qualified_name != NULL)
13832 {
13833 printf (_("Contents of binary %s at offset "), qualified_name);
13834 (void) print_vma (arch.index_array[i], PREFIX_HEX);
13835 putchar ('\n');
13836 free (qualified_name);
13837 }
13838 }
13839 }
13840
13841 if (l >= arch.sym_size)
13842 {
13843 error (_("%s: end of the symbol table reached before the end of the index\n"),
13844 file_name);
13845 break;
13846 }
13847 printf ("\t%s\n", arch.sym_table + l);
13848 l += strlen (arch.sym_table + l) + 1;
13849 }
13850
13851 if (arch.uses_64bit_indicies)
13852 l = (l + 7) & ~ 7;
13853 else
13854 l += l & 1;
13855
13856 if (l < arch.sym_size)
13857 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13858 file_name, arch.sym_size - l);
13859
13860 if (fseek (file, current_pos, SEEK_SET) != 0)
13861 {
13862 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
13863 ret = 1;
13864 goto out;
13865 }
13866 }
13867
13868 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13869 && !do_segments && !do_header && !do_dump && !do_version
13870 && !do_histogram && !do_debugging && !do_arch && !do_notes
13871 && !do_section_groups && !do_dyn_syms)
13872 {
13873 ret = 0; /* Archive index only. */
13874 goto out;
13875 }
13876 }
13877
13878 ret = 0;
13879
13880 while (1)
13881 {
13882 char * name;
13883 size_t namelen;
13884 char * qualified_name;
13885
13886 /* Read the next archive header. */
13887 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13888 {
13889 error (_("%s: failed to seek to next archive header\n"), file_name);
13890 return 1;
13891 }
13892 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13893 if (got != sizeof arch.arhdr)
13894 {
13895 if (got == 0)
13896 break;
13897 error (_("%s: failed to read archive header\n"), file_name);
13898 ret = 1;
13899 break;
13900 }
13901 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13902 {
13903 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13904 ret = 1;
13905 break;
13906 }
13907
13908 arch.next_arhdr_offset += sizeof arch.arhdr;
13909
13910 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13911 if (archive_file_size & 01)
13912 ++archive_file_size;
13913
13914 name = get_archive_member_name (&arch, &nested_arch);
13915 if (name == NULL)
13916 {
13917 error (_("%s: bad archive file name\n"), file_name);
13918 ret = 1;
13919 break;
13920 }
13921 namelen = strlen (name);
13922
13923 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13924 if (qualified_name == NULL)
13925 {
13926 error (_("%s: bad archive file name\n"), file_name);
13927 ret = 1;
13928 break;
13929 }
13930
13931 if (is_thin_archive && arch.nested_member_origin == 0)
13932 {
13933 /* This is a proxy for an external member of a thin archive. */
13934 FILE * member_file;
13935 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13936 if (member_file_name == NULL)
13937 {
13938 ret = 1;
13939 break;
13940 }
13941
13942 member_file = fopen (member_file_name, "rb");
13943 if (member_file == NULL)
13944 {
13945 error (_("Input file '%s' is not readable.\n"), member_file_name);
13946 free (member_file_name);
13947 ret = 1;
13948 break;
13949 }
13950
13951 archive_file_offset = arch.nested_member_origin;
13952
13953 ret |= process_object (qualified_name, member_file);
13954
13955 fclose (member_file);
13956 free (member_file_name);
13957 }
13958 else if (is_thin_archive)
13959 {
13960 /* This is a proxy for a member of a nested archive. */
13961 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13962
13963 /* The nested archive file will have been opened and setup by
13964 get_archive_member_name. */
13965 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13966 {
13967 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13968 ret = 1;
13969 break;
13970 }
13971
13972 ret |= process_object (qualified_name, nested_arch.file);
13973 }
13974 else
13975 {
13976 archive_file_offset = arch.next_arhdr_offset;
13977 arch.next_arhdr_offset += archive_file_size;
13978
13979 ret |= process_object (qualified_name, file);
13980 }
13981
13982 if (dump_sects != NULL)
13983 {
13984 free (dump_sects);
13985 dump_sects = NULL;
13986 num_dump_sects = 0;
13987 }
13988
13989 free (qualified_name);
13990 }
13991
13992 out:
13993 if (nested_arch.file != NULL)
13994 fclose (nested_arch.file);
13995 release_archive (&nested_arch);
13996 release_archive (&arch);
13997
13998 return ret;
13999}
14000
14001static int
14002process_file (char * file_name)
14003{
14004 FILE * file;
14005 struct stat statbuf;
14006 char armag[SARMAG];
14007 int ret;
14008
14009 if (stat (file_name, &statbuf) < 0)
14010 {
14011 if (errno == ENOENT)
14012 error (_("'%s': No such file\n"), file_name);
14013 else
14014 error (_("Could not locate '%s'. System error message: %s\n"),
14015 file_name, strerror (errno));
14016 return 1;
14017 }
14018
14019 if (! S_ISREG (statbuf.st_mode))
14020 {
14021 error (_("'%s' is not an ordinary file\n"), file_name);
14022 return 1;
14023 }
14024
14025 file = fopen (file_name, "rb");
14026 if (file == NULL)
14027 {
14028 error (_("Input file '%s' is not readable.\n"), file_name);
14029 return 1;
14030 }
14031
14032 if (fread (armag, SARMAG, 1, file) != 1)
14033 {
14034 error (_("%s: Failed to read file's magic number\n"), file_name);
14035 fclose (file);
14036 return 1;
14037 }
14038
14039 if (memcmp (armag, ARMAG, SARMAG) == 0)
14040 ret = process_archive (file_name, file, FALSE);
14041 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14042 ret = process_archive (file_name, file, TRUE);
14043 else
14044 {
14045 if (do_archive_index)
14046 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14047 file_name);
14048
14049 rewind (file);
14050 archive_file_size = archive_file_offset = 0;
14051 ret = process_object (file_name, file);
14052 }
14053
14054 fclose (file);
14055
14056 return ret;
14057}
14058
14059#ifdef SUPPORT_DISASSEMBLY
14060/* Needed by the i386 disassembler. For extra credit, someone could
14061 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14062 symbols. */
14063
14064void
14065print_address (unsigned int addr, FILE * outfile)
14066{
14067 fprintf (outfile,"0x%8.8x", addr);
14068}
14069
14070/* Needed by the i386 disassembler. */
14071void
14072db_task_printsym (unsigned int addr)
14073{
14074 print_address (addr, stderr);
14075}
14076#endif
14077
14078int
14079main (int argc, char ** argv)
14080{
14081 int err;
14082
14083#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14084 setlocale (LC_MESSAGES, "");
14085#endif
14086#if defined (HAVE_SETLOCALE)
14087 setlocale (LC_CTYPE, "");
14088#endif
14089 bindtextdomain (PACKAGE, LOCALEDIR);
14090 textdomain (PACKAGE);
14091
14092 expandargv (&argc, &argv);
14093
14094 parse_args (argc, argv);
14095
14096 if (num_dump_sects > 0)
14097 {
14098 /* Make a copy of the dump_sects array. */
14099 cmdline_dump_sects = (dump_type *)
14100 malloc (num_dump_sects * sizeof (* dump_sects));
14101 if (cmdline_dump_sects == NULL)
14102 error (_("Out of memory allocating dump request table.\n"));
14103 else
14104 {
14105 memcpy (cmdline_dump_sects, dump_sects,
14106 num_dump_sects * sizeof (* dump_sects));
14107 num_cmdline_dump_sects = num_dump_sects;
14108 }
14109 }
14110
14111 if (optind < (argc - 1))
14112 show_name = 1;
14113
14114 err = 0;
14115 while (optind < argc)
14116 err |= process_file (argv[optind++]);
14117
14118 if (dump_sects != NULL)
14119 free (dump_sects);
14120 if (cmdline_dump_sects != NULL)
14121 free (cmdline_dump_sects);
14122
14123 return err;
14124}
A mirror of the official binutils-gdb repository