]> 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
Fix typo.
[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
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/microblaze.h"
128#include "elf/mips.h"
129#include "elf/mmix.h"
130#include "elf/mn10200.h"
131#include "elf/mn10300.h"
132#include "elf/moxie.h"
133#include "elf/mt.h"
134#include "elf/msp430.h"
135#include "elf/or32.h"
136#include "elf/pj.h"
137#include "elf/ppc.h"
138#include "elf/ppc64.h"
139#include "elf/rl78.h"
140#include "elf/rx.h"
141#include "elf/s390.h"
142#include "elf/score.h"
143#include "elf/sh.h"
144#include "elf/sparc.h"
145#include "elf/spu.h"
146#include "elf/tic6x.h"
147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
149#include "elf/v850.h"
150#include "elf/vax.h"
151#include "elf/x86-64.h"
152#include "elf/xc16x.h"
153#include "elf/xgate.h"
154#include "elf/xstormy16.h"
155#include "elf/xtensa.h"
156
157#include "getopt.h"
158#include "libiberty.h"
159#include "safe-ctype.h"
160#include "filenames.h"
161
162char * program_name = "readelf";
163static long archive_file_offset;
164static unsigned long archive_file_size;
165static unsigned long dynamic_addr;
166static bfd_size_type dynamic_size;
167static unsigned int dynamic_nent;
168static char * dynamic_strings;
169static unsigned long dynamic_strings_length;
170static char * string_table;
171static unsigned long string_table_length;
172static unsigned long num_dynamic_syms;
173static Elf_Internal_Sym * dynamic_symbols;
174static Elf_Internal_Syminfo * dynamic_syminfo;
175static unsigned long dynamic_syminfo_offset;
176static unsigned int dynamic_syminfo_nent;
177static char program_interpreter[PATH_MAX];
178static bfd_vma dynamic_info[DT_ENCODING];
179static bfd_vma dynamic_info_DT_GNU_HASH;
180static bfd_vma version_info[16];
181static Elf_Internal_Ehdr elf_header;
182static Elf_Internal_Shdr * section_headers;
183static Elf_Internal_Phdr * program_headers;
184static Elf_Internal_Dyn * dynamic_section;
185static Elf_Internal_Shdr * symtab_shndx_hdr;
186static int show_name;
187static int do_dynamic;
188static int do_syms;
189static int do_dyn_syms;
190static int do_reloc;
191static int do_sections;
192static int do_section_groups;
193static int do_section_details;
194static int do_segments;
195static int do_unwind;
196static int do_using_dynamic;
197static int do_header;
198static int do_dump;
199static int do_version;
200static int do_histogram;
201static int do_debugging;
202static int do_arch;
203static int do_notes;
204static int do_archive_index;
205static int is_32bit_elf;
206
207struct group_list
208{
209 struct group_list * next;
210 unsigned int section_index;
211};
212
213struct group
214{
215 struct group_list * root;
216 unsigned int group_index;
217};
218
219static size_t group_count;
220static struct group * section_groups;
221static struct group ** section_headers_groups;
222
223
224/* Flag bits indicating particular types of dump. */
225#define HEX_DUMP (1 << 0) /* The -x command line switch. */
226#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
227#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
228#define STRING_DUMP (1 << 3) /* The -p command line switch. */
229#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
230
231typedef unsigned char dump_type;
232
233/* A linked list of the section names for which dumps were requested. */
234struct dump_list_entry
235{
236 char * name;
237 dump_type type;
238 struct dump_list_entry * next;
239};
240static struct dump_list_entry * dump_sects_byname;
241
242/* A dynamic array of flags indicating for which sections a dump
243 has been requested via command line switches. */
244static dump_type * cmdline_dump_sects = NULL;
245static unsigned int num_cmdline_dump_sects = 0;
246
247/* A dynamic array of flags indicating for which sections a dump of
248 some kind has been requested. It is reset on a per-object file
249 basis and then initialised from the cmdline_dump_sects array,
250 the results of interpreting the -w switch, and the
251 dump_sects_byname list. */
252static dump_type * dump_sects = NULL;
253static unsigned int num_dump_sects = 0;
254
255
256/* How to print a vma value. */
257typedef enum print_mode
258{
259 HEX,
260 DEC,
261 DEC_5,
262 UNSIGNED,
263 PREFIX_HEX,
264 FULL_HEX,
265 LONG_HEX
266}
267print_mode;
268
269#define UNKNOWN -1
270
271#define SECTION_NAME(X) \
272 ((X) == NULL ? _("<none>") \
273 : string_table == NULL ? _("<no-name>") \
274 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
275 : string_table + (X)->sh_name))
276
277#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
278
279#define GET_ELF_SYMBOLS(file, section, sym_count) \
280 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
281 : get_64bit_elf_symbols (file, section, sym_count))
282
283#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
284/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
285 already been called and verified that the string exists. */
286#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
287
288#define REMOVE_ARCH_BITS(ADDR) \
289 do \
290 { \
291 if (elf_header.e_machine == EM_ARM) \
292 (ADDR) &= ~1; \
293 } \
294 while (0)
295\f
296/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
297 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
298 using malloc and fill that. In either case return the pointer to the start of
299 the retrieved data or NULL if something went wrong. If something does go wrong
300 emit an error message using REASON as part of the context. */
301
302static void *
303get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
304 const char * reason)
305{
306 void * mvar;
307
308 if (size == 0 || nmemb == 0)
309 return NULL;
310
311 if (fseek (file, archive_file_offset + offset, SEEK_SET))
312 {
313 error (_("Unable to seek to 0x%lx for %s\n"),
314 (unsigned long) archive_file_offset + offset, reason);
315 return NULL;
316 }
317
318 mvar = var;
319 if (mvar == NULL)
320 {
321 /* Check for overflow. */
322 if (nmemb < (~(size_t) 0 - 1) / size)
323 /* + 1 so that we can '\0' terminate invalid string table sections. */
324 mvar = malloc (size * nmemb + 1);
325
326 if (mvar == NULL)
327 {
328 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
329 (unsigned long)(size * nmemb), reason);
330 return NULL;
331 }
332
333 ((char *) mvar)[size * nmemb] = '\0';
334 }
335
336 if (fread (mvar, size, nmemb, file) != nmemb)
337 {
338 error (_("Unable to read in 0x%lx bytes of %s\n"),
339 (unsigned long)(size * nmemb), reason);
340 if (mvar != var)
341 free (mvar);
342 return NULL;
343 }
344
345 return mvar;
346}
347
348/* Print a VMA value. */
349
350static int
351print_vma (bfd_vma vma, print_mode mode)
352{
353 int nc = 0;
354
355 switch (mode)
356 {
357 case FULL_HEX:
358 nc = printf ("0x");
359 /* Drop through. */
360
361 case LONG_HEX:
362#ifdef BFD64
363 if (is_32bit_elf)
364 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
365#endif
366 printf_vma (vma);
367 return nc + 16;
368
369 case DEC_5:
370 if (vma <= 99999)
371 return printf ("%5" BFD_VMA_FMT "d", vma);
372 /* Drop through. */
373
374 case PREFIX_HEX:
375 nc = printf ("0x");
376 /* Drop through. */
377
378 case HEX:
379 return nc + printf ("%" BFD_VMA_FMT "x", vma);
380
381 case DEC:
382 return printf ("%" BFD_VMA_FMT "d", vma);
383
384 case UNSIGNED:
385 return printf ("%" BFD_VMA_FMT "u", vma);
386 }
387 return 0;
388}
389
390/* Display a symbol on stdout. Handles the display of control characters and
391 multibye characters (assuming the host environment supports them).
392
393 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
394
395 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
396 padding as necessary.
397
398 Returns the number of emitted characters. */
399
400static unsigned int
401print_symbol (int width, const char *symbol)
402{
403 bfd_boolean extra_padding = FALSE;
404 int num_printed = 0;
405#ifdef HAVE_MBSTATE_T
406 mbstate_t state;
407#endif
408 int width_remaining;
409
410 if (width < 0)
411 {
412 /* Keep the width positive. This also helps. */
413 width = - width;
414 extra_padding = TRUE;
415 }
416
417 if (do_wide)
418 /* Set the remaining width to a very large value.
419 This simplifies the code below. */
420 width_remaining = INT_MAX;
421 else
422 width_remaining = width;
423
424#ifdef HAVE_MBSTATE_T
425 /* Initialise the multibyte conversion state. */
426 memset (& state, 0, sizeof (state));
427#endif
428
429 while (width_remaining)
430 {
431 size_t n;
432 const char c = *symbol++;
433
434 if (c == 0)
435 break;
436
437 /* Do not print control characters directly as they can affect terminal
438 settings. Such characters usually appear in the names generated
439 by the assembler for local labels. */
440 if (ISCNTRL (c))
441 {
442 if (width_remaining < 2)
443 break;
444
445 printf ("^%c", c + 0x40);
446 width_remaining -= 2;
447 num_printed += 2;
448 }
449 else if (ISPRINT (c))
450 {
451 putchar (c);
452 width_remaining --;
453 num_printed ++;
454 }
455 else
456 {
457#ifdef HAVE_MBSTATE_T
458 wchar_t w;
459#endif
460 /* Let printf do the hard work of displaying multibyte characters. */
461 printf ("%.1s", symbol - 1);
462 width_remaining --;
463 num_printed ++;
464
465#ifdef HAVE_MBSTATE_T
466 /* Try to find out how many bytes made up the character that was
467 just printed. Advance the symbol pointer past the bytes that
468 were displayed. */
469 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
470#else
471 n = 1;
472#endif
473 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
474 symbol += (n - 1);
475 }
476 }
477
478 if (extra_padding && num_printed < width)
479 {
480 /* Fill in the remaining spaces. */
481 printf ("%-*s", width - num_printed, " ");
482 num_printed = width;
483 }
484
485 return num_printed;
486}
487
488/* Return a pointer to section NAME, or NULL if no such section exists. */
489
490static Elf_Internal_Shdr *
491find_section (const char * name)
492{
493 unsigned int i;
494
495 for (i = 0; i < elf_header.e_shnum; i++)
496 if (streq (SECTION_NAME (section_headers + i), name))
497 return section_headers + i;
498
499 return NULL;
500}
501
502/* Return a pointer to a section containing ADDR, or NULL if no such
503 section exists. */
504
505static Elf_Internal_Shdr *
506find_section_by_address (bfd_vma addr)
507{
508 unsigned int i;
509
510 for (i = 0; i < elf_header.e_shnum; i++)
511 {
512 Elf_Internal_Shdr *sec = section_headers + i;
513 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
514 return sec;
515 }
516
517 return NULL;
518}
519
520/* Return a pointer to section NAME, or NULL if no such section exists,
521 restricted to the list of sections given in SET. */
522
523static Elf_Internal_Shdr *
524find_section_in_set (const char * name, unsigned int * set)
525{
526 unsigned int i;
527
528 if (set != NULL)
529 {
530 while ((i = *set++) > 0)
531 if (streq (SECTION_NAME (section_headers + i), name))
532 return section_headers + i;
533 }
534
535 return find_section (name);
536}
537
538/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
539 bytes read. */
540
541static unsigned long
542read_uleb128 (unsigned char *data, unsigned int *length_return)
543{
544 return read_leb128 (data, length_return, 0);
545}
546
547/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
548 This OS has so many departures from the ELF standard that we test it at
549 many places. */
550
551static inline int
552is_ia64_vms (void)
553{
554 return elf_header.e_machine == EM_IA_64
555 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
556}
557
558/* Guess the relocation size commonly used by the specific machines. */
559
560static int
561guess_is_rela (unsigned int e_machine)
562{
563 switch (e_machine)
564 {
565 /* Targets that use REL relocations. */
566 case EM_386:
567 case EM_486:
568 case EM_960:
569 case EM_ARM:
570 case EM_D10V:
571 case EM_CYGNUS_D10V:
572 case EM_DLX:
573 case EM_MIPS:
574 case EM_MIPS_RS3_LE:
575 case EM_CYGNUS_M32R:
576 case EM_OPENRISC:
577 case EM_OR32:
578 case EM_SCORE:
579 case EM_XGATE:
580 return FALSE;
581
582 /* Targets that use RELA relocations. */
583 case EM_68K:
584 case EM_860:
585 case EM_AARCH64:
586 case EM_ADAPTEVA_EPIPHANY:
587 case EM_ALPHA:
588 case EM_ALTERA_NIOS2:
589 case EM_AVR:
590 case EM_AVR_OLD:
591 case EM_BLACKFIN:
592 case EM_CR16:
593 case EM_CRIS:
594 case EM_CRX:
595 case EM_D30V:
596 case EM_CYGNUS_D30V:
597 case EM_FR30:
598 case EM_CYGNUS_FR30:
599 case EM_CYGNUS_FRV:
600 case EM_H8S:
601 case EM_H8_300:
602 case EM_H8_300H:
603 case EM_IA_64:
604 case EM_IP2K:
605 case EM_IP2K_OLD:
606 case EM_IQ2000:
607 case EM_LATTICEMICO32:
608 case EM_M32C_OLD:
609 case EM_M32C:
610 case EM_M32R:
611 case EM_MCORE:
612 case EM_CYGNUS_MEP:
613 case EM_MMIX:
614 case EM_MN10200:
615 case EM_CYGNUS_MN10200:
616 case EM_MN10300:
617 case EM_CYGNUS_MN10300:
618 case EM_MOXIE:
619 case EM_MSP430:
620 case EM_MSP430_OLD:
621 case EM_MT:
622 case EM_NIOS32:
623 case EM_PPC64:
624 case EM_PPC:
625 case EM_RL78:
626 case EM_RX:
627 case EM_S390:
628 case EM_S390_OLD:
629 case EM_SH:
630 case EM_SPARC:
631 case EM_SPARC32PLUS:
632 case EM_SPARCV9:
633 case EM_SPU:
634 case EM_TI_C6000:
635 case EM_TILEGX:
636 case EM_TILEPRO:
637 case EM_V800:
638 case EM_V850:
639 case EM_CYGNUS_V850:
640 case EM_VAX:
641 case EM_X86_64:
642 case EM_L1OM:
643 case EM_K1OM:
644 case EM_XSTORMY16:
645 case EM_XTENSA:
646 case EM_XTENSA_OLD:
647 case EM_MICROBLAZE:
648 case EM_MICROBLAZE_OLD:
649 return TRUE;
650
651 case EM_68HC05:
652 case EM_68HC08:
653 case EM_68HC11:
654 case EM_68HC16:
655 case EM_FX66:
656 case EM_ME16:
657 case EM_MMA:
658 case EM_NCPU:
659 case EM_NDR1:
660 case EM_PCP:
661 case EM_ST100:
662 case EM_ST19:
663 case EM_ST7:
664 case EM_ST9PLUS:
665 case EM_STARCORE:
666 case EM_SVX:
667 case EM_TINYJ:
668 default:
669 warn (_("Don't know about relocations on this machine architecture\n"));
670 return FALSE;
671 }
672}
673
674static int
675slurp_rela_relocs (FILE * file,
676 unsigned long rel_offset,
677 unsigned long rel_size,
678 Elf_Internal_Rela ** relasp,
679 unsigned long * nrelasp)
680{
681 Elf_Internal_Rela * relas;
682 unsigned long nrelas;
683 unsigned int i;
684
685 if (is_32bit_elf)
686 {
687 Elf32_External_Rela * erelas;
688
689 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
690 rel_size, _("32-bit relocation data"));
691 if (!erelas)
692 return 0;
693
694 nrelas = rel_size / sizeof (Elf32_External_Rela);
695
696 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
697 sizeof (Elf_Internal_Rela));
698
699 if (relas == NULL)
700 {
701 free (erelas);
702 error (_("out of memory parsing relocs\n"));
703 return 0;
704 }
705
706 for (i = 0; i < nrelas; i++)
707 {
708 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
709 relas[i].r_info = BYTE_GET (erelas[i].r_info);
710 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
711 }
712
713 free (erelas);
714 }
715 else
716 {
717 Elf64_External_Rela * erelas;
718
719 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
720 rel_size, _("64-bit relocation data"));
721 if (!erelas)
722 return 0;
723
724 nrelas = rel_size / sizeof (Elf64_External_Rela);
725
726 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
727 sizeof (Elf_Internal_Rela));
728
729 if (relas == NULL)
730 {
731 free (erelas);
732 error (_("out of memory parsing relocs\n"));
733 return 0;
734 }
735
736 for (i = 0; i < nrelas; i++)
737 {
738 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
739 relas[i].r_info = BYTE_GET (erelas[i].r_info);
740 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
741
742 /* The #ifdef BFD64 below is to prevent a compile time
743 warning. We know that if we do not have a 64 bit data
744 type that we will never execute this code anyway. */
745#ifdef BFD64
746 if (elf_header.e_machine == EM_MIPS
747 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
748 {
749 /* In little-endian objects, r_info isn't really a
750 64-bit little-endian value: it has a 32-bit
751 little-endian symbol index followed by four
752 individual byte fields. Reorder INFO
753 accordingly. */
754 bfd_vma inf = relas[i].r_info;
755 inf = (((inf & 0xffffffff) << 32)
756 | ((inf >> 56) & 0xff)
757 | ((inf >> 40) & 0xff00)
758 | ((inf >> 24) & 0xff0000)
759 | ((inf >> 8) & 0xff000000));
760 relas[i].r_info = inf;
761 }
762#endif /* BFD64 */
763 }
764
765 free (erelas);
766 }
767 *relasp = relas;
768 *nrelasp = nrelas;
769 return 1;
770}
771
772static int
773slurp_rel_relocs (FILE * file,
774 unsigned long rel_offset,
775 unsigned long rel_size,
776 Elf_Internal_Rela ** relsp,
777 unsigned long * nrelsp)
778{
779 Elf_Internal_Rela * rels;
780 unsigned long nrels;
781 unsigned int i;
782
783 if (is_32bit_elf)
784 {
785 Elf32_External_Rel * erels;
786
787 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
788 rel_size, _("32-bit relocation data"));
789 if (!erels)
790 return 0;
791
792 nrels = rel_size / sizeof (Elf32_External_Rel);
793
794 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
795
796 if (rels == NULL)
797 {
798 free (erels);
799 error (_("out of memory parsing relocs\n"));
800 return 0;
801 }
802
803 for (i = 0; i < nrels; i++)
804 {
805 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
806 rels[i].r_info = BYTE_GET (erels[i].r_info);
807 rels[i].r_addend = 0;
808 }
809
810 free (erels);
811 }
812 else
813 {
814 Elf64_External_Rel * erels;
815
816 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
817 rel_size, _("64-bit relocation data"));
818 if (!erels)
819 return 0;
820
821 nrels = rel_size / sizeof (Elf64_External_Rel);
822
823 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
824
825 if (rels == NULL)
826 {
827 free (erels);
828 error (_("out of memory parsing relocs\n"));
829 return 0;
830 }
831
832 for (i = 0; i < nrels; i++)
833 {
834 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
835 rels[i].r_info = BYTE_GET (erels[i].r_info);
836 rels[i].r_addend = 0;
837
838 /* The #ifdef BFD64 below is to prevent a compile time
839 warning. We know that if we do not have a 64 bit data
840 type that we will never execute this code anyway. */
841#ifdef BFD64
842 if (elf_header.e_machine == EM_MIPS
843 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
844 {
845 /* In little-endian objects, r_info isn't really a
846 64-bit little-endian value: it has a 32-bit
847 little-endian symbol index followed by four
848 individual byte fields. Reorder INFO
849 accordingly. */
850 bfd_vma inf = rels[i].r_info;
851 inf = (((inf & 0xffffffff) << 32)
852 | ((inf >> 56) & 0xff)
853 | ((inf >> 40) & 0xff00)
854 | ((inf >> 24) & 0xff0000)
855 | ((inf >> 8) & 0xff000000));
856 rels[i].r_info = inf;
857 }
858#endif /* BFD64 */
859 }
860
861 free (erels);
862 }
863 *relsp = rels;
864 *nrelsp = nrels;
865 return 1;
866}
867
868/* Returns the reloc type extracted from the reloc info field. */
869
870static unsigned int
871get_reloc_type (bfd_vma reloc_info)
872{
873 if (is_32bit_elf)
874 return ELF32_R_TYPE (reloc_info);
875
876 switch (elf_header.e_machine)
877 {
878 case EM_MIPS:
879 /* Note: We assume that reloc_info has already been adjusted for us. */
880 return ELF64_MIPS_R_TYPE (reloc_info);
881
882 case EM_SPARCV9:
883 return ELF64_R_TYPE_ID (reloc_info);
884
885 default:
886 return ELF64_R_TYPE (reloc_info);
887 }
888}
889
890/* Return the symbol index extracted from the reloc info field. */
891
892static bfd_vma
893get_reloc_symindex (bfd_vma reloc_info)
894{
895 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
896}
897
898/* Display the contents of the relocation data found at the specified
899 offset. */
900
901static void
902dump_relocations (FILE * file,
903 unsigned long rel_offset,
904 unsigned long rel_size,
905 Elf_Internal_Sym * symtab,
906 unsigned long nsyms,
907 char * strtab,
908 unsigned long strtablen,
909 int is_rela)
910{
911 unsigned int i;
912 Elf_Internal_Rela * rels;
913
914 if (is_rela == UNKNOWN)
915 is_rela = guess_is_rela (elf_header.e_machine);
916
917 if (is_rela)
918 {
919 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
920 return;
921 }
922 else
923 {
924 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
925 return;
926 }
927
928 if (is_32bit_elf)
929 {
930 if (is_rela)
931 {
932 if (do_wide)
933 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
934 else
935 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
936 }
937 else
938 {
939 if (do_wide)
940 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
941 else
942 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
943 }
944 }
945 else
946 {
947 if (is_rela)
948 {
949 if (do_wide)
950 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
951 else
952 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
953 }
954 else
955 {
956 if (do_wide)
957 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
958 else
959 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
960 }
961 }
962
963 for (i = 0; i < rel_size; i++)
964 {
965 const char * rtype;
966 bfd_vma offset;
967 bfd_vma inf;
968 bfd_vma symtab_index;
969 bfd_vma type;
970
971 offset = rels[i].r_offset;
972 inf = rels[i].r_info;
973
974 type = get_reloc_type (inf);
975 symtab_index = get_reloc_symindex (inf);
976
977 if (is_32bit_elf)
978 {
979 printf ("%8.8lx %8.8lx ",
980 (unsigned long) offset & 0xffffffff,
981 (unsigned long) inf & 0xffffffff);
982 }
983 else
984 {
985#if BFD_HOST_64BIT_LONG
986 printf (do_wide
987 ? "%16.16lx %16.16lx "
988 : "%12.12lx %12.12lx ",
989 offset, inf);
990#elif BFD_HOST_64BIT_LONG_LONG
991#ifndef __MSVCRT__
992 printf (do_wide
993 ? "%16.16llx %16.16llx "
994 : "%12.12llx %12.12llx ",
995 offset, inf);
996#else
997 printf (do_wide
998 ? "%16.16I64x %16.16I64x "
999 : "%12.12I64x %12.12I64x ",
1000 offset, inf);
1001#endif
1002#else
1003 printf (do_wide
1004 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1005 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1006 _bfd_int64_high (offset),
1007 _bfd_int64_low (offset),
1008 _bfd_int64_high (inf),
1009 _bfd_int64_low (inf));
1010#endif
1011 }
1012
1013 switch (elf_header.e_machine)
1014 {
1015 default:
1016 rtype = NULL;
1017 break;
1018
1019 case EM_AARCH64:
1020 rtype = elf_aarch64_reloc_type (type);
1021 break;
1022
1023 case EM_M32R:
1024 case EM_CYGNUS_M32R:
1025 rtype = elf_m32r_reloc_type (type);
1026 break;
1027
1028 case EM_386:
1029 case EM_486:
1030 rtype = elf_i386_reloc_type (type);
1031 break;
1032
1033 case EM_68HC11:
1034 case EM_68HC12:
1035 rtype = elf_m68hc11_reloc_type (type);
1036 break;
1037
1038 case EM_68K:
1039 rtype = elf_m68k_reloc_type (type);
1040 break;
1041
1042 case EM_960:
1043 rtype = elf_i960_reloc_type (type);
1044 break;
1045
1046 case EM_AVR:
1047 case EM_AVR_OLD:
1048 rtype = elf_avr_reloc_type (type);
1049 break;
1050
1051 case EM_OLD_SPARCV9:
1052 case EM_SPARC32PLUS:
1053 case EM_SPARCV9:
1054 case EM_SPARC:
1055 rtype = elf_sparc_reloc_type (type);
1056 break;
1057
1058 case EM_SPU:
1059 rtype = elf_spu_reloc_type (type);
1060 break;
1061
1062 case EM_V800:
1063 rtype = v800_reloc_type (type);
1064 break;
1065 case EM_V850:
1066 case EM_CYGNUS_V850:
1067 rtype = v850_reloc_type (type);
1068 break;
1069
1070 case EM_D10V:
1071 case EM_CYGNUS_D10V:
1072 rtype = elf_d10v_reloc_type (type);
1073 break;
1074
1075 case EM_D30V:
1076 case EM_CYGNUS_D30V:
1077 rtype = elf_d30v_reloc_type (type);
1078 break;
1079
1080 case EM_DLX:
1081 rtype = elf_dlx_reloc_type (type);
1082 break;
1083
1084 case EM_SH:
1085 rtype = elf_sh_reloc_type (type);
1086 break;
1087
1088 case EM_MN10300:
1089 case EM_CYGNUS_MN10300:
1090 rtype = elf_mn10300_reloc_type (type);
1091 break;
1092
1093 case EM_MN10200:
1094 case EM_CYGNUS_MN10200:
1095 rtype = elf_mn10200_reloc_type (type);
1096 break;
1097
1098 case EM_FR30:
1099 case EM_CYGNUS_FR30:
1100 rtype = elf_fr30_reloc_type (type);
1101 break;
1102
1103 case EM_CYGNUS_FRV:
1104 rtype = elf_frv_reloc_type (type);
1105 break;
1106
1107 case EM_MCORE:
1108 rtype = elf_mcore_reloc_type (type);
1109 break;
1110
1111 case EM_MMIX:
1112 rtype = elf_mmix_reloc_type (type);
1113 break;
1114
1115 case EM_MOXIE:
1116 rtype = elf_moxie_reloc_type (type);
1117 break;
1118
1119 case EM_MSP430:
1120 case EM_MSP430_OLD:
1121 rtype = elf_msp430_reloc_type (type);
1122 break;
1123
1124 case EM_PPC:
1125 rtype = elf_ppc_reloc_type (type);
1126 break;
1127
1128 case EM_PPC64:
1129 rtype = elf_ppc64_reloc_type (type);
1130 break;
1131
1132 case EM_MIPS:
1133 case EM_MIPS_RS3_LE:
1134 rtype = elf_mips_reloc_type (type);
1135 break;
1136
1137 case EM_ALPHA:
1138 rtype = elf_alpha_reloc_type (type);
1139 break;
1140
1141 case EM_ARM:
1142 rtype = elf_arm_reloc_type (type);
1143 break;
1144
1145 case EM_ARC:
1146 rtype = elf_arc_reloc_type (type);
1147 break;
1148
1149 case EM_PARISC:
1150 rtype = elf_hppa_reloc_type (type);
1151 break;
1152
1153 case EM_H8_300:
1154 case EM_H8_300H:
1155 case EM_H8S:
1156 rtype = elf_h8_reloc_type (type);
1157 break;
1158
1159 case EM_OPENRISC:
1160 case EM_OR32:
1161 rtype = elf_or32_reloc_type (type);
1162 break;
1163
1164 case EM_PJ:
1165 case EM_PJ_OLD:
1166 rtype = elf_pj_reloc_type (type);
1167 break;
1168 case EM_IA_64:
1169 rtype = elf_ia64_reloc_type (type);
1170 break;
1171
1172 case EM_CRIS:
1173 rtype = elf_cris_reloc_type (type);
1174 break;
1175
1176 case EM_860:
1177 rtype = elf_i860_reloc_type (type);
1178 break;
1179
1180 case EM_X86_64:
1181 case EM_L1OM:
1182 case EM_K1OM:
1183 rtype = elf_x86_64_reloc_type (type);
1184 break;
1185
1186 case EM_S370:
1187 rtype = i370_reloc_type (type);
1188 break;
1189
1190 case EM_S390_OLD:
1191 case EM_S390:
1192 rtype = elf_s390_reloc_type (type);
1193 break;
1194
1195 case EM_SCORE:
1196 rtype = elf_score_reloc_type (type);
1197 break;
1198
1199 case EM_XSTORMY16:
1200 rtype = elf_xstormy16_reloc_type (type);
1201 break;
1202
1203 case EM_CRX:
1204 rtype = elf_crx_reloc_type (type);
1205 break;
1206
1207 case EM_VAX:
1208 rtype = elf_vax_reloc_type (type);
1209 break;
1210
1211 case EM_ADAPTEVA_EPIPHANY:
1212 rtype = elf_epiphany_reloc_type (type);
1213 break;
1214
1215 case EM_IP2K:
1216 case EM_IP2K_OLD:
1217 rtype = elf_ip2k_reloc_type (type);
1218 break;
1219
1220 case EM_IQ2000:
1221 rtype = elf_iq2000_reloc_type (type);
1222 break;
1223
1224 case EM_XTENSA_OLD:
1225 case EM_XTENSA:
1226 rtype = elf_xtensa_reloc_type (type);
1227 break;
1228
1229 case EM_LATTICEMICO32:
1230 rtype = elf_lm32_reloc_type (type);
1231 break;
1232
1233 case EM_M32C_OLD:
1234 case EM_M32C:
1235 rtype = elf_m32c_reloc_type (type);
1236 break;
1237
1238 case EM_MT:
1239 rtype = elf_mt_reloc_type (type);
1240 break;
1241
1242 case EM_BLACKFIN:
1243 rtype = elf_bfin_reloc_type (type);
1244 break;
1245
1246 case EM_CYGNUS_MEP:
1247 rtype = elf_mep_reloc_type (type);
1248 break;
1249
1250 case EM_CR16:
1251 rtype = elf_cr16_reloc_type (type);
1252 break;
1253
1254 case EM_MICROBLAZE:
1255 case EM_MICROBLAZE_OLD:
1256 rtype = elf_microblaze_reloc_type (type);
1257 break;
1258
1259 case EM_RL78:
1260 rtype = elf_rl78_reloc_type (type);
1261 break;
1262
1263 case EM_RX:
1264 rtype = elf_rx_reloc_type (type);
1265 break;
1266
1267 case EM_XC16X:
1268 case EM_C166:
1269 rtype = elf_xc16x_reloc_type (type);
1270 break;
1271
1272 case EM_TI_C6000:
1273 rtype = elf_tic6x_reloc_type (type);
1274 break;
1275
1276 case EM_TILEGX:
1277 rtype = elf_tilegx_reloc_type (type);
1278 break;
1279
1280 case EM_TILEPRO:
1281 rtype = elf_tilepro_reloc_type (type);
1282 break;
1283
1284 case EM_XGATE:
1285 rtype = elf_xgate_reloc_type (type);
1286 break;
1287 }
1288
1289 if (rtype == NULL)
1290 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1291 else
1292 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1293
1294 if (elf_header.e_machine == EM_ALPHA
1295 && rtype != NULL
1296 && streq (rtype, "R_ALPHA_LITUSE")
1297 && is_rela)
1298 {
1299 switch (rels[i].r_addend)
1300 {
1301 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1302 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1303 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1304 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1305 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1306 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1307 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1308 default: rtype = NULL;
1309 }
1310 if (rtype)
1311 printf (" (%s)", rtype);
1312 else
1313 {
1314 putchar (' ');
1315 printf (_("<unknown addend: %lx>"),
1316 (unsigned long) rels[i].r_addend);
1317 }
1318 }
1319 else if (symtab_index)
1320 {
1321 if (symtab == NULL || symtab_index >= nsyms)
1322 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1323 else
1324 {
1325 Elf_Internal_Sym * psym;
1326
1327 psym = symtab + symtab_index;
1328
1329 printf (" ");
1330
1331 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1332 {
1333 const char * name;
1334 unsigned int len;
1335 unsigned int width = is_32bit_elf ? 8 : 14;
1336
1337 /* Relocations against GNU_IFUNC symbols do not use the value
1338 of the symbol as the address to relocate against. Instead
1339 they invoke the function named by the symbol and use its
1340 result as the address for relocation.
1341
1342 To indicate this to the user, do not display the value of
1343 the symbol in the "Symbols's Value" field. Instead show
1344 its name followed by () as a hint that the symbol is
1345 invoked. */
1346
1347 if (strtab == NULL
1348 || psym->st_name == 0
1349 || psym->st_name >= strtablen)
1350 name = "??";
1351 else
1352 name = strtab + psym->st_name;
1353
1354 len = print_symbol (width, name);
1355 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1356 }
1357 else
1358 {
1359 print_vma (psym->st_value, LONG_HEX);
1360
1361 printf (is_32bit_elf ? " " : " ");
1362 }
1363
1364 if (psym->st_name == 0)
1365 {
1366 const char * sec_name = "<null>";
1367 char name_buf[40];
1368
1369 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1370 {
1371 if (psym->st_shndx < elf_header.e_shnum)
1372 sec_name
1373 = SECTION_NAME (section_headers + psym->st_shndx);
1374 else if (psym->st_shndx == SHN_ABS)
1375 sec_name = "ABS";
1376 else if (psym->st_shndx == SHN_COMMON)
1377 sec_name = "COMMON";
1378 else if ((elf_header.e_machine == EM_MIPS
1379 && psym->st_shndx == SHN_MIPS_SCOMMON)
1380 || (elf_header.e_machine == EM_TI_C6000
1381 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1382 sec_name = "SCOMMON";
1383 else if (elf_header.e_machine == EM_MIPS
1384 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1385 sec_name = "SUNDEF";
1386 else if ((elf_header.e_machine == EM_X86_64
1387 || elf_header.e_machine == EM_L1OM
1388 || elf_header.e_machine == EM_K1OM)
1389 && psym->st_shndx == SHN_X86_64_LCOMMON)
1390 sec_name = "LARGE_COMMON";
1391 else if (elf_header.e_machine == EM_IA_64
1392 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1393 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1394 sec_name = "ANSI_COM";
1395 else if (is_ia64_vms ()
1396 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1397 sec_name = "VMS_SYMVEC";
1398 else
1399 {
1400 sprintf (name_buf, "<section 0x%x>",
1401 (unsigned int) psym->st_shndx);
1402 sec_name = name_buf;
1403 }
1404 }
1405 print_symbol (22, sec_name);
1406 }
1407 else if (strtab == NULL)
1408 printf (_("<string table index: %3ld>"), psym->st_name);
1409 else if (psym->st_name >= strtablen)
1410 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1411 else
1412 print_symbol (22, strtab + psym->st_name);
1413
1414 if (is_rela)
1415 {
1416 bfd_signed_vma off = rels[i].r_addend;
1417
1418 if (off < 0)
1419 printf (" - %" BFD_VMA_FMT "x", - off);
1420 else
1421 printf (" + %" BFD_VMA_FMT "x", off);
1422 }
1423 }
1424 }
1425 else if (is_rela)
1426 {
1427 bfd_signed_vma off = rels[i].r_addend;
1428
1429 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1430 if (off < 0)
1431 printf ("-%" BFD_VMA_FMT "x", - off);
1432 else
1433 printf ("%" BFD_VMA_FMT "x", off);
1434 }
1435
1436 if (elf_header.e_machine == EM_SPARCV9
1437 && rtype != NULL
1438 && streq (rtype, "R_SPARC_OLO10"))
1439 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1440
1441 putchar ('\n');
1442
1443#ifdef BFD64
1444 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1445 {
1446 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1447 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1448 const char * rtype2 = elf_mips_reloc_type (type2);
1449 const char * rtype3 = elf_mips_reloc_type (type3);
1450
1451 printf (" Type2: ");
1452
1453 if (rtype2 == NULL)
1454 printf (_("unrecognized: %-7lx"),
1455 (unsigned long) type2 & 0xffffffff);
1456 else
1457 printf ("%-17.17s", rtype2);
1458
1459 printf ("\n Type3: ");
1460
1461 if (rtype3 == NULL)
1462 printf (_("unrecognized: %-7lx"),
1463 (unsigned long) type3 & 0xffffffff);
1464 else
1465 printf ("%-17.17s", rtype3);
1466
1467 putchar ('\n');
1468 }
1469#endif /* BFD64 */
1470 }
1471
1472 free (rels);
1473}
1474
1475static const char *
1476get_mips_dynamic_type (unsigned long type)
1477{
1478 switch (type)
1479 {
1480 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1481 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1482 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1483 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1484 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1485 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1486 case DT_MIPS_MSYM: return "MIPS_MSYM";
1487 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1488 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1489 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1490 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1491 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1492 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1493 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1494 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1495 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1496 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1497 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1498 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1499 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1500 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1501 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1502 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1503 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1504 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1505 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1506 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1507 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1508 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1509 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1510 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1511 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1512 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1513 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1514 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1515 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1516 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1517 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1518 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1519 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1520 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1521 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1522 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1523 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1524 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1525 default:
1526 return NULL;
1527 }
1528}
1529
1530static const char *
1531get_sparc64_dynamic_type (unsigned long type)
1532{
1533 switch (type)
1534 {
1535 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1536 default:
1537 return NULL;
1538 }
1539}
1540
1541static const char *
1542get_ppc_dynamic_type (unsigned long type)
1543{
1544 switch (type)
1545 {
1546 case DT_PPC_GOT: return "PPC_GOT";
1547 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1548 default:
1549 return NULL;
1550 }
1551}
1552
1553static const char *
1554get_ppc64_dynamic_type (unsigned long type)
1555{
1556 switch (type)
1557 {
1558 case DT_PPC64_GLINK: return "PPC64_GLINK";
1559 case DT_PPC64_OPD: return "PPC64_OPD";
1560 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1561 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1562 default:
1563 return NULL;
1564 }
1565}
1566
1567static const char *
1568get_parisc_dynamic_type (unsigned long type)
1569{
1570 switch (type)
1571 {
1572 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1573 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1574 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1575 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1576 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1577 case DT_HP_PREINIT: return "HP_PREINIT";
1578 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1579 case DT_HP_NEEDED: return "HP_NEEDED";
1580 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1581 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1582 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1583 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1584 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1585 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1586 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1587 case DT_HP_FILTERED: return "HP_FILTERED";
1588 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1589 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1590 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1591 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1592 case DT_PLT: return "PLT";
1593 case DT_PLT_SIZE: return "PLT_SIZE";
1594 case DT_DLT: return "DLT";
1595 case DT_DLT_SIZE: return "DLT_SIZE";
1596 default:
1597 return NULL;
1598 }
1599}
1600
1601static const char *
1602get_ia64_dynamic_type (unsigned long type)
1603{
1604 switch (type)
1605 {
1606 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1607 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1608 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1609 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1610 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1611 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1612 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1613 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1614 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1615 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1616 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1617 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1618 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1619 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1620 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1621 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1622 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1623 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1624 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1625 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1626 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1627 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1628 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1629 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1630 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1631 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1632 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1633 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1634 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1635 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1636 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1637 default:
1638 return NULL;
1639 }
1640}
1641
1642static const char *
1643get_alpha_dynamic_type (unsigned long type)
1644{
1645 switch (type)
1646 {
1647 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1648 default:
1649 return NULL;
1650 }
1651}
1652
1653static const char *
1654get_score_dynamic_type (unsigned long type)
1655{
1656 switch (type)
1657 {
1658 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1659 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1660 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1661 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1662 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1663 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1664 default:
1665 return NULL;
1666 }
1667}
1668
1669static const char *
1670get_tic6x_dynamic_type (unsigned long type)
1671{
1672 switch (type)
1673 {
1674 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1675 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1676 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1677 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1678 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1679 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1680 default:
1681 return NULL;
1682 }
1683}
1684
1685static const char *
1686get_dynamic_type (unsigned long type)
1687{
1688 static char buff[64];
1689
1690 switch (type)
1691 {
1692 case DT_NULL: return "NULL";
1693 case DT_NEEDED: return "NEEDED";
1694 case DT_PLTRELSZ: return "PLTRELSZ";
1695 case DT_PLTGOT: return "PLTGOT";
1696 case DT_HASH: return "HASH";
1697 case DT_STRTAB: return "STRTAB";
1698 case DT_SYMTAB: return "SYMTAB";
1699 case DT_RELA: return "RELA";
1700 case DT_RELASZ: return "RELASZ";
1701 case DT_RELAENT: return "RELAENT";
1702 case DT_STRSZ: return "STRSZ";
1703 case DT_SYMENT: return "SYMENT";
1704 case DT_INIT: return "INIT";
1705 case DT_FINI: return "FINI";
1706 case DT_SONAME: return "SONAME";
1707 case DT_RPATH: return "RPATH";
1708 case DT_SYMBOLIC: return "SYMBOLIC";
1709 case DT_REL: return "REL";
1710 case DT_RELSZ: return "RELSZ";
1711 case DT_RELENT: return "RELENT";
1712 case DT_PLTREL: return "PLTREL";
1713 case DT_DEBUG: return "DEBUG";
1714 case DT_TEXTREL: return "TEXTREL";
1715 case DT_JMPREL: return "JMPREL";
1716 case DT_BIND_NOW: return "BIND_NOW";
1717 case DT_INIT_ARRAY: return "INIT_ARRAY";
1718 case DT_FINI_ARRAY: return "FINI_ARRAY";
1719 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1720 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1721 case DT_RUNPATH: return "RUNPATH";
1722 case DT_FLAGS: return "FLAGS";
1723
1724 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1725 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1726
1727 case DT_CHECKSUM: return "CHECKSUM";
1728 case DT_PLTPADSZ: return "PLTPADSZ";
1729 case DT_MOVEENT: return "MOVEENT";
1730 case DT_MOVESZ: return "MOVESZ";
1731 case DT_FEATURE: return "FEATURE";
1732 case DT_POSFLAG_1: return "POSFLAG_1";
1733 case DT_SYMINSZ: return "SYMINSZ";
1734 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1735
1736 case DT_ADDRRNGLO: return "ADDRRNGLO";
1737 case DT_CONFIG: return "CONFIG";
1738 case DT_DEPAUDIT: return "DEPAUDIT";
1739 case DT_AUDIT: return "AUDIT";
1740 case DT_PLTPAD: return "PLTPAD";
1741 case DT_MOVETAB: return "MOVETAB";
1742 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1743
1744 case DT_VERSYM: return "VERSYM";
1745
1746 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1747 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1748 case DT_RELACOUNT: return "RELACOUNT";
1749 case DT_RELCOUNT: return "RELCOUNT";
1750 case DT_FLAGS_1: return "FLAGS_1";
1751 case DT_VERDEF: return "VERDEF";
1752 case DT_VERDEFNUM: return "VERDEFNUM";
1753 case DT_VERNEED: return "VERNEED";
1754 case DT_VERNEEDNUM: return "VERNEEDNUM";
1755
1756 case DT_AUXILIARY: return "AUXILIARY";
1757 case DT_USED: return "USED";
1758 case DT_FILTER: return "FILTER";
1759
1760 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1761 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1762 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1763 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1764 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1765 case DT_GNU_HASH: return "GNU_HASH";
1766
1767 default:
1768 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1769 {
1770 const char * result;
1771
1772 switch (elf_header.e_machine)
1773 {
1774 case EM_MIPS:
1775 case EM_MIPS_RS3_LE:
1776 result = get_mips_dynamic_type (type);
1777 break;
1778 case EM_SPARCV9:
1779 result = get_sparc64_dynamic_type (type);
1780 break;
1781 case EM_PPC:
1782 result = get_ppc_dynamic_type (type);
1783 break;
1784 case EM_PPC64:
1785 result = get_ppc64_dynamic_type (type);
1786 break;
1787 case EM_IA_64:
1788 result = get_ia64_dynamic_type (type);
1789 break;
1790 case EM_ALPHA:
1791 result = get_alpha_dynamic_type (type);
1792 break;
1793 case EM_SCORE:
1794 result = get_score_dynamic_type (type);
1795 break;
1796 case EM_TI_C6000:
1797 result = get_tic6x_dynamic_type (type);
1798 break;
1799 default:
1800 result = NULL;
1801 break;
1802 }
1803
1804 if (result != NULL)
1805 return result;
1806
1807 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1808 }
1809 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1810 || (elf_header.e_machine == EM_PARISC
1811 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1812 {
1813 const char * result;
1814
1815 switch (elf_header.e_machine)
1816 {
1817 case EM_PARISC:
1818 result = get_parisc_dynamic_type (type);
1819 break;
1820 case EM_IA_64:
1821 result = get_ia64_dynamic_type (type);
1822 break;
1823 default:
1824 result = NULL;
1825 break;
1826 }
1827
1828 if (result != NULL)
1829 return result;
1830
1831 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1832 type);
1833 }
1834 else
1835 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1836
1837 return buff;
1838 }
1839}
1840
1841static char *
1842get_file_type (unsigned e_type)
1843{
1844 static char buff[32];
1845
1846 switch (e_type)
1847 {
1848 case ET_NONE: return _("NONE (None)");
1849 case ET_REL: return _("REL (Relocatable file)");
1850 case ET_EXEC: return _("EXEC (Executable file)");
1851 case ET_DYN: return _("DYN (Shared object file)");
1852 case ET_CORE: return _("CORE (Core file)");
1853
1854 default:
1855 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1856 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1857 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1858 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1859 else
1860 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1861 return buff;
1862 }
1863}
1864
1865static char *
1866get_machine_name (unsigned e_machine)
1867{
1868 static char buff[64]; /* XXX */
1869
1870 switch (e_machine)
1871 {
1872 case EM_NONE: return _("None");
1873 case EM_AARCH64: return "AArch64";
1874 case EM_M32: return "WE32100";
1875 case EM_SPARC: return "Sparc";
1876 case EM_SPU: return "SPU";
1877 case EM_386: return "Intel 80386";
1878 case EM_68K: return "MC68000";
1879 case EM_88K: return "MC88000";
1880 case EM_486: return "Intel 80486";
1881 case EM_860: return "Intel 80860";
1882 case EM_MIPS: return "MIPS R3000";
1883 case EM_S370: return "IBM System/370";
1884 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1885 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1886 case EM_PARISC: return "HPPA";
1887 case EM_PPC_OLD: return "Power PC (old)";
1888 case EM_SPARC32PLUS: return "Sparc v8+" ;
1889 case EM_960: return "Intel 90860";
1890 case EM_PPC: return "PowerPC";
1891 case EM_PPC64: return "PowerPC64";
1892 case EM_FR20: return "Fujitsu FR20";
1893 case EM_RH32: return "TRW RH32";
1894 case EM_MCORE: return "MCORE";
1895 case EM_ARM: return "ARM";
1896 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1897 case EM_SH: return "Renesas / SuperH SH";
1898 case EM_SPARCV9: return "Sparc v9";
1899 case EM_TRICORE: return "Siemens Tricore";
1900 case EM_ARC: return "ARC";
1901 case EM_H8_300: return "Renesas H8/300";
1902 case EM_H8_300H: return "Renesas H8/300H";
1903 case EM_H8S: return "Renesas H8S";
1904 case EM_H8_500: return "Renesas H8/500";
1905 case EM_IA_64: return "Intel IA-64";
1906 case EM_MIPS_X: return "Stanford MIPS-X";
1907 case EM_COLDFIRE: return "Motorola Coldfire";
1908 case EM_ALPHA: return "Alpha";
1909 case EM_CYGNUS_D10V:
1910 case EM_D10V: return "d10v";
1911 case EM_CYGNUS_D30V:
1912 case EM_D30V: return "d30v";
1913 case EM_CYGNUS_M32R:
1914 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1915 case EM_CYGNUS_V850:
1916 case EM_V800: return "Renesas V850 (using RH850 ABI)";
1917 case EM_V850: return "Renesas V850";
1918 case EM_CYGNUS_MN10300:
1919 case EM_MN10300: return "mn10300";
1920 case EM_CYGNUS_MN10200:
1921 case EM_MN10200: return "mn10200";
1922 case EM_MOXIE: return "Moxie";
1923 case EM_CYGNUS_FR30:
1924 case EM_FR30: return "Fujitsu FR30";
1925 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1926 case EM_PJ_OLD:
1927 case EM_PJ: return "picoJava";
1928 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1929 case EM_PCP: return "Siemens PCP";
1930 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1931 case EM_NDR1: return "Denso NDR1 microprocesspr";
1932 case EM_STARCORE: return "Motorola Star*Core processor";
1933 case EM_ME16: return "Toyota ME16 processor";
1934 case EM_ST100: return "STMicroelectronics ST100 processor";
1935 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1936 case EM_PDSP: return "Sony DSP processor";
1937 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1938 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
1939 case EM_FX66: return "Siemens FX66 microcontroller";
1940 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1941 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1942 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1943 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
1944 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1945 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1946 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1947 case EM_SVX: return "Silicon Graphics SVx";
1948 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1949 case EM_VAX: return "Digital VAX";
1950 case EM_AVR_OLD:
1951 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1952 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1953 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1954 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1955 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1956 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1957 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1958 case EM_PRISM: return "Vitesse Prism";
1959 case EM_X86_64: return "Advanced Micro Devices X86-64";
1960 case EM_L1OM: return "Intel L1OM";
1961 case EM_K1OM: return "Intel K1OM";
1962 case EM_S390_OLD:
1963 case EM_S390: return "IBM S/390";
1964 case EM_SCORE: return "SUNPLUS S+Core";
1965 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
1966 case EM_OPENRISC:
1967 case EM_OR32: return "OpenRISC";
1968 case EM_ARC_A5: return "ARC International ARCompact processor";
1969 case EM_CRX: return "National Semiconductor CRX microprocessor";
1970 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
1971 case EM_DLX: return "OpenDLX";
1972 case EM_IP2K_OLD:
1973 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1974 case EM_IQ2000: return "Vitesse IQ2000";
1975 case EM_XTENSA_OLD:
1976 case EM_XTENSA: return "Tensilica Xtensa Processor";
1977 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1978 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1979 case EM_NS32K: return "National Semiconductor 32000 series";
1980 case EM_TPC: return "Tenor Network TPC processor";
1981 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1982 case EM_MAX: return "MAX Processor";
1983 case EM_CR: return "National Semiconductor CompactRISC";
1984 case EM_F2MC16: return "Fujitsu F2MC16";
1985 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
1986 case EM_LATTICEMICO32: return "Lattice Mico32";
1987 case EM_M32C_OLD:
1988 case EM_M32C: return "Renesas M32c";
1989 case EM_MT: return "Morpho Techologies MT processor";
1990 case EM_BLACKFIN: return "Analog Devices Blackfin";
1991 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1992 case EM_SEP: return "Sharp embedded microprocessor";
1993 case EM_ARCA: return "Arca RISC microprocessor";
1994 case EM_UNICORE: return "Unicore";
1995 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1996 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
1997 case EM_NIOS32: return "Altera Nios";
1998 case EM_ALTERA_NIOS2: return "Altera Nios II";
1999 case EM_C166:
2000 case EM_XC16X: return "Infineon Technologies xc16x";
2001 case EM_M16C: return "Renesas M16C series microprocessors";
2002 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2003 case EM_CE: return "Freescale Communication Engine RISC core";
2004 case EM_TSK3000: return "Altium TSK3000 core";
2005 case EM_RS08: return "Freescale RS08 embedded processor";
2006 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2007 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2008 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2009 case EM_SE_C17: return "Seiko Epson C17 family";
2010 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2011 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2012 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2013 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2014 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2015 case EM_R32C: return "Renesas R32C series microprocessors";
2016 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2017 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2018 case EM_8051: return "Intel 8051 and variants";
2019 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2020 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2021 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2022 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2023 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2024 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2025 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2026 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2027 case EM_CR16:
2028 case EM_MICROBLAZE:
2029 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2030 case EM_RL78: return "Renesas RL78";
2031 case EM_RX: return "Renesas RX";
2032 case EM_METAG: return "Imagination Technologies META processor architecture";
2033 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2034 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2035 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2036 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2037 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2038 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2039 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2040 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2041 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2042 case EM_CUDA: return "NVIDIA CUDA architecture";
2043 case EM_XGATE: return "Motorola XGATE embedded processor";
2044 default:
2045 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2046 return buff;
2047 }
2048}
2049
2050static void
2051decode_ARM_machine_flags (unsigned e_flags, char buf[])
2052{
2053 unsigned eabi;
2054 int unknown = 0;
2055
2056 eabi = EF_ARM_EABI_VERSION (e_flags);
2057 e_flags &= ~ EF_ARM_EABIMASK;
2058
2059 /* Handle "generic" ARM flags. */
2060 if (e_flags & EF_ARM_RELEXEC)
2061 {
2062 strcat (buf, ", relocatable executable");
2063 e_flags &= ~ EF_ARM_RELEXEC;
2064 }
2065
2066 if (e_flags & EF_ARM_HASENTRY)
2067 {
2068 strcat (buf, ", has entry point");
2069 e_flags &= ~ EF_ARM_HASENTRY;
2070 }
2071
2072 /* Now handle EABI specific flags. */
2073 switch (eabi)
2074 {
2075 default:
2076 strcat (buf, ", <unrecognized EABI>");
2077 if (e_flags)
2078 unknown = 1;
2079 break;
2080
2081 case EF_ARM_EABI_VER1:
2082 strcat (buf, ", Version1 EABI");
2083 while (e_flags)
2084 {
2085 unsigned flag;
2086
2087 /* Process flags one bit at a time. */
2088 flag = e_flags & - e_flags;
2089 e_flags &= ~ flag;
2090
2091 switch (flag)
2092 {
2093 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2094 strcat (buf, ", sorted symbol tables");
2095 break;
2096
2097 default:
2098 unknown = 1;
2099 break;
2100 }
2101 }
2102 break;
2103
2104 case EF_ARM_EABI_VER2:
2105 strcat (buf, ", Version2 EABI");
2106 while (e_flags)
2107 {
2108 unsigned flag;
2109
2110 /* Process flags one bit at a time. */
2111 flag = e_flags & - e_flags;
2112 e_flags &= ~ flag;
2113
2114 switch (flag)
2115 {
2116 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2117 strcat (buf, ", sorted symbol tables");
2118 break;
2119
2120 case EF_ARM_DYNSYMSUSESEGIDX:
2121 strcat (buf, ", dynamic symbols use segment index");
2122 break;
2123
2124 case EF_ARM_MAPSYMSFIRST:
2125 strcat (buf, ", mapping symbols precede others");
2126 break;
2127
2128 default:
2129 unknown = 1;
2130 break;
2131 }
2132 }
2133 break;
2134
2135 case EF_ARM_EABI_VER3:
2136 strcat (buf, ", Version3 EABI");
2137 break;
2138
2139 case EF_ARM_EABI_VER4:
2140 strcat (buf, ", Version4 EABI");
2141 while (e_flags)
2142 {
2143 unsigned flag;
2144
2145 /* Process flags one bit at a time. */
2146 flag = e_flags & - e_flags;
2147 e_flags &= ~ flag;
2148
2149 switch (flag)
2150 {
2151 case EF_ARM_BE8:
2152 strcat (buf, ", BE8");
2153 break;
2154
2155 case EF_ARM_LE8:
2156 strcat (buf, ", LE8");
2157 break;
2158
2159 default:
2160 unknown = 1;
2161 break;
2162 }
2163 break;
2164 }
2165 break;
2166
2167 case EF_ARM_EABI_VER5:
2168 strcat (buf, ", Version5 EABI");
2169 while (e_flags)
2170 {
2171 unsigned flag;
2172
2173 /* Process flags one bit at a time. */
2174 flag = e_flags & - e_flags;
2175 e_flags &= ~ flag;
2176
2177 switch (flag)
2178 {
2179 case EF_ARM_BE8:
2180 strcat (buf, ", BE8");
2181 break;
2182
2183 case EF_ARM_LE8:
2184 strcat (buf, ", LE8");
2185 break;
2186
2187 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2188 strcat (buf, ", soft-float ABI");
2189 break;
2190
2191 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2192 strcat (buf, ", hard-float ABI");
2193 break;
2194
2195 default:
2196 unknown = 1;
2197 break;
2198 }
2199 }
2200 break;
2201
2202 case EF_ARM_EABI_UNKNOWN:
2203 strcat (buf, ", GNU EABI");
2204 while (e_flags)
2205 {
2206 unsigned flag;
2207
2208 /* Process flags one bit at a time. */
2209 flag = e_flags & - e_flags;
2210 e_flags &= ~ flag;
2211
2212 switch (flag)
2213 {
2214 case EF_ARM_INTERWORK:
2215 strcat (buf, ", interworking enabled");
2216 break;
2217
2218 case EF_ARM_APCS_26:
2219 strcat (buf, ", uses APCS/26");
2220 break;
2221
2222 case EF_ARM_APCS_FLOAT:
2223 strcat (buf, ", uses APCS/float");
2224 break;
2225
2226 case EF_ARM_PIC:
2227 strcat (buf, ", position independent");
2228 break;
2229
2230 case EF_ARM_ALIGN8:
2231 strcat (buf, ", 8 bit structure alignment");
2232 break;
2233
2234 case EF_ARM_NEW_ABI:
2235 strcat (buf, ", uses new ABI");
2236 break;
2237
2238 case EF_ARM_OLD_ABI:
2239 strcat (buf, ", uses old ABI");
2240 break;
2241
2242 case EF_ARM_SOFT_FLOAT:
2243 strcat (buf, ", software FP");
2244 break;
2245
2246 case EF_ARM_VFP_FLOAT:
2247 strcat (buf, ", VFP");
2248 break;
2249
2250 case EF_ARM_MAVERICK_FLOAT:
2251 strcat (buf, ", Maverick FP");
2252 break;
2253
2254 default:
2255 unknown = 1;
2256 break;
2257 }
2258 }
2259 }
2260
2261 if (unknown)
2262 strcat (buf,_(", <unknown>"));
2263}
2264
2265static char *
2266get_machine_flags (unsigned e_flags, unsigned e_machine)
2267{
2268 static char buf[1024];
2269
2270 buf[0] = '\0';
2271
2272 if (e_flags)
2273 {
2274 switch (e_machine)
2275 {
2276 default:
2277 break;
2278
2279 case EM_ARM:
2280 decode_ARM_machine_flags (e_flags, buf);
2281 break;
2282
2283 case EM_BLACKFIN:
2284 if (e_flags & EF_BFIN_PIC)
2285 strcat (buf, ", PIC");
2286
2287 if (e_flags & EF_BFIN_FDPIC)
2288 strcat (buf, ", FDPIC");
2289
2290 if (e_flags & EF_BFIN_CODE_IN_L1)
2291 strcat (buf, ", code in L1");
2292
2293 if (e_flags & EF_BFIN_DATA_IN_L1)
2294 strcat (buf, ", data in L1");
2295
2296 break;
2297
2298 case EM_CYGNUS_FRV:
2299 switch (e_flags & EF_FRV_CPU_MASK)
2300 {
2301 case EF_FRV_CPU_GENERIC:
2302 break;
2303
2304 default:
2305 strcat (buf, ", fr???");
2306 break;
2307
2308 case EF_FRV_CPU_FR300:
2309 strcat (buf, ", fr300");
2310 break;
2311
2312 case EF_FRV_CPU_FR400:
2313 strcat (buf, ", fr400");
2314 break;
2315 case EF_FRV_CPU_FR405:
2316 strcat (buf, ", fr405");
2317 break;
2318
2319 case EF_FRV_CPU_FR450:
2320 strcat (buf, ", fr450");
2321 break;
2322
2323 case EF_FRV_CPU_FR500:
2324 strcat (buf, ", fr500");
2325 break;
2326 case EF_FRV_CPU_FR550:
2327 strcat (buf, ", fr550");
2328 break;
2329
2330 case EF_FRV_CPU_SIMPLE:
2331 strcat (buf, ", simple");
2332 break;
2333 case EF_FRV_CPU_TOMCAT:
2334 strcat (buf, ", tomcat");
2335 break;
2336 }
2337 break;
2338
2339 case EM_68K:
2340 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2341 strcat (buf, ", m68000");
2342 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2343 strcat (buf, ", cpu32");
2344 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2345 strcat (buf, ", fido_a");
2346 else
2347 {
2348 char const * isa = _("unknown");
2349 char const * mac = _("unknown mac");
2350 char const * additional = NULL;
2351
2352 switch (e_flags & EF_M68K_CF_ISA_MASK)
2353 {
2354 case EF_M68K_CF_ISA_A_NODIV:
2355 isa = "A";
2356 additional = ", nodiv";
2357 break;
2358 case EF_M68K_CF_ISA_A:
2359 isa = "A";
2360 break;
2361 case EF_M68K_CF_ISA_A_PLUS:
2362 isa = "A+";
2363 break;
2364 case EF_M68K_CF_ISA_B_NOUSP:
2365 isa = "B";
2366 additional = ", nousp";
2367 break;
2368 case EF_M68K_CF_ISA_B:
2369 isa = "B";
2370 break;
2371 case EF_M68K_CF_ISA_C:
2372 isa = "C";
2373 break;
2374 case EF_M68K_CF_ISA_C_NODIV:
2375 isa = "C";
2376 additional = ", nodiv";
2377 break;
2378 }
2379 strcat (buf, ", cf, isa ");
2380 strcat (buf, isa);
2381 if (additional)
2382 strcat (buf, additional);
2383 if (e_flags & EF_M68K_CF_FLOAT)
2384 strcat (buf, ", float");
2385 switch (e_flags & EF_M68K_CF_MAC_MASK)
2386 {
2387 case 0:
2388 mac = NULL;
2389 break;
2390 case EF_M68K_CF_MAC:
2391 mac = "mac";
2392 break;
2393 case EF_M68K_CF_EMAC:
2394 mac = "emac";
2395 break;
2396 case EF_M68K_CF_EMAC_B:
2397 mac = "emac_b";
2398 break;
2399 }
2400 if (mac)
2401 {
2402 strcat (buf, ", ");
2403 strcat (buf, mac);
2404 }
2405 }
2406 break;
2407
2408 case EM_PPC:
2409 if (e_flags & EF_PPC_EMB)
2410 strcat (buf, ", emb");
2411
2412 if (e_flags & EF_PPC_RELOCATABLE)
2413 strcat (buf, _(", relocatable"));
2414
2415 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2416 strcat (buf, _(", relocatable-lib"));
2417 break;
2418
2419 case EM_V800:
2420 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2421 strcat (buf, ", RH850 ABI");
2422
2423 if (e_flags & EF_V800_850E3)
2424 strcat (buf, ", V3 architecture");
2425
2426 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2427 strcat (buf, ", FPU not used");
2428
2429 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2430 strcat (buf, ", regmode: COMMON");
2431
2432 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2433 strcat (buf, ", r4 not used");
2434
2435 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2436 strcat (buf, ", r30 not used");
2437
2438 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2439 strcat (buf, ", r5 not used");
2440
2441 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2442 strcat (buf, ", r2 not used");
2443
2444 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2445 {
2446 switch (e_flags & - e_flags)
2447 {
2448 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2449 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2450 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2451 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2452 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2453 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2454 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2455 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2456 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2457 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2458 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2459 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2460 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2461 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2462 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2463 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2464 default: break;
2465 }
2466 }
2467 break;
2468
2469 case EM_V850:
2470 case EM_CYGNUS_V850:
2471 switch (e_flags & EF_V850_ARCH)
2472 {
2473 case E_V850E2V3_ARCH:
2474 strcat (buf, ", v850e2v3");
2475 break;
2476 case E_V850E2_ARCH:
2477 strcat (buf, ", v850e2");
2478 break;
2479 case E_V850E1_ARCH:
2480 strcat (buf, ", v850e1");
2481 break;
2482 case E_V850E_ARCH:
2483 strcat (buf, ", v850e");
2484 break;
2485 case E_V850_ARCH:
2486 strcat (buf, ", v850");
2487 break;
2488 default:
2489 strcat (buf, _(", unknown v850 architecture variant"));
2490 break;
2491 }
2492 break;
2493
2494 case EM_M32R:
2495 case EM_CYGNUS_M32R:
2496 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2497 strcat (buf, ", m32r");
2498 break;
2499
2500 case EM_MIPS:
2501 case EM_MIPS_RS3_LE:
2502 if (e_flags & EF_MIPS_NOREORDER)
2503 strcat (buf, ", noreorder");
2504
2505 if (e_flags & EF_MIPS_PIC)
2506 strcat (buf, ", pic");
2507
2508 if (e_flags & EF_MIPS_CPIC)
2509 strcat (buf, ", cpic");
2510
2511 if (e_flags & EF_MIPS_UCODE)
2512 strcat (buf, ", ugen_reserved");
2513
2514 if (e_flags & EF_MIPS_ABI2)
2515 strcat (buf, ", abi2");
2516
2517 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2518 strcat (buf, ", odk first");
2519
2520 if (e_flags & EF_MIPS_32BITMODE)
2521 strcat (buf, ", 32bitmode");
2522
2523 switch ((e_flags & EF_MIPS_MACH))
2524 {
2525 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2526 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2527 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2528 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2529 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2530 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2531 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2532 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2533 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2534 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2535 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2536 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2537 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2538 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2539 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2540 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2541 case 0:
2542 /* We simply ignore the field in this case to avoid confusion:
2543 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2544 extension. */
2545 break;
2546 default: strcat (buf, _(", unknown CPU")); break;
2547 }
2548
2549 switch ((e_flags & EF_MIPS_ABI))
2550 {
2551 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2552 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2553 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2554 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2555 case 0:
2556 /* We simply ignore the field in this case to avoid confusion:
2557 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2558 This means it is likely to be an o32 file, but not for
2559 sure. */
2560 break;
2561 default: strcat (buf, _(", unknown ABI")); break;
2562 }
2563
2564 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2565 strcat (buf, ", mdmx");
2566
2567 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2568 strcat (buf, ", mips16");
2569
2570 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2571 strcat (buf, ", micromips");
2572
2573 switch ((e_flags & EF_MIPS_ARCH))
2574 {
2575 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2576 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2577 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2578 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2579 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2580 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2581 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2582 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2583 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2584 default: strcat (buf, _(", unknown ISA")); break;
2585 }
2586 break;
2587
2588 case EM_SH:
2589 switch ((e_flags & EF_SH_MACH_MASK))
2590 {
2591 case EF_SH1: strcat (buf, ", sh1"); break;
2592 case EF_SH2: strcat (buf, ", sh2"); break;
2593 case EF_SH3: strcat (buf, ", sh3"); break;
2594 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2595 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2596 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2597 case EF_SH3E: strcat (buf, ", sh3e"); break;
2598 case EF_SH4: strcat (buf, ", sh4"); break;
2599 case EF_SH5: strcat (buf, ", sh5"); break;
2600 case EF_SH2E: strcat (buf, ", sh2e"); break;
2601 case EF_SH4A: strcat (buf, ", sh4a"); break;
2602 case EF_SH2A: strcat (buf, ", sh2a"); break;
2603 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2604 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2605 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2606 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2607 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2608 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2609 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2610 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2611 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2612 default: strcat (buf, _(", unknown ISA")); break;
2613 }
2614
2615 if (e_flags & EF_SH_PIC)
2616 strcat (buf, ", pic");
2617
2618 if (e_flags & EF_SH_FDPIC)
2619 strcat (buf, ", fdpic");
2620 break;
2621
2622 case EM_SPARCV9:
2623 if (e_flags & EF_SPARC_32PLUS)
2624 strcat (buf, ", v8+");
2625
2626 if (e_flags & EF_SPARC_SUN_US1)
2627 strcat (buf, ", ultrasparcI");
2628
2629 if (e_flags & EF_SPARC_SUN_US3)
2630 strcat (buf, ", ultrasparcIII");
2631
2632 if (e_flags & EF_SPARC_HAL_R1)
2633 strcat (buf, ", halr1");
2634
2635 if (e_flags & EF_SPARC_LEDATA)
2636 strcat (buf, ", ledata");
2637
2638 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2639 strcat (buf, ", tso");
2640
2641 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2642 strcat (buf, ", pso");
2643
2644 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2645 strcat (buf, ", rmo");
2646 break;
2647
2648 case EM_PARISC:
2649 switch (e_flags & EF_PARISC_ARCH)
2650 {
2651 case EFA_PARISC_1_0:
2652 strcpy (buf, ", PA-RISC 1.0");
2653 break;
2654 case EFA_PARISC_1_1:
2655 strcpy (buf, ", PA-RISC 1.1");
2656 break;
2657 case EFA_PARISC_2_0:
2658 strcpy (buf, ", PA-RISC 2.0");
2659 break;
2660 default:
2661 break;
2662 }
2663 if (e_flags & EF_PARISC_TRAPNIL)
2664 strcat (buf, ", trapnil");
2665 if (e_flags & EF_PARISC_EXT)
2666 strcat (buf, ", ext");
2667 if (e_flags & EF_PARISC_LSB)
2668 strcat (buf, ", lsb");
2669 if (e_flags & EF_PARISC_WIDE)
2670 strcat (buf, ", wide");
2671 if (e_flags & EF_PARISC_NO_KABP)
2672 strcat (buf, ", no kabp");
2673 if (e_flags & EF_PARISC_LAZYSWAP)
2674 strcat (buf, ", lazyswap");
2675 break;
2676
2677 case EM_PJ:
2678 case EM_PJ_OLD:
2679 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2680 strcat (buf, ", new calling convention");
2681
2682 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2683 strcat (buf, ", gnu calling convention");
2684 break;
2685
2686 case EM_IA_64:
2687 if ((e_flags & EF_IA_64_ABI64))
2688 strcat (buf, ", 64-bit");
2689 else
2690 strcat (buf, ", 32-bit");
2691 if ((e_flags & EF_IA_64_REDUCEDFP))
2692 strcat (buf, ", reduced fp model");
2693 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2694 strcat (buf, ", no function descriptors, constant gp");
2695 else if ((e_flags & EF_IA_64_CONS_GP))
2696 strcat (buf, ", constant gp");
2697 if ((e_flags & EF_IA_64_ABSOLUTE))
2698 strcat (buf, ", absolute");
2699 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2700 {
2701 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2702 strcat (buf, ", vms_linkages");
2703 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2704 {
2705 case EF_IA_64_VMS_COMCOD_SUCCESS:
2706 break;
2707 case EF_IA_64_VMS_COMCOD_WARNING:
2708 strcat (buf, ", warning");
2709 break;
2710 case EF_IA_64_VMS_COMCOD_ERROR:
2711 strcat (buf, ", error");
2712 break;
2713 case EF_IA_64_VMS_COMCOD_ABORT:
2714 strcat (buf, ", abort");
2715 break;
2716 default:
2717 abort ();
2718 }
2719 }
2720 break;
2721
2722 case EM_VAX:
2723 if ((e_flags & EF_VAX_NONPIC))
2724 strcat (buf, ", non-PIC");
2725 if ((e_flags & EF_VAX_DFLOAT))
2726 strcat (buf, ", D-Float");
2727 if ((e_flags & EF_VAX_GFLOAT))
2728 strcat (buf, ", G-Float");
2729 break;
2730
2731 case EM_RX:
2732 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2733 strcat (buf, ", 64-bit doubles");
2734 if (e_flags & E_FLAG_RX_DSP)
2735 strcat (buf, ", dsp");
2736 if (e_flags & E_FLAG_RX_PID)
2737 strcat (buf, ", pid");
2738 if (e_flags & E_FLAG_RX_ABI)
2739 strcat (buf, ", RX ABI");
2740 break;
2741
2742 case EM_S390:
2743 if (e_flags & EF_S390_HIGH_GPRS)
2744 strcat (buf, ", highgprs");
2745 break;
2746
2747 case EM_TI_C6000:
2748 if ((e_flags & EF_C6000_REL))
2749 strcat (buf, ", relocatable module");
2750 break;
2751 }
2752 }
2753
2754 return buf;
2755}
2756
2757static const char *
2758get_osabi_name (unsigned int osabi)
2759{
2760 static char buff[32];
2761
2762 switch (osabi)
2763 {
2764 case ELFOSABI_NONE: return "UNIX - System V";
2765 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2766 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2767 case ELFOSABI_GNU: return "UNIX - GNU";
2768 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2769 case ELFOSABI_AIX: return "UNIX - AIX";
2770 case ELFOSABI_IRIX: return "UNIX - IRIX";
2771 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2772 case ELFOSABI_TRU64: return "UNIX - TRU64";
2773 case ELFOSABI_MODESTO: return "Novell - Modesto";
2774 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2775 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2776 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2777 case ELFOSABI_AROS: return "AROS";
2778 case ELFOSABI_FENIXOS: return "FenixOS";
2779 default:
2780 if (osabi >= 64)
2781 switch (elf_header.e_machine)
2782 {
2783 case EM_ARM:
2784 switch (osabi)
2785 {
2786 case ELFOSABI_ARM: return "ARM";
2787 default:
2788 break;
2789 }
2790 break;
2791
2792 case EM_MSP430:
2793 case EM_MSP430_OLD:
2794 switch (osabi)
2795 {
2796 case ELFOSABI_STANDALONE: return _("Standalone App");
2797 default:
2798 break;
2799 }
2800 break;
2801
2802 case EM_TI_C6000:
2803 switch (osabi)
2804 {
2805 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2806 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2807 default:
2808 break;
2809 }
2810 break;
2811
2812 default:
2813 break;
2814 }
2815 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2816 return buff;
2817 }
2818}
2819
2820static const char *
2821get_aarch64_segment_type (unsigned long type)
2822{
2823 switch (type)
2824 {
2825 case PT_AARCH64_ARCHEXT:
2826 return "AARCH64_ARCHEXT";
2827 default:
2828 break;
2829 }
2830
2831 return NULL;
2832}
2833
2834static const char *
2835get_arm_segment_type (unsigned long type)
2836{
2837 switch (type)
2838 {
2839 case PT_ARM_EXIDX:
2840 return "EXIDX";
2841 default:
2842 break;
2843 }
2844
2845 return NULL;
2846}
2847
2848static const char *
2849get_mips_segment_type (unsigned long type)
2850{
2851 switch (type)
2852 {
2853 case PT_MIPS_REGINFO:
2854 return "REGINFO";
2855 case PT_MIPS_RTPROC:
2856 return "RTPROC";
2857 case PT_MIPS_OPTIONS:
2858 return "OPTIONS";
2859 default:
2860 break;
2861 }
2862
2863 return NULL;
2864}
2865
2866static const char *
2867get_parisc_segment_type (unsigned long type)
2868{
2869 switch (type)
2870 {
2871 case PT_HP_TLS: return "HP_TLS";
2872 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2873 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2874 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2875 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2876 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2877 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2878 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2879 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2880 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2881 case PT_HP_PARALLEL: return "HP_PARALLEL";
2882 case PT_HP_FASTBIND: return "HP_FASTBIND";
2883 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2884 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2885 case PT_HP_STACK: return "HP_STACK";
2886 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2887 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2888 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2889 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2890 default:
2891 break;
2892 }
2893
2894 return NULL;
2895}
2896
2897static const char *
2898get_ia64_segment_type (unsigned long type)
2899{
2900 switch (type)
2901 {
2902 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2903 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2904 case PT_HP_TLS: return "HP_TLS";
2905 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2906 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2907 case PT_IA_64_HP_STACK: return "HP_STACK";
2908 default:
2909 break;
2910 }
2911
2912 return NULL;
2913}
2914
2915static const char *
2916get_tic6x_segment_type (unsigned long type)
2917{
2918 switch (type)
2919 {
2920 case PT_C6000_PHATTR: return "C6000_PHATTR";
2921 default:
2922 break;
2923 }
2924
2925 return NULL;
2926}
2927
2928static const char *
2929get_segment_type (unsigned long p_type)
2930{
2931 static char buff[32];
2932
2933 switch (p_type)
2934 {
2935 case PT_NULL: return "NULL";
2936 case PT_LOAD: return "LOAD";
2937 case PT_DYNAMIC: return "DYNAMIC";
2938 case PT_INTERP: return "INTERP";
2939 case PT_NOTE: return "NOTE";
2940 case PT_SHLIB: return "SHLIB";
2941 case PT_PHDR: return "PHDR";
2942 case PT_TLS: return "TLS";
2943
2944 case PT_GNU_EH_FRAME:
2945 return "GNU_EH_FRAME";
2946 case PT_GNU_STACK: return "GNU_STACK";
2947 case PT_GNU_RELRO: return "GNU_RELRO";
2948
2949 default:
2950 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2951 {
2952 const char * result;
2953
2954 switch (elf_header.e_machine)
2955 {
2956 case EM_AARCH64:
2957 result = get_aarch64_segment_type (p_type);
2958 break;
2959 case EM_ARM:
2960 result = get_arm_segment_type (p_type);
2961 break;
2962 case EM_MIPS:
2963 case EM_MIPS_RS3_LE:
2964 result = get_mips_segment_type (p_type);
2965 break;
2966 case EM_PARISC:
2967 result = get_parisc_segment_type (p_type);
2968 break;
2969 case EM_IA_64:
2970 result = get_ia64_segment_type (p_type);
2971 break;
2972 case EM_TI_C6000:
2973 result = get_tic6x_segment_type (p_type);
2974 break;
2975 default:
2976 result = NULL;
2977 break;
2978 }
2979
2980 if (result != NULL)
2981 return result;
2982
2983 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2984 }
2985 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2986 {
2987 const char * result;
2988
2989 switch (elf_header.e_machine)
2990 {
2991 case EM_PARISC:
2992 result = get_parisc_segment_type (p_type);
2993 break;
2994 case EM_IA_64:
2995 result = get_ia64_segment_type (p_type);
2996 break;
2997 default:
2998 result = NULL;
2999 break;
3000 }
3001
3002 if (result != NULL)
3003 return result;
3004
3005 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3006 }
3007 else
3008 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3009
3010 return buff;
3011 }
3012}
3013
3014static const char *
3015get_mips_section_type_name (unsigned int sh_type)
3016{
3017 switch (sh_type)
3018 {
3019 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3020 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3021 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3022 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3023 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3024 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3025 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3026 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3027 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3028 case SHT_MIPS_RELD: return "MIPS_RELD";
3029 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3030 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3031 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3032 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3033 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3034 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3035 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3036 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3037 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3038 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3039 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3040 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3041 case SHT_MIPS_LINE: return "MIPS_LINE";
3042 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3043 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3044 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3045 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3046 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3047 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3048 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3049 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3050 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3051 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3052 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3053 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3054 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3055 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3056 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3057 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3058 default:
3059 break;
3060 }
3061 return NULL;
3062}
3063
3064static const char *
3065get_parisc_section_type_name (unsigned int sh_type)
3066{
3067 switch (sh_type)
3068 {
3069 case SHT_PARISC_EXT: return "PARISC_EXT";
3070 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3071 case SHT_PARISC_DOC: return "PARISC_DOC";
3072 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3073 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3074 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3075 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3076 default:
3077 break;
3078 }
3079 return NULL;
3080}
3081
3082static const char *
3083get_ia64_section_type_name (unsigned int sh_type)
3084{
3085 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3086 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3087 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3088
3089 switch (sh_type)
3090 {
3091 case SHT_IA_64_EXT: return "IA_64_EXT";
3092 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3093 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3094 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3095 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3096 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3097 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3098 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3099 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3100 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3101 default:
3102 break;
3103 }
3104 return NULL;
3105}
3106
3107static const char *
3108get_x86_64_section_type_name (unsigned int sh_type)
3109{
3110 switch (sh_type)
3111 {
3112 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3113 default:
3114 break;
3115 }
3116 return NULL;
3117}
3118
3119static const char *
3120get_aarch64_section_type_name (unsigned int sh_type)
3121{
3122 switch (sh_type)
3123 {
3124 case SHT_AARCH64_ATTRIBUTES:
3125 return "AARCH64_ATTRIBUTES";
3126 default:
3127 break;
3128 }
3129 return NULL;
3130}
3131
3132static const char *
3133get_arm_section_type_name (unsigned int sh_type)
3134{
3135 switch (sh_type)
3136 {
3137 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3138 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3139 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3140 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3141 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3142 default:
3143 break;
3144 }
3145 return NULL;
3146}
3147
3148static const char *
3149get_tic6x_section_type_name (unsigned int sh_type)
3150{
3151 switch (sh_type)
3152 {
3153 case SHT_C6000_UNWIND:
3154 return "C6000_UNWIND";
3155 case SHT_C6000_PREEMPTMAP:
3156 return "C6000_PREEMPTMAP";
3157 case SHT_C6000_ATTRIBUTES:
3158 return "C6000_ATTRIBUTES";
3159 case SHT_TI_ICODE:
3160 return "TI_ICODE";
3161 case SHT_TI_XREF:
3162 return "TI_XREF";
3163 case SHT_TI_HANDLER:
3164 return "TI_HANDLER";
3165 case SHT_TI_INITINFO:
3166 return "TI_INITINFO";
3167 case SHT_TI_PHATTRS:
3168 return "TI_PHATTRS";
3169 default:
3170 break;
3171 }
3172 return NULL;
3173}
3174
3175static const char *
3176get_section_type_name (unsigned int sh_type)
3177{
3178 static char buff[32];
3179
3180 switch (sh_type)
3181 {
3182 case SHT_NULL: return "NULL";
3183 case SHT_PROGBITS: return "PROGBITS";
3184 case SHT_SYMTAB: return "SYMTAB";
3185 case SHT_STRTAB: return "STRTAB";
3186 case SHT_RELA: return "RELA";
3187 case SHT_HASH: return "HASH";
3188 case SHT_DYNAMIC: return "DYNAMIC";
3189 case SHT_NOTE: return "NOTE";
3190 case SHT_NOBITS: return "NOBITS";
3191 case SHT_REL: return "REL";
3192 case SHT_SHLIB: return "SHLIB";
3193 case SHT_DYNSYM: return "DYNSYM";
3194 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3195 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3196 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3197 case SHT_GNU_HASH: return "GNU_HASH";
3198 case SHT_GROUP: return "GROUP";
3199 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3200 case SHT_GNU_verdef: return "VERDEF";
3201 case SHT_GNU_verneed: return "VERNEED";
3202 case SHT_GNU_versym: return "VERSYM";
3203 case 0x6ffffff0: return "VERSYM";
3204 case 0x6ffffffc: return "VERDEF";
3205 case 0x7ffffffd: return "AUXILIARY";
3206 case 0x7fffffff: return "FILTER";
3207 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3208
3209 default:
3210 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3211 {
3212 const char * result;
3213
3214 switch (elf_header.e_machine)
3215 {
3216 case EM_MIPS:
3217 case EM_MIPS_RS3_LE:
3218 result = get_mips_section_type_name (sh_type);
3219 break;
3220 case EM_PARISC:
3221 result = get_parisc_section_type_name (sh_type);
3222 break;
3223 case EM_IA_64:
3224 result = get_ia64_section_type_name (sh_type);
3225 break;
3226 case EM_X86_64:
3227 case EM_L1OM:
3228 case EM_K1OM:
3229 result = get_x86_64_section_type_name (sh_type);
3230 break;
3231 case EM_AARCH64:
3232 result = get_aarch64_section_type_name (sh_type);
3233 break;
3234 case EM_ARM:
3235 result = get_arm_section_type_name (sh_type);
3236 break;
3237 case EM_TI_C6000:
3238 result = get_tic6x_section_type_name (sh_type);
3239 break;
3240 default:
3241 result = NULL;
3242 break;
3243 }
3244
3245 if (result != NULL)
3246 return result;
3247
3248 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3249 }
3250 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3251 {
3252 const char * result;
3253
3254 switch (elf_header.e_machine)
3255 {
3256 case EM_IA_64:
3257 result = get_ia64_section_type_name (sh_type);
3258 break;
3259 default:
3260 result = NULL;
3261 break;
3262 }
3263
3264 if (result != NULL)
3265 return result;
3266
3267 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3268 }
3269 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3270 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3271 else
3272 /* This message is probably going to be displayed in a 15
3273 character wide field, so put the hex value first. */
3274 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3275
3276 return buff;
3277 }
3278}
3279
3280#define OPTION_DEBUG_DUMP 512
3281#define OPTION_DYN_SYMS 513
3282#define OPTION_DWARF_DEPTH 514
3283#define OPTION_DWARF_START 515
3284#define OPTION_DWARF_CHECK 516
3285
3286static struct option options[] =
3287{
3288 {"all", no_argument, 0, 'a'},
3289 {"file-header", no_argument, 0, 'h'},
3290 {"program-headers", no_argument, 0, 'l'},
3291 {"headers", no_argument, 0, 'e'},
3292 {"histogram", no_argument, 0, 'I'},
3293 {"segments", no_argument, 0, 'l'},
3294 {"sections", no_argument, 0, 'S'},
3295 {"section-headers", no_argument, 0, 'S'},
3296 {"section-groups", no_argument, 0, 'g'},
3297 {"section-details", no_argument, 0, 't'},
3298 {"full-section-name",no_argument, 0, 'N'},
3299 {"symbols", no_argument, 0, 's'},
3300 {"syms", no_argument, 0, 's'},
3301 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3302 {"relocs", no_argument, 0, 'r'},
3303 {"notes", no_argument, 0, 'n'},
3304 {"dynamic", no_argument, 0, 'd'},
3305 {"arch-specific", no_argument, 0, 'A'},
3306 {"version-info", no_argument, 0, 'V'},
3307 {"use-dynamic", no_argument, 0, 'D'},
3308 {"unwind", no_argument, 0, 'u'},
3309 {"archive-index", no_argument, 0, 'c'},
3310 {"hex-dump", required_argument, 0, 'x'},
3311 {"relocated-dump", required_argument, 0, 'R'},
3312 {"string-dump", required_argument, 0, 'p'},
3313#ifdef SUPPORT_DISASSEMBLY
3314 {"instruction-dump", required_argument, 0, 'i'},
3315#endif
3316 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3317
3318 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3319 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3320 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
3321
3322 {"version", no_argument, 0, 'v'},
3323 {"wide", no_argument, 0, 'W'},
3324 {"help", no_argument, 0, 'H'},
3325 {0, no_argument, 0, 0}
3326};
3327
3328static void
3329usage (FILE * stream)
3330{
3331 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3332 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3333 fprintf (stream, _(" Options are:\n\
3334 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3335 -h --file-header Display the ELF file header\n\
3336 -l --program-headers Display the program headers\n\
3337 --segments An alias for --program-headers\n\
3338 -S --section-headers Display the sections' header\n\
3339 --sections An alias for --section-headers\n\
3340 -g --section-groups Display the section groups\n\
3341 -t --section-details Display the section details\n\
3342 -e --headers Equivalent to: -h -l -S\n\
3343 -s --syms Display the symbol table\n\
3344 --symbols An alias for --syms\n\
3345 --dyn-syms Display the dynamic symbol table\n\
3346 -n --notes Display the core notes (if present)\n\
3347 -r --relocs Display the relocations (if present)\n\
3348 -u --unwind Display the unwind info (if present)\n\
3349 -d --dynamic Display the dynamic section (if present)\n\
3350 -V --version-info Display the version sections (if present)\n\
3351 -A --arch-specific Display architecture specific information (if any)\n\
3352 -c --archive-index Display the symbol/file index in an archive\n\
3353 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3354 -x --hex-dump=<number|name>\n\
3355 Dump the contents of section <number|name> as bytes\n\
3356 -p --string-dump=<number|name>\n\
3357 Dump the contents of section <number|name> as strings\n\
3358 -R --relocated-dump=<number|name>\n\
3359 Dump the contents of section <number|name> as relocated bytes\n\
3360 -w[lLiaprmfFsoRt] or\n\
3361 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3362 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3363 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3364 =addr,=cu_index]\n\
3365 Display the contents of DWARF2 debug sections\n"));
3366 fprintf (stream, _("\
3367 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3368 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3369 or deeper\n"));
3370#ifdef SUPPORT_DISASSEMBLY
3371 fprintf (stream, _("\
3372 -i --instruction-dump=<number|name>\n\
3373 Disassemble the contents of section <number|name>\n"));
3374#endif
3375 fprintf (stream, _("\
3376 -I --histogram Display histogram of bucket list lengths\n\
3377 -W --wide Allow output width to exceed 80 characters\n\
3378 @<file> Read options from <file>\n\
3379 -H --help Display this information\n\
3380 -v --version Display the version number of readelf\n"));
3381
3382 if (REPORT_BUGS_TO[0] && stream == stdout)
3383 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3384
3385 exit (stream == stdout ? 0 : 1);
3386}
3387
3388/* Record the fact that the user wants the contents of section number
3389 SECTION to be displayed using the method(s) encoded as flags bits
3390 in TYPE. Note, TYPE can be zero if we are creating the array for
3391 the first time. */
3392
3393static void
3394request_dump_bynumber (unsigned int section, dump_type type)
3395{
3396 if (section >= num_dump_sects)
3397 {
3398 dump_type * new_dump_sects;
3399
3400 new_dump_sects = (dump_type *) calloc (section + 1,
3401 sizeof (* dump_sects));
3402
3403 if (new_dump_sects == NULL)
3404 error (_("Out of memory allocating dump request table.\n"));
3405 else
3406 {
3407 /* Copy current flag settings. */
3408 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3409
3410 free (dump_sects);
3411
3412 dump_sects = new_dump_sects;
3413 num_dump_sects = section + 1;
3414 }
3415 }
3416
3417 if (dump_sects)
3418 dump_sects[section] |= type;
3419
3420 return;
3421}
3422
3423/* Request a dump by section name. */
3424
3425static void
3426request_dump_byname (const char * section, dump_type type)
3427{
3428 struct dump_list_entry * new_request;
3429
3430 new_request = (struct dump_list_entry *)
3431 malloc (sizeof (struct dump_list_entry));
3432 if (!new_request)
3433 error (_("Out of memory allocating dump request table.\n"));
3434
3435 new_request->name = strdup (section);
3436 if (!new_request->name)
3437 error (_("Out of memory allocating dump request table.\n"));
3438
3439 new_request->type = type;
3440
3441 new_request->next = dump_sects_byname;
3442 dump_sects_byname = new_request;
3443}
3444
3445static inline void
3446request_dump (dump_type type)
3447{
3448 int section;
3449 char * cp;
3450
3451 do_dump++;
3452 section = strtoul (optarg, & cp, 0);
3453
3454 if (! *cp && section >= 0)
3455 request_dump_bynumber (section, type);
3456 else
3457 request_dump_byname (optarg, type);
3458}
3459
3460
3461static void
3462parse_args (int argc, char ** argv)
3463{
3464 int c;
3465
3466 if (argc < 2)
3467 usage (stderr);
3468
3469 while ((c = getopt_long
3470 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3471 {
3472 switch (c)
3473 {
3474 case 0:
3475 /* Long options. */
3476 break;
3477 case 'H':
3478 usage (stdout);
3479 break;
3480
3481 case 'a':
3482 do_syms++;
3483 do_reloc++;
3484 do_unwind++;
3485 do_dynamic++;
3486 do_header++;
3487 do_sections++;
3488 do_section_groups++;
3489 do_segments++;
3490 do_version++;
3491 do_histogram++;
3492 do_arch++;
3493 do_notes++;
3494 break;
3495 case 'g':
3496 do_section_groups++;
3497 break;
3498 case 't':
3499 case 'N':
3500 do_sections++;
3501 do_section_details++;
3502 break;
3503 case 'e':
3504 do_header++;
3505 do_sections++;
3506 do_segments++;
3507 break;
3508 case 'A':
3509 do_arch++;
3510 break;
3511 case 'D':
3512 do_using_dynamic++;
3513 break;
3514 case 'r':
3515 do_reloc++;
3516 break;
3517 case 'u':
3518 do_unwind++;
3519 break;
3520 case 'h':
3521 do_header++;
3522 break;
3523 case 'l':
3524 do_segments++;
3525 break;
3526 case 's':
3527 do_syms++;
3528 break;
3529 case 'S':
3530 do_sections++;
3531 break;
3532 case 'd':
3533 do_dynamic++;
3534 break;
3535 case 'I':
3536 do_histogram++;
3537 break;
3538 case 'n':
3539 do_notes++;
3540 break;
3541 case 'c':
3542 do_archive_index++;
3543 break;
3544 case 'x':
3545 request_dump (HEX_DUMP);
3546 break;
3547 case 'p':
3548 request_dump (STRING_DUMP);
3549 break;
3550 case 'R':
3551 request_dump (RELOC_DUMP);
3552 break;
3553 case 'w':
3554 do_dump++;
3555 if (optarg == 0)
3556 {
3557 do_debugging = 1;
3558 dwarf_select_sections_all ();
3559 }
3560 else
3561 {
3562 do_debugging = 0;
3563 dwarf_select_sections_by_letters (optarg);
3564 }
3565 break;
3566 case OPTION_DEBUG_DUMP:
3567 do_dump++;
3568 if (optarg == 0)
3569 do_debugging = 1;
3570 else
3571 {
3572 do_debugging = 0;
3573 dwarf_select_sections_by_names (optarg);
3574 }
3575 break;
3576 case OPTION_DWARF_DEPTH:
3577 {
3578 char *cp;
3579
3580 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3581 }
3582 break;
3583 case OPTION_DWARF_START:
3584 {
3585 char *cp;
3586
3587 dwarf_start_die = strtoul (optarg, & cp, 0);
3588 }
3589 break;
3590 case OPTION_DWARF_CHECK:
3591 dwarf_check = 1;
3592 break;
3593 case OPTION_DYN_SYMS:
3594 do_dyn_syms++;
3595 break;
3596#ifdef SUPPORT_DISASSEMBLY
3597 case 'i':
3598 request_dump (DISASS_DUMP);
3599 break;
3600#endif
3601 case 'v':
3602 print_version (program_name);
3603 break;
3604 case 'V':
3605 do_version++;
3606 break;
3607 case 'W':
3608 do_wide++;
3609 break;
3610 default:
3611 /* xgettext:c-format */
3612 error (_("Invalid option '-%c'\n"), c);
3613 /* Drop through. */
3614 case '?':
3615 usage (stderr);
3616 }
3617 }
3618
3619 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3620 && !do_segments && !do_header && !do_dump && !do_version
3621 && !do_histogram && !do_debugging && !do_arch && !do_notes
3622 && !do_section_groups && !do_archive_index
3623 && !do_dyn_syms)
3624 usage (stderr);
3625 else if (argc < 3)
3626 {
3627 warn (_("Nothing to do.\n"));
3628 usage (stderr);
3629 }
3630}
3631
3632static const char *
3633get_elf_class (unsigned int elf_class)
3634{
3635 static char buff[32];
3636
3637 switch (elf_class)
3638 {
3639 case ELFCLASSNONE: return _("none");
3640 case ELFCLASS32: return "ELF32";
3641 case ELFCLASS64: return "ELF64";
3642 default:
3643 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3644 return buff;
3645 }
3646}
3647
3648static const char *
3649get_data_encoding (unsigned int encoding)
3650{
3651 static char buff[32];
3652
3653 switch (encoding)
3654 {
3655 case ELFDATANONE: return _("none");
3656 case ELFDATA2LSB: return _("2's complement, little endian");
3657 case ELFDATA2MSB: return _("2's complement, big endian");
3658 default:
3659 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3660 return buff;
3661 }
3662}
3663
3664/* Decode the data held in 'elf_header'. */
3665
3666static int
3667process_file_header (void)
3668{
3669 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3670 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3671 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3672 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3673 {
3674 error
3675 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3676 return 0;
3677 }
3678
3679 init_dwarf_regnames (elf_header.e_machine);
3680
3681 if (do_header)
3682 {
3683 int i;
3684
3685 printf (_("ELF Header:\n"));
3686 printf (_(" Magic: "));
3687 for (i = 0; i < EI_NIDENT; i++)
3688 printf ("%2.2x ", elf_header.e_ident[i]);
3689 printf ("\n");
3690 printf (_(" Class: %s\n"),
3691 get_elf_class (elf_header.e_ident[EI_CLASS]));
3692 printf (_(" Data: %s\n"),
3693 get_data_encoding (elf_header.e_ident[EI_DATA]));
3694 printf (_(" Version: %d %s\n"),
3695 elf_header.e_ident[EI_VERSION],
3696 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3697 ? "(current)"
3698 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3699 ? _("<unknown: %lx>")
3700 : "")));
3701 printf (_(" OS/ABI: %s\n"),
3702 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3703 printf (_(" ABI Version: %d\n"),
3704 elf_header.e_ident[EI_ABIVERSION]);
3705 printf (_(" Type: %s\n"),
3706 get_file_type (elf_header.e_type));
3707 printf (_(" Machine: %s\n"),
3708 get_machine_name (elf_header.e_machine));
3709 printf (_(" Version: 0x%lx\n"),
3710 (unsigned long) elf_header.e_version);
3711
3712 printf (_(" Entry point address: "));
3713 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3714 printf (_("\n Start of program headers: "));
3715 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3716 printf (_(" (bytes into file)\n Start of section headers: "));
3717 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3718 printf (_(" (bytes into file)\n"));
3719
3720 printf (_(" Flags: 0x%lx%s\n"),
3721 (unsigned long) elf_header.e_flags,
3722 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3723 printf (_(" Size of this header: %ld (bytes)\n"),
3724 (long) elf_header.e_ehsize);
3725 printf (_(" Size of program headers: %ld (bytes)\n"),
3726 (long) elf_header.e_phentsize);
3727 printf (_(" Number of program headers: %ld"),
3728 (long) elf_header.e_phnum);
3729 if (section_headers != NULL
3730 && elf_header.e_phnum == PN_XNUM
3731 && section_headers[0].sh_info != 0)
3732 printf (" (%ld)", (long) section_headers[0].sh_info);
3733 putc ('\n', stdout);
3734 printf (_(" Size of section headers: %ld (bytes)\n"),
3735 (long) elf_header.e_shentsize);
3736 printf (_(" Number of section headers: %ld"),
3737 (long) elf_header.e_shnum);
3738 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3739 printf (" (%ld)", (long) section_headers[0].sh_size);
3740 putc ('\n', stdout);
3741 printf (_(" Section header string table index: %ld"),
3742 (long) elf_header.e_shstrndx);
3743 if (section_headers != NULL
3744 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3745 printf (" (%u)", section_headers[0].sh_link);
3746 else if (elf_header.e_shstrndx != SHN_UNDEF
3747 && elf_header.e_shstrndx >= elf_header.e_shnum)
3748 printf (_(" <corrupt: out of range>"));
3749 putc ('\n', stdout);
3750 }
3751
3752 if (section_headers != NULL)
3753 {
3754 if (elf_header.e_phnum == PN_XNUM
3755 && section_headers[0].sh_info != 0)
3756 elf_header.e_phnum = section_headers[0].sh_info;
3757 if (elf_header.e_shnum == SHN_UNDEF)
3758 elf_header.e_shnum = section_headers[0].sh_size;
3759 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3760 elf_header.e_shstrndx = section_headers[0].sh_link;
3761 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3762 elf_header.e_shstrndx = SHN_UNDEF;
3763 free (section_headers);
3764 section_headers = NULL;
3765 }
3766
3767 return 1;
3768}
3769
3770
3771static int
3772get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3773{
3774 Elf32_External_Phdr * phdrs;
3775 Elf32_External_Phdr * external;
3776 Elf_Internal_Phdr * internal;
3777 unsigned int i;
3778
3779 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3780 elf_header.e_phentsize,
3781 elf_header.e_phnum,
3782 _("program headers"));
3783 if (!phdrs)
3784 return 0;
3785
3786 for (i = 0, internal = pheaders, external = phdrs;
3787 i < elf_header.e_phnum;
3788 i++, internal++, external++)
3789 {
3790 internal->p_type = BYTE_GET (external->p_type);
3791 internal->p_offset = BYTE_GET (external->p_offset);
3792 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3793 internal->p_paddr = BYTE_GET (external->p_paddr);
3794 internal->p_filesz = BYTE_GET (external->p_filesz);
3795 internal->p_memsz = BYTE_GET (external->p_memsz);
3796 internal->p_flags = BYTE_GET (external->p_flags);
3797 internal->p_align = BYTE_GET (external->p_align);
3798 }
3799
3800 free (phdrs);
3801
3802 return 1;
3803}
3804
3805static int
3806get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3807{
3808 Elf64_External_Phdr * phdrs;
3809 Elf64_External_Phdr * external;
3810 Elf_Internal_Phdr * internal;
3811 unsigned int i;
3812
3813 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3814 elf_header.e_phentsize,
3815 elf_header.e_phnum,
3816 _("program headers"));
3817 if (!phdrs)
3818 return 0;
3819
3820 for (i = 0, internal = pheaders, external = phdrs;
3821 i < elf_header.e_phnum;
3822 i++, internal++, external++)
3823 {
3824 internal->p_type = BYTE_GET (external->p_type);
3825 internal->p_flags = BYTE_GET (external->p_flags);
3826 internal->p_offset = BYTE_GET (external->p_offset);
3827 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3828 internal->p_paddr = BYTE_GET (external->p_paddr);
3829 internal->p_filesz = BYTE_GET (external->p_filesz);
3830 internal->p_memsz = BYTE_GET (external->p_memsz);
3831 internal->p_align = BYTE_GET (external->p_align);
3832 }
3833
3834 free (phdrs);
3835
3836 return 1;
3837}
3838
3839/* Returns 1 if the program headers were read into `program_headers'. */
3840
3841static int
3842get_program_headers (FILE * file)
3843{
3844 Elf_Internal_Phdr * phdrs;
3845
3846 /* Check cache of prior read. */
3847 if (program_headers != NULL)
3848 return 1;
3849
3850 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3851 sizeof (Elf_Internal_Phdr));
3852
3853 if (phdrs == NULL)
3854 {
3855 error (_("Out of memory\n"));
3856 return 0;
3857 }
3858
3859 if (is_32bit_elf
3860 ? get_32bit_program_headers (file, phdrs)
3861 : get_64bit_program_headers (file, phdrs))
3862 {
3863 program_headers = phdrs;
3864 return 1;
3865 }
3866
3867 free (phdrs);
3868 return 0;
3869}
3870
3871/* Returns 1 if the program headers were loaded. */
3872
3873static int
3874process_program_headers (FILE * file)
3875{
3876 Elf_Internal_Phdr * segment;
3877 unsigned int i;
3878
3879 if (elf_header.e_phnum == 0)
3880 {
3881 /* PR binutils/12467. */
3882 if (elf_header.e_phoff != 0)
3883 warn (_("possibly corrupt ELF header - it has a non-zero program"
3884 " header offset, but no program headers"));
3885 else if (do_segments)
3886 printf (_("\nThere are no program headers in this file.\n"));
3887 return 0;
3888 }
3889
3890 if (do_segments && !do_header)
3891 {
3892 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3893 printf (_("Entry point "));
3894 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3895 printf (_("\nThere are %d program headers, starting at offset "),
3896 elf_header.e_phnum);
3897 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3898 printf ("\n");
3899 }
3900
3901 if (! get_program_headers (file))
3902 return 0;
3903
3904 if (do_segments)
3905 {
3906 if (elf_header.e_phnum > 1)
3907 printf (_("\nProgram Headers:\n"));
3908 else
3909 printf (_("\nProgram Headers:\n"));
3910
3911 if (is_32bit_elf)
3912 printf
3913 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3914 else if (do_wide)
3915 printf
3916 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3917 else
3918 {
3919 printf
3920 (_(" Type Offset VirtAddr PhysAddr\n"));
3921 printf
3922 (_(" FileSiz MemSiz Flags Align\n"));
3923 }
3924 }
3925
3926 dynamic_addr = 0;
3927 dynamic_size = 0;
3928
3929 for (i = 0, segment = program_headers;
3930 i < elf_header.e_phnum;
3931 i++, segment++)
3932 {
3933 if (do_segments)
3934 {
3935 printf (" %-14.14s ", get_segment_type (segment->p_type));
3936
3937 if (is_32bit_elf)
3938 {
3939 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3940 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3941 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3942 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3943 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3944 printf ("%c%c%c ",
3945 (segment->p_flags & PF_R ? 'R' : ' '),
3946 (segment->p_flags & PF_W ? 'W' : ' '),
3947 (segment->p_flags & PF_X ? 'E' : ' '));
3948 printf ("%#lx", (unsigned long) segment->p_align);
3949 }
3950 else if (do_wide)
3951 {
3952 if ((unsigned long) segment->p_offset == segment->p_offset)
3953 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3954 else
3955 {
3956 print_vma (segment->p_offset, FULL_HEX);
3957 putchar (' ');
3958 }
3959
3960 print_vma (segment->p_vaddr, FULL_HEX);
3961 putchar (' ');
3962 print_vma (segment->p_paddr, FULL_HEX);
3963 putchar (' ');
3964
3965 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3966 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3967 else
3968 {
3969 print_vma (segment->p_filesz, FULL_HEX);
3970 putchar (' ');
3971 }
3972
3973 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3974 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3975 else
3976 {
3977 print_vma (segment->p_memsz, FULL_HEX);
3978 }
3979
3980 printf (" %c%c%c ",
3981 (segment->p_flags & PF_R ? 'R' : ' '),
3982 (segment->p_flags & PF_W ? 'W' : ' '),
3983 (segment->p_flags & PF_X ? 'E' : ' '));
3984
3985 if ((unsigned long) segment->p_align == segment->p_align)
3986 printf ("%#lx", (unsigned long) segment->p_align);
3987 else
3988 {
3989 print_vma (segment->p_align, PREFIX_HEX);
3990 }
3991 }
3992 else
3993 {
3994 print_vma (segment->p_offset, FULL_HEX);
3995 putchar (' ');
3996 print_vma (segment->p_vaddr, FULL_HEX);
3997 putchar (' ');
3998 print_vma (segment->p_paddr, FULL_HEX);
3999 printf ("\n ");
4000 print_vma (segment->p_filesz, FULL_HEX);
4001 putchar (' ');
4002 print_vma (segment->p_memsz, FULL_HEX);
4003 printf (" %c%c%c ",
4004 (segment->p_flags & PF_R ? 'R' : ' '),
4005 (segment->p_flags & PF_W ? 'W' : ' '),
4006 (segment->p_flags & PF_X ? 'E' : ' '));
4007 print_vma (segment->p_align, HEX);
4008 }
4009 }
4010
4011 switch (segment->p_type)
4012 {
4013 case PT_DYNAMIC:
4014 if (dynamic_addr)
4015 error (_("more than one dynamic segment\n"));
4016
4017 /* By default, assume that the .dynamic section is the first
4018 section in the DYNAMIC segment. */
4019 dynamic_addr = segment->p_offset;
4020 dynamic_size = segment->p_filesz;
4021
4022 /* Try to locate the .dynamic section. If there is
4023 a section header table, we can easily locate it. */
4024 if (section_headers != NULL)
4025 {
4026 Elf_Internal_Shdr * sec;
4027
4028 sec = find_section (".dynamic");
4029 if (sec == NULL || sec->sh_size == 0)
4030 {
4031 /* A corresponding .dynamic section is expected, but on
4032 IA-64/OpenVMS it is OK for it to be missing. */
4033 if (!is_ia64_vms ())
4034 error (_("no .dynamic section in the dynamic segment\n"));
4035 break;
4036 }
4037
4038 if (sec->sh_type == SHT_NOBITS)
4039 {
4040 dynamic_size = 0;
4041 break;
4042 }
4043
4044 dynamic_addr = sec->sh_offset;
4045 dynamic_size = sec->sh_size;
4046
4047 if (dynamic_addr < segment->p_offset
4048 || dynamic_addr > segment->p_offset + segment->p_filesz)
4049 warn (_("the .dynamic section is not contained"
4050 " within the dynamic segment\n"));
4051 else if (dynamic_addr > segment->p_offset)
4052 warn (_("the .dynamic section is not the first section"
4053 " in the dynamic segment.\n"));
4054 }
4055 break;
4056
4057 case PT_INTERP:
4058 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4059 SEEK_SET))
4060 error (_("Unable to find program interpreter name\n"));
4061 else
4062 {
4063 char fmt [32];
4064 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4065
4066 if (ret >= (int) sizeof (fmt) || ret < 0)
4067 error (_("Internal error: failed to create format string to display program interpreter\n"));
4068
4069 program_interpreter[0] = 0;
4070 if (fscanf (file, fmt, program_interpreter) <= 0)
4071 error (_("Unable to read program interpreter name\n"));
4072
4073 if (do_segments)
4074 printf (_("\n [Requesting program interpreter: %s]"),
4075 program_interpreter);
4076 }
4077 break;
4078 }
4079
4080 if (do_segments)
4081 putc ('\n', stdout);
4082 }
4083
4084 if (do_segments && section_headers != NULL && string_table != NULL)
4085 {
4086 printf (_("\n Section to Segment mapping:\n"));
4087 printf (_(" Segment Sections...\n"));
4088
4089 for (i = 0; i < elf_header.e_phnum; i++)
4090 {
4091 unsigned int j;
4092 Elf_Internal_Shdr * section;
4093
4094 segment = program_headers + i;
4095 section = section_headers + 1;
4096
4097 printf (" %2.2d ", i);
4098
4099 for (j = 1; j < elf_header.e_shnum; j++, section++)
4100 {
4101 if (!ELF_TBSS_SPECIAL (section, segment)
4102 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4103 printf ("%s ", SECTION_NAME (section));
4104 }
4105
4106 putc ('\n',stdout);
4107 }
4108 }
4109
4110 return 1;
4111}
4112
4113
4114/* Find the file offset corresponding to VMA by using the program headers. */
4115
4116static long
4117offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4118{
4119 Elf_Internal_Phdr * seg;
4120
4121 if (! get_program_headers (file))
4122 {
4123 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4124 return (long) vma;
4125 }
4126
4127 for (seg = program_headers;
4128 seg < program_headers + elf_header.e_phnum;
4129 ++seg)
4130 {
4131 if (seg->p_type != PT_LOAD)
4132 continue;
4133
4134 if (vma >= (seg->p_vaddr & -seg->p_align)
4135 && vma + size <= seg->p_vaddr + seg->p_filesz)
4136 return vma - seg->p_vaddr + seg->p_offset;
4137 }
4138
4139 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4140 (unsigned long) vma);
4141 return (long) vma;
4142}
4143
4144
4145static int
4146get_32bit_section_headers (FILE * file, unsigned int num)
4147{
4148 Elf32_External_Shdr * shdrs;
4149 Elf_Internal_Shdr * internal;
4150 unsigned int i;
4151
4152 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4153 elf_header.e_shentsize, num,
4154 _("section headers"));
4155 if (!shdrs)
4156 return 0;
4157
4158 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4159 sizeof (Elf_Internal_Shdr));
4160
4161 if (section_headers == NULL)
4162 {
4163 error (_("Out of memory\n"));
4164 return 0;
4165 }
4166
4167 for (i = 0, internal = section_headers;
4168 i < num;
4169 i++, internal++)
4170 {
4171 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4172 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4173 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4174 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4175 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4176 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4177 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4178 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4179 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4180 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4181 }
4182
4183 free (shdrs);
4184
4185 return 1;
4186}
4187
4188static int
4189get_64bit_section_headers (FILE * file, unsigned int num)
4190{
4191 Elf64_External_Shdr * shdrs;
4192 Elf_Internal_Shdr * internal;
4193 unsigned int i;
4194
4195 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4196 elf_header.e_shentsize, num,
4197 _("section headers"));
4198 if (!shdrs)
4199 return 0;
4200
4201 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4202 sizeof (Elf_Internal_Shdr));
4203
4204 if (section_headers == NULL)
4205 {
4206 error (_("Out of memory\n"));
4207 return 0;
4208 }
4209
4210 for (i = 0, internal = section_headers;
4211 i < num;
4212 i++, internal++)
4213 {
4214 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4215 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4216 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4217 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4218 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4219 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4220 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4221 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4222 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4223 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4224 }
4225
4226 free (shdrs);
4227
4228 return 1;
4229}
4230
4231static Elf_Internal_Sym *
4232get_32bit_elf_symbols (FILE * file,
4233 Elf_Internal_Shdr * section,
4234 unsigned long * num_syms_return)
4235{
4236 unsigned long number = 0;
4237 Elf32_External_Sym * esyms = NULL;
4238 Elf_External_Sym_Shndx * shndx = NULL;
4239 Elf_Internal_Sym * isyms = NULL;
4240 Elf_Internal_Sym * psym;
4241 unsigned int j;
4242
4243 /* Run some sanity checks first. */
4244 if (section->sh_entsize == 0)
4245 {
4246 error (_("sh_entsize is zero\n"));
4247 goto exit_point;
4248 }
4249
4250 number = section->sh_size / section->sh_entsize;
4251
4252 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4253 {
4254 error (_("Invalid sh_entsize\n"));
4255 goto exit_point;
4256 }
4257
4258 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4259 section->sh_size, _("symbols"));
4260 if (esyms == NULL)
4261 goto exit_point;
4262
4263 shndx = NULL;
4264 if (symtab_shndx_hdr != NULL
4265 && (symtab_shndx_hdr->sh_link
4266 == (unsigned long) (section - section_headers)))
4267 {
4268 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4269 symtab_shndx_hdr->sh_offset,
4270 1, symtab_shndx_hdr->sh_size,
4271 _("symbol table section indicies"));
4272 if (shndx == NULL)
4273 goto exit_point;
4274 }
4275
4276 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4277
4278 if (isyms == NULL)
4279 {
4280 error (_("Out of memory\n"));
4281 goto exit_point;
4282 }
4283
4284 for (j = 0, psym = isyms; j < number; j++, psym++)
4285 {
4286 psym->st_name = BYTE_GET (esyms[j].st_name);
4287 psym->st_value = BYTE_GET (esyms[j].st_value);
4288 psym->st_size = BYTE_GET (esyms[j].st_size);
4289 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4290 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4291 psym->st_shndx
4292 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4293 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4294 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4295 psym->st_info = BYTE_GET (esyms[j].st_info);
4296 psym->st_other = BYTE_GET (esyms[j].st_other);
4297 }
4298
4299 exit_point:
4300 if (shndx != NULL)
4301 free (shndx);
4302 if (esyms != NULL)
4303 free (esyms);
4304
4305 if (num_syms_return != NULL)
4306 * num_syms_return = isyms == NULL ? 0 : number;
4307
4308 return isyms;
4309}
4310
4311static Elf_Internal_Sym *
4312get_64bit_elf_symbols (FILE * file,
4313 Elf_Internal_Shdr * section,
4314 unsigned long * num_syms_return)
4315{
4316 unsigned long number = 0;
4317 Elf64_External_Sym * esyms = NULL;
4318 Elf_External_Sym_Shndx * shndx = NULL;
4319 Elf_Internal_Sym * isyms = NULL;
4320 Elf_Internal_Sym * psym;
4321 unsigned int j;
4322
4323 /* Run some sanity checks first. */
4324 if (section->sh_entsize == 0)
4325 {
4326 error (_("sh_entsize is zero\n"));
4327 goto exit_point;
4328 }
4329
4330 number = section->sh_size / section->sh_entsize;
4331
4332 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4333 {
4334 error (_("Invalid sh_entsize\n"));
4335 goto exit_point;
4336 }
4337
4338 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4339 section->sh_size, _("symbols"));
4340 if (!esyms)
4341 goto exit_point;
4342
4343 if (symtab_shndx_hdr != NULL
4344 && (symtab_shndx_hdr->sh_link
4345 == (unsigned long) (section - section_headers)))
4346 {
4347 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4348 symtab_shndx_hdr->sh_offset,
4349 1, symtab_shndx_hdr->sh_size,
4350 _("symbol table section indicies"));
4351 if (shndx == NULL)
4352 goto exit_point;
4353 }
4354
4355 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4356
4357 if (isyms == NULL)
4358 {
4359 error (_("Out of memory\n"));
4360 goto exit_point;
4361 }
4362
4363 for (j = 0, psym = isyms; j < number; j++, psym++)
4364 {
4365 psym->st_name = BYTE_GET (esyms[j].st_name);
4366 psym->st_info = BYTE_GET (esyms[j].st_info);
4367 psym->st_other = BYTE_GET (esyms[j].st_other);
4368 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4369
4370 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4371 psym->st_shndx
4372 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4373 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4374 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4375
4376 psym->st_value = BYTE_GET (esyms[j].st_value);
4377 psym->st_size = BYTE_GET (esyms[j].st_size);
4378 }
4379
4380 exit_point:
4381 if (shndx != NULL)
4382 free (shndx);
4383 if (esyms != NULL)
4384 free (esyms);
4385
4386 if (num_syms_return != NULL)
4387 * num_syms_return = isyms == NULL ? 0 : number;
4388
4389 return isyms;
4390}
4391
4392static const char *
4393get_elf_section_flags (bfd_vma sh_flags)
4394{
4395 static char buff[1024];
4396 char * p = buff;
4397 int field_size = is_32bit_elf ? 8 : 16;
4398 int sindex;
4399 int size = sizeof (buff) - (field_size + 4 + 1);
4400 bfd_vma os_flags = 0;
4401 bfd_vma proc_flags = 0;
4402 bfd_vma unknown_flags = 0;
4403 static const struct
4404 {
4405 const char * str;
4406 int len;
4407 }
4408 flags [] =
4409 {
4410 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4411 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4412 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4413 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4414 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4415 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4416 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4417 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4418 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4419 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4420 /* IA-64 specific. */
4421 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4422 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4423 /* IA-64 OpenVMS specific. */
4424 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4425 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4426 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4427 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4428 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4429 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4430 /* Generic. */
4431 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4432 /* SPARC specific. */
4433 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4434 };
4435
4436 if (do_section_details)
4437 {
4438 sprintf (buff, "[%*.*lx]: ",
4439 field_size, field_size, (unsigned long) sh_flags);
4440 p += field_size + 4;
4441 }
4442
4443 while (sh_flags)
4444 {
4445 bfd_vma flag;
4446
4447 flag = sh_flags & - sh_flags;
4448 sh_flags &= ~ flag;
4449
4450 if (do_section_details)
4451 {
4452 switch (flag)
4453 {
4454 case SHF_WRITE: sindex = 0; break;
4455 case SHF_ALLOC: sindex = 1; break;
4456 case SHF_EXECINSTR: sindex = 2; break;
4457 case SHF_MERGE: sindex = 3; break;
4458 case SHF_STRINGS: sindex = 4; break;
4459 case SHF_INFO_LINK: sindex = 5; break;
4460 case SHF_LINK_ORDER: sindex = 6; break;
4461 case SHF_OS_NONCONFORMING: sindex = 7; break;
4462 case SHF_GROUP: sindex = 8; break;
4463 case SHF_TLS: sindex = 9; break;
4464 case SHF_EXCLUDE: sindex = 18; break;
4465
4466 default:
4467 sindex = -1;
4468 switch (elf_header.e_machine)
4469 {
4470 case EM_IA_64:
4471 if (flag == SHF_IA_64_SHORT)
4472 sindex = 10;
4473 else if (flag == SHF_IA_64_NORECOV)
4474 sindex = 11;
4475#ifdef BFD64
4476 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4477 switch (flag)
4478 {
4479 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4480 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4481 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4482 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4483 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4484 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4485 default: break;
4486 }
4487#endif
4488 break;
4489
4490 case EM_386:
4491 case EM_486:
4492 case EM_X86_64:
4493 case EM_L1OM:
4494 case EM_K1OM:
4495 case EM_OLD_SPARCV9:
4496 case EM_SPARC32PLUS:
4497 case EM_SPARCV9:
4498 case EM_SPARC:
4499 if (flag == SHF_ORDERED)
4500 sindex = 19;
4501 break;
4502 default:
4503 break;
4504 }
4505 }
4506
4507 if (sindex != -1)
4508 {
4509 if (p != buff + field_size + 4)
4510 {
4511 if (size < (10 + 2))
4512 abort ();
4513 size -= 2;
4514 *p++ = ',';
4515 *p++ = ' ';
4516 }
4517
4518 size -= flags [sindex].len;
4519 p = stpcpy (p, flags [sindex].str);
4520 }
4521 else if (flag & SHF_MASKOS)
4522 os_flags |= flag;
4523 else if (flag & SHF_MASKPROC)
4524 proc_flags |= flag;
4525 else
4526 unknown_flags |= flag;
4527 }
4528 else
4529 {
4530 switch (flag)
4531 {
4532 case SHF_WRITE: *p = 'W'; break;
4533 case SHF_ALLOC: *p = 'A'; break;
4534 case SHF_EXECINSTR: *p = 'X'; break;
4535 case SHF_MERGE: *p = 'M'; break;
4536 case SHF_STRINGS: *p = 'S'; break;
4537 case SHF_INFO_LINK: *p = 'I'; break;
4538 case SHF_LINK_ORDER: *p = 'L'; break;
4539 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4540 case SHF_GROUP: *p = 'G'; break;
4541 case SHF_TLS: *p = 'T'; break;
4542 case SHF_EXCLUDE: *p = 'E'; break;
4543
4544 default:
4545 if ((elf_header.e_machine == EM_X86_64
4546 || elf_header.e_machine == EM_L1OM
4547 || elf_header.e_machine == EM_K1OM)
4548 && flag == SHF_X86_64_LARGE)
4549 *p = 'l';
4550 else if (flag & SHF_MASKOS)
4551 {
4552 *p = 'o';
4553 sh_flags &= ~ SHF_MASKOS;
4554 }
4555 else if (flag & SHF_MASKPROC)
4556 {
4557 *p = 'p';
4558 sh_flags &= ~ SHF_MASKPROC;
4559 }
4560 else
4561 *p = 'x';
4562 break;
4563 }
4564 p++;
4565 }
4566 }
4567
4568 if (do_section_details)
4569 {
4570 if (os_flags)
4571 {
4572 size -= 5 + field_size;
4573 if (p != buff + field_size + 4)
4574 {
4575 if (size < (2 + 1))
4576 abort ();
4577 size -= 2;
4578 *p++ = ',';
4579 *p++ = ' ';
4580 }
4581 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4582 (unsigned long) os_flags);
4583 p += 5 + field_size;
4584 }
4585 if (proc_flags)
4586 {
4587 size -= 7 + field_size;
4588 if (p != buff + field_size + 4)
4589 {
4590 if (size < (2 + 1))
4591 abort ();
4592 size -= 2;
4593 *p++ = ',';
4594 *p++ = ' ';
4595 }
4596 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4597 (unsigned long) proc_flags);
4598 p += 7 + field_size;
4599 }
4600 if (unknown_flags)
4601 {
4602 size -= 10 + field_size;
4603 if (p != buff + field_size + 4)
4604 {
4605 if (size < (2 + 1))
4606 abort ();
4607 size -= 2;
4608 *p++ = ',';
4609 *p++ = ' ';
4610 }
4611 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4612 (unsigned long) unknown_flags);
4613 p += 10 + field_size;
4614 }
4615 }
4616
4617 *p = '\0';
4618 return buff;
4619}
4620
4621static int
4622process_section_headers (FILE * file)
4623{
4624 Elf_Internal_Shdr * section;
4625 unsigned int i;
4626
4627 section_headers = NULL;
4628
4629 if (elf_header.e_shnum == 0)
4630 {
4631 /* PR binutils/12467. */
4632 if (elf_header.e_shoff != 0)
4633 warn (_("possibly corrupt ELF file header - it has a non-zero"
4634 " section header offset, but no section headers\n"));
4635 else if (do_sections)
4636 printf (_("\nThere are no sections in this file.\n"));
4637
4638 return 1;
4639 }
4640
4641 if (do_sections && !do_header)
4642 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4643 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4644
4645 if (is_32bit_elf)
4646 {
4647 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4648 return 0;
4649 }
4650 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4651 return 0;
4652
4653 /* Read in the string table, so that we have names to display. */
4654 if (elf_header.e_shstrndx != SHN_UNDEF
4655 && elf_header.e_shstrndx < elf_header.e_shnum)
4656 {
4657 section = section_headers + elf_header.e_shstrndx;
4658
4659 if (section->sh_size != 0)
4660 {
4661 string_table = (char *) get_data (NULL, file, section->sh_offset,
4662 1, section->sh_size,
4663 _("string table"));
4664
4665 string_table_length = string_table != NULL ? section->sh_size : 0;
4666 }
4667 }
4668
4669 /* Scan the sections for the dynamic symbol table
4670 and dynamic string table and debug sections. */
4671 dynamic_symbols = NULL;
4672 dynamic_strings = NULL;
4673 dynamic_syminfo = NULL;
4674 symtab_shndx_hdr = NULL;
4675
4676 eh_addr_size = is_32bit_elf ? 4 : 8;
4677 switch (elf_header.e_machine)
4678 {
4679 case EM_MIPS:
4680 case EM_MIPS_RS3_LE:
4681 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4682 FDE addresses. However, the ABI also has a semi-official ILP32
4683 variant for which the normal FDE address size rules apply.
4684
4685 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4686 section, where XX is the size of longs in bits. Unfortunately,
4687 earlier compilers provided no way of distinguishing ILP32 objects
4688 from LP64 objects, so if there's any doubt, we should assume that
4689 the official LP64 form is being used. */
4690 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4691 && find_section (".gcc_compiled_long32") == NULL)
4692 eh_addr_size = 8;
4693 break;
4694
4695 case EM_H8_300:
4696 case EM_H8_300H:
4697 switch (elf_header.e_flags & EF_H8_MACH)
4698 {
4699 case E_H8_MACH_H8300:
4700 case E_H8_MACH_H8300HN:
4701 case E_H8_MACH_H8300SN:
4702 case E_H8_MACH_H8300SXN:
4703 eh_addr_size = 2;
4704 break;
4705 case E_H8_MACH_H8300H:
4706 case E_H8_MACH_H8300S:
4707 case E_H8_MACH_H8300SX:
4708 eh_addr_size = 4;
4709 break;
4710 }
4711 break;
4712
4713 case EM_M32C_OLD:
4714 case EM_M32C:
4715 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4716 {
4717 case EF_M32C_CPU_M16C:
4718 eh_addr_size = 2;
4719 break;
4720 }
4721 break;
4722 }
4723
4724#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4725 do \
4726 { \
4727 size_t expected_entsize \
4728 = is_32bit_elf ? size32 : size64; \
4729 if (section->sh_entsize != expected_entsize) \
4730 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4731 i, (unsigned long int) section->sh_entsize, \
4732 (unsigned long int) expected_entsize); \
4733 section->sh_entsize = expected_entsize; \
4734 } \
4735 while (0)
4736#define CHECK_ENTSIZE(section, i, type) \
4737 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4738 sizeof (Elf64_External_##type))
4739
4740 for (i = 0, section = section_headers;
4741 i < elf_header.e_shnum;
4742 i++, section++)
4743 {
4744 char * name = SECTION_NAME (section);
4745
4746 if (section->sh_type == SHT_DYNSYM)
4747 {
4748 if (dynamic_symbols != NULL)
4749 {
4750 error (_("File contains multiple dynamic symbol tables\n"));
4751 continue;
4752 }
4753
4754 CHECK_ENTSIZE (section, i, Sym);
4755 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
4756 }
4757 else if (section->sh_type == SHT_STRTAB
4758 && streq (name, ".dynstr"))
4759 {
4760 if (dynamic_strings != NULL)
4761 {
4762 error (_("File contains multiple dynamic string tables\n"));
4763 continue;
4764 }
4765
4766 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4767 1, section->sh_size,
4768 _("dynamic strings"));
4769 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4770 }
4771 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4772 {
4773 if (symtab_shndx_hdr != NULL)
4774 {
4775 error (_("File contains multiple symtab shndx tables\n"));
4776 continue;
4777 }
4778 symtab_shndx_hdr = section;
4779 }
4780 else if (section->sh_type == SHT_SYMTAB)
4781 CHECK_ENTSIZE (section, i, Sym);
4782 else if (section->sh_type == SHT_GROUP)
4783 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4784 else if (section->sh_type == SHT_REL)
4785 CHECK_ENTSIZE (section, i, Rel);
4786 else if (section->sh_type == SHT_RELA)
4787 CHECK_ENTSIZE (section, i, Rela);
4788 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4789 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4790 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4791 || do_debug_str || do_debug_loc || do_debug_ranges
4792 || do_debug_addr || do_debug_cu_index)
4793 && (const_strneq (name, ".debug_")
4794 || const_strneq (name, ".zdebug_")))
4795 {
4796 if (name[1] == 'z')
4797 name += sizeof (".zdebug_") - 1;
4798 else
4799 name += sizeof (".debug_") - 1;
4800
4801 if (do_debugging
4802 || (do_debug_info && const_strneq (name, "info"))
4803 || (do_debug_info && const_strneq (name, "types"))
4804 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
4805 || (do_debug_lines && const_strneq (name, "line"))
4806 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4807 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4808 || (do_debug_aranges && const_strneq (name, "aranges"))
4809 || (do_debug_ranges && const_strneq (name, "ranges"))
4810 || (do_debug_frames && const_strneq (name, "frame"))
4811 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4812 || (do_debug_macinfo && const_strneq (name, "macro"))
4813 || (do_debug_str && const_strneq (name, "str"))
4814 || (do_debug_loc && const_strneq (name, "loc"))
4815 || (do_debug_addr && const_strneq (name, "addr"))
4816 || (do_debug_cu_index && const_strneq (name, "cu_index"))
4817 || (do_debug_cu_index && const_strneq (name, "tu_index"))
4818 )
4819 request_dump_bynumber (i, DEBUG_DUMP);
4820 }
4821 /* Linkonce section to be combined with .debug_info at link time. */
4822 else if ((do_debugging || do_debug_info)
4823 && const_strneq (name, ".gnu.linkonce.wi."))
4824 request_dump_bynumber (i, DEBUG_DUMP);
4825 else if (do_debug_frames && streq (name, ".eh_frame"))
4826 request_dump_bynumber (i, DEBUG_DUMP);
4827 else if (do_gdb_index && streq (name, ".gdb_index"))
4828 request_dump_bynumber (i, DEBUG_DUMP);
4829 /* Trace sections for Itanium VMS. */
4830 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4831 || do_trace_aranges)
4832 && const_strneq (name, ".trace_"))
4833 {
4834 name += sizeof (".trace_") - 1;
4835
4836 if (do_debugging
4837 || (do_trace_info && streq (name, "info"))
4838 || (do_trace_abbrevs && streq (name, "abbrev"))
4839 || (do_trace_aranges && streq (name, "aranges"))
4840 )
4841 request_dump_bynumber (i, DEBUG_DUMP);
4842 }
4843
4844 }
4845
4846 if (! do_sections)
4847 return 1;
4848
4849 if (elf_header.e_shnum > 1)
4850 printf (_("\nSection Headers:\n"));
4851 else
4852 printf (_("\nSection Header:\n"));
4853
4854 if (is_32bit_elf)
4855 {
4856 if (do_section_details)
4857 {
4858 printf (_(" [Nr] Name\n"));
4859 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4860 }
4861 else
4862 printf
4863 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4864 }
4865 else if (do_wide)
4866 {
4867 if (do_section_details)
4868 {
4869 printf (_(" [Nr] Name\n"));
4870 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4871 }
4872 else
4873 printf
4874 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4875 }
4876 else
4877 {
4878 if (do_section_details)
4879 {
4880 printf (_(" [Nr] Name\n"));
4881 printf (_(" Type Address Offset Link\n"));
4882 printf (_(" Size EntSize Info Align\n"));
4883 }
4884 else
4885 {
4886 printf (_(" [Nr] Name Type Address Offset\n"));
4887 printf (_(" Size EntSize Flags Link Info Align\n"));
4888 }
4889 }
4890
4891 if (do_section_details)
4892 printf (_(" Flags\n"));
4893
4894 for (i = 0, section = section_headers;
4895 i < elf_header.e_shnum;
4896 i++, section++)
4897 {
4898 printf (" [%2u] ", i);
4899 if (do_section_details)
4900 {
4901 print_symbol (INT_MAX, SECTION_NAME (section));
4902 printf ("\n ");
4903 }
4904 else
4905 {
4906 print_symbol (-17, SECTION_NAME (section));
4907 }
4908
4909 printf (do_wide ? " %-15s " : " %-15.15s ",
4910 get_section_type_name (section->sh_type));
4911
4912 if (is_32bit_elf)
4913 {
4914 const char * link_too_big = NULL;
4915
4916 print_vma (section->sh_addr, LONG_HEX);
4917
4918 printf ( " %6.6lx %6.6lx %2.2lx",
4919 (unsigned long) section->sh_offset,
4920 (unsigned long) section->sh_size,
4921 (unsigned long) section->sh_entsize);
4922
4923 if (do_section_details)
4924 fputs (" ", stdout);
4925 else
4926 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4927
4928 if (section->sh_link >= elf_header.e_shnum)
4929 {
4930 link_too_big = "";
4931 /* The sh_link value is out of range. Normally this indicates
4932 an error but it can have special values in Solaris binaries. */
4933 switch (elf_header.e_machine)
4934 {
4935 case EM_386:
4936 case EM_486:
4937 case EM_X86_64:
4938 case EM_L1OM:
4939 case EM_K1OM:
4940 case EM_OLD_SPARCV9:
4941 case EM_SPARC32PLUS:
4942 case EM_SPARCV9:
4943 case EM_SPARC:
4944 if (section->sh_link == (SHN_BEFORE & 0xffff))
4945 link_too_big = "BEFORE";
4946 else if (section->sh_link == (SHN_AFTER & 0xffff))
4947 link_too_big = "AFTER";
4948 break;
4949 default:
4950 break;
4951 }
4952 }
4953
4954 if (do_section_details)
4955 {
4956 if (link_too_big != NULL && * link_too_big)
4957 printf ("<%s> ", link_too_big);
4958 else
4959 printf ("%2u ", section->sh_link);
4960 printf ("%3u %2lu\n", section->sh_info,
4961 (unsigned long) section->sh_addralign);
4962 }
4963 else
4964 printf ("%2u %3u %2lu\n",
4965 section->sh_link,
4966 section->sh_info,
4967 (unsigned long) section->sh_addralign);
4968
4969 if (link_too_big && ! * link_too_big)
4970 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4971 i, section->sh_link);
4972 }
4973 else if (do_wide)
4974 {
4975 print_vma (section->sh_addr, LONG_HEX);
4976
4977 if ((long) section->sh_offset == section->sh_offset)
4978 printf (" %6.6lx", (unsigned long) section->sh_offset);
4979 else
4980 {
4981 putchar (' ');
4982 print_vma (section->sh_offset, LONG_HEX);
4983 }
4984
4985 if ((unsigned long) section->sh_size == section->sh_size)
4986 printf (" %6.6lx", (unsigned long) section->sh_size);
4987 else
4988 {
4989 putchar (' ');
4990 print_vma (section->sh_size, LONG_HEX);
4991 }
4992
4993 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4994 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4995 else
4996 {
4997 putchar (' ');
4998 print_vma (section->sh_entsize, LONG_HEX);
4999 }
5000
5001 if (do_section_details)
5002 fputs (" ", stdout);
5003 else
5004 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5005
5006 printf ("%2u %3u ", section->sh_link, section->sh_info);
5007
5008 if ((unsigned long) section->sh_addralign == section->sh_addralign)
5009 printf ("%2lu\n", (unsigned long) section->sh_addralign);
5010 else
5011 {
5012 print_vma (section->sh_addralign, DEC);
5013 putchar ('\n');
5014 }
5015 }
5016 else if (do_section_details)
5017 {
5018 printf (" %-15.15s ",
5019 get_section_type_name (section->sh_type));
5020 print_vma (section->sh_addr, LONG_HEX);
5021 if ((long) section->sh_offset == section->sh_offset)
5022 printf (" %16.16lx", (unsigned long) section->sh_offset);
5023 else
5024 {
5025 printf (" ");
5026 print_vma (section->sh_offset, LONG_HEX);
5027 }
5028 printf (" %u\n ", section->sh_link);
5029 print_vma (section->sh_size, LONG_HEX);
5030 putchar (' ');
5031 print_vma (section->sh_entsize, LONG_HEX);
5032
5033 printf (" %-16u %lu\n",
5034 section->sh_info,
5035 (unsigned long) section->sh_addralign);
5036 }
5037 else
5038 {
5039 putchar (' ');
5040 print_vma (section->sh_addr, LONG_HEX);
5041 if ((long) section->sh_offset == section->sh_offset)
5042 printf (" %8.8lx", (unsigned long) section->sh_offset);
5043 else
5044 {
5045 printf (" ");
5046 print_vma (section->sh_offset, LONG_HEX);
5047 }
5048 printf ("\n ");
5049 print_vma (section->sh_size, LONG_HEX);
5050 printf (" ");
5051 print_vma (section->sh_entsize, LONG_HEX);
5052
5053 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5054
5055 printf (" %2u %3u %lu\n",
5056 section->sh_link,
5057 section->sh_info,
5058 (unsigned long) section->sh_addralign);
5059 }
5060
5061 if (do_section_details)
5062 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5063 }
5064
5065 if (!do_section_details)
5066 {
5067 if (elf_header.e_machine == EM_X86_64
5068 || elf_header.e_machine == EM_L1OM
5069 || elf_header.e_machine == EM_K1OM)
5070 printf (_("Key to Flags:\n\
5071 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5072 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5073 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5074 else
5075 printf (_("Key to Flags:\n\
5076 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5077 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5078 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5079 }
5080
5081 return 1;
5082}
5083
5084static const char *
5085get_group_flags (unsigned int flags)
5086{
5087 static char buff[32];
5088 switch (flags)
5089 {
5090 case 0:
5091 return "";
5092
5093 case GRP_COMDAT:
5094 return "COMDAT ";
5095
5096 default:
5097 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5098 break;
5099 }
5100 return buff;
5101}
5102
5103static int
5104process_section_groups (FILE * file)
5105{
5106 Elf_Internal_Shdr * section;
5107 unsigned int i;
5108 struct group * group;
5109 Elf_Internal_Shdr * symtab_sec;
5110 Elf_Internal_Shdr * strtab_sec;
5111 Elf_Internal_Sym * symtab;
5112 unsigned long num_syms;
5113 char * strtab;
5114 size_t strtab_size;
5115
5116 /* Don't process section groups unless needed. */
5117 if (!do_unwind && !do_section_groups)
5118 return 1;
5119
5120 if (elf_header.e_shnum == 0)
5121 {
5122 if (do_section_groups)
5123 printf (_("\nThere are no sections to group in this file.\n"));
5124
5125 return 1;
5126 }
5127
5128 if (section_headers == NULL)
5129 {
5130 error (_("Section headers are not available!\n"));
5131 /* PR 13622: This can happen with a corrupt ELF header. */
5132 return 0;
5133 }
5134
5135 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5136 sizeof (struct group *));
5137
5138 if (section_headers_groups == NULL)
5139 {
5140 error (_("Out of memory\n"));
5141 return 0;
5142 }
5143
5144 /* Scan the sections for the group section. */
5145 group_count = 0;
5146 for (i = 0, section = section_headers;
5147 i < elf_header.e_shnum;
5148 i++, section++)
5149 if (section->sh_type == SHT_GROUP)
5150 group_count++;
5151
5152 if (group_count == 0)
5153 {
5154 if (do_section_groups)
5155 printf (_("\nThere are no section groups in this file.\n"));
5156
5157 return 1;
5158 }
5159
5160 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5161
5162 if (section_groups == NULL)
5163 {
5164 error (_("Out of memory\n"));
5165 return 0;
5166 }
5167
5168 symtab_sec = NULL;
5169 strtab_sec = NULL;
5170 symtab = NULL;
5171 num_syms = 0;
5172 strtab = NULL;
5173 strtab_size = 0;
5174 for (i = 0, section = section_headers, group = section_groups;
5175 i < elf_header.e_shnum;
5176 i++, section++)
5177 {
5178 if (section->sh_type == SHT_GROUP)
5179 {
5180 char * name = SECTION_NAME (section);
5181 char * group_name;
5182 unsigned char * start;
5183 unsigned char * indices;
5184 unsigned int entry, j, size;
5185 Elf_Internal_Shdr * sec;
5186 Elf_Internal_Sym * sym;
5187
5188 /* Get the symbol table. */
5189 if (section->sh_link >= elf_header.e_shnum
5190 || ((sec = section_headers + section->sh_link)->sh_type
5191 != SHT_SYMTAB))
5192 {
5193 error (_("Bad sh_link in group section `%s'\n"), name);
5194 continue;
5195 }
5196
5197 if (symtab_sec != sec)
5198 {
5199 symtab_sec = sec;
5200 if (symtab)
5201 free (symtab);
5202 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5203 }
5204
5205 if (symtab == NULL)
5206 {
5207 error (_("Corrupt header in group section `%s'\n"), name);
5208 continue;
5209 }
5210
5211 if (section->sh_info >= num_syms)
5212 {
5213 error (_("Bad sh_info in group section `%s'\n"), name);
5214 continue;
5215 }
5216
5217 sym = symtab + section->sh_info;
5218
5219 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5220 {
5221 if (sym->st_shndx == 0
5222 || sym->st_shndx >= elf_header.e_shnum)
5223 {
5224 error (_("Bad sh_info in group section `%s'\n"), name);
5225 continue;
5226 }
5227
5228 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5229 strtab_sec = NULL;
5230 if (strtab)
5231 free (strtab);
5232 strtab = NULL;
5233 strtab_size = 0;
5234 }
5235 else
5236 {
5237 /* Get the string table. */
5238 if (symtab_sec->sh_link >= elf_header.e_shnum)
5239 {
5240 strtab_sec = NULL;
5241 if (strtab)
5242 free (strtab);
5243 strtab = NULL;
5244 strtab_size = 0;
5245 }
5246 else if (strtab_sec
5247 != (sec = section_headers + symtab_sec->sh_link))
5248 {
5249 strtab_sec = sec;
5250 if (strtab)
5251 free (strtab);
5252 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5253 1, strtab_sec->sh_size,
5254 _("string table"));
5255 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5256 }
5257 group_name = sym->st_name < strtab_size
5258 ? strtab + sym->st_name : _("<corrupt>");
5259 }
5260
5261 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5262 1, section->sh_size,
5263 _("section data"));
5264 if (start == NULL)
5265 continue;
5266
5267 indices = start;
5268 size = (section->sh_size / section->sh_entsize) - 1;
5269 entry = byte_get (indices, 4);
5270 indices += 4;
5271
5272 if (do_section_groups)
5273 {
5274 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5275 get_group_flags (entry), i, name, group_name, size);
5276
5277 printf (_(" [Index] Name\n"));
5278 }
5279
5280 group->group_index = i;
5281
5282 for (j = 0; j < size; j++)
5283 {
5284 struct group_list * g;
5285
5286 entry = byte_get (indices, 4);
5287 indices += 4;
5288
5289 if (entry >= elf_header.e_shnum)
5290 {
5291 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5292 entry, i, elf_header.e_shnum - 1);
5293 continue;
5294 }
5295
5296 if (section_headers_groups [entry] != NULL)
5297 {
5298 if (entry)
5299 {
5300 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5301 entry, i,
5302 section_headers_groups [entry]->group_index);
5303 continue;
5304 }
5305 else
5306 {
5307 /* Intel C/C++ compiler may put section 0 in a
5308 section group. We just warn it the first time
5309 and ignore it afterwards. */
5310 static int warned = 0;
5311 if (!warned)
5312 {
5313 error (_("section 0 in group section [%5u]\n"),
5314 section_headers_groups [entry]->group_index);
5315 warned++;
5316 }
5317 }
5318 }
5319
5320 section_headers_groups [entry] = group;
5321
5322 if (do_section_groups)
5323 {
5324 sec = section_headers + entry;
5325 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5326 }
5327
5328 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5329 g->section_index = entry;
5330 g->next = group->root;
5331 group->root = g;
5332 }
5333
5334 if (start)
5335 free (start);
5336
5337 group++;
5338 }
5339 }
5340
5341 if (symtab)
5342 free (symtab);
5343 if (strtab)
5344 free (strtab);
5345 return 1;
5346}
5347
5348/* Data used to display dynamic fixups. */
5349
5350struct ia64_vms_dynfixup
5351{
5352 bfd_vma needed_ident; /* Library ident number. */
5353 bfd_vma needed; /* Index in the dstrtab of the library name. */
5354 bfd_vma fixup_needed; /* Index of the library. */
5355 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5356 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5357};
5358
5359/* Data used to display dynamic relocations. */
5360
5361struct ia64_vms_dynimgrela
5362{
5363 bfd_vma img_rela_cnt; /* Number of relocations. */
5364 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5365};
5366
5367/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5368 library). */
5369
5370static void
5371dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5372 const char *strtab, unsigned int strtab_sz)
5373{
5374 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5375 long i;
5376 const char *lib_name;
5377
5378 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5379 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5380 _("dynamic section image fixups"));
5381 if (!imfs)
5382 return;
5383
5384 if (fixup->needed < strtab_sz)
5385 lib_name = strtab + fixup->needed;
5386 else
5387 {
5388 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5389 (unsigned long) fixup->needed);
5390 lib_name = "???";
5391 }
5392 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5393 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5394 printf
5395 (_("Seg Offset Type SymVec DataType\n"));
5396
5397 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5398 {
5399 unsigned int type;
5400 const char *rtype;
5401
5402 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5403 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5404 type = BYTE_GET (imfs [i].type);
5405 rtype = elf_ia64_reloc_type (type);
5406 if (rtype == NULL)
5407 printf (" 0x%08x ", type);
5408 else
5409 printf (" %-32s ", rtype);
5410 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5411 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5412 }
5413
5414 free (imfs);
5415}
5416
5417/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5418
5419static void
5420dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5421{
5422 Elf64_External_VMS_IMAGE_RELA *imrs;
5423 long i;
5424
5425 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5426 1, imgrela->img_rela_cnt * sizeof (*imrs),
5427 _("dynamic section image relocations"));
5428 if (!imrs)
5429 return;
5430
5431 printf (_("\nImage relocs\n"));
5432 printf
5433 (_("Seg Offset Type Addend Seg Sym Off\n"));
5434
5435 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5436 {
5437 unsigned int type;
5438 const char *rtype;
5439
5440 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5441 printf ("%08" BFD_VMA_FMT "x ",
5442 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5443 type = BYTE_GET (imrs [i].type);
5444 rtype = elf_ia64_reloc_type (type);
5445 if (rtype == NULL)
5446 printf ("0x%08x ", type);
5447 else
5448 printf ("%-31s ", rtype);
5449 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5450 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5451 printf ("%08" BFD_VMA_FMT "x\n",
5452 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5453 }
5454
5455 free (imrs);
5456}
5457
5458/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5459
5460static int
5461process_ia64_vms_dynamic_relocs (FILE *file)
5462{
5463 struct ia64_vms_dynfixup fixup;
5464 struct ia64_vms_dynimgrela imgrela;
5465 Elf_Internal_Dyn *entry;
5466 int res = 0;
5467 bfd_vma strtab_off = 0;
5468 bfd_vma strtab_sz = 0;
5469 char *strtab = NULL;
5470
5471 memset (&fixup, 0, sizeof (fixup));
5472 memset (&imgrela, 0, sizeof (imgrela));
5473
5474 /* Note: the order of the entries is specified by the OpenVMS specs. */
5475 for (entry = dynamic_section;
5476 entry < dynamic_section + dynamic_nent;
5477 entry++)
5478 {
5479 switch (entry->d_tag)
5480 {
5481 case DT_IA_64_VMS_STRTAB_OFFSET:
5482 strtab_off = entry->d_un.d_val;
5483 break;
5484 case DT_STRSZ:
5485 strtab_sz = entry->d_un.d_val;
5486 if (strtab == NULL)
5487 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5488 1, strtab_sz, _("dynamic string section"));
5489 break;
5490
5491 case DT_IA_64_VMS_NEEDED_IDENT:
5492 fixup.needed_ident = entry->d_un.d_val;
5493 break;
5494 case DT_NEEDED:
5495 fixup.needed = entry->d_un.d_val;
5496 break;
5497 case DT_IA_64_VMS_FIXUP_NEEDED:
5498 fixup.fixup_needed = entry->d_un.d_val;
5499 break;
5500 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5501 fixup.fixup_rela_cnt = entry->d_un.d_val;
5502 break;
5503 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5504 fixup.fixup_rela_off = entry->d_un.d_val;
5505 res++;
5506 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5507 break;
5508
5509 case DT_IA_64_VMS_IMG_RELA_CNT:
5510 imgrela.img_rela_cnt = entry->d_un.d_val;
5511 break;
5512 case DT_IA_64_VMS_IMG_RELA_OFF:
5513 imgrela.img_rela_off = entry->d_un.d_val;
5514 res++;
5515 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5516 break;
5517
5518 default:
5519 break;
5520 }
5521 }
5522
5523 if (strtab != NULL)
5524 free (strtab);
5525
5526 return res;
5527}
5528
5529static struct
5530{
5531 const char * name;
5532 int reloc;
5533 int size;
5534 int rela;
5535} dynamic_relocations [] =
5536{
5537 { "REL", DT_REL, DT_RELSZ, FALSE },
5538 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5539 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5540};
5541
5542/* Process the reloc section. */
5543
5544static int
5545process_relocs (FILE * file)
5546{
5547 unsigned long rel_size;
5548 unsigned long rel_offset;
5549
5550
5551 if (!do_reloc)
5552 return 1;
5553
5554 if (do_using_dynamic)
5555 {
5556 int is_rela;
5557 const char * name;
5558 int has_dynamic_reloc;
5559 unsigned int i;
5560
5561 has_dynamic_reloc = 0;
5562
5563 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5564 {
5565 is_rela = dynamic_relocations [i].rela;
5566 name = dynamic_relocations [i].name;
5567 rel_size = dynamic_info [dynamic_relocations [i].size];
5568 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5569
5570 has_dynamic_reloc |= rel_size;
5571
5572 if (is_rela == UNKNOWN)
5573 {
5574 if (dynamic_relocations [i].reloc == DT_JMPREL)
5575 switch (dynamic_info[DT_PLTREL])
5576 {
5577 case DT_REL:
5578 is_rela = FALSE;
5579 break;
5580 case DT_RELA:
5581 is_rela = TRUE;
5582 break;
5583 }
5584 }
5585
5586 if (rel_size)
5587 {
5588 printf
5589 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5590 name, rel_offset, rel_size);
5591
5592 dump_relocations (file,
5593 offset_from_vma (file, rel_offset, rel_size),
5594 rel_size,
5595 dynamic_symbols, num_dynamic_syms,
5596 dynamic_strings, dynamic_strings_length, is_rela);
5597 }
5598 }
5599
5600 if (is_ia64_vms ())
5601 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5602
5603 if (! has_dynamic_reloc)
5604 printf (_("\nThere are no dynamic relocations in this file.\n"));
5605 }
5606 else
5607 {
5608 Elf_Internal_Shdr * section;
5609 unsigned long i;
5610 int found = 0;
5611
5612 for (i = 0, section = section_headers;
5613 i < elf_header.e_shnum;
5614 i++, section++)
5615 {
5616 if ( section->sh_type != SHT_RELA
5617 && section->sh_type != SHT_REL)
5618 continue;
5619
5620 rel_offset = section->sh_offset;
5621 rel_size = section->sh_size;
5622
5623 if (rel_size)
5624 {
5625 Elf_Internal_Shdr * strsec;
5626 int is_rela;
5627
5628 printf (_("\nRelocation section "));
5629
5630 if (string_table == NULL)
5631 printf ("%d", section->sh_name);
5632 else
5633 printf ("'%s'", SECTION_NAME (section));
5634
5635 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5636 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5637
5638 is_rela = section->sh_type == SHT_RELA;
5639
5640 if (section->sh_link != 0
5641 && section->sh_link < elf_header.e_shnum)
5642 {
5643 Elf_Internal_Shdr * symsec;
5644 Elf_Internal_Sym * symtab;
5645 unsigned long nsyms;
5646 unsigned long strtablen = 0;
5647 char * strtab = NULL;
5648
5649 symsec = section_headers + section->sh_link;
5650 if (symsec->sh_type != SHT_SYMTAB
5651 && symsec->sh_type != SHT_DYNSYM)
5652 continue;
5653
5654 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5655
5656 if (symtab == NULL)
5657 continue;
5658
5659 if (symsec->sh_link != 0
5660 && symsec->sh_link < elf_header.e_shnum)
5661 {
5662 strsec = section_headers + symsec->sh_link;
5663
5664 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5665 1, strsec->sh_size,
5666 _("string table"));
5667 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5668 }
5669
5670 dump_relocations (file, rel_offset, rel_size,
5671 symtab, nsyms, strtab, strtablen, is_rela);
5672 if (strtab)
5673 free (strtab);
5674 free (symtab);
5675 }
5676 else
5677 dump_relocations (file, rel_offset, rel_size,
5678 NULL, 0, NULL, 0, is_rela);
5679
5680 found = 1;
5681 }
5682 }
5683
5684 if (! found)
5685 printf (_("\nThere are no relocations in this file.\n"));
5686 }
5687
5688 return 1;
5689}
5690
5691/* Process the unwind section. */
5692
5693#include "unwind-ia64.h"
5694
5695/* An absolute address consists of a section and an offset. If the
5696 section is NULL, the offset itself is the address, otherwise, the
5697 address equals to LOAD_ADDRESS(section) + offset. */
5698
5699struct absaddr
5700 {
5701 unsigned short section;
5702 bfd_vma offset;
5703 };
5704
5705#define ABSADDR(a) \
5706 ((a).section \
5707 ? section_headers [(a).section].sh_addr + (a).offset \
5708 : (a).offset)
5709
5710struct ia64_unw_table_entry
5711 {
5712 struct absaddr start;
5713 struct absaddr end;
5714 struct absaddr info;
5715 };
5716
5717struct ia64_unw_aux_info
5718 {
5719
5720 struct ia64_unw_table_entry *table; /* Unwind table. */
5721 unsigned long table_len; /* Length of unwind table. */
5722 unsigned char * info; /* Unwind info. */
5723 unsigned long info_size; /* Size of unwind info. */
5724 bfd_vma info_addr; /* starting address of unwind info. */
5725 bfd_vma seg_base; /* Starting address of segment. */
5726 Elf_Internal_Sym * symtab; /* The symbol table. */
5727 unsigned long nsyms; /* Number of symbols. */
5728 char * strtab; /* The string table. */
5729 unsigned long strtab_size; /* Size of string table. */
5730 };
5731
5732static void
5733find_symbol_for_address (Elf_Internal_Sym * symtab,
5734 unsigned long nsyms,
5735 const char * strtab,
5736 unsigned long strtab_size,
5737 struct absaddr addr,
5738 const char ** symname,
5739 bfd_vma * offset)
5740{
5741 bfd_vma dist = 0x100000;
5742 Elf_Internal_Sym * sym;
5743 Elf_Internal_Sym * best = NULL;
5744 unsigned long i;
5745
5746 REMOVE_ARCH_BITS (addr.offset);
5747
5748 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5749 {
5750 bfd_vma value = sym->st_value;
5751
5752 REMOVE_ARCH_BITS (value);
5753
5754 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5755 && sym->st_name != 0
5756 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5757 && addr.offset >= value
5758 && addr.offset - value < dist)
5759 {
5760 best = sym;
5761 dist = addr.offset - value;
5762 if (!dist)
5763 break;
5764 }
5765 }
5766
5767 if (best)
5768 {
5769 *symname = (best->st_name >= strtab_size
5770 ? _("<corrupt>") : strtab + best->st_name);
5771 *offset = dist;
5772 return;
5773 }
5774
5775 *symname = NULL;
5776 *offset = addr.offset;
5777}
5778
5779static void
5780dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5781{
5782 struct ia64_unw_table_entry * tp;
5783 int in_body;
5784
5785 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5786 {
5787 bfd_vma stamp;
5788 bfd_vma offset;
5789 const unsigned char * dp;
5790 const unsigned char * head;
5791 const char * procname;
5792
5793 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5794 aux->strtab_size, tp->start, &procname, &offset);
5795
5796 fputs ("\n<", stdout);
5797
5798 if (procname)
5799 {
5800 fputs (procname, stdout);
5801
5802 if (offset)
5803 printf ("+%lx", (unsigned long) offset);
5804 }
5805
5806 fputs (">: [", stdout);
5807 print_vma (tp->start.offset, PREFIX_HEX);
5808 fputc ('-', stdout);
5809 print_vma (tp->end.offset, PREFIX_HEX);
5810 printf ("], info at +0x%lx\n",
5811 (unsigned long) (tp->info.offset - aux->seg_base));
5812
5813 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5814 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5815
5816 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5817 (unsigned) UNW_VER (stamp),
5818 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5819 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5820 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5821 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5822
5823 if (UNW_VER (stamp) != 1)
5824 {
5825 printf (_("\tUnknown version.\n"));
5826 continue;
5827 }
5828
5829 in_body = 0;
5830 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5831 dp = unw_decode (dp, in_body, & in_body);
5832 }
5833}
5834
5835static int
5836slurp_ia64_unwind_table (FILE * file,
5837 struct ia64_unw_aux_info * aux,
5838 Elf_Internal_Shdr * sec)
5839{
5840 unsigned long size, nrelas, i;
5841 Elf_Internal_Phdr * seg;
5842 struct ia64_unw_table_entry * tep;
5843 Elf_Internal_Shdr * relsec;
5844 Elf_Internal_Rela * rela;
5845 Elf_Internal_Rela * rp;
5846 unsigned char * table;
5847 unsigned char * tp;
5848 Elf_Internal_Sym * sym;
5849 const char * relname;
5850
5851 /* First, find the starting address of the segment that includes
5852 this section: */
5853
5854 if (elf_header.e_phnum)
5855 {
5856 if (! get_program_headers (file))
5857 return 0;
5858
5859 for (seg = program_headers;
5860 seg < program_headers + elf_header.e_phnum;
5861 ++seg)
5862 {
5863 if (seg->p_type != PT_LOAD)
5864 continue;
5865
5866 if (sec->sh_addr >= seg->p_vaddr
5867 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5868 {
5869 aux->seg_base = seg->p_vaddr;
5870 break;
5871 }
5872 }
5873 }
5874
5875 /* Second, build the unwind table from the contents of the unwind section: */
5876 size = sec->sh_size;
5877 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5878 _("unwind table"));
5879 if (!table)
5880 return 0;
5881
5882 aux->table = (struct ia64_unw_table_entry *)
5883 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5884 tep = aux->table;
5885 for (tp = table; tp < table + size; ++tep)
5886 {
5887 tep->start.section = SHN_UNDEF;
5888 tep->end.section = SHN_UNDEF;
5889 tep->info.section = SHN_UNDEF;
5890 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5891 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5892 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5893 tep->start.offset += aux->seg_base;
5894 tep->end.offset += aux->seg_base;
5895 tep->info.offset += aux->seg_base;
5896 }
5897 free (table);
5898
5899 /* Third, apply any relocations to the unwind table: */
5900 for (relsec = section_headers;
5901 relsec < section_headers + elf_header.e_shnum;
5902 ++relsec)
5903 {
5904 if (relsec->sh_type != SHT_RELA
5905 || relsec->sh_info >= elf_header.e_shnum
5906 || section_headers + relsec->sh_info != sec)
5907 continue;
5908
5909 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5910 & rela, & nrelas))
5911 return 0;
5912
5913 for (rp = rela; rp < rela + nrelas; ++rp)
5914 {
5915 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5916 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5917
5918 if (! const_strneq (relname, "R_IA64_SEGREL"))
5919 {
5920 warn (_("Skipping unexpected relocation type %s\n"), relname);
5921 continue;
5922 }
5923
5924 i = rp->r_offset / (3 * eh_addr_size);
5925
5926 switch (rp->r_offset/eh_addr_size % 3)
5927 {
5928 case 0:
5929 aux->table[i].start.section = sym->st_shndx;
5930 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5931 break;
5932 case 1:
5933 aux->table[i].end.section = sym->st_shndx;
5934 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5935 break;
5936 case 2:
5937 aux->table[i].info.section = sym->st_shndx;
5938 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5939 break;
5940 default:
5941 break;
5942 }
5943 }
5944
5945 free (rela);
5946 }
5947
5948 aux->table_len = size / (3 * eh_addr_size);
5949 return 1;
5950}
5951
5952static void
5953ia64_process_unwind (FILE * file)
5954{
5955 Elf_Internal_Shdr * sec;
5956 Elf_Internal_Shdr * unwsec = NULL;
5957 Elf_Internal_Shdr * strsec;
5958 unsigned long i, unwcount = 0, unwstart = 0;
5959 struct ia64_unw_aux_info aux;
5960
5961 memset (& aux, 0, sizeof (aux));
5962
5963 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5964 {
5965 if (sec->sh_type == SHT_SYMTAB
5966 && sec->sh_link < elf_header.e_shnum)
5967 {
5968 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
5969
5970 strsec = section_headers + sec->sh_link;
5971 assert (aux.strtab == NULL);
5972 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5973 1, strsec->sh_size,
5974 _("string table"));
5975 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5976 }
5977 else if (sec->sh_type == SHT_IA_64_UNWIND)
5978 unwcount++;
5979 }
5980
5981 if (!unwcount)
5982 printf (_("\nThere are no unwind sections in this file.\n"));
5983
5984 while (unwcount-- > 0)
5985 {
5986 char * suffix;
5987 size_t len, len2;
5988
5989 for (i = unwstart, sec = section_headers + unwstart;
5990 i < elf_header.e_shnum; ++i, ++sec)
5991 if (sec->sh_type == SHT_IA_64_UNWIND)
5992 {
5993 unwsec = sec;
5994 break;
5995 }
5996
5997 unwstart = i + 1;
5998 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5999
6000 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6001 {
6002 /* We need to find which section group it is in. */
6003 struct group_list * g = section_headers_groups [i]->root;
6004
6005 for (; g != NULL; g = g->next)
6006 {
6007 sec = section_headers + g->section_index;
6008
6009 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6010 break;
6011 }
6012
6013 if (g == NULL)
6014 i = elf_header.e_shnum;
6015 }
6016 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6017 {
6018 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6019 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6020 suffix = SECTION_NAME (unwsec) + len;
6021 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6022 ++i, ++sec)
6023 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6024 && streq (SECTION_NAME (sec) + len2, suffix))
6025 break;
6026 }
6027 else
6028 {
6029 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6030 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6031 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6032 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6033 suffix = "";
6034 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6035 suffix = SECTION_NAME (unwsec) + len;
6036 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6037 ++i, ++sec)
6038 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6039 && streq (SECTION_NAME (sec) + len2, suffix))
6040 break;
6041 }
6042
6043 if (i == elf_header.e_shnum)
6044 {
6045 printf (_("\nCould not find unwind info section for "));
6046
6047 if (string_table == NULL)
6048 printf ("%d", unwsec->sh_name);
6049 else
6050 printf (_("'%s'"), SECTION_NAME (unwsec));
6051 }
6052 else
6053 {
6054 aux.info_addr = sec->sh_addr;
6055 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6056 sec->sh_size,
6057 _("unwind info"));
6058 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6059
6060 printf (_("\nUnwind section "));
6061
6062 if (string_table == NULL)
6063 printf ("%d", unwsec->sh_name);
6064 else
6065 printf (_("'%s'"), SECTION_NAME (unwsec));
6066
6067 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6068 (unsigned long) unwsec->sh_offset,
6069 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6070
6071 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6072
6073 if (aux.table_len > 0)
6074 dump_ia64_unwind (& aux);
6075
6076 if (aux.table)
6077 free ((char *) aux.table);
6078 if (aux.info)
6079 free ((char *) aux.info);
6080 aux.table = NULL;
6081 aux.info = NULL;
6082 }
6083 }
6084
6085 if (aux.symtab)
6086 free (aux.symtab);
6087 if (aux.strtab)
6088 free ((char *) aux.strtab);
6089}
6090
6091struct hppa_unw_table_entry
6092 {
6093 struct absaddr start;
6094 struct absaddr end;
6095 unsigned int Cannot_unwind:1; /* 0 */
6096 unsigned int Millicode:1; /* 1 */
6097 unsigned int Millicode_save_sr0:1; /* 2 */
6098 unsigned int Region_description:2; /* 3..4 */
6099 unsigned int reserved1:1; /* 5 */
6100 unsigned int Entry_SR:1; /* 6 */
6101 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6102 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6103 unsigned int Args_stored:1; /* 16 */
6104 unsigned int Variable_Frame:1; /* 17 */
6105 unsigned int Separate_Package_Body:1; /* 18 */
6106 unsigned int Frame_Extension_Millicode:1; /* 19 */
6107 unsigned int Stack_Overflow_Check:1; /* 20 */
6108 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6109 unsigned int Ada_Region:1; /* 22 */
6110 unsigned int cxx_info:1; /* 23 */
6111 unsigned int cxx_try_catch:1; /* 24 */
6112 unsigned int sched_entry_seq:1; /* 25 */
6113 unsigned int reserved2:1; /* 26 */
6114 unsigned int Save_SP:1; /* 27 */
6115 unsigned int Save_RP:1; /* 28 */
6116 unsigned int Save_MRP_in_frame:1; /* 29 */
6117 unsigned int extn_ptr_defined:1; /* 30 */
6118 unsigned int Cleanup_defined:1; /* 31 */
6119
6120 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6121 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6122 unsigned int Large_frame:1; /* 2 */
6123 unsigned int Pseudo_SP_Set:1; /* 3 */
6124 unsigned int reserved4:1; /* 4 */
6125 unsigned int Total_frame_size:27; /* 5..31 */
6126 };
6127
6128struct hppa_unw_aux_info
6129 {
6130 struct hppa_unw_table_entry *table; /* Unwind table. */
6131 unsigned long table_len; /* Length of unwind table. */
6132 bfd_vma seg_base; /* Starting address of segment. */
6133 Elf_Internal_Sym * symtab; /* The symbol table. */
6134 unsigned long nsyms; /* Number of symbols. */
6135 char * strtab; /* The string table. */
6136 unsigned long strtab_size; /* Size of string table. */
6137 };
6138
6139static void
6140dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6141{
6142 struct hppa_unw_table_entry * tp;
6143
6144 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6145 {
6146 bfd_vma offset;
6147 const char * procname;
6148
6149 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6150 aux->strtab_size, tp->start, &procname,
6151 &offset);
6152
6153 fputs ("\n<", stdout);
6154
6155 if (procname)
6156 {
6157 fputs (procname, stdout);
6158
6159 if (offset)
6160 printf ("+%lx", (unsigned long) offset);
6161 }
6162
6163 fputs (">: [", stdout);
6164 print_vma (tp->start.offset, PREFIX_HEX);
6165 fputc ('-', stdout);
6166 print_vma (tp->end.offset, PREFIX_HEX);
6167 printf ("]\n\t");
6168
6169#define PF(_m) if (tp->_m) printf (#_m " ");
6170#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6171 PF(Cannot_unwind);
6172 PF(Millicode);
6173 PF(Millicode_save_sr0);
6174 /* PV(Region_description); */
6175 PF(Entry_SR);
6176 PV(Entry_FR);
6177 PV(Entry_GR);
6178 PF(Args_stored);
6179 PF(Variable_Frame);
6180 PF(Separate_Package_Body);
6181 PF(Frame_Extension_Millicode);
6182 PF(Stack_Overflow_Check);
6183 PF(Two_Instruction_SP_Increment);
6184 PF(Ada_Region);
6185 PF(cxx_info);
6186 PF(cxx_try_catch);
6187 PF(sched_entry_seq);
6188 PF(Save_SP);
6189 PF(Save_RP);
6190 PF(Save_MRP_in_frame);
6191 PF(extn_ptr_defined);
6192 PF(Cleanup_defined);
6193 PF(MPE_XL_interrupt_marker);
6194 PF(HP_UX_interrupt_marker);
6195 PF(Large_frame);
6196 PF(Pseudo_SP_Set);
6197 PV(Total_frame_size);
6198#undef PF
6199#undef PV
6200 }
6201
6202 printf ("\n");
6203}
6204
6205static int
6206slurp_hppa_unwind_table (FILE * file,
6207 struct hppa_unw_aux_info * aux,
6208 Elf_Internal_Shdr * sec)
6209{
6210 unsigned long size, unw_ent_size, nentries, nrelas, i;
6211 Elf_Internal_Phdr * seg;
6212 struct hppa_unw_table_entry * tep;
6213 Elf_Internal_Shdr * relsec;
6214 Elf_Internal_Rela * rela;
6215 Elf_Internal_Rela * rp;
6216 unsigned char * table;
6217 unsigned char * tp;
6218 Elf_Internal_Sym * sym;
6219 const char * relname;
6220
6221 /* First, find the starting address of the segment that includes
6222 this section. */
6223
6224 if (elf_header.e_phnum)
6225 {
6226 if (! get_program_headers (file))
6227 return 0;
6228
6229 for (seg = program_headers;
6230 seg < program_headers + elf_header.e_phnum;
6231 ++seg)
6232 {
6233 if (seg->p_type != PT_LOAD)
6234 continue;
6235
6236 if (sec->sh_addr >= seg->p_vaddr
6237 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6238 {
6239 aux->seg_base = seg->p_vaddr;
6240 break;
6241 }
6242 }
6243 }
6244
6245 /* Second, build the unwind table from the contents of the unwind
6246 section. */
6247 size = sec->sh_size;
6248 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6249 _("unwind table"));
6250 if (!table)
6251 return 0;
6252
6253 unw_ent_size = 16;
6254 nentries = size / unw_ent_size;
6255 size = unw_ent_size * nentries;
6256
6257 tep = aux->table = (struct hppa_unw_table_entry *)
6258 xcmalloc (nentries, sizeof (aux->table[0]));
6259
6260 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6261 {
6262 unsigned int tmp1, tmp2;
6263
6264 tep->start.section = SHN_UNDEF;
6265 tep->end.section = SHN_UNDEF;
6266
6267 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6268 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6269 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6270 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6271
6272 tep->start.offset += aux->seg_base;
6273 tep->end.offset += aux->seg_base;
6274
6275 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6276 tep->Millicode = (tmp1 >> 30) & 0x1;
6277 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6278 tep->Region_description = (tmp1 >> 27) & 0x3;
6279 tep->reserved1 = (tmp1 >> 26) & 0x1;
6280 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6281 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6282 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6283 tep->Args_stored = (tmp1 >> 15) & 0x1;
6284 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6285 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6286 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6287 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6288 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6289 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6290 tep->cxx_info = (tmp1 >> 8) & 0x1;
6291 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6292 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6293 tep->reserved2 = (tmp1 >> 5) & 0x1;
6294 tep->Save_SP = (tmp1 >> 4) & 0x1;
6295 tep->Save_RP = (tmp1 >> 3) & 0x1;
6296 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6297 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6298 tep->Cleanup_defined = tmp1 & 0x1;
6299
6300 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6301 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6302 tep->Large_frame = (tmp2 >> 29) & 0x1;
6303 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6304 tep->reserved4 = (tmp2 >> 27) & 0x1;
6305 tep->Total_frame_size = tmp2 & 0x7ffffff;
6306 }
6307 free (table);
6308
6309 /* Third, apply any relocations to the unwind table. */
6310 for (relsec = section_headers;
6311 relsec < section_headers + elf_header.e_shnum;
6312 ++relsec)
6313 {
6314 if (relsec->sh_type != SHT_RELA
6315 || relsec->sh_info >= elf_header.e_shnum
6316 || section_headers + relsec->sh_info != sec)
6317 continue;
6318
6319 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6320 & rela, & nrelas))
6321 return 0;
6322
6323 for (rp = rela; rp < rela + nrelas; ++rp)
6324 {
6325 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6326 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6327
6328 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6329 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6330 {
6331 warn (_("Skipping unexpected relocation type %s\n"), relname);
6332 continue;
6333 }
6334
6335 i = rp->r_offset / unw_ent_size;
6336
6337 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6338 {
6339 case 0:
6340 aux->table[i].start.section = sym->st_shndx;
6341 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6342 break;
6343 case 1:
6344 aux->table[i].end.section = sym->st_shndx;
6345 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6346 break;
6347 default:
6348 break;
6349 }
6350 }
6351
6352 free (rela);
6353 }
6354
6355 aux->table_len = nentries;
6356
6357 return 1;
6358}
6359
6360static void
6361hppa_process_unwind (FILE * file)
6362{
6363 struct hppa_unw_aux_info aux;
6364 Elf_Internal_Shdr * unwsec = NULL;
6365 Elf_Internal_Shdr * strsec;
6366 Elf_Internal_Shdr * sec;
6367 unsigned long i;
6368
6369 if (string_table == NULL)
6370 return;
6371
6372 memset (& aux, 0, sizeof (aux));
6373
6374 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6375 {
6376 if (sec->sh_type == SHT_SYMTAB
6377 && sec->sh_link < elf_header.e_shnum)
6378 {
6379 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6380
6381 strsec = section_headers + sec->sh_link;
6382 assert (aux.strtab == NULL);
6383 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6384 1, strsec->sh_size,
6385 _("string table"));
6386 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6387 }
6388 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6389 unwsec = sec;
6390 }
6391
6392 if (!unwsec)
6393 printf (_("\nThere are no unwind sections in this file.\n"));
6394
6395 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6396 {
6397 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6398 {
6399 printf (_("\nUnwind section "));
6400 printf (_("'%s'"), SECTION_NAME (sec));
6401
6402 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6403 (unsigned long) sec->sh_offset,
6404 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6405
6406 slurp_hppa_unwind_table (file, &aux, sec);
6407 if (aux.table_len > 0)
6408 dump_hppa_unwind (&aux);
6409
6410 if (aux.table)
6411 free ((char *) aux.table);
6412 aux.table = NULL;
6413 }
6414 }
6415
6416 if (aux.symtab)
6417 free (aux.symtab);
6418 if (aux.strtab)
6419 free ((char *) aux.strtab);
6420}
6421
6422struct arm_section
6423{
6424 unsigned char * data; /* The unwind data. */
6425 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6426 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6427 unsigned long nrelas; /* The number of relocations. */
6428 unsigned int rel_type; /* REL or RELA ? */
6429 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
6430};
6431
6432struct arm_unw_aux_info
6433{
6434 FILE * file; /* The file containing the unwind sections. */
6435 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6436 unsigned long nsyms; /* Number of symbols. */
6437 char * strtab; /* The file's string table. */
6438 unsigned long strtab_size; /* Size of string table. */
6439};
6440
6441static const char *
6442arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6443 bfd_vma fn, struct absaddr addr)
6444{
6445 const char *procname;
6446 bfd_vma sym_offset;
6447
6448 if (addr.section == SHN_UNDEF)
6449 addr.offset = fn;
6450
6451 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6452 aux->strtab_size, addr, &procname,
6453 &sym_offset);
6454
6455 print_vma (fn, PREFIX_HEX);
6456
6457 if (procname)
6458 {
6459 fputs (" <", stdout);
6460 fputs (procname, stdout);
6461
6462 if (sym_offset)
6463 printf ("+0x%lx", (unsigned long) sym_offset);
6464 fputc ('>', stdout);
6465 }
6466
6467 return procname;
6468}
6469
6470static void
6471arm_free_section (struct arm_section *arm_sec)
6472{
6473 if (arm_sec->data != NULL)
6474 free (arm_sec->data);
6475
6476 if (arm_sec->rela != NULL)
6477 free (arm_sec->rela);
6478}
6479
6480/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6481 cached section and install SEC instead.
6482 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6483 and return its valued in * WORDP, relocating if necessary.
6484 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6485 relocation's offset in ADDR.
6486 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6487 into the string table of the symbol associated with the reloc. If no
6488 reloc was applied store -1 there.
6489 5) Return TRUE upon success, FALSE otherwise. */
6490
6491static bfd_boolean
6492get_unwind_section_word (struct arm_unw_aux_info * aux,
6493 struct arm_section * arm_sec,
6494 Elf_Internal_Shdr * sec,
6495 bfd_vma word_offset,
6496 unsigned int * wordp,
6497 struct absaddr * addr,
6498 bfd_vma * sym_name)
6499{
6500 Elf_Internal_Rela *rp;
6501 Elf_Internal_Sym *sym;
6502 const char * relname;
6503 unsigned int word;
6504 bfd_boolean wrapped;
6505
6506 addr->section = SHN_UNDEF;
6507 addr->offset = 0;
6508
6509 if (sym_name != NULL)
6510 *sym_name = (bfd_vma) -1;
6511
6512 /* If necessary, update the section cache. */
6513 if (sec != arm_sec->sec)
6514 {
6515 Elf_Internal_Shdr *relsec;
6516
6517 arm_free_section (arm_sec);
6518
6519 arm_sec->sec = sec;
6520 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6521 sec->sh_size, _("unwind data"));
6522 arm_sec->rela = NULL;
6523 arm_sec->nrelas = 0;
6524
6525 for (relsec = section_headers;
6526 relsec < section_headers + elf_header.e_shnum;
6527 ++relsec)
6528 {
6529 if (relsec->sh_info >= elf_header.e_shnum
6530 || section_headers + relsec->sh_info != sec)
6531 continue;
6532
6533 arm_sec->rel_type = relsec->sh_type;
6534 if (relsec->sh_type == SHT_REL)
6535 {
6536 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6537 relsec->sh_size,
6538 & arm_sec->rela, & arm_sec->nrelas))
6539 return FALSE;
6540 break;
6541 }
6542 else if (relsec->sh_type == SHT_RELA)
6543 {
6544 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6545 relsec->sh_size,
6546 & arm_sec->rela, & arm_sec->nrelas))
6547 return FALSE;
6548 break;
6549 }
6550 else
6551 warn (_("unexpected relocation type (%d) for section %d"),
6552 relsec->sh_type, relsec->sh_info);
6553 }
6554
6555 arm_sec->next_rela = arm_sec->rela;
6556 }
6557
6558 /* If there is no unwind data we can do nothing. */
6559 if (arm_sec->data == NULL)
6560 return FALSE;
6561
6562 /* Get the word at the required offset. */
6563 word = byte_get (arm_sec->data + word_offset, 4);
6564
6565 /* Look through the relocs to find the one that applies to the provided offset. */
6566 wrapped = FALSE;
6567 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6568 {
6569 bfd_vma prelval, offset;
6570
6571 if (rp->r_offset > word_offset && !wrapped)
6572 {
6573 rp = arm_sec->rela;
6574 wrapped = TRUE;
6575 }
6576 if (rp->r_offset > word_offset)
6577 break;
6578
6579 if (rp->r_offset & 3)
6580 {
6581 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6582 (unsigned long) rp->r_offset);
6583 continue;
6584 }
6585
6586 if (rp->r_offset < word_offset)
6587 continue;
6588
6589 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6590
6591 if (arm_sec->rel_type == SHT_REL)
6592 {
6593 offset = word & 0x7fffffff;
6594 if (offset & 0x40000000)
6595 offset |= ~ (bfd_vma) 0x7fffffff;
6596 }
6597 else if (arm_sec->rel_type == SHT_RELA)
6598 offset = rp->r_addend;
6599 else
6600 abort ();
6601
6602 offset += sym->st_value;
6603 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6604
6605 /* Check that we are processing the expected reloc type. */
6606 if (elf_header.e_machine == EM_ARM)
6607 {
6608 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6609
6610 if (streq (relname, "R_ARM_NONE"))
6611 continue;
6612
6613 if (! streq (relname, "R_ARM_PREL31"))
6614 {
6615 warn (_("Skipping unexpected relocation type %s\n"), relname);
6616 continue;
6617 }
6618 }
6619 else if (elf_header.e_machine == EM_TI_C6000)
6620 {
6621 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6622
6623 if (streq (relname, "R_C6000_NONE"))
6624 continue;
6625
6626 if (! streq (relname, "R_C6000_PREL31"))
6627 {
6628 warn (_("Skipping unexpected relocation type %s\n"), relname);
6629 continue;
6630 }
6631
6632 prelval >>= 1;
6633 }
6634 else
6635 /* This function currently only supports ARM and TI unwinders. */
6636 abort ();
6637
6638 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6639 addr->section = sym->st_shndx;
6640 addr->offset = offset;
6641 if (sym_name)
6642 * sym_name = sym->st_name;
6643 break;
6644 }
6645
6646 *wordp = word;
6647 arm_sec->next_rela = rp;
6648
6649 return TRUE;
6650}
6651
6652static const char *tic6x_unwind_regnames[16] =
6653{
6654 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6655 "A14", "A13", "A12", "A11", "A10",
6656 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6657};
6658
6659static void
6660decode_tic6x_unwind_regmask (unsigned int mask)
6661{
6662 int i;
6663
6664 for (i = 12; mask; mask >>= 1, i--)
6665 {
6666 if (mask & 1)
6667 {
6668 fputs (tic6x_unwind_regnames[i], stdout);
6669 if (mask > 1)
6670 fputs (", ", stdout);
6671 }
6672 }
6673}
6674
6675#define ADVANCE \
6676 if (remaining == 0 && more_words) \
6677 { \
6678 data_offset += 4; \
6679 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6680 data_offset, & word, & addr, NULL)) \
6681 return; \
6682 remaining = 4; \
6683 more_words--; \
6684 } \
6685
6686#define GET_OP(OP) \
6687 ADVANCE; \
6688 if (remaining) \
6689 { \
6690 remaining--; \
6691 (OP) = word >> 24; \
6692 word <<= 8; \
6693 } \
6694 else \
6695 { \
6696 printf (_("[Truncated opcode]\n")); \
6697 return; \
6698 } \
6699 printf ("0x%02x ", OP)
6700
6701static void
6702decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6703 unsigned int word, unsigned int remaining,
6704 unsigned int more_words,
6705 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6706 struct arm_section *data_arm_sec)
6707{
6708 struct absaddr addr;
6709
6710 /* Decode the unwinding instructions. */
6711 while (1)
6712 {
6713 unsigned int op, op2;
6714
6715 ADVANCE;
6716 if (remaining == 0)
6717 break;
6718 remaining--;
6719 op = word >> 24;
6720 word <<= 8;
6721
6722 printf (" 0x%02x ", op);
6723
6724 if ((op & 0xc0) == 0x00)
6725 {
6726 int offset = ((op & 0x3f) << 2) + 4;
6727
6728 printf (" vsp = vsp + %d", offset);
6729 }
6730 else if ((op & 0xc0) == 0x40)
6731 {
6732 int offset = ((op & 0x3f) << 2) + 4;
6733
6734 printf (" vsp = vsp - %d", offset);
6735 }
6736 else if ((op & 0xf0) == 0x80)
6737 {
6738 GET_OP (op2);
6739 if (op == 0x80 && op2 == 0)
6740 printf (_("Refuse to unwind"));
6741 else
6742 {
6743 unsigned int mask = ((op & 0x0f) << 8) | op2;
6744 int first = 1;
6745 int i;
6746
6747 printf ("pop {");
6748 for (i = 0; i < 12; i++)
6749 if (mask & (1 << i))
6750 {
6751 if (first)
6752 first = 0;
6753 else
6754 printf (", ");
6755 printf ("r%d", 4 + i);
6756 }
6757 printf ("}");
6758 }
6759 }
6760 else if ((op & 0xf0) == 0x90)
6761 {
6762 if (op == 0x9d || op == 0x9f)
6763 printf (_(" [Reserved]"));
6764 else
6765 printf (" vsp = r%d", op & 0x0f);
6766 }
6767 else if ((op & 0xf0) == 0xa0)
6768 {
6769 int end = 4 + (op & 0x07);
6770 int first = 1;
6771 int i;
6772
6773 printf (" pop {");
6774 for (i = 4; i <= end; i++)
6775 {
6776 if (first)
6777 first = 0;
6778 else
6779 printf (", ");
6780 printf ("r%d", i);
6781 }
6782 if (op & 0x08)
6783 {
6784 if (!first)
6785 printf (", ");
6786 printf ("r14");
6787 }
6788 printf ("}");
6789 }
6790 else if (op == 0xb0)
6791 printf (_(" finish"));
6792 else if (op == 0xb1)
6793 {
6794 GET_OP (op2);
6795 if (op2 == 0 || (op2 & 0xf0) != 0)
6796 printf (_("[Spare]"));
6797 else
6798 {
6799 unsigned int mask = op2 & 0x0f;
6800 int first = 1;
6801 int i;
6802
6803 printf ("pop {");
6804 for (i = 0; i < 12; i++)
6805 if (mask & (1 << i))
6806 {
6807 if (first)
6808 first = 0;
6809 else
6810 printf (", ");
6811 printf ("r%d", i);
6812 }
6813 printf ("}");
6814 }
6815 }
6816 else if (op == 0xb2)
6817 {
6818 unsigned char buf[9];
6819 unsigned int i, len;
6820 unsigned long offset;
6821
6822 for (i = 0; i < sizeof (buf); i++)
6823 {
6824 GET_OP (buf[i]);
6825 if ((buf[i] & 0x80) == 0)
6826 break;
6827 }
6828 assert (i < sizeof (buf));
6829 offset = read_uleb128 (buf, &len);
6830 assert (len == i + 1);
6831 offset = offset * 4 + 0x204;
6832 printf ("vsp = vsp + %ld", offset);
6833 }
6834 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6835 {
6836 unsigned int first, last;
6837
6838 GET_OP (op2);
6839 first = op2 >> 4;
6840 last = op2 & 0x0f;
6841 if (op == 0xc8)
6842 first = first + 16;
6843 printf ("pop {D%d", first);
6844 if (last)
6845 printf ("-D%d", first + last);
6846 printf ("}");
6847 }
6848 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6849 {
6850 unsigned int count = op & 0x07;
6851
6852 printf ("pop {D8");
6853 if (count)
6854 printf ("-D%d", 8 + count);
6855 printf ("}");
6856 }
6857 else if (op >= 0xc0 && op <= 0xc5)
6858 {
6859 unsigned int count = op & 0x07;
6860
6861 printf (" pop {wR10");
6862 if (count)
6863 printf ("-wR%d", 10 + count);
6864 printf ("}");
6865 }
6866 else if (op == 0xc6)
6867 {
6868 unsigned int first, last;
6869
6870 GET_OP (op2);
6871 first = op2 >> 4;
6872 last = op2 & 0x0f;
6873 printf ("pop {wR%d", first);
6874 if (last)
6875 printf ("-wR%d", first + last);
6876 printf ("}");
6877 }
6878 else if (op == 0xc7)
6879 {
6880 GET_OP (op2);
6881 if (op2 == 0 || (op2 & 0xf0) != 0)
6882 printf (_("[Spare]"));
6883 else
6884 {
6885 unsigned int mask = op2 & 0x0f;
6886 int first = 1;
6887 int i;
6888
6889 printf ("pop {");
6890 for (i = 0; i < 4; i++)
6891 if (mask & (1 << i))
6892 {
6893 if (first)
6894 first = 0;
6895 else
6896 printf (", ");
6897 printf ("wCGR%d", i);
6898 }
6899 printf ("}");
6900 }
6901 }
6902 else
6903 printf (_(" [unsupported opcode]"));
6904 printf ("\n");
6905 }
6906}
6907
6908static void
6909decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6910 unsigned int word, unsigned int remaining,
6911 unsigned int more_words,
6912 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6913 struct arm_section *data_arm_sec)
6914{
6915 struct absaddr addr;
6916
6917 /* Decode the unwinding instructions. */
6918 while (1)
6919 {
6920 unsigned int op, op2;
6921
6922 ADVANCE;
6923 if (remaining == 0)
6924 break;
6925 remaining--;
6926 op = word >> 24;
6927 word <<= 8;
6928
6929 printf (" 0x%02x ", op);
6930
6931 if ((op & 0xc0) == 0x00)
6932 {
6933 int offset = ((op & 0x3f) << 3) + 8;
6934 printf (" sp = sp + %d", offset);
6935 }
6936 else if ((op & 0xc0) == 0x80)
6937 {
6938 GET_OP (op2);
6939 if (op == 0x80 && op2 == 0)
6940 printf (_("Refuse to unwind"));
6941 else
6942 {
6943 unsigned int mask = ((op & 0x1f) << 8) | op2;
6944 if (op & 0x20)
6945 printf ("pop compact {");
6946 else
6947 printf ("pop {");
6948
6949 decode_tic6x_unwind_regmask (mask);
6950 printf("}");
6951 }
6952 }
6953 else if ((op & 0xf0) == 0xc0)
6954 {
6955 unsigned int reg;
6956 unsigned int nregs;
6957 unsigned int i;
6958 const char *name;
6959 struct
6960 {
6961 unsigned int offset;
6962 unsigned int reg;
6963 } regpos[16];
6964
6965 /* Scan entire instruction first so that GET_OP output is not
6966 interleaved with disassembly. */
6967 nregs = 0;
6968 for (i = 0; nregs < (op & 0xf); i++)
6969 {
6970 GET_OP (op2);
6971 reg = op2 >> 4;
6972 if (reg != 0xf)
6973 {
6974 regpos[nregs].offset = i * 2;
6975 regpos[nregs].reg = reg;
6976 nregs++;
6977 }
6978
6979 reg = op2 & 0xf;
6980 if (reg != 0xf)
6981 {
6982 regpos[nregs].offset = i * 2 + 1;
6983 regpos[nregs].reg = reg;
6984 nregs++;
6985 }
6986 }
6987
6988 printf (_("pop frame {"));
6989 reg = nregs - 1;
6990 for (i = i * 2; i > 0; i--)
6991 {
6992 if (regpos[reg].offset == i - 1)
6993 {
6994 name = tic6x_unwind_regnames[regpos[reg].reg];
6995 if (reg > 0)
6996 reg--;
6997 }
6998 else
6999 name = _("[pad]");
7000
7001 fputs (name, stdout);
7002 if (i > 1)
7003 printf (", ");
7004 }
7005
7006 printf ("}");
7007 }
7008 else if (op == 0xd0)
7009 printf (" MOV FP, SP");
7010 else if (op == 0xd1)
7011 printf (" __c6xabi_pop_rts");
7012 else if (op == 0xd2)
7013 {
7014 unsigned char buf[9];
7015 unsigned int i, len;
7016 unsigned long offset;
7017
7018 for (i = 0; i < sizeof (buf); i++)
7019 {
7020 GET_OP (buf[i]);
7021 if ((buf[i] & 0x80) == 0)
7022 break;
7023 }
7024 assert (i < sizeof (buf));
7025 offset = read_uleb128 (buf, &len);
7026 assert (len == i + 1);
7027 offset = offset * 8 + 0x408;
7028 printf (_("sp = sp + %ld"), offset);
7029 }
7030 else if ((op & 0xf0) == 0xe0)
7031 {
7032 if ((op & 0x0f) == 7)
7033 printf (" RETURN");
7034 else
7035 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7036 }
7037 else
7038 {
7039 printf (_(" [unsupported opcode]"));
7040 }
7041 putchar ('\n');
7042 }
7043}
7044
7045static bfd_vma
7046arm_expand_prel31 (bfd_vma word, bfd_vma where)
7047{
7048 bfd_vma offset;
7049
7050 offset = word & 0x7fffffff;
7051 if (offset & 0x40000000)
7052 offset |= ~ (bfd_vma) 0x7fffffff;
7053
7054 if (elf_header.e_machine == EM_TI_C6000)
7055 offset <<= 1;
7056
7057 return offset + where;
7058}
7059
7060static void
7061decode_arm_unwind (struct arm_unw_aux_info * aux,
7062 unsigned int word,
7063 unsigned int remaining,
7064 bfd_vma data_offset,
7065 Elf_Internal_Shdr * data_sec,
7066 struct arm_section * data_arm_sec)
7067{
7068 int per_index;
7069 unsigned int more_words = 0;
7070 struct absaddr addr;
7071 bfd_vma sym_name = (bfd_vma) -1;
7072
7073 if (remaining == 0)
7074 {
7075 /* Fetch the first word.
7076 Note - when decoding an object file the address extracted
7077 here will always be 0. So we also pass in the sym_name
7078 parameter so that we can find the symbol associated with
7079 the personality routine. */
7080 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7081 & word, & addr, & sym_name))
7082 return;
7083
7084 remaining = 4;
7085 }
7086
7087 if ((word & 0x80000000) == 0)
7088 {
7089 /* Expand prel31 for personality routine. */
7090 bfd_vma fn;
7091 const char *procname;
7092
7093 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7094 printf (_(" Personality routine: "));
7095 if (fn == 0
7096 && addr.section == SHN_UNDEF && addr.offset == 0
7097 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7098 {
7099 procname = aux->strtab + sym_name;
7100 print_vma (fn, PREFIX_HEX);
7101 if (procname)
7102 {
7103 fputs (" <", stdout);
7104 fputs (procname, stdout);
7105 fputc ('>', stdout);
7106 }
7107 }
7108 else
7109 procname = arm_print_vma_and_name (aux, fn, addr);
7110 fputc ('\n', stdout);
7111
7112 /* The GCC personality routines use the standard compact
7113 encoding, starting with one byte giving the number of
7114 words. */
7115 if (procname != NULL
7116 && (const_strneq (procname, "__gcc_personality_v0")
7117 || const_strneq (procname, "__gxx_personality_v0")
7118 || const_strneq (procname, "__gcj_personality_v0")
7119 || const_strneq (procname, "__gnu_objc_personality_v0")))
7120 {
7121 remaining = 0;
7122 more_words = 1;
7123 ADVANCE;
7124 if (!remaining)
7125 {
7126 printf (_(" [Truncated data]\n"));
7127 return;
7128 }
7129 more_words = word >> 24;
7130 word <<= 8;
7131 remaining--;
7132 per_index = -1;
7133 }
7134 else
7135 return;
7136 }
7137 else
7138 {
7139 /* ARM EHABI Section 6.3:
7140
7141 An exception-handling table entry for the compact model looks like:
7142
7143 31 30-28 27-24 23-0
7144 -- ----- ----- ----
7145 1 0 index Data for personalityRoutine[index] */
7146
7147 if (elf_header.e_machine == EM_ARM
7148 && (word & 0x70000000))
7149 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7150
7151 per_index = (word >> 24) & 0x7f;
7152 printf (_(" Compact model index: %d\n"), per_index);
7153 if (per_index == 0)
7154 {
7155 more_words = 0;
7156 word <<= 8;
7157 remaining--;
7158 }
7159 else if (per_index < 3)
7160 {
7161 more_words = (word >> 16) & 0xff;
7162 word <<= 16;
7163 remaining -= 2;
7164 }
7165 }
7166
7167 switch (elf_header.e_machine)
7168 {
7169 case EM_ARM:
7170 if (per_index < 3)
7171 {
7172 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7173 data_offset, data_sec, data_arm_sec);
7174 }
7175 else
7176 {
7177 warn (_("Unknown ARM compact model index encountered\n"));
7178 printf (_(" [reserved]\n"));
7179 }
7180 break;
7181
7182 case EM_TI_C6000:
7183 if (per_index < 3)
7184 {
7185 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7186 data_offset, data_sec, data_arm_sec);
7187 }
7188 else if (per_index < 5)
7189 {
7190 if (((word >> 17) & 0x7f) == 0x7f)
7191 printf (_(" Restore stack from frame pointer\n"));
7192 else
7193 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7194 printf (_(" Registers restored: "));
7195 if (per_index == 4)
7196 printf (" (compact) ");
7197 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7198 putchar ('\n');
7199 printf (_(" Return register: %s\n"),
7200 tic6x_unwind_regnames[word & 0xf]);
7201 }
7202 else
7203 printf (_(" [reserved (%d)]\n"), per_index);
7204 break;
7205
7206 default:
7207 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7208 elf_header.e_machine);
7209 }
7210
7211 /* Decode the descriptors. Not implemented. */
7212}
7213
7214static void
7215dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7216{
7217 struct arm_section exidx_arm_sec, extab_arm_sec;
7218 unsigned int i, exidx_len;
7219
7220 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7221 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7222 exidx_len = exidx_sec->sh_size / 8;
7223
7224 for (i = 0; i < exidx_len; i++)
7225 {
7226 unsigned int exidx_fn, exidx_entry;
7227 struct absaddr fn_addr, entry_addr;
7228 bfd_vma fn;
7229
7230 fputc ('\n', stdout);
7231
7232 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7233 8 * i, & exidx_fn, & fn_addr, NULL)
7234 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7235 8 * i + 4, & exidx_entry, & entry_addr, NULL))
7236 {
7237 arm_free_section (& exidx_arm_sec);
7238 arm_free_section (& extab_arm_sec);
7239 return;
7240 }
7241
7242 /* ARM EHABI, Section 5:
7243 An index table entry consists of 2 words.
7244 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7245 if (exidx_fn & 0x80000000)
7246 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7247
7248 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7249
7250 arm_print_vma_and_name (aux, fn, fn_addr);
7251 fputs (": ", stdout);
7252
7253 if (exidx_entry == 1)
7254 {
7255 print_vma (exidx_entry, PREFIX_HEX);
7256 fputs (" [cantunwind]\n", stdout);
7257 }
7258 else if (exidx_entry & 0x80000000)
7259 {
7260 print_vma (exidx_entry, PREFIX_HEX);
7261 fputc ('\n', stdout);
7262 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7263 }
7264 else
7265 {
7266 bfd_vma table, table_offset = 0;
7267 Elf_Internal_Shdr *table_sec;
7268
7269 fputs ("@", stdout);
7270 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7271 print_vma (table, PREFIX_HEX);
7272 printf ("\n");
7273
7274 /* Locate the matching .ARM.extab. */
7275 if (entry_addr.section != SHN_UNDEF
7276 && entry_addr.section < elf_header.e_shnum)
7277 {
7278 table_sec = section_headers + entry_addr.section;
7279 table_offset = entry_addr.offset;
7280 }
7281 else
7282 {
7283 table_sec = find_section_by_address (table);
7284 if (table_sec != NULL)
7285 table_offset = table - table_sec->sh_addr;
7286 }
7287 if (table_sec == NULL)
7288 {
7289 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7290 (unsigned long) table);
7291 continue;
7292 }
7293 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7294 &extab_arm_sec);
7295 }
7296 }
7297
7298 printf ("\n");
7299
7300 arm_free_section (&exidx_arm_sec);
7301 arm_free_section (&extab_arm_sec);
7302}
7303
7304/* Used for both ARM and C6X unwinding tables. */
7305
7306static void
7307arm_process_unwind (FILE *file)
7308{
7309 struct arm_unw_aux_info aux;
7310 Elf_Internal_Shdr *unwsec = NULL;
7311 Elf_Internal_Shdr *strsec;
7312 Elf_Internal_Shdr *sec;
7313 unsigned long i;
7314 unsigned int sec_type;
7315
7316 switch (elf_header.e_machine)
7317 {
7318 case EM_ARM:
7319 sec_type = SHT_ARM_EXIDX;
7320 break;
7321
7322 case EM_TI_C6000:
7323 sec_type = SHT_C6000_UNWIND;
7324 break;
7325
7326 default:
7327 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7328 elf_header.e_machine);
7329 return;
7330 }
7331
7332 if (string_table == NULL)
7333 return;
7334
7335 memset (& aux, 0, sizeof (aux));
7336 aux.file = file;
7337
7338 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7339 {
7340 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7341 {
7342 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7343
7344 strsec = section_headers + sec->sh_link;
7345 assert (aux.strtab == NULL);
7346 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7347 1, strsec->sh_size, _("string table"));
7348 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7349 }
7350 else if (sec->sh_type == sec_type)
7351 unwsec = sec;
7352 }
7353
7354 if (unwsec == NULL)
7355 printf (_("\nThere are no unwind sections in this file.\n"));
7356 else
7357 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7358 {
7359 if (sec->sh_type == sec_type)
7360 {
7361 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7362 SECTION_NAME (sec),
7363 (unsigned long) sec->sh_offset,
7364 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7365
7366 dump_arm_unwind (&aux, sec);
7367 }
7368 }
7369
7370 if (aux.symtab)
7371 free (aux.symtab);
7372 if (aux.strtab)
7373 free ((char *) aux.strtab);
7374}
7375
7376static void
7377process_unwind (FILE * file)
7378{
7379 struct unwind_handler
7380 {
7381 int machtype;
7382 void (* handler)(FILE *);
7383 } handlers[] =
7384 {
7385 { EM_ARM, arm_process_unwind },
7386 { EM_IA_64, ia64_process_unwind },
7387 { EM_PARISC, hppa_process_unwind },
7388 { EM_TI_C6000, arm_process_unwind },
7389 { 0, 0 }
7390 };
7391 int i;
7392
7393 if (!do_unwind)
7394 return;
7395
7396 for (i = 0; handlers[i].handler != NULL; i++)
7397 if (elf_header.e_machine == handlers[i].machtype)
7398 return handlers[i].handler (file);
7399
7400 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7401 get_machine_name (elf_header.e_machine));
7402}
7403
7404static void
7405dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7406{
7407 switch (entry->d_tag)
7408 {
7409 case DT_MIPS_FLAGS:
7410 if (entry->d_un.d_val == 0)
7411 printf (_("NONE"));
7412 else
7413 {
7414 static const char * opts[] =
7415 {
7416 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7417 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7418 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7419 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7420 "RLD_ORDER_SAFE"
7421 };
7422 unsigned int cnt;
7423 int first = 1;
7424
7425 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7426 if (entry->d_un.d_val & (1 << cnt))
7427 {
7428 printf ("%s%s", first ? "" : " ", opts[cnt]);
7429 first = 0;
7430 }
7431 }
7432 break;
7433
7434 case DT_MIPS_IVERSION:
7435 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7436 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7437 else
7438 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7439 break;
7440
7441 case DT_MIPS_TIME_STAMP:
7442 {
7443 char timebuf[20];
7444 struct tm * tmp;
7445
7446 time_t atime = entry->d_un.d_val;
7447 tmp = gmtime (&atime);
7448 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7449 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7450 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7451 printf (_("Time Stamp: %s"), timebuf);
7452 }
7453 break;
7454
7455 case DT_MIPS_RLD_VERSION:
7456 case DT_MIPS_LOCAL_GOTNO:
7457 case DT_MIPS_CONFLICTNO:
7458 case DT_MIPS_LIBLISTNO:
7459 case DT_MIPS_SYMTABNO:
7460 case DT_MIPS_UNREFEXTNO:
7461 case DT_MIPS_HIPAGENO:
7462 case DT_MIPS_DELTA_CLASS_NO:
7463 case DT_MIPS_DELTA_INSTANCE_NO:
7464 case DT_MIPS_DELTA_RELOC_NO:
7465 case DT_MIPS_DELTA_SYM_NO:
7466 case DT_MIPS_DELTA_CLASSSYM_NO:
7467 case DT_MIPS_COMPACT_SIZE:
7468 print_vma (entry->d_un.d_ptr, DEC);
7469 break;
7470
7471 default:
7472 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7473 }
7474 putchar ('\n');
7475}
7476
7477static void
7478dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7479{
7480 switch (entry->d_tag)
7481 {
7482 case DT_HP_DLD_FLAGS:
7483 {
7484 static struct
7485 {
7486 long int bit;
7487 const char * str;
7488 }
7489 flags[] =
7490 {
7491 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7492 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7493 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7494 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7495 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7496 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7497 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7498 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7499 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7500 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7501 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7502 { DT_HP_GST, "HP_GST" },
7503 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7504 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7505 { DT_HP_NODELETE, "HP_NODELETE" },
7506 { DT_HP_GROUP, "HP_GROUP" },
7507 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7508 };
7509 int first = 1;
7510 size_t cnt;
7511 bfd_vma val = entry->d_un.d_val;
7512
7513 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7514 if (val & flags[cnt].bit)
7515 {
7516 if (! first)
7517 putchar (' ');
7518 fputs (flags[cnt].str, stdout);
7519 first = 0;
7520 val ^= flags[cnt].bit;
7521 }
7522
7523 if (val != 0 || first)
7524 {
7525 if (! first)
7526 putchar (' ');
7527 print_vma (val, HEX);
7528 }
7529 }
7530 break;
7531
7532 default:
7533 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7534 break;
7535 }
7536 putchar ('\n');
7537}
7538
7539#ifdef BFD64
7540
7541/* VMS vs Unix time offset and factor. */
7542
7543#define VMS_EPOCH_OFFSET 35067168000000000LL
7544#define VMS_GRANULARITY_FACTOR 10000000
7545
7546/* Display a VMS time in a human readable format. */
7547
7548static void
7549print_vms_time (bfd_int64_t vmstime)
7550{
7551 struct tm *tm;
7552 time_t unxtime;
7553
7554 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7555 tm = gmtime (&unxtime);
7556 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7557 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7558 tm->tm_hour, tm->tm_min, tm->tm_sec);
7559}
7560#endif /* BFD64 */
7561
7562static void
7563dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7564{
7565 switch (entry->d_tag)
7566 {
7567 case DT_IA_64_PLT_RESERVE:
7568 /* First 3 slots reserved. */
7569 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7570 printf (" -- ");
7571 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7572 break;
7573
7574 case DT_IA_64_VMS_LINKTIME:
7575#ifdef BFD64
7576 print_vms_time (entry->d_un.d_val);
7577#endif
7578 break;
7579
7580 case DT_IA_64_VMS_LNKFLAGS:
7581 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7582 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7583 printf (" CALL_DEBUG");
7584 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7585 printf (" NOP0BUFS");
7586 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7587 printf (" P0IMAGE");
7588 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7589 printf (" MKTHREADS");
7590 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7591 printf (" UPCALLS");
7592 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7593 printf (" IMGSTA");
7594 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7595 printf (" INITIALIZE");
7596 if (entry->d_un.d_val & VMS_LF_MAIN)
7597 printf (" MAIN");
7598 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7599 printf (" EXE_INIT");
7600 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7601 printf (" TBK_IN_IMG");
7602 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7603 printf (" DBG_IN_IMG");
7604 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7605 printf (" TBK_IN_DSF");
7606 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7607 printf (" DBG_IN_DSF");
7608 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7609 printf (" SIGNATURES");
7610 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7611 printf (" REL_SEG_OFF");
7612 break;
7613
7614 default:
7615 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7616 break;
7617 }
7618 putchar ('\n');
7619}
7620
7621static int
7622get_32bit_dynamic_section (FILE * file)
7623{
7624 Elf32_External_Dyn * edyn;
7625 Elf32_External_Dyn * ext;
7626 Elf_Internal_Dyn * entry;
7627
7628 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7629 dynamic_size, _("dynamic section"));
7630 if (!edyn)
7631 return 0;
7632
7633/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7634 might not have the luxury of section headers. Look for the DT_NULL
7635 terminator to determine the number of entries. */
7636 for (ext = edyn, dynamic_nent = 0;
7637 (char *) ext < (char *) edyn + dynamic_size;
7638 ext++)
7639 {
7640 dynamic_nent++;
7641 if (BYTE_GET (ext->d_tag) == DT_NULL)
7642 break;
7643 }
7644
7645 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7646 sizeof (* entry));
7647 if (dynamic_section == NULL)
7648 {
7649 error (_("Out of memory\n"));
7650 free (edyn);
7651 return 0;
7652 }
7653
7654 for (ext = edyn, entry = dynamic_section;
7655 entry < dynamic_section + dynamic_nent;
7656 ext++, entry++)
7657 {
7658 entry->d_tag = BYTE_GET (ext->d_tag);
7659 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7660 }
7661
7662 free (edyn);
7663
7664 return 1;
7665}
7666
7667static int
7668get_64bit_dynamic_section (FILE * file)
7669{
7670 Elf64_External_Dyn * edyn;
7671 Elf64_External_Dyn * ext;
7672 Elf_Internal_Dyn * entry;
7673
7674 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7675 dynamic_size, _("dynamic section"));
7676 if (!edyn)
7677 return 0;
7678
7679/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7680 might not have the luxury of section headers. Look for the DT_NULL
7681 terminator to determine the number of entries. */
7682 for (ext = edyn, dynamic_nent = 0;
7683 (char *) ext < (char *) edyn + dynamic_size;
7684 ext++)
7685 {
7686 dynamic_nent++;
7687 if (BYTE_GET (ext->d_tag) == DT_NULL)
7688 break;
7689 }
7690
7691 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7692 sizeof (* entry));
7693 if (dynamic_section == NULL)
7694 {
7695 error (_("Out of memory\n"));
7696 free (edyn);
7697 return 0;
7698 }
7699
7700 for (ext = edyn, entry = dynamic_section;
7701 entry < dynamic_section + dynamic_nent;
7702 ext++, entry++)
7703 {
7704 entry->d_tag = BYTE_GET (ext->d_tag);
7705 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7706 }
7707
7708 free (edyn);
7709
7710 return 1;
7711}
7712
7713static void
7714print_dynamic_flags (bfd_vma flags)
7715{
7716 int first = 1;
7717
7718 while (flags)
7719 {
7720 bfd_vma flag;
7721
7722 flag = flags & - flags;
7723 flags &= ~ flag;
7724
7725 if (first)
7726 first = 0;
7727 else
7728 putc (' ', stdout);
7729
7730 switch (flag)
7731 {
7732 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7733 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7734 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7735 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7736 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7737 default: fputs (_("unknown"), stdout); break;
7738 }
7739 }
7740 puts ("");
7741}
7742
7743/* Parse and display the contents of the dynamic section. */
7744
7745static int
7746process_dynamic_section (FILE * file)
7747{
7748 Elf_Internal_Dyn * entry;
7749
7750 if (dynamic_size == 0)
7751 {
7752 if (do_dynamic)
7753 printf (_("\nThere is no dynamic section in this file.\n"));
7754
7755 return 1;
7756 }
7757
7758 if (is_32bit_elf)
7759 {
7760 if (! get_32bit_dynamic_section (file))
7761 return 0;
7762 }
7763 else if (! get_64bit_dynamic_section (file))
7764 return 0;
7765
7766 /* Find the appropriate symbol table. */
7767 if (dynamic_symbols == NULL)
7768 {
7769 for (entry = dynamic_section;
7770 entry < dynamic_section + dynamic_nent;
7771 ++entry)
7772 {
7773 Elf_Internal_Shdr section;
7774
7775 if (entry->d_tag != DT_SYMTAB)
7776 continue;
7777
7778 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7779
7780 /* Since we do not know how big the symbol table is,
7781 we default to reading in the entire file (!) and
7782 processing that. This is overkill, I know, but it
7783 should work. */
7784 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7785
7786 if (archive_file_offset != 0)
7787 section.sh_size = archive_file_size - section.sh_offset;
7788 else
7789 {
7790 if (fseek (file, 0, SEEK_END))
7791 error (_("Unable to seek to end of file!\n"));
7792
7793 section.sh_size = ftell (file) - section.sh_offset;
7794 }
7795
7796 if (is_32bit_elf)
7797 section.sh_entsize = sizeof (Elf32_External_Sym);
7798 else
7799 section.sh_entsize = sizeof (Elf64_External_Sym);
7800
7801 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
7802 if (num_dynamic_syms < 1)
7803 {
7804 error (_("Unable to determine the number of symbols to load\n"));
7805 continue;
7806 }
7807 }
7808 }
7809
7810 /* Similarly find a string table. */
7811 if (dynamic_strings == NULL)
7812 {
7813 for (entry = dynamic_section;
7814 entry < dynamic_section + dynamic_nent;
7815 ++entry)
7816 {
7817 unsigned long offset;
7818 long str_tab_len;
7819
7820 if (entry->d_tag != DT_STRTAB)
7821 continue;
7822
7823 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7824
7825 /* Since we do not know how big the string table is,
7826 we default to reading in the entire file (!) and
7827 processing that. This is overkill, I know, but it
7828 should work. */
7829
7830 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7831
7832 if (archive_file_offset != 0)
7833 str_tab_len = archive_file_size - offset;
7834 else
7835 {
7836 if (fseek (file, 0, SEEK_END))
7837 error (_("Unable to seek to end of file\n"));
7838 str_tab_len = ftell (file) - offset;
7839 }
7840
7841 if (str_tab_len < 1)
7842 {
7843 error
7844 (_("Unable to determine the length of the dynamic string table\n"));
7845 continue;
7846 }
7847
7848 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7849 str_tab_len,
7850 _("dynamic string table"));
7851 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7852 break;
7853 }
7854 }
7855
7856 /* And find the syminfo section if available. */
7857 if (dynamic_syminfo == NULL)
7858 {
7859 unsigned long syminsz = 0;
7860
7861 for (entry = dynamic_section;
7862 entry < dynamic_section + dynamic_nent;
7863 ++entry)
7864 {
7865 if (entry->d_tag == DT_SYMINENT)
7866 {
7867 /* Note: these braces are necessary to avoid a syntax
7868 error from the SunOS4 C compiler. */
7869 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7870 }
7871 else if (entry->d_tag == DT_SYMINSZ)
7872 syminsz = entry->d_un.d_val;
7873 else if (entry->d_tag == DT_SYMINFO)
7874 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7875 syminsz);
7876 }
7877
7878 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7879 {
7880 Elf_External_Syminfo * extsyminfo;
7881 Elf_External_Syminfo * extsym;
7882 Elf_Internal_Syminfo * syminfo;
7883
7884 /* There is a syminfo section. Read the data. */
7885 extsyminfo = (Elf_External_Syminfo *)
7886 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7887 _("symbol information"));
7888 if (!extsyminfo)
7889 return 0;
7890
7891 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7892 if (dynamic_syminfo == NULL)
7893 {
7894 error (_("Out of memory\n"));
7895 return 0;
7896 }
7897
7898 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7899 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7900 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7901 ++syminfo, ++extsym)
7902 {
7903 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7904 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7905 }
7906
7907 free (extsyminfo);
7908 }
7909 }
7910
7911 if (do_dynamic && dynamic_addr)
7912 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7913 dynamic_addr, dynamic_nent);
7914 if (do_dynamic)
7915 printf (_(" Tag Type Name/Value\n"));
7916
7917 for (entry = dynamic_section;
7918 entry < dynamic_section + dynamic_nent;
7919 entry++)
7920 {
7921 if (do_dynamic)
7922 {
7923 const char * dtype;
7924
7925 putchar (' ');
7926 print_vma (entry->d_tag, FULL_HEX);
7927 dtype = get_dynamic_type (entry->d_tag);
7928 printf (" (%s)%*s", dtype,
7929 ((is_32bit_elf ? 27 : 19)
7930 - (int) strlen (dtype)),
7931 " ");
7932 }
7933
7934 switch (entry->d_tag)
7935 {
7936 case DT_FLAGS:
7937 if (do_dynamic)
7938 print_dynamic_flags (entry->d_un.d_val);
7939 break;
7940
7941 case DT_AUXILIARY:
7942 case DT_FILTER:
7943 case DT_CONFIG:
7944 case DT_DEPAUDIT:
7945 case DT_AUDIT:
7946 if (do_dynamic)
7947 {
7948 switch (entry->d_tag)
7949 {
7950 case DT_AUXILIARY:
7951 printf (_("Auxiliary library"));
7952 break;
7953
7954 case DT_FILTER:
7955 printf (_("Filter library"));
7956 break;
7957
7958 case DT_CONFIG:
7959 printf (_("Configuration file"));
7960 break;
7961
7962 case DT_DEPAUDIT:
7963 printf (_("Dependency audit library"));
7964 break;
7965
7966 case DT_AUDIT:
7967 printf (_("Audit library"));
7968 break;
7969 }
7970
7971 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7972 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7973 else
7974 {
7975 printf (": ");
7976 print_vma (entry->d_un.d_val, PREFIX_HEX);
7977 putchar ('\n');
7978 }
7979 }
7980 break;
7981
7982 case DT_FEATURE:
7983 if (do_dynamic)
7984 {
7985 printf (_("Flags:"));
7986
7987 if (entry->d_un.d_val == 0)
7988 printf (_(" None\n"));
7989 else
7990 {
7991 unsigned long int val = entry->d_un.d_val;
7992
7993 if (val & DTF_1_PARINIT)
7994 {
7995 printf (" PARINIT");
7996 val ^= DTF_1_PARINIT;
7997 }
7998 if (val & DTF_1_CONFEXP)
7999 {
8000 printf (" CONFEXP");
8001 val ^= DTF_1_CONFEXP;
8002 }
8003 if (val != 0)
8004 printf (" %lx", val);
8005 puts ("");
8006 }
8007 }
8008 break;
8009
8010 case DT_POSFLAG_1:
8011 if (do_dynamic)
8012 {
8013 printf (_("Flags:"));
8014
8015 if (entry->d_un.d_val == 0)
8016 printf (_(" None\n"));
8017 else
8018 {
8019 unsigned long int val = entry->d_un.d_val;
8020
8021 if (val & DF_P1_LAZYLOAD)
8022 {
8023 printf (" LAZYLOAD");
8024 val ^= DF_P1_LAZYLOAD;
8025 }
8026 if (val & DF_P1_GROUPPERM)
8027 {
8028 printf (" GROUPPERM");
8029 val ^= DF_P1_GROUPPERM;
8030 }
8031 if (val != 0)
8032 printf (" %lx", val);
8033 puts ("");
8034 }
8035 }
8036 break;
8037
8038 case DT_FLAGS_1:
8039 if (do_dynamic)
8040 {
8041 printf (_("Flags:"));
8042 if (entry->d_un.d_val == 0)
8043 printf (_(" None\n"));
8044 else
8045 {
8046 unsigned long int val = entry->d_un.d_val;
8047
8048 if (val & DF_1_NOW)
8049 {
8050 printf (" NOW");
8051 val ^= DF_1_NOW;
8052 }
8053 if (val & DF_1_GLOBAL)
8054 {
8055 printf (" GLOBAL");
8056 val ^= DF_1_GLOBAL;
8057 }
8058 if (val & DF_1_GROUP)
8059 {
8060 printf (" GROUP");
8061 val ^= DF_1_GROUP;
8062 }
8063 if (val & DF_1_NODELETE)
8064 {
8065 printf (" NODELETE");
8066 val ^= DF_1_NODELETE;
8067 }
8068 if (val & DF_1_LOADFLTR)
8069 {
8070 printf (" LOADFLTR");
8071 val ^= DF_1_LOADFLTR;
8072 }
8073 if (val & DF_1_INITFIRST)
8074 {
8075 printf (" INITFIRST");
8076 val ^= DF_1_INITFIRST;
8077 }
8078 if (val & DF_1_NOOPEN)
8079 {
8080 printf (" NOOPEN");
8081 val ^= DF_1_NOOPEN;
8082 }
8083 if (val & DF_1_ORIGIN)
8084 {
8085 printf (" ORIGIN");
8086 val ^= DF_1_ORIGIN;
8087 }
8088 if (val & DF_1_DIRECT)
8089 {
8090 printf (" DIRECT");
8091 val ^= DF_1_DIRECT;
8092 }
8093 if (val & DF_1_TRANS)
8094 {
8095 printf (" TRANS");
8096 val ^= DF_1_TRANS;
8097 }
8098 if (val & DF_1_INTERPOSE)
8099 {
8100 printf (" INTERPOSE");
8101 val ^= DF_1_INTERPOSE;
8102 }
8103 if (val & DF_1_NODEFLIB)
8104 {
8105 printf (" NODEFLIB");
8106 val ^= DF_1_NODEFLIB;
8107 }
8108 if (val & DF_1_NODUMP)
8109 {
8110 printf (" NODUMP");
8111 val ^= DF_1_NODUMP;
8112 }
8113 if (val & DF_1_CONLFAT)
8114 {
8115 printf (" CONLFAT");
8116 val ^= DF_1_CONLFAT;
8117 }
8118 if (val != 0)
8119 printf (" %lx", val);
8120 puts ("");
8121 }
8122 }
8123 break;
8124
8125 case DT_PLTREL:
8126 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8127 if (do_dynamic)
8128 puts (get_dynamic_type (entry->d_un.d_val));
8129 break;
8130
8131 case DT_NULL :
8132 case DT_NEEDED :
8133 case DT_PLTGOT :
8134 case DT_HASH :
8135 case DT_STRTAB :
8136 case DT_SYMTAB :
8137 case DT_RELA :
8138 case DT_INIT :
8139 case DT_FINI :
8140 case DT_SONAME :
8141 case DT_RPATH :
8142 case DT_SYMBOLIC:
8143 case DT_REL :
8144 case DT_DEBUG :
8145 case DT_TEXTREL :
8146 case DT_JMPREL :
8147 case DT_RUNPATH :
8148 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8149
8150 if (do_dynamic)
8151 {
8152 char * name;
8153
8154 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8155 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8156 else
8157 name = NULL;
8158
8159 if (name)
8160 {
8161 switch (entry->d_tag)
8162 {
8163 case DT_NEEDED:
8164 printf (_("Shared library: [%s]"), name);
8165
8166 if (streq (name, program_interpreter))
8167 printf (_(" program interpreter"));
8168 break;
8169
8170 case DT_SONAME:
8171 printf (_("Library soname: [%s]"), name);
8172 break;
8173
8174 case DT_RPATH:
8175 printf (_("Library rpath: [%s]"), name);
8176 break;
8177
8178 case DT_RUNPATH:
8179 printf (_("Library runpath: [%s]"), name);
8180 break;
8181
8182 default:
8183 print_vma (entry->d_un.d_val, PREFIX_HEX);
8184 break;
8185 }
8186 }
8187 else
8188 print_vma (entry->d_un.d_val, PREFIX_HEX);
8189
8190 putchar ('\n');
8191 }
8192 break;
8193
8194 case DT_PLTRELSZ:
8195 case DT_RELASZ :
8196 case DT_STRSZ :
8197 case DT_RELSZ :
8198 case DT_RELAENT :
8199 case DT_SYMENT :
8200 case DT_RELENT :
8201 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8202 case DT_PLTPADSZ:
8203 case DT_MOVEENT :
8204 case DT_MOVESZ :
8205 case DT_INIT_ARRAYSZ:
8206 case DT_FINI_ARRAYSZ:
8207 case DT_GNU_CONFLICTSZ:
8208 case DT_GNU_LIBLISTSZ:
8209 if (do_dynamic)
8210 {
8211 print_vma (entry->d_un.d_val, UNSIGNED);
8212 printf (_(" (bytes)\n"));
8213 }
8214 break;
8215
8216 case DT_VERDEFNUM:
8217 case DT_VERNEEDNUM:
8218 case DT_RELACOUNT:
8219 case DT_RELCOUNT:
8220 if (do_dynamic)
8221 {
8222 print_vma (entry->d_un.d_val, UNSIGNED);
8223 putchar ('\n');
8224 }
8225 break;
8226
8227 case DT_SYMINSZ:
8228 case DT_SYMINENT:
8229 case DT_SYMINFO:
8230 case DT_USED:
8231 case DT_INIT_ARRAY:
8232 case DT_FINI_ARRAY:
8233 if (do_dynamic)
8234 {
8235 if (entry->d_tag == DT_USED
8236 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8237 {
8238 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8239
8240 if (*name)
8241 {
8242 printf (_("Not needed object: [%s]\n"), name);
8243 break;
8244 }
8245 }
8246
8247 print_vma (entry->d_un.d_val, PREFIX_HEX);
8248 putchar ('\n');
8249 }
8250 break;
8251
8252 case DT_BIND_NOW:
8253 /* The value of this entry is ignored. */
8254 if (do_dynamic)
8255 putchar ('\n');
8256 break;
8257
8258 case DT_GNU_PRELINKED:
8259 if (do_dynamic)
8260 {
8261 struct tm * tmp;
8262 time_t atime = entry->d_un.d_val;
8263
8264 tmp = gmtime (&atime);
8265 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8266 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8267 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8268
8269 }
8270 break;
8271
8272 case DT_GNU_HASH:
8273 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8274 if (do_dynamic)
8275 {
8276 print_vma (entry->d_un.d_val, PREFIX_HEX);
8277 putchar ('\n');
8278 }
8279 break;
8280
8281 default:
8282 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8283 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8284 entry->d_un.d_val;
8285
8286 if (do_dynamic)
8287 {
8288 switch (elf_header.e_machine)
8289 {
8290 case EM_MIPS:
8291 case EM_MIPS_RS3_LE:
8292 dynamic_section_mips_val (entry);
8293 break;
8294 case EM_PARISC:
8295 dynamic_section_parisc_val (entry);
8296 break;
8297 case EM_IA_64:
8298 dynamic_section_ia64_val (entry);
8299 break;
8300 default:
8301 print_vma (entry->d_un.d_val, PREFIX_HEX);
8302 putchar ('\n');
8303 }
8304 }
8305 break;
8306 }
8307 }
8308
8309 return 1;
8310}
8311
8312static char *
8313get_ver_flags (unsigned int flags)
8314{
8315 static char buff[32];
8316
8317 buff[0] = 0;
8318
8319 if (flags == 0)
8320 return _("none");
8321
8322 if (flags & VER_FLG_BASE)
8323 strcat (buff, "BASE ");
8324
8325 if (flags & VER_FLG_WEAK)
8326 {
8327 if (flags & VER_FLG_BASE)
8328 strcat (buff, "| ");
8329
8330 strcat (buff, "WEAK ");
8331 }
8332
8333 if (flags & VER_FLG_INFO)
8334 {
8335 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8336 strcat (buff, "| ");
8337
8338 strcat (buff, "INFO ");
8339 }
8340
8341 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8342 strcat (buff, _("| <unknown>"));
8343
8344 return buff;
8345}
8346
8347/* Display the contents of the version sections. */
8348
8349static int
8350process_version_sections (FILE * file)
8351{
8352 Elf_Internal_Shdr * section;
8353 unsigned i;
8354 int found = 0;
8355
8356 if (! do_version)
8357 return 1;
8358
8359 for (i = 0, section = section_headers;
8360 i < elf_header.e_shnum;
8361 i++, section++)
8362 {
8363 switch (section->sh_type)
8364 {
8365 case SHT_GNU_verdef:
8366 {
8367 Elf_External_Verdef * edefs;
8368 unsigned int idx;
8369 unsigned int cnt;
8370 char * endbuf;
8371
8372 found = 1;
8373
8374 printf
8375 (_("\nVersion definition section '%s' contains %u entries:\n"),
8376 SECTION_NAME (section), section->sh_info);
8377
8378 printf (_(" Addr: 0x"));
8379 printf_vma (section->sh_addr);
8380 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8381 (unsigned long) section->sh_offset, section->sh_link,
8382 section->sh_link < elf_header.e_shnum
8383 ? SECTION_NAME (section_headers + section->sh_link)
8384 : _("<corrupt>"));
8385
8386 edefs = (Elf_External_Verdef *)
8387 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8388 _("version definition section"));
8389 if (!edefs)
8390 break;
8391 endbuf = (char *) edefs + section->sh_size;
8392
8393 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8394 {
8395 char * vstart;
8396 Elf_External_Verdef * edef;
8397 Elf_Internal_Verdef ent;
8398 Elf_External_Verdaux * eaux;
8399 Elf_Internal_Verdaux aux;
8400 int j;
8401 int isum;
8402
8403 /* Check for negative or very large indicies. */
8404 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8405 break;
8406
8407 vstart = ((char *) edefs) + idx;
8408 if (vstart + sizeof (*edef) > endbuf)
8409 break;
8410
8411 edef = (Elf_External_Verdef *) vstart;
8412
8413 ent.vd_version = BYTE_GET (edef->vd_version);
8414 ent.vd_flags = BYTE_GET (edef->vd_flags);
8415 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8416 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8417 ent.vd_hash = BYTE_GET (edef->vd_hash);
8418 ent.vd_aux = BYTE_GET (edef->vd_aux);
8419 ent.vd_next = BYTE_GET (edef->vd_next);
8420
8421 printf (_(" %#06x: Rev: %d Flags: %s"),
8422 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8423
8424 printf (_(" Index: %d Cnt: %d "),
8425 ent.vd_ndx, ent.vd_cnt);
8426
8427 /* Check for overflow. */
8428 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8429 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8430 break;
8431
8432 vstart += ent.vd_aux;
8433
8434 eaux = (Elf_External_Verdaux *) vstart;
8435
8436 aux.vda_name = BYTE_GET (eaux->vda_name);
8437 aux.vda_next = BYTE_GET (eaux->vda_next);
8438
8439 if (VALID_DYNAMIC_NAME (aux.vda_name))
8440 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8441 else
8442 printf (_("Name index: %ld\n"), aux.vda_name);
8443
8444 isum = idx + ent.vd_aux;
8445
8446 for (j = 1; j < ent.vd_cnt; j++)
8447 {
8448 /* Check for overflow. */
8449 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8450 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8451 break;
8452
8453 isum += aux.vda_next;
8454 vstart += aux.vda_next;
8455
8456 eaux = (Elf_External_Verdaux *) vstart;
8457 if (vstart + sizeof (*eaux) > endbuf)
8458 break;
8459
8460 aux.vda_name = BYTE_GET (eaux->vda_name);
8461 aux.vda_next = BYTE_GET (eaux->vda_next);
8462
8463 if (VALID_DYNAMIC_NAME (aux.vda_name))
8464 printf (_(" %#06x: Parent %d: %s\n"),
8465 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8466 else
8467 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8468 isum, j, aux.vda_name);
8469 }
8470
8471 if (j < ent.vd_cnt)
8472 printf (_(" Version def aux past end of section\n"));
8473
8474 idx += ent.vd_next;
8475 }
8476
8477 if (cnt < section->sh_info)
8478 printf (_(" Version definition past end of section\n"));
8479
8480 free (edefs);
8481 }
8482 break;
8483
8484 case SHT_GNU_verneed:
8485 {
8486 Elf_External_Verneed * eneed;
8487 unsigned int idx;
8488 unsigned int cnt;
8489 char * endbuf;
8490
8491 found = 1;
8492
8493 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8494 SECTION_NAME (section), section->sh_info);
8495
8496 printf (_(" Addr: 0x"));
8497 printf_vma (section->sh_addr);
8498 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8499 (unsigned long) section->sh_offset, section->sh_link,
8500 section->sh_link < elf_header.e_shnum
8501 ? SECTION_NAME (section_headers + section->sh_link)
8502 : _("<corrupt>"));
8503
8504 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8505 section->sh_offset, 1,
8506 section->sh_size,
8507 _("Version Needs section"));
8508 if (!eneed)
8509 break;
8510 endbuf = (char *) eneed + section->sh_size;
8511
8512 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8513 {
8514 Elf_External_Verneed * entry;
8515 Elf_Internal_Verneed ent;
8516 int j;
8517 int isum;
8518 char * vstart;
8519
8520 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8521 break;
8522
8523 vstart = ((char *) eneed) + idx;
8524 if (vstart + sizeof (*entry) > endbuf)
8525 break;
8526
8527 entry = (Elf_External_Verneed *) vstart;
8528
8529 ent.vn_version = BYTE_GET (entry->vn_version);
8530 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8531 ent.vn_file = BYTE_GET (entry->vn_file);
8532 ent.vn_aux = BYTE_GET (entry->vn_aux);
8533 ent.vn_next = BYTE_GET (entry->vn_next);
8534
8535 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8536
8537 if (VALID_DYNAMIC_NAME (ent.vn_file))
8538 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8539 else
8540 printf (_(" File: %lx"), ent.vn_file);
8541
8542 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8543
8544 /* Check for overflow. */
8545 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8546 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8547 break;
8548
8549 vstart += ent.vn_aux;
8550
8551 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8552 {
8553 Elf_External_Vernaux * eaux;
8554 Elf_Internal_Vernaux aux;
8555
8556 if (vstart + sizeof (*eaux) > endbuf)
8557 break;
8558 eaux = (Elf_External_Vernaux *) vstart;
8559
8560 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8561 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8562 aux.vna_other = BYTE_GET (eaux->vna_other);
8563 aux.vna_name = BYTE_GET (eaux->vna_name);
8564 aux.vna_next = BYTE_GET (eaux->vna_next);
8565
8566 if (VALID_DYNAMIC_NAME (aux.vna_name))
8567 printf (_(" %#06x: Name: %s"),
8568 isum, GET_DYNAMIC_NAME (aux.vna_name));
8569 else
8570 printf (_(" %#06x: Name index: %lx"),
8571 isum, aux.vna_name);
8572
8573 printf (_(" Flags: %s Version: %d\n"),
8574 get_ver_flags (aux.vna_flags), aux.vna_other);
8575
8576 /* Check for overflow. */
8577 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8578 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8579 break;
8580
8581 isum += aux.vna_next;
8582 vstart += aux.vna_next;
8583 }
8584
8585 if (j < ent.vn_cnt)
8586 warn (_("Missing Version Needs auxillary information\n"));
8587
8588 idx += ent.vn_next;
8589 }
8590
8591 if (cnt < section->sh_info)
8592 warn (_("Missing Version Needs information\n"));
8593
8594 free (eneed);
8595 }
8596 break;
8597
8598 case SHT_GNU_versym:
8599 {
8600 Elf_Internal_Shdr * link_section;
8601 int total;
8602 int cnt;
8603 unsigned char * edata;
8604 unsigned short * data;
8605 char * strtab;
8606 Elf_Internal_Sym * symbols;
8607 Elf_Internal_Shdr * string_sec;
8608 unsigned long num_syms;
8609 long off;
8610
8611 if (section->sh_link >= elf_header.e_shnum)
8612 break;
8613
8614 link_section = section_headers + section->sh_link;
8615 total = section->sh_size / sizeof (Elf_External_Versym);
8616
8617 if (link_section->sh_link >= elf_header.e_shnum)
8618 break;
8619
8620 found = 1;
8621
8622 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
8623 if (symbols == NULL)
8624 break;
8625
8626 string_sec = section_headers + link_section->sh_link;
8627
8628 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8629 string_sec->sh_size,
8630 _("version string table"));
8631 if (!strtab)
8632 {
8633 free (symbols);
8634 break;
8635 }
8636
8637 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8638 SECTION_NAME (section), total);
8639
8640 printf (_(" Addr: "));
8641 printf_vma (section->sh_addr);
8642 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8643 (unsigned long) section->sh_offset, section->sh_link,
8644 SECTION_NAME (link_section));
8645
8646 off = offset_from_vma (file,
8647 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8648 total * sizeof (short));
8649 edata = (unsigned char *) get_data (NULL, file, off, total,
8650 sizeof (short),
8651 _("version symbol data"));
8652 if (!edata)
8653 {
8654 free (strtab);
8655 free (symbols);
8656 break;
8657 }
8658
8659 data = (short unsigned int *) cmalloc (total, sizeof (short));
8660
8661 for (cnt = total; cnt --;)
8662 data[cnt] = byte_get (edata + cnt * sizeof (short),
8663 sizeof (short));
8664
8665 free (edata);
8666
8667 for (cnt = 0; cnt < total; cnt += 4)
8668 {
8669 int j, nn;
8670 int check_def, check_need;
8671 char * name;
8672
8673 printf (" %03x:", cnt);
8674
8675 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8676 switch (data[cnt + j])
8677 {
8678 case 0:
8679 fputs (_(" 0 (*local*) "), stdout);
8680 break;
8681
8682 case 1:
8683 fputs (_(" 1 (*global*) "), stdout);
8684 break;
8685
8686 default:
8687 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8688 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8689
8690 /* If this index value is greater than the size of the symbols
8691 array, break to avoid an out-of-bounds read. */
8692 if ((unsigned long)(cnt + j) >= num_syms)
8693 {
8694 warn (_("invalid index into symbol array\n"));
8695 break;
8696 }
8697
8698 check_def = 1;
8699 check_need = 1;
8700 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8701 || section_headers[symbols[cnt + j].st_shndx].sh_type
8702 != SHT_NOBITS)
8703 {
8704 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8705 check_def = 0;
8706 else
8707 check_need = 0;
8708 }
8709
8710 if (check_need
8711 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8712 {
8713 Elf_Internal_Verneed ivn;
8714 unsigned long offset;
8715
8716 offset = offset_from_vma
8717 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8718 sizeof (Elf_External_Verneed));
8719
8720 do
8721 {
8722 Elf_Internal_Vernaux ivna;
8723 Elf_External_Verneed evn;
8724 Elf_External_Vernaux evna;
8725 unsigned long a_off;
8726
8727 if (get_data (&evn, file, offset, sizeof (evn), 1,
8728 _("version need")) == NULL)
8729 break;
8730
8731 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8732 ivn.vn_next = BYTE_GET (evn.vn_next);
8733
8734 a_off = offset + ivn.vn_aux;
8735
8736 do
8737 {
8738 if (get_data (&evna, file, a_off, sizeof (evna),
8739 1, _("version need aux (2)")) == NULL)
8740 {
8741 ivna.vna_next = 0;
8742 ivna.vna_other = 0;
8743 }
8744 else
8745 {
8746 ivna.vna_next = BYTE_GET (evna.vna_next);
8747 ivna.vna_other = BYTE_GET (evna.vna_other);
8748 }
8749
8750 a_off += ivna.vna_next;
8751 }
8752 while (ivna.vna_other != data[cnt + j]
8753 && ivna.vna_next != 0);
8754
8755 if (ivna.vna_other == data[cnt + j])
8756 {
8757 ivna.vna_name = BYTE_GET (evna.vna_name);
8758
8759 if (ivna.vna_name >= string_sec->sh_size)
8760 name = _("*invalid*");
8761 else
8762 name = strtab + ivna.vna_name;
8763 nn += printf ("(%s%-*s",
8764 name,
8765 12 - (int) strlen (name),
8766 ")");
8767 check_def = 0;
8768 break;
8769 }
8770
8771 offset += ivn.vn_next;
8772 }
8773 while (ivn.vn_next);
8774 }
8775
8776 if (check_def && data[cnt + j] != 0x8001
8777 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8778 {
8779 Elf_Internal_Verdef ivd;
8780 Elf_External_Verdef evd;
8781 unsigned long offset;
8782
8783 offset = offset_from_vma
8784 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8785 sizeof evd);
8786
8787 do
8788 {
8789 if (get_data (&evd, file, offset, sizeof (evd), 1,
8790 _("version def")) == NULL)
8791 {
8792 ivd.vd_next = 0;
8793 ivd.vd_ndx = 0;
8794 }
8795 else
8796 {
8797 ivd.vd_next = BYTE_GET (evd.vd_next);
8798 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8799 }
8800
8801 offset += ivd.vd_next;
8802 }
8803 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8804 && ivd.vd_next != 0);
8805
8806 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8807 {
8808 Elf_External_Verdaux evda;
8809 Elf_Internal_Verdaux ivda;
8810
8811 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8812
8813 if (get_data (&evda, file,
8814 offset - ivd.vd_next + ivd.vd_aux,
8815 sizeof (evda), 1,
8816 _("version def aux")) == NULL)
8817 break;
8818
8819 ivda.vda_name = BYTE_GET (evda.vda_name);
8820
8821 if (ivda.vda_name >= string_sec->sh_size)
8822 name = _("*invalid*");
8823 else
8824 name = strtab + ivda.vda_name;
8825 nn += printf ("(%s%-*s",
8826 name,
8827 12 - (int) strlen (name),
8828 ")");
8829 }
8830 }
8831
8832 if (nn < 18)
8833 printf ("%*c", 18 - nn, ' ');
8834 }
8835
8836 putchar ('\n');
8837 }
8838
8839 free (data);
8840 free (strtab);
8841 free (symbols);
8842 }
8843 break;
8844
8845 default:
8846 break;
8847 }
8848 }
8849
8850 if (! found)
8851 printf (_("\nNo version information found in this file.\n"));
8852
8853 return 1;
8854}
8855
8856static const char *
8857get_symbol_binding (unsigned int binding)
8858{
8859 static char buff[32];
8860
8861 switch (binding)
8862 {
8863 case STB_LOCAL: return "LOCAL";
8864 case STB_GLOBAL: return "GLOBAL";
8865 case STB_WEAK: return "WEAK";
8866 default:
8867 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8868 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8869 binding);
8870 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8871 {
8872 if (binding == STB_GNU_UNIQUE
8873 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8874 /* GNU is still using the default value 0. */
8875 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8876 return "UNIQUE";
8877 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8878 }
8879 else
8880 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8881 return buff;
8882 }
8883}
8884
8885static const char *
8886get_symbol_type (unsigned int type)
8887{
8888 static char buff[32];
8889
8890 switch (type)
8891 {
8892 case STT_NOTYPE: return "NOTYPE";
8893 case STT_OBJECT: return "OBJECT";
8894 case STT_FUNC: return "FUNC";
8895 case STT_SECTION: return "SECTION";
8896 case STT_FILE: return "FILE";
8897 case STT_COMMON: return "COMMON";
8898 case STT_TLS: return "TLS";
8899 case STT_RELC: return "RELC";
8900 case STT_SRELC: return "SRELC";
8901 default:
8902 if (type >= STT_LOPROC && type <= STT_HIPROC)
8903 {
8904 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8905 return "THUMB_FUNC";
8906
8907 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8908 return "REGISTER";
8909
8910 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8911 return "PARISC_MILLI";
8912
8913 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8914 }
8915 else if (type >= STT_LOOS && type <= STT_HIOS)
8916 {
8917 if (elf_header.e_machine == EM_PARISC)
8918 {
8919 if (type == STT_HP_OPAQUE)
8920 return "HP_OPAQUE";
8921 if (type == STT_HP_STUB)
8922 return "HP_STUB";
8923 }
8924
8925 if (type == STT_GNU_IFUNC
8926 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8927 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
8928 /* GNU is still using the default value 0. */
8929 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8930 return "IFUNC";
8931
8932 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8933 }
8934 else
8935 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8936 return buff;
8937 }
8938}
8939
8940static const char *
8941get_symbol_visibility (unsigned int visibility)
8942{
8943 switch (visibility)
8944 {
8945 case STV_DEFAULT: return "DEFAULT";
8946 case STV_INTERNAL: return "INTERNAL";
8947 case STV_HIDDEN: return "HIDDEN";
8948 case STV_PROTECTED: return "PROTECTED";
8949 default: abort ();
8950 }
8951}
8952
8953static const char *
8954get_mips_symbol_other (unsigned int other)
8955{
8956 switch (other)
8957 {
8958 case STO_OPTIONAL:
8959 return "OPTIONAL";
8960 case STO_MIPS_PLT:
8961 return "MIPS PLT";
8962 case STO_MIPS_PIC:
8963 return "MIPS PIC";
8964 case STO_MICROMIPS:
8965 return "MICROMIPS";
8966 case STO_MICROMIPS | STO_MIPS_PIC:
8967 return "MICROMIPS, MIPS PIC";
8968 case STO_MIPS16:
8969 return "MIPS16";
8970 default:
8971 return NULL;
8972 }
8973}
8974
8975static const char *
8976get_ia64_symbol_other (unsigned int other)
8977{
8978 if (is_ia64_vms ())
8979 {
8980 static char res[32];
8981
8982 res[0] = 0;
8983
8984 /* Function types is for images and .STB files only. */
8985 switch (elf_header.e_type)
8986 {
8987 case ET_DYN:
8988 case ET_EXEC:
8989 switch (VMS_ST_FUNC_TYPE (other))
8990 {
8991 case VMS_SFT_CODE_ADDR:
8992 strcat (res, " CA");
8993 break;
8994 case VMS_SFT_SYMV_IDX:
8995 strcat (res, " VEC");
8996 break;
8997 case VMS_SFT_FD:
8998 strcat (res, " FD");
8999 break;
9000 case VMS_SFT_RESERVE:
9001 strcat (res, " RSV");
9002 break;
9003 default:
9004 abort ();
9005 }
9006 break;
9007 default:
9008 break;
9009 }
9010 switch (VMS_ST_LINKAGE (other))
9011 {
9012 case VMS_STL_IGNORE:
9013 strcat (res, " IGN");
9014 break;
9015 case VMS_STL_RESERVE:
9016 strcat (res, " RSV");
9017 break;
9018 case VMS_STL_STD:
9019 strcat (res, " STD");
9020 break;
9021 case VMS_STL_LNK:
9022 strcat (res, " LNK");
9023 break;
9024 default:
9025 abort ();
9026 }
9027
9028 if (res[0] != 0)
9029 return res + 1;
9030 else
9031 return res;
9032 }
9033 return NULL;
9034}
9035
9036static const char *
9037get_symbol_other (unsigned int other)
9038{
9039 const char * result = NULL;
9040 static char buff [32];
9041
9042 if (other == 0)
9043 return "";
9044
9045 switch (elf_header.e_machine)
9046 {
9047 case EM_MIPS:
9048 result = get_mips_symbol_other (other);
9049 break;
9050 case EM_IA_64:
9051 result = get_ia64_symbol_other (other);
9052 break;
9053 default:
9054 break;
9055 }
9056
9057 if (result)
9058 return result;
9059
9060 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9061 return buff;
9062}
9063
9064static const char *
9065get_symbol_index_type (unsigned int type)
9066{
9067 static char buff[32];
9068
9069 switch (type)
9070 {
9071 case SHN_UNDEF: return "UND";
9072 case SHN_ABS: return "ABS";
9073 case SHN_COMMON: return "COM";
9074 default:
9075 if (type == SHN_IA_64_ANSI_COMMON
9076 && elf_header.e_machine == EM_IA_64
9077 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9078 return "ANSI_COM";
9079 else if ((elf_header.e_machine == EM_X86_64
9080 || elf_header.e_machine == EM_L1OM
9081 || elf_header.e_machine == EM_K1OM)
9082 && type == SHN_X86_64_LCOMMON)
9083 return "LARGE_COM";
9084 else if ((type == SHN_MIPS_SCOMMON
9085 && elf_header.e_machine == EM_MIPS)
9086 || (type == SHN_TIC6X_SCOMMON
9087 && elf_header.e_machine == EM_TI_C6000))
9088 return "SCOM";
9089 else if (type == SHN_MIPS_SUNDEFINED
9090 && elf_header.e_machine == EM_MIPS)
9091 return "SUND";
9092 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9093 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9094 else if (type >= SHN_LOOS && type <= SHN_HIOS)
9095 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9096 else if (type >= SHN_LORESERVE)
9097 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9098 else if (type >= elf_header.e_shnum)
9099 sprintf (buff, "bad section index[%3d]", type);
9100 else
9101 sprintf (buff, "%3d", type);
9102 break;
9103 }
9104
9105 return buff;
9106}
9107
9108static bfd_vma *
9109get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9110{
9111 unsigned char * e_data;
9112 bfd_vma * i_data;
9113
9114 e_data = (unsigned char *) cmalloc (number, ent_size);
9115
9116 if (e_data == NULL)
9117 {
9118 error (_("Out of memory\n"));
9119 return NULL;
9120 }
9121
9122 if (fread (e_data, ent_size, number, file) != number)
9123 {
9124 error (_("Unable to read in dynamic data\n"));
9125 return NULL;
9126 }
9127
9128 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9129
9130 if (i_data == NULL)
9131 {
9132 error (_("Out of memory\n"));
9133 free (e_data);
9134 return NULL;
9135 }
9136
9137 while (number--)
9138 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9139
9140 free (e_data);
9141
9142 return i_data;
9143}
9144
9145static void
9146print_dynamic_symbol (bfd_vma si, unsigned long hn)
9147{
9148 Elf_Internal_Sym * psym;
9149 int n;
9150
9151 psym = dynamic_symbols + si;
9152
9153 n = print_vma (si, DEC_5);
9154 if (n < 5)
9155 fputs (" " + n, stdout);
9156 printf (" %3lu: ", hn);
9157 print_vma (psym->st_value, LONG_HEX);
9158 putchar (' ');
9159 print_vma (psym->st_size, DEC_5);
9160
9161 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9162 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9163 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9164 /* Check to see if any other bits in the st_other field are set.
9165 Note - displaying this information disrupts the layout of the
9166 table being generated, but for the moment this case is very
9167 rare. */
9168 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9169 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9170 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9171 if (VALID_DYNAMIC_NAME (psym->st_name))
9172 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9173 else
9174 printf (_(" <corrupt: %14ld>"), psym->st_name);
9175 putchar ('\n');
9176}
9177
9178/* Dump the symbol table. */
9179static int
9180process_symbol_table (FILE * file)
9181{
9182 Elf_Internal_Shdr * section;
9183 bfd_vma nbuckets = 0;
9184 bfd_vma nchains = 0;
9185 bfd_vma * buckets = NULL;
9186 bfd_vma * chains = NULL;
9187 bfd_vma ngnubuckets = 0;
9188 bfd_vma * gnubuckets = NULL;
9189 bfd_vma * gnuchains = NULL;
9190 bfd_vma gnusymidx = 0;
9191
9192 if (!do_syms && !do_dyn_syms && !do_histogram)
9193 return 1;
9194
9195 if (dynamic_info[DT_HASH]
9196 && (do_histogram
9197 || (do_using_dynamic
9198 && !do_dyn_syms
9199 && dynamic_strings != NULL)))
9200 {
9201 unsigned char nb[8];
9202 unsigned char nc[8];
9203 int hash_ent_size = 4;
9204
9205 if ((elf_header.e_machine == EM_ALPHA
9206 || elf_header.e_machine == EM_S390
9207 || elf_header.e_machine == EM_S390_OLD)
9208 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9209 hash_ent_size = 8;
9210
9211 if (fseek (file,
9212 (archive_file_offset
9213 + offset_from_vma (file, dynamic_info[DT_HASH],
9214 sizeof nb + sizeof nc)),
9215 SEEK_SET))
9216 {
9217 error (_("Unable to seek to start of dynamic information\n"));
9218 goto no_hash;
9219 }
9220
9221 if (fread (nb, hash_ent_size, 1, file) != 1)
9222 {
9223 error (_("Failed to read in number of buckets\n"));
9224 goto no_hash;
9225 }
9226
9227 if (fread (nc, hash_ent_size, 1, file) != 1)
9228 {
9229 error (_("Failed to read in number of chains\n"));
9230 goto no_hash;
9231 }
9232
9233 nbuckets = byte_get (nb, hash_ent_size);
9234 nchains = byte_get (nc, hash_ent_size);
9235
9236 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9237 chains = get_dynamic_data (file, nchains, hash_ent_size);
9238
9239 no_hash:
9240 if (buckets == NULL || chains == NULL)
9241 {
9242 if (do_using_dynamic)
9243 return 0;
9244 free (buckets);
9245 free (chains);
9246 buckets = NULL;
9247 chains = NULL;
9248 nbuckets = 0;
9249 nchains = 0;
9250 }
9251 }
9252
9253 if (dynamic_info_DT_GNU_HASH
9254 && (do_histogram
9255 || (do_using_dynamic
9256 && !do_dyn_syms
9257 && dynamic_strings != NULL)))
9258 {
9259 unsigned char nb[16];
9260 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9261 bfd_vma buckets_vma;
9262
9263 if (fseek (file,
9264 (archive_file_offset
9265 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9266 sizeof nb)),
9267 SEEK_SET))
9268 {
9269 error (_("Unable to seek to start of dynamic information\n"));
9270 goto no_gnu_hash;
9271 }
9272
9273 if (fread (nb, 16, 1, file) != 1)
9274 {
9275 error (_("Failed to read in number of buckets\n"));
9276 goto no_gnu_hash;
9277 }
9278
9279 ngnubuckets = byte_get (nb, 4);
9280 gnusymidx = byte_get (nb + 4, 4);
9281 bitmaskwords = byte_get (nb + 8, 4);
9282 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9283 if (is_32bit_elf)
9284 buckets_vma += bitmaskwords * 4;
9285 else
9286 buckets_vma += bitmaskwords * 8;
9287
9288 if (fseek (file,
9289 (archive_file_offset
9290 + offset_from_vma (file, buckets_vma, 4)),
9291 SEEK_SET))
9292 {
9293 error (_("Unable to seek to start of dynamic information\n"));
9294 goto no_gnu_hash;
9295 }
9296
9297 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9298
9299 if (gnubuckets == NULL)
9300 goto no_gnu_hash;
9301
9302 for (i = 0; i < ngnubuckets; i++)
9303 if (gnubuckets[i] != 0)
9304 {
9305 if (gnubuckets[i] < gnusymidx)
9306 return 0;
9307
9308 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9309 maxchain = gnubuckets[i];
9310 }
9311
9312 if (maxchain == 0xffffffff)
9313 goto no_gnu_hash;
9314
9315 maxchain -= gnusymidx;
9316
9317 if (fseek (file,
9318 (archive_file_offset
9319 + offset_from_vma (file, buckets_vma
9320 + 4 * (ngnubuckets + maxchain), 4)),
9321 SEEK_SET))
9322 {
9323 error (_("Unable to seek to start of dynamic information\n"));
9324 goto no_gnu_hash;
9325 }
9326
9327 do
9328 {
9329 if (fread (nb, 4, 1, file) != 1)
9330 {
9331 error (_("Failed to determine last chain length\n"));
9332 goto no_gnu_hash;
9333 }
9334
9335 if (maxchain + 1 == 0)
9336 goto no_gnu_hash;
9337
9338 ++maxchain;
9339 }
9340 while ((byte_get (nb, 4) & 1) == 0);
9341
9342 if (fseek (file,
9343 (archive_file_offset
9344 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9345 SEEK_SET))
9346 {
9347 error (_("Unable to seek to start of dynamic information\n"));
9348 goto no_gnu_hash;
9349 }
9350
9351 gnuchains = get_dynamic_data (file, maxchain, 4);
9352
9353 no_gnu_hash:
9354 if (gnuchains == NULL)
9355 {
9356 free (gnubuckets);
9357 gnubuckets = NULL;
9358 ngnubuckets = 0;
9359 if (do_using_dynamic)
9360 return 0;
9361 }
9362 }
9363
9364 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9365 && do_syms
9366 && do_using_dynamic
9367 && dynamic_strings != NULL)
9368 {
9369 unsigned long hn;
9370
9371 if (dynamic_info[DT_HASH])
9372 {
9373 bfd_vma si;
9374
9375 printf (_("\nSymbol table for image:\n"));
9376 if (is_32bit_elf)
9377 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9378 else
9379 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9380
9381 for (hn = 0; hn < nbuckets; hn++)
9382 {
9383 if (! buckets[hn])
9384 continue;
9385
9386 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9387 print_dynamic_symbol (si, hn);
9388 }
9389 }
9390
9391 if (dynamic_info_DT_GNU_HASH)
9392 {
9393 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9394 if (is_32bit_elf)
9395 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9396 else
9397 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9398
9399 for (hn = 0; hn < ngnubuckets; ++hn)
9400 if (gnubuckets[hn] != 0)
9401 {
9402 bfd_vma si = gnubuckets[hn];
9403 bfd_vma off = si - gnusymidx;
9404
9405 do
9406 {
9407 print_dynamic_symbol (si, hn);
9408 si++;
9409 }
9410 while ((gnuchains[off++] & 1) == 0);
9411 }
9412 }
9413 }
9414 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9415 {
9416 unsigned int i;
9417
9418 for (i = 0, section = section_headers;
9419 i < elf_header.e_shnum;
9420 i++, section++)
9421 {
9422 unsigned int si;
9423 char * strtab = NULL;
9424 unsigned long int strtab_size = 0;
9425 Elf_Internal_Sym * symtab;
9426 Elf_Internal_Sym * psym;
9427 unsigned long num_syms;
9428
9429 if ((section->sh_type != SHT_SYMTAB
9430 && section->sh_type != SHT_DYNSYM)
9431 || (!do_syms
9432 && section->sh_type == SHT_SYMTAB))
9433 continue;
9434
9435 if (section->sh_entsize == 0)
9436 {
9437 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9438 SECTION_NAME (section));
9439 continue;
9440 }
9441
9442 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9443 SECTION_NAME (section),
9444 (unsigned long) (section->sh_size / section->sh_entsize));
9445
9446 if (is_32bit_elf)
9447 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9448 else
9449 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9450
9451 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9452 if (symtab == NULL)
9453 continue;
9454
9455 if (section->sh_link == elf_header.e_shstrndx)
9456 {
9457 strtab = string_table;
9458 strtab_size = string_table_length;
9459 }
9460 else if (section->sh_link < elf_header.e_shnum)
9461 {
9462 Elf_Internal_Shdr * string_sec;
9463
9464 string_sec = section_headers + section->sh_link;
9465
9466 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9467 1, string_sec->sh_size,
9468 _("string table"));
9469 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9470 }
9471
9472 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9473 {
9474 printf ("%6d: ", si);
9475 print_vma (psym->st_value, LONG_HEX);
9476 putchar (' ');
9477 print_vma (psym->st_size, DEC_5);
9478 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9479 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9480 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9481 /* Check to see if any other bits in the st_other field are set.
9482 Note - displaying this information disrupts the layout of the
9483 table being generated, but for the moment this case is very rare. */
9484 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9485 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9486 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9487 print_symbol (25, psym->st_name < strtab_size
9488 ? strtab + psym->st_name : _("<corrupt>"));
9489
9490 if (section->sh_type == SHT_DYNSYM
9491 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9492 {
9493 unsigned char data[2];
9494 unsigned short vers_data;
9495 unsigned long offset;
9496 int is_nobits;
9497 int check_def;
9498
9499 offset = offset_from_vma
9500 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9501 sizeof data + si * sizeof (vers_data));
9502
9503 if (get_data (&data, file, offset + si * sizeof (vers_data),
9504 sizeof (data), 1, _("version data")) == NULL)
9505 break;
9506
9507 vers_data = byte_get (data, 2);
9508
9509 is_nobits = (psym->st_shndx < elf_header.e_shnum
9510 && section_headers[psym->st_shndx].sh_type
9511 == SHT_NOBITS);
9512
9513 check_def = (psym->st_shndx != SHN_UNDEF);
9514
9515 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9516 {
9517 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9518 && (is_nobits || ! check_def))
9519 {
9520 Elf_External_Verneed evn;
9521 Elf_Internal_Verneed ivn;
9522 Elf_Internal_Vernaux ivna;
9523
9524 /* We must test both. */
9525 offset = offset_from_vma
9526 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9527 sizeof evn);
9528
9529 do
9530 {
9531 unsigned long vna_off;
9532
9533 if (get_data (&evn, file, offset, sizeof (evn), 1,
9534 _("version need")) == NULL)
9535 {
9536 ivna.vna_next = 0;
9537 ivna.vna_other = 0;
9538 ivna.vna_name = 0;
9539 break;
9540 }
9541
9542 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9543 ivn.vn_next = BYTE_GET (evn.vn_next);
9544
9545 vna_off = offset + ivn.vn_aux;
9546
9547 do
9548 {
9549 Elf_External_Vernaux evna;
9550
9551 if (get_data (&evna, file, vna_off,
9552 sizeof (evna), 1,
9553 _("version need aux (3)")) == NULL)
9554 {
9555 ivna.vna_next = 0;
9556 ivna.vna_other = 0;
9557 ivna.vna_name = 0;
9558 }
9559 else
9560 {
9561 ivna.vna_other = BYTE_GET (evna.vna_other);
9562 ivna.vna_next = BYTE_GET (evna.vna_next);
9563 ivna.vna_name = BYTE_GET (evna.vna_name);
9564 }
9565
9566 vna_off += ivna.vna_next;
9567 }
9568 while (ivna.vna_other != vers_data
9569 && ivna.vna_next != 0);
9570
9571 if (ivna.vna_other == vers_data)
9572 break;
9573
9574 offset += ivn.vn_next;
9575 }
9576 while (ivn.vn_next != 0);
9577
9578 if (ivna.vna_other == vers_data)
9579 {
9580 printf ("@%s (%d)",
9581 ivna.vna_name < strtab_size
9582 ? strtab + ivna.vna_name : _("<corrupt>"),
9583 ivna.vna_other);
9584 check_def = 0;
9585 }
9586 else if (! is_nobits)
9587 error (_("bad dynamic symbol\n"));
9588 else
9589 check_def = 1;
9590 }
9591
9592 if (check_def)
9593 {
9594 if (vers_data != 0x8001
9595 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9596 {
9597 Elf_Internal_Verdef ivd;
9598 Elf_Internal_Verdaux ivda;
9599 Elf_External_Verdaux evda;
9600 unsigned long off;
9601
9602 off = offset_from_vma
9603 (file,
9604 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9605 sizeof (Elf_External_Verdef));
9606
9607 do
9608 {
9609 Elf_External_Verdef evd;
9610
9611 if (get_data (&evd, file, off, sizeof (evd),
9612 1, _("version def")) == NULL)
9613 {
9614 ivd.vd_ndx = 0;
9615 ivd.vd_aux = 0;
9616 ivd.vd_next = 0;
9617 }
9618 else
9619 {
9620 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9621 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9622 ivd.vd_next = BYTE_GET (evd.vd_next);
9623 }
9624
9625 off += ivd.vd_next;
9626 }
9627 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9628 && ivd.vd_next != 0);
9629
9630 off -= ivd.vd_next;
9631 off += ivd.vd_aux;
9632
9633 if (get_data (&evda, file, off, sizeof (evda),
9634 1, _("version def aux")) == NULL)
9635 break;
9636
9637 ivda.vda_name = BYTE_GET (evda.vda_name);
9638
9639 if (psym->st_name != ivda.vda_name)
9640 printf ((vers_data & VERSYM_HIDDEN)
9641 ? "@%s" : "@@%s",
9642 ivda.vda_name < strtab_size
9643 ? strtab + ivda.vda_name : _("<corrupt>"));
9644 }
9645 }
9646 }
9647 }
9648
9649 putchar ('\n');
9650 }
9651
9652 free (symtab);
9653 if (strtab != string_table)
9654 free (strtab);
9655 }
9656 }
9657 else if (do_syms)
9658 printf
9659 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9660
9661 if (do_histogram && buckets != NULL)
9662 {
9663 unsigned long * lengths;
9664 unsigned long * counts;
9665 unsigned long hn;
9666 bfd_vma si;
9667 unsigned long maxlength = 0;
9668 unsigned long nzero_counts = 0;
9669 unsigned long nsyms = 0;
9670
9671 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9672 (unsigned long) nbuckets);
9673 printf (_(" Length Number %% of total Coverage\n"));
9674
9675 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9676 if (lengths == NULL)
9677 {
9678 error (_("Out of memory\n"));
9679 return 0;
9680 }
9681 for (hn = 0; hn < nbuckets; ++hn)
9682 {
9683 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9684 {
9685 ++nsyms;
9686 if (maxlength < ++lengths[hn])
9687 ++maxlength;
9688 }
9689 }
9690
9691 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9692 if (counts == NULL)
9693 {
9694 error (_("Out of memory\n"));
9695 return 0;
9696 }
9697
9698 for (hn = 0; hn < nbuckets; ++hn)
9699 ++counts[lengths[hn]];
9700
9701 if (nbuckets > 0)
9702 {
9703 unsigned long i;
9704 printf (" 0 %-10lu (%5.1f%%)\n",
9705 counts[0], (counts[0] * 100.0) / nbuckets);
9706 for (i = 1; i <= maxlength; ++i)
9707 {
9708 nzero_counts += counts[i] * i;
9709 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9710 i, counts[i], (counts[i] * 100.0) / nbuckets,
9711 (nzero_counts * 100.0) / nsyms);
9712 }
9713 }
9714
9715 free (counts);
9716 free (lengths);
9717 }
9718
9719 if (buckets != NULL)
9720 {
9721 free (buckets);
9722 free (chains);
9723 }
9724
9725 if (do_histogram && gnubuckets != NULL)
9726 {
9727 unsigned long * lengths;
9728 unsigned long * counts;
9729 unsigned long hn;
9730 unsigned long maxlength = 0;
9731 unsigned long nzero_counts = 0;
9732 unsigned long nsyms = 0;
9733
9734 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9735 if (lengths == NULL)
9736 {
9737 error (_("Out of memory\n"));
9738 return 0;
9739 }
9740
9741 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9742 (unsigned long) ngnubuckets);
9743 printf (_(" Length Number %% of total Coverage\n"));
9744
9745 for (hn = 0; hn < ngnubuckets; ++hn)
9746 if (gnubuckets[hn] != 0)
9747 {
9748 bfd_vma off, length = 1;
9749
9750 for (off = gnubuckets[hn] - gnusymidx;
9751 (gnuchains[off] & 1) == 0; ++off)
9752 ++length;
9753 lengths[hn] = length;
9754 if (length > maxlength)
9755 maxlength = length;
9756 nsyms += length;
9757 }
9758
9759 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9760 if (counts == NULL)
9761 {
9762 error (_("Out of memory\n"));
9763 return 0;
9764 }
9765
9766 for (hn = 0; hn < ngnubuckets; ++hn)
9767 ++counts[lengths[hn]];
9768
9769 if (ngnubuckets > 0)
9770 {
9771 unsigned long j;
9772 printf (" 0 %-10lu (%5.1f%%)\n",
9773 counts[0], (counts[0] * 100.0) / ngnubuckets);
9774 for (j = 1; j <= maxlength; ++j)
9775 {
9776 nzero_counts += counts[j] * j;
9777 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9778 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9779 (nzero_counts * 100.0) / nsyms);
9780 }
9781 }
9782
9783 free (counts);
9784 free (lengths);
9785 free (gnubuckets);
9786 free (gnuchains);
9787 }
9788
9789 return 1;
9790}
9791
9792static int
9793process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9794{
9795 unsigned int i;
9796
9797 if (dynamic_syminfo == NULL
9798 || !do_dynamic)
9799 /* No syminfo, this is ok. */
9800 return 1;
9801
9802 /* There better should be a dynamic symbol section. */
9803 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9804 return 0;
9805
9806 if (dynamic_addr)
9807 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9808 dynamic_syminfo_offset, dynamic_syminfo_nent);
9809
9810 printf (_(" Num: Name BoundTo Flags\n"));
9811 for (i = 0; i < dynamic_syminfo_nent; ++i)
9812 {
9813 unsigned short int flags = dynamic_syminfo[i].si_flags;
9814
9815 printf ("%4d: ", i);
9816 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9817 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9818 else
9819 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9820 putchar (' ');
9821
9822 switch (dynamic_syminfo[i].si_boundto)
9823 {
9824 case SYMINFO_BT_SELF:
9825 fputs ("SELF ", stdout);
9826 break;
9827 case SYMINFO_BT_PARENT:
9828 fputs ("PARENT ", stdout);
9829 break;
9830 default:
9831 if (dynamic_syminfo[i].si_boundto > 0
9832 && dynamic_syminfo[i].si_boundto < dynamic_nent
9833 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9834 {
9835 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9836 putchar (' ' );
9837 }
9838 else
9839 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9840 break;
9841 }
9842
9843 if (flags & SYMINFO_FLG_DIRECT)
9844 printf (" DIRECT");
9845 if (flags & SYMINFO_FLG_PASSTHRU)
9846 printf (" PASSTHRU");
9847 if (flags & SYMINFO_FLG_COPY)
9848 printf (" COPY");
9849 if (flags & SYMINFO_FLG_LAZYLOAD)
9850 printf (" LAZYLOAD");
9851
9852 puts ("");
9853 }
9854
9855 return 1;
9856}
9857
9858/* Check to see if the given reloc needs to be handled in a target specific
9859 manner. If so then process the reloc and return TRUE otherwise return
9860 FALSE. */
9861
9862static bfd_boolean
9863target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9864 unsigned char * start,
9865 Elf_Internal_Sym * symtab)
9866{
9867 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9868
9869 switch (elf_header.e_machine)
9870 {
9871 case EM_MN10300:
9872 case EM_CYGNUS_MN10300:
9873 {
9874 static Elf_Internal_Sym * saved_sym = NULL;
9875
9876 switch (reloc_type)
9877 {
9878 case 34: /* R_MN10300_ALIGN */
9879 return TRUE;
9880 case 33: /* R_MN10300_SYM_DIFF */
9881 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9882 return TRUE;
9883 case 1: /* R_MN10300_32 */
9884 case 2: /* R_MN10300_16 */
9885 if (saved_sym != NULL)
9886 {
9887 bfd_vma value;
9888
9889 value = reloc->r_addend
9890 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9891 - saved_sym->st_value);
9892
9893 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9894
9895 saved_sym = NULL;
9896 return TRUE;
9897 }
9898 break;
9899 default:
9900 if (saved_sym != NULL)
9901 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9902 break;
9903 }
9904 break;
9905 }
9906 }
9907
9908 return FALSE;
9909}
9910
9911/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9912 DWARF debug sections. This is a target specific test. Note - we do not
9913 go through the whole including-target-headers-multiple-times route, (as
9914 we have already done with <elf/h8.h>) because this would become very
9915 messy and even then this function would have to contain target specific
9916 information (the names of the relocs instead of their numeric values).
9917 FIXME: This is not the correct way to solve this problem. The proper way
9918 is to have target specific reloc sizing and typing functions created by
9919 the reloc-macros.h header, in the same way that it already creates the
9920 reloc naming functions. */
9921
9922static bfd_boolean
9923is_32bit_abs_reloc (unsigned int reloc_type)
9924{
9925 switch (elf_header.e_machine)
9926 {
9927 case EM_386:
9928 case EM_486:
9929 return reloc_type == 1; /* R_386_32. */
9930 case EM_68K:
9931 return reloc_type == 1; /* R_68K_32. */
9932 case EM_860:
9933 return reloc_type == 1; /* R_860_32. */
9934 case EM_960:
9935 return reloc_type == 2; /* R_960_32. */
9936 case EM_AARCH64:
9937 return reloc_type == 258; /* R_AARCH64_ABS32 */
9938 case EM_ALPHA:
9939 return reloc_type == 1; /* R_ALPHA_REFLONG. */
9940 case EM_ARC:
9941 return reloc_type == 1; /* R_ARC_32. */
9942 case EM_ARM:
9943 return reloc_type == 2; /* R_ARM_ABS32 */
9944 case EM_AVR_OLD:
9945 case EM_AVR:
9946 return reloc_type == 1;
9947 case EM_ADAPTEVA_EPIPHANY:
9948 return reloc_type == 3;
9949 case EM_BLACKFIN:
9950 return reloc_type == 0x12; /* R_byte4_data. */
9951 case EM_CRIS:
9952 return reloc_type == 3; /* R_CRIS_32. */
9953 case EM_CR16:
9954 return reloc_type == 3; /* R_CR16_NUM32. */
9955 case EM_CRX:
9956 return reloc_type == 15; /* R_CRX_NUM32. */
9957 case EM_CYGNUS_FRV:
9958 return reloc_type == 1;
9959 case EM_CYGNUS_D10V:
9960 case EM_D10V:
9961 return reloc_type == 6; /* R_D10V_32. */
9962 case EM_CYGNUS_D30V:
9963 case EM_D30V:
9964 return reloc_type == 12; /* R_D30V_32_NORMAL. */
9965 case EM_DLX:
9966 return reloc_type == 3; /* R_DLX_RELOC_32. */
9967 case EM_CYGNUS_FR30:
9968 case EM_FR30:
9969 return reloc_type == 3; /* R_FR30_32. */
9970 case EM_H8S:
9971 case EM_H8_300:
9972 case EM_H8_300H:
9973 return reloc_type == 1; /* R_H8_DIR32. */
9974 case EM_IA_64:
9975 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
9976 case EM_IP2K_OLD:
9977 case EM_IP2K:
9978 return reloc_type == 2; /* R_IP2K_32. */
9979 case EM_IQ2000:
9980 return reloc_type == 2; /* R_IQ2000_32. */
9981 case EM_LATTICEMICO32:
9982 return reloc_type == 3; /* R_LM32_32. */
9983 case EM_M32C_OLD:
9984 case EM_M32C:
9985 return reloc_type == 3; /* R_M32C_32. */
9986 case EM_M32R:
9987 return reloc_type == 34; /* R_M32R_32_RELA. */
9988 case EM_MCORE:
9989 return reloc_type == 1; /* R_MCORE_ADDR32. */
9990 case EM_CYGNUS_MEP:
9991 return reloc_type == 4; /* R_MEP_32. */
9992 case EM_MICROBLAZE:
9993 return reloc_type == 1; /* R_MICROBLAZE_32. */
9994 case EM_MIPS:
9995 return reloc_type == 2; /* R_MIPS_32. */
9996 case EM_MMIX:
9997 return reloc_type == 4; /* R_MMIX_32. */
9998 case EM_CYGNUS_MN10200:
9999 case EM_MN10200:
10000 return reloc_type == 1; /* R_MN10200_32. */
10001 case EM_CYGNUS_MN10300:
10002 case EM_MN10300:
10003 return reloc_type == 1; /* R_MN10300_32. */
10004 case EM_MOXIE:
10005 return reloc_type == 1; /* R_MOXIE_32. */
10006 case EM_MSP430_OLD:
10007 case EM_MSP430:
10008 return reloc_type == 1; /* R_MSP43_32. */
10009 case EM_MT:
10010 return reloc_type == 2; /* R_MT_32. */
10011 case EM_ALTERA_NIOS2:
10012 case EM_NIOS32:
10013 return reloc_type == 1; /* R_NIOS_32. */
10014 case EM_OPENRISC:
10015 case EM_OR32:
10016 return reloc_type == 1; /* R_OR32_32. */
10017 case EM_PARISC:
10018 return (reloc_type == 1 /* R_PARISC_DIR32. */
10019 || reloc_type == 41); /* R_PARISC_SECREL32. */
10020 case EM_PJ:
10021 case EM_PJ_OLD:
10022 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10023 case EM_PPC64:
10024 return reloc_type == 1; /* R_PPC64_ADDR32. */
10025 case EM_PPC:
10026 return reloc_type == 1; /* R_PPC_ADDR32. */
10027 case EM_RL78:
10028 return reloc_type == 1; /* R_RL78_DIR32. */
10029 case EM_RX:
10030 return reloc_type == 1; /* R_RX_DIR32. */
10031 case EM_S370:
10032 return reloc_type == 1; /* R_I370_ADDR31. */
10033 case EM_S390_OLD:
10034 case EM_S390:
10035 return reloc_type == 4; /* R_S390_32. */
10036 case EM_SCORE:
10037 return reloc_type == 8; /* R_SCORE_ABS32. */
10038 case EM_SH:
10039 return reloc_type == 1; /* R_SH_DIR32. */
10040 case EM_SPARC32PLUS:
10041 case EM_SPARCV9:
10042 case EM_SPARC:
10043 return reloc_type == 3 /* R_SPARC_32. */
10044 || reloc_type == 23; /* R_SPARC_UA32. */
10045 case EM_SPU:
10046 return reloc_type == 6; /* R_SPU_ADDR32 */
10047 case EM_TI_C6000:
10048 return reloc_type == 1; /* R_C6000_ABS32. */
10049 case EM_TILEGX:
10050 return reloc_type == 2; /* R_TILEGX_32. */
10051 case EM_TILEPRO:
10052 return reloc_type == 1; /* R_TILEPRO_32. */
10053 case EM_CYGNUS_V850:
10054 case EM_V850:
10055 return reloc_type == 6; /* R_V850_ABS32. */
10056 case EM_V800:
10057 return reloc_type == 0x33; /* R_V810_WORD. */
10058 case EM_VAX:
10059 return reloc_type == 1; /* R_VAX_32. */
10060 case EM_X86_64:
10061 case EM_L1OM:
10062 case EM_K1OM:
10063 return reloc_type == 10; /* R_X86_64_32. */
10064 case EM_XC16X:
10065 case EM_C166:
10066 return reloc_type == 3; /* R_XC16C_ABS_32. */
10067 case EM_XGATE:
10068 return reloc_type == 4; /* R_XGATE_32. */
10069 case EM_XSTORMY16:
10070 return reloc_type == 1; /* R_XSTROMY16_32. */
10071 case EM_XTENSA_OLD:
10072 case EM_XTENSA:
10073 return reloc_type == 1; /* R_XTENSA_32. */
10074 default:
10075 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10076 elf_header.e_machine);
10077 abort ();
10078 }
10079}
10080
10081/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10082 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10083
10084static bfd_boolean
10085is_32bit_pcrel_reloc (unsigned int reloc_type)
10086{
10087 switch (elf_header.e_machine)
10088 {
10089 case EM_386:
10090 case EM_486:
10091 return reloc_type == 2; /* R_386_PC32. */
10092 case EM_68K:
10093 return reloc_type == 4; /* R_68K_PC32. */
10094 case EM_AARCH64:
10095 return reloc_type == 261; /* R_AARCH64_PREL32 */
10096 case EM_ADAPTEVA_EPIPHANY:
10097 return reloc_type == 6;
10098 case EM_ALPHA:
10099 return reloc_type == 10; /* R_ALPHA_SREL32. */
10100 case EM_ARM:
10101 return reloc_type == 3; /* R_ARM_REL32 */
10102 case EM_MICROBLAZE:
10103 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
10104 case EM_PARISC:
10105 return reloc_type == 9; /* R_PARISC_PCREL32. */
10106 case EM_PPC:
10107 return reloc_type == 26; /* R_PPC_REL32. */
10108 case EM_PPC64:
10109 return reloc_type == 26; /* R_PPC64_REL32. */
10110 case EM_S390_OLD:
10111 case EM_S390:
10112 return reloc_type == 5; /* R_390_PC32. */
10113 case EM_SH:
10114 return reloc_type == 2; /* R_SH_REL32. */
10115 case EM_SPARC32PLUS:
10116 case EM_SPARCV9:
10117 case EM_SPARC:
10118 return reloc_type == 6; /* R_SPARC_DISP32. */
10119 case EM_SPU:
10120 return reloc_type == 13; /* R_SPU_REL32. */
10121 case EM_TILEGX:
10122 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10123 case EM_TILEPRO:
10124 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
10125 case EM_X86_64:
10126 case EM_L1OM:
10127 case EM_K1OM:
10128 return reloc_type == 2; /* R_X86_64_PC32. */
10129 case EM_XTENSA_OLD:
10130 case EM_XTENSA:
10131 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
10132 default:
10133 /* Do not abort or issue an error message here. Not all targets use
10134 pc-relative 32-bit relocs in their DWARF debug information and we
10135 have already tested for target coverage in is_32bit_abs_reloc. A
10136 more helpful warning message will be generated by apply_relocations
10137 anyway, so just return. */
10138 return FALSE;
10139 }
10140}
10141
10142/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10143 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10144
10145static bfd_boolean
10146is_64bit_abs_reloc (unsigned int reloc_type)
10147{
10148 switch (elf_header.e_machine)
10149 {
10150 case EM_AARCH64:
10151 return reloc_type == 257; /* R_AARCH64_ABS64. */
10152 case EM_ALPHA:
10153 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
10154 case EM_IA_64:
10155 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
10156 case EM_PARISC:
10157 return reloc_type == 80; /* R_PARISC_DIR64. */
10158 case EM_PPC64:
10159 return reloc_type == 38; /* R_PPC64_ADDR64. */
10160 case EM_SPARC32PLUS:
10161 case EM_SPARCV9:
10162 case EM_SPARC:
10163 return reloc_type == 54; /* R_SPARC_UA64. */
10164 case EM_X86_64:
10165 case EM_L1OM:
10166 case EM_K1OM:
10167 return reloc_type == 1; /* R_X86_64_64. */
10168 case EM_S390_OLD:
10169 case EM_S390:
10170 return reloc_type == 22; /* R_S390_64. */
10171 case EM_TILEGX:
10172 return reloc_type == 1; /* R_TILEGX_64. */
10173 case EM_MIPS:
10174 return reloc_type == 18; /* R_MIPS_64. */
10175 default:
10176 return FALSE;
10177 }
10178}
10179
10180/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10181 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10182
10183static bfd_boolean
10184is_64bit_pcrel_reloc (unsigned int reloc_type)
10185{
10186 switch (elf_header.e_machine)
10187 {
10188 case EM_AARCH64:
10189 return reloc_type == 260; /* R_AARCH64_PREL64. */
10190 case EM_ALPHA:
10191 return reloc_type == 11; /* R_ALPHA_SREL64. */
10192 case EM_IA_64:
10193 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
10194 case EM_PARISC:
10195 return reloc_type == 72; /* R_PARISC_PCREL64. */
10196 case EM_PPC64:
10197 return reloc_type == 44; /* R_PPC64_REL64. */
10198 case EM_SPARC32PLUS:
10199 case EM_SPARCV9:
10200 case EM_SPARC:
10201 return reloc_type == 46; /* R_SPARC_DISP64. */
10202 case EM_X86_64:
10203 case EM_L1OM:
10204 case EM_K1OM:
10205 return reloc_type == 24; /* R_X86_64_PC64. */
10206 case EM_S390_OLD:
10207 case EM_S390:
10208 return reloc_type == 23; /* R_S390_PC64. */
10209 case EM_TILEGX:
10210 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
10211 default:
10212 return FALSE;
10213 }
10214}
10215
10216/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10217 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10218
10219static bfd_boolean
10220is_24bit_abs_reloc (unsigned int reloc_type)
10221{
10222 switch (elf_header.e_machine)
10223 {
10224 case EM_CYGNUS_MN10200:
10225 case EM_MN10200:
10226 return reloc_type == 4; /* R_MN10200_24. */
10227 default:
10228 return FALSE;
10229 }
10230}
10231
10232/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10233 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10234
10235static bfd_boolean
10236is_16bit_abs_reloc (unsigned int reloc_type)
10237{
10238 switch (elf_header.e_machine)
10239 {
10240 case EM_AVR_OLD:
10241 case EM_AVR:
10242 return reloc_type == 4; /* R_AVR_16. */
10243 case EM_ADAPTEVA_EPIPHANY:
10244 return reloc_type == 5;
10245 case EM_CYGNUS_D10V:
10246 case EM_D10V:
10247 return reloc_type == 3; /* R_D10V_16. */
10248 case EM_H8S:
10249 case EM_H8_300:
10250 case EM_H8_300H:
10251 return reloc_type == R_H8_DIR16;
10252 case EM_IP2K_OLD:
10253 case EM_IP2K:
10254 return reloc_type == 1; /* R_IP2K_16. */
10255 case EM_M32C_OLD:
10256 case EM_M32C:
10257 return reloc_type == 1; /* R_M32C_16 */
10258 case EM_MSP430_OLD:
10259 case EM_MSP430:
10260 return reloc_type == 5; /* R_MSP430_16_BYTE. */
10261 case EM_ALTERA_NIOS2:
10262 case EM_NIOS32:
10263 return reloc_type == 9; /* R_NIOS_16. */
10264 case EM_TI_C6000:
10265 return reloc_type == 2; /* R_C6000_ABS16. */
10266 case EM_XC16X:
10267 case EM_C166:
10268 return reloc_type == 2; /* R_XC16C_ABS_16. */
10269 case EM_CYGNUS_MN10200:
10270 case EM_MN10200:
10271 return reloc_type == 2; /* R_MN10200_16. */
10272 case EM_CYGNUS_MN10300:
10273 case EM_MN10300:
10274 return reloc_type == 2; /* R_MN10300_16. */
10275 case EM_XGATE:
10276 return reloc_type == 3; /* R_XGATE_16. */
10277 default:
10278 return FALSE;
10279 }
10280}
10281
10282/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10283 relocation entries (possibly formerly used for SHT_GROUP sections). */
10284
10285static bfd_boolean
10286is_none_reloc (unsigned int reloc_type)
10287{
10288 switch (elf_header.e_machine)
10289 {
10290 case EM_68K: /* R_68K_NONE. */
10291 case EM_386: /* R_386_NONE. */
10292 case EM_SPARC32PLUS:
10293 case EM_SPARCV9:
10294 case EM_SPARC: /* R_SPARC_NONE. */
10295 case EM_MIPS: /* R_MIPS_NONE. */
10296 case EM_PARISC: /* R_PARISC_NONE. */
10297 case EM_ALPHA: /* R_ALPHA_NONE. */
10298 case EM_ADAPTEVA_EPIPHANY:
10299 case EM_PPC: /* R_PPC_NONE. */
10300 case EM_PPC64: /* R_PPC64_NONE. */
10301 case EM_ARM: /* R_ARM_NONE. */
10302 case EM_IA_64: /* R_IA64_NONE. */
10303 case EM_SH: /* R_SH_NONE. */
10304 case EM_S390_OLD:
10305 case EM_S390: /* R_390_NONE. */
10306 case EM_CRIS: /* R_CRIS_NONE. */
10307 case EM_X86_64: /* R_X86_64_NONE. */
10308 case EM_L1OM: /* R_X86_64_NONE. */
10309 case EM_K1OM: /* R_X86_64_NONE. */
10310 case EM_MN10300: /* R_MN10300_NONE. */
10311 case EM_MOXIE: /* R_MOXIE_NONE. */
10312 case EM_M32R: /* R_M32R_NONE. */
10313 case EM_TI_C6000:/* R_C6000_NONE. */
10314 case EM_TILEGX: /* R_TILEGX_NONE. */
10315 case EM_TILEPRO: /* R_TILEPRO_NONE. */
10316 case EM_XC16X:
10317 case EM_C166: /* R_XC16X_NONE. */
10318 return reloc_type == 0;
10319 case EM_AARCH64:
10320 return reloc_type == 0 || reloc_type == 256;
10321 case EM_XTENSA_OLD:
10322 case EM_XTENSA:
10323 return (reloc_type == 0 /* R_XTENSA_NONE. */
10324 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10325 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10326 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
10327 }
10328 return FALSE;
10329}
10330
10331/* Apply relocations to a section.
10332 Note: So far support has been added only for those relocations
10333 which can be found in debug sections.
10334 FIXME: Add support for more relocations ? */
10335
10336static void
10337apply_relocations (void * file,
10338 Elf_Internal_Shdr * section,
10339 unsigned char * start)
10340{
10341 Elf_Internal_Shdr * relsec;
10342 unsigned char * end = start + section->sh_size;
10343
10344 if (elf_header.e_type != ET_REL)
10345 return;
10346
10347 /* Find the reloc section associated with the section. */
10348 for (relsec = section_headers;
10349 relsec < section_headers + elf_header.e_shnum;
10350 ++relsec)
10351 {
10352 bfd_boolean is_rela;
10353 unsigned long num_relocs;
10354 Elf_Internal_Rela * relocs;
10355 Elf_Internal_Rela * rp;
10356 Elf_Internal_Shdr * symsec;
10357 Elf_Internal_Sym * symtab;
10358 unsigned long num_syms;
10359 Elf_Internal_Sym * sym;
10360
10361 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10362 || relsec->sh_info >= elf_header.e_shnum
10363 || section_headers + relsec->sh_info != section
10364 || relsec->sh_size == 0
10365 || relsec->sh_link >= elf_header.e_shnum)
10366 continue;
10367
10368 is_rela = relsec->sh_type == SHT_RELA;
10369
10370 if (is_rela)
10371 {
10372 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10373 relsec->sh_size, & relocs, & num_relocs))
10374 return;
10375 }
10376 else
10377 {
10378 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10379 relsec->sh_size, & relocs, & num_relocs))
10380 return;
10381 }
10382
10383 /* SH uses RELA but uses in place value instead of the addend field. */
10384 if (elf_header.e_machine == EM_SH)
10385 is_rela = FALSE;
10386
10387 symsec = section_headers + relsec->sh_link;
10388 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10389
10390 for (rp = relocs; rp < relocs + num_relocs; ++rp)
10391 {
10392 bfd_vma addend;
10393 unsigned int reloc_type;
10394 unsigned int reloc_size;
10395 unsigned char * rloc;
10396 unsigned long sym_index;
10397
10398 reloc_type = get_reloc_type (rp->r_info);
10399
10400 if (target_specific_reloc_handling (rp, start, symtab))
10401 continue;
10402 else if (is_none_reloc (reloc_type))
10403 continue;
10404 else if (is_32bit_abs_reloc (reloc_type)
10405 || is_32bit_pcrel_reloc (reloc_type))
10406 reloc_size = 4;
10407 else if (is_64bit_abs_reloc (reloc_type)
10408 || is_64bit_pcrel_reloc (reloc_type))
10409 reloc_size = 8;
10410 else if (is_24bit_abs_reloc (reloc_type))
10411 reloc_size = 3;
10412 else if (is_16bit_abs_reloc (reloc_type))
10413 reloc_size = 2;
10414 else
10415 {
10416 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10417 reloc_type, SECTION_NAME (section));
10418 continue;
10419 }
10420
10421 rloc = start + rp->r_offset;
10422 if ((rloc + reloc_size) > end)
10423 {
10424 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10425 (unsigned long) rp->r_offset,
10426 SECTION_NAME (section));
10427 continue;
10428 }
10429
10430 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10431 if (sym_index >= num_syms)
10432 {
10433 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10434 sym_index, SECTION_NAME (section));
10435 continue;
10436 }
10437 sym = symtab + sym_index;
10438
10439 /* If the reloc has a symbol associated with it,
10440 make sure that it is of an appropriate type.
10441
10442 Relocations against symbols without type can happen.
10443 Gcc -feliminate-dwarf2-dups may generate symbols
10444 without type for debug info.
10445
10446 Icc generates relocations against function symbols
10447 instead of local labels.
10448
10449 Relocations against object symbols can happen, eg when
10450 referencing a global array. For an example of this see
10451 the _clz.o binary in libgcc.a. */
10452 if (sym != symtab
10453 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10454 {
10455 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10456 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10457 (long int)(rp - relocs),
10458 SECTION_NAME (relsec));
10459 continue;
10460 }
10461
10462 addend = 0;
10463 if (is_rela)
10464 addend += rp->r_addend;
10465 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10466 partial_inplace. */
10467 if (!is_rela
10468 || (elf_header.e_machine == EM_XTENSA
10469 && reloc_type == 1)
10470 || ((elf_header.e_machine == EM_PJ
10471 || elf_header.e_machine == EM_PJ_OLD)
10472 && reloc_type == 1)
10473 || ((elf_header.e_machine == EM_D30V
10474 || elf_header.e_machine == EM_CYGNUS_D30V)
10475 && reloc_type == 12))
10476 addend += byte_get (rloc, reloc_size);
10477
10478 if (is_32bit_pcrel_reloc (reloc_type)
10479 || is_64bit_pcrel_reloc (reloc_type))
10480 {
10481 /* On HPPA, all pc-relative relocations are biased by 8. */
10482 if (elf_header.e_machine == EM_PARISC)
10483 addend -= 8;
10484 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10485 reloc_size);
10486 }
10487 else
10488 byte_put (rloc, addend + sym->st_value, reloc_size);
10489 }
10490
10491 free (symtab);
10492 free (relocs);
10493 break;
10494 }
10495}
10496
10497#ifdef SUPPORT_DISASSEMBLY
10498static int
10499disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10500{
10501 printf (_("\nAssembly dump of section %s\n"),
10502 SECTION_NAME (section));
10503
10504 /* XXX -- to be done --- XXX */
10505
10506 return 1;
10507}
10508#endif
10509
10510/* Reads in the contents of SECTION from FILE, returning a pointer
10511 to a malloc'ed buffer or NULL if something went wrong. */
10512
10513static char *
10514get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10515{
10516 bfd_size_type num_bytes;
10517
10518 num_bytes = section->sh_size;
10519
10520 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10521 {
10522 printf (_("\nSection '%s' has no data to dump.\n"),
10523 SECTION_NAME (section));
10524 return NULL;
10525 }
10526
10527 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10528 _("section contents"));
10529}
10530
10531
10532static void
10533dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10534{
10535 Elf_Internal_Shdr * relsec;
10536 bfd_size_type num_bytes;
10537 char * data;
10538 char * end;
10539 char * start;
10540 char * name = SECTION_NAME (section);
10541 bfd_boolean some_strings_shown;
10542
10543 start = get_section_contents (section, file);
10544 if (start == NULL)
10545 return;
10546
10547 printf (_("\nString dump of section '%s':\n"), name);
10548
10549 /* If the section being dumped has relocations against it the user might
10550 be expecting these relocations to have been applied. Check for this
10551 case and issue a warning message in order to avoid confusion.
10552 FIXME: Maybe we ought to have an option that dumps a section with
10553 relocs applied ? */
10554 for (relsec = section_headers;
10555 relsec < section_headers + elf_header.e_shnum;
10556 ++relsec)
10557 {
10558 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10559 || relsec->sh_info >= elf_header.e_shnum
10560 || section_headers + relsec->sh_info != section
10561 || relsec->sh_size == 0
10562 || relsec->sh_link >= elf_header.e_shnum)
10563 continue;
10564
10565 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10566 break;
10567 }
10568
10569 num_bytes = section->sh_size;
10570 data = start;
10571 end = start + num_bytes;
10572 some_strings_shown = FALSE;
10573
10574 while (data < end)
10575 {
10576 while (!ISPRINT (* data))
10577 if (++ data >= end)
10578 break;
10579
10580 if (data < end)
10581 {
10582#ifndef __MSVCRT__
10583 /* PR 11128: Use two separate invocations in order to work
10584 around bugs in the Solaris 8 implementation of printf. */
10585 printf (" [%6tx] ", data - start);
10586 printf ("%s\n", data);
10587#else
10588 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10589#endif
10590 data += strlen (data);
10591 some_strings_shown = TRUE;
10592 }
10593 }
10594
10595 if (! some_strings_shown)
10596 printf (_(" No strings found in this section."));
10597
10598 free (start);
10599
10600 putchar ('\n');
10601}
10602
10603static void
10604dump_section_as_bytes (Elf_Internal_Shdr * section,
10605 FILE * file,
10606 bfd_boolean relocate)
10607{
10608 Elf_Internal_Shdr * relsec;
10609 bfd_size_type bytes;
10610 bfd_vma addr;
10611 unsigned char * data;
10612 unsigned char * start;
10613
10614 start = (unsigned char *) get_section_contents (section, file);
10615 if (start == NULL)
10616 return;
10617
10618 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10619
10620 if (relocate)
10621 {
10622 apply_relocations (file, section, start);
10623 }
10624 else
10625 {
10626 /* If the section being dumped has relocations against it the user might
10627 be expecting these relocations to have been applied. Check for this
10628 case and issue a warning message in order to avoid confusion.
10629 FIXME: Maybe we ought to have an option that dumps a section with
10630 relocs applied ? */
10631 for (relsec = section_headers;
10632 relsec < section_headers + elf_header.e_shnum;
10633 ++relsec)
10634 {
10635 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10636 || relsec->sh_info >= elf_header.e_shnum
10637 || section_headers + relsec->sh_info != section
10638 || relsec->sh_size == 0
10639 || relsec->sh_link >= elf_header.e_shnum)
10640 continue;
10641
10642 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10643 break;
10644 }
10645 }
10646
10647 addr = section->sh_addr;
10648 bytes = section->sh_size;
10649 data = start;
10650
10651 while (bytes)
10652 {
10653 int j;
10654 int k;
10655 int lbytes;
10656
10657 lbytes = (bytes > 16 ? 16 : bytes);
10658
10659 printf (" 0x%8.8lx ", (unsigned long) addr);
10660
10661 for (j = 0; j < 16; j++)
10662 {
10663 if (j < lbytes)
10664 printf ("%2.2x", data[j]);
10665 else
10666 printf (" ");
10667
10668 if ((j & 3) == 3)
10669 printf (" ");
10670 }
10671
10672 for (j = 0; j < lbytes; j++)
10673 {
10674 k = data[j];
10675 if (k >= ' ' && k < 0x7f)
10676 printf ("%c", k);
10677 else
10678 printf (".");
10679 }
10680
10681 putchar ('\n');
10682
10683 data += lbytes;
10684 addr += lbytes;
10685 bytes -= lbytes;
10686 }
10687
10688 free (start);
10689
10690 putchar ('\n');
10691}
10692
10693/* Uncompresses a section that was compressed using zlib, in place. */
10694
10695static int
10696uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10697 dwarf_size_type *size ATTRIBUTE_UNUSED)
10698{
10699#ifndef HAVE_ZLIB_H
10700 return FALSE;
10701#else
10702 dwarf_size_type compressed_size = *size;
10703 unsigned char * compressed_buffer = *buffer;
10704 dwarf_size_type uncompressed_size;
10705 unsigned char * uncompressed_buffer;
10706 z_stream strm;
10707 int rc;
10708 dwarf_size_type header_size = 12;
10709
10710 /* Read the zlib header. In this case, it should be "ZLIB" followed
10711 by the uncompressed section size, 8 bytes in big-endian order. */
10712 if (compressed_size < header_size
10713 || ! streq ((char *) compressed_buffer, "ZLIB"))
10714 return 0;
10715
10716 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10717 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10718 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10719 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10720 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10721 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10722 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10723 uncompressed_size += compressed_buffer[11];
10724
10725 /* It is possible the section consists of several compressed
10726 buffers concatenated together, so we uncompress in a loop. */
10727 strm.zalloc = NULL;
10728 strm.zfree = NULL;
10729 strm.opaque = NULL;
10730 strm.avail_in = compressed_size - header_size;
10731 strm.next_in = (Bytef *) compressed_buffer + header_size;
10732 strm.avail_out = uncompressed_size;
10733 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10734
10735 rc = inflateInit (& strm);
10736 while (strm.avail_in > 0)
10737 {
10738 if (rc != Z_OK)
10739 goto fail;
10740 strm.next_out = ((Bytef *) uncompressed_buffer
10741 + (uncompressed_size - strm.avail_out));
10742 rc = inflate (&strm, Z_FINISH);
10743 if (rc != Z_STREAM_END)
10744 goto fail;
10745 rc = inflateReset (& strm);
10746 }
10747 rc = inflateEnd (& strm);
10748 if (rc != Z_OK
10749 || strm.avail_out != 0)
10750 goto fail;
10751
10752 free (compressed_buffer);
10753 *buffer = uncompressed_buffer;
10754 *size = uncompressed_size;
10755 return 1;
10756
10757 fail:
10758 free (uncompressed_buffer);
10759 /* Indicate decompression failure. */
10760 *buffer = NULL;
10761 return 0;
10762#endif /* HAVE_ZLIB_H */
10763}
10764
10765static int
10766load_specific_debug_section (enum dwarf_section_display_enum debug,
10767 Elf_Internal_Shdr * sec, void * file)
10768{
10769 struct dwarf_section * section = &debug_displays [debug].section;
10770 char buf [64];
10771
10772 /* If it is already loaded, do nothing. */
10773 if (section->start != NULL)
10774 return 1;
10775
10776 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10777 section->address = sec->sh_addr;
10778 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10779 sec->sh_offset, 1,
10780 sec->sh_size, buf);
10781 if (section->start == NULL)
10782 section->size = 0;
10783 else
10784 {
10785 section->size = sec->sh_size;
10786 if (uncompress_section_contents (&section->start, &section->size))
10787 sec->sh_size = section->size;
10788 }
10789
10790 if (section->start == NULL)
10791 return 0;
10792
10793 if (debug_displays [debug].relocate)
10794 apply_relocations ((FILE *) file, sec, section->start);
10795
10796 return 1;
10797}
10798
10799/* If this is not NULL, load_debug_section will only look for sections
10800 within the list of sections given here. */
10801unsigned int *section_subset = NULL;
10802
10803int
10804load_debug_section (enum dwarf_section_display_enum debug, void * file)
10805{
10806 struct dwarf_section * section = &debug_displays [debug].section;
10807 Elf_Internal_Shdr * sec;
10808
10809 /* Locate the debug section. */
10810 sec = find_section_in_set (section->uncompressed_name, section_subset);
10811 if (sec != NULL)
10812 section->name = section->uncompressed_name;
10813 else
10814 {
10815 sec = find_section_in_set (section->compressed_name, section_subset);
10816 if (sec != NULL)
10817 section->name = section->compressed_name;
10818 }
10819 if (sec == NULL)
10820 return 0;
10821
10822 /* If we're loading from a subset of sections, and we've loaded
10823 a section matching this name before, it's likely that it's a
10824 different one. */
10825 if (section_subset != NULL)
10826 free_debug_section (debug);
10827
10828 return load_specific_debug_section (debug, sec, (FILE *) file);
10829}
10830
10831void
10832free_debug_section (enum dwarf_section_display_enum debug)
10833{
10834 struct dwarf_section * section = &debug_displays [debug].section;
10835
10836 if (section->start == NULL)
10837 return;
10838
10839 free ((char *) section->start);
10840 section->start = NULL;
10841 section->address = 0;
10842 section->size = 0;
10843}
10844
10845static int
10846display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
10847{
10848 char * name = SECTION_NAME (section);
10849 bfd_size_type length;
10850 int result = 1;
10851 int i;
10852
10853 length = section->sh_size;
10854 if (length == 0)
10855 {
10856 printf (_("\nSection '%s' has no debugging data.\n"), name);
10857 return 0;
10858 }
10859 if (section->sh_type == SHT_NOBITS)
10860 {
10861 /* There is no point in dumping the contents of a debugging section
10862 which has the NOBITS type - the bits in the file will be random.
10863 This can happen when a file containing a .eh_frame section is
10864 stripped with the --only-keep-debug command line option. */
10865 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10866 return 0;
10867 }
10868
10869 if (const_strneq (name, ".gnu.linkonce.wi."))
10870 name = ".debug_info";
10871
10872 /* See if we know how to display the contents of this section. */
10873 for (i = 0; i < max; i++)
10874 if (streq (debug_displays[i].section.uncompressed_name, name)
10875 || streq (debug_displays[i].section.compressed_name, name))
10876 {
10877 struct dwarf_section * sec = &debug_displays [i].section;
10878 int secondary = (section != find_section (name));
10879
10880 if (secondary)
10881 free_debug_section ((enum dwarf_section_display_enum) i);
10882
10883 if (streq (sec->uncompressed_name, name))
10884 sec->name = sec->uncompressed_name;
10885 else
10886 sec->name = sec->compressed_name;
10887 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10888 section, file))
10889 {
10890 /* If this debug section is part of a CU/TU set in a .dwp file,
10891 restrict load_debug_section to the sections in that set. */
10892 section_subset = find_cu_tu_set (file, shndx);
10893
10894 result &= debug_displays[i].display (sec, file);
10895
10896 section_subset = NULL;
10897
10898 if (secondary || (i != info && i != abbrev))
10899 free_debug_section ((enum dwarf_section_display_enum) i);
10900 }
10901
10902 break;
10903 }
10904
10905 if (i == max)
10906 {
10907 printf (_("Unrecognized debug section: %s\n"), name);
10908 result = 0;
10909 }
10910
10911 return result;
10912}
10913
10914/* Set DUMP_SECTS for all sections where dumps were requested
10915 based on section name. */
10916
10917static void
10918initialise_dumps_byname (void)
10919{
10920 struct dump_list_entry * cur;
10921
10922 for (cur = dump_sects_byname; cur; cur = cur->next)
10923 {
10924 unsigned int i;
10925 int any;
10926
10927 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10928 if (streq (SECTION_NAME (section_headers + i), cur->name))
10929 {
10930 request_dump_bynumber (i, cur->type);
10931 any = 1;
10932 }
10933
10934 if (!any)
10935 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10936 cur->name);
10937 }
10938}
10939
10940static void
10941process_section_contents (FILE * file)
10942{
10943 Elf_Internal_Shdr * section;
10944 unsigned int i;
10945
10946 if (! do_dump)
10947 return;
10948
10949 initialise_dumps_byname ();
10950
10951 for (i = 0, section = section_headers;
10952 i < elf_header.e_shnum && i < num_dump_sects;
10953 i++, section++)
10954 {
10955#ifdef SUPPORT_DISASSEMBLY
10956 if (dump_sects[i] & DISASS_DUMP)
10957 disassemble_section (section, file);
10958#endif
10959 if (dump_sects[i] & HEX_DUMP)
10960 dump_section_as_bytes (section, file, FALSE);
10961
10962 if (dump_sects[i] & RELOC_DUMP)
10963 dump_section_as_bytes (section, file, TRUE);
10964
10965 if (dump_sects[i] & STRING_DUMP)
10966 dump_section_as_strings (section, file);
10967
10968 if (dump_sects[i] & DEBUG_DUMP)
10969 display_debug_section (i, section, file);
10970 }
10971
10972 /* Check to see if the user requested a
10973 dump of a section that does not exist. */
10974 while (i++ < num_dump_sects)
10975 if (dump_sects[i])
10976 warn (_("Section %d was not dumped because it does not exist!\n"), i);
10977}
10978
10979static void
10980process_mips_fpe_exception (int mask)
10981{
10982 if (mask)
10983 {
10984 int first = 1;
10985 if (mask & OEX_FPU_INEX)
10986 fputs ("INEX", stdout), first = 0;
10987 if (mask & OEX_FPU_UFLO)
10988 printf ("%sUFLO", first ? "" : "|"), first = 0;
10989 if (mask & OEX_FPU_OFLO)
10990 printf ("%sOFLO", first ? "" : "|"), first = 0;
10991 if (mask & OEX_FPU_DIV0)
10992 printf ("%sDIV0", first ? "" : "|"), first = 0;
10993 if (mask & OEX_FPU_INVAL)
10994 printf ("%sINVAL", first ? "" : "|");
10995 }
10996 else
10997 fputs ("0", stdout);
10998}
10999
11000/* ARM EABI attributes section. */
11001typedef struct
11002{
11003 int tag;
11004 const char * name;
11005 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11006 int type;
11007 const char ** table;
11008} arm_attr_public_tag;
11009
11010static const char * arm_attr_tag_CPU_arch[] =
11011 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11012 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11013static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11014static const char * arm_attr_tag_THUMB_ISA_use[] =
11015 {"No", "Thumb-1", "Thumb-2"};
11016static const char * arm_attr_tag_FP_arch[] =
11017 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11018 "FP for ARMv8"};
11019static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11020static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11021 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11022static const char * arm_attr_tag_PCS_config[] =
11023 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11024 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11025static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11026 {"V6", "SB", "TLS", "Unused"};
11027static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11028 {"Absolute", "PC-relative", "SB-relative", "None"};
11029static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11030 {"Absolute", "PC-relative", "None"};
11031static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11032 {"None", "direct", "GOT-indirect"};
11033static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11034 {"None", "??? 1", "2", "??? 3", "4"};
11035static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11036static const char * arm_attr_tag_ABI_FP_denormal[] =
11037 {"Unused", "Needed", "Sign only"};
11038static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11039static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11040static const char * arm_attr_tag_ABI_FP_number_model[] =
11041 {"Unused", "Finite", "RTABI", "IEEE 754"};
11042static const char * arm_attr_tag_ABI_enum_size[] =
11043 {"Unused", "small", "int", "forced to int"};
11044static const char * arm_attr_tag_ABI_HardFP_use[] =
11045 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11046static const char * arm_attr_tag_ABI_VFP_args[] =
11047 {"AAPCS", "VFP registers", "custom"};
11048static const char * arm_attr_tag_ABI_WMMX_args[] =
11049 {"AAPCS", "WMMX registers", "custom"};
11050static const char * arm_attr_tag_ABI_optimization_goals[] =
11051 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11052 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11053static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11054 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11055 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11056static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11057static const char * arm_attr_tag_FP_HP_extension[] =
11058 {"Not Allowed", "Allowed"};
11059static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11060 {"None", "IEEE 754", "Alternative Format"};
11061static const char * arm_attr_tag_MPextension_use[] =
11062 {"Not Allowed", "Allowed"};
11063static const char * arm_attr_tag_DIV_use[] =
11064 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11065 "Allowed in v7-A with integer division extension"};
11066static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11067static const char * arm_attr_tag_Virtualization_use[] =
11068 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11069 "TrustZone and Virtualization Extensions"};
11070static const char * arm_attr_tag_MPextension_use_legacy[] =
11071 {"Not Allowed", "Allowed"};
11072
11073#define LOOKUP(id, name) \
11074 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11075static arm_attr_public_tag arm_attr_public_tags[] =
11076{
11077 {4, "CPU_raw_name", 1, NULL},
11078 {5, "CPU_name", 1, NULL},
11079 LOOKUP(6, CPU_arch),
11080 {7, "CPU_arch_profile", 0, NULL},
11081 LOOKUP(8, ARM_ISA_use),
11082 LOOKUP(9, THUMB_ISA_use),
11083 LOOKUP(10, FP_arch),
11084 LOOKUP(11, WMMX_arch),
11085 LOOKUP(12, Advanced_SIMD_arch),
11086 LOOKUP(13, PCS_config),
11087 LOOKUP(14, ABI_PCS_R9_use),
11088 LOOKUP(15, ABI_PCS_RW_data),
11089 LOOKUP(16, ABI_PCS_RO_data),
11090 LOOKUP(17, ABI_PCS_GOT_use),
11091 LOOKUP(18, ABI_PCS_wchar_t),
11092 LOOKUP(19, ABI_FP_rounding),
11093 LOOKUP(20, ABI_FP_denormal),
11094 LOOKUP(21, ABI_FP_exceptions),
11095 LOOKUP(22, ABI_FP_user_exceptions),
11096 LOOKUP(23, ABI_FP_number_model),
11097 {24, "ABI_align_needed", 0, NULL},
11098 {25, "ABI_align_preserved", 0, NULL},
11099 LOOKUP(26, ABI_enum_size),
11100 LOOKUP(27, ABI_HardFP_use),
11101 LOOKUP(28, ABI_VFP_args),
11102 LOOKUP(29, ABI_WMMX_args),
11103 LOOKUP(30, ABI_optimization_goals),
11104 LOOKUP(31, ABI_FP_optimization_goals),
11105 {32, "compatibility", 0, NULL},
11106 LOOKUP(34, CPU_unaligned_access),
11107 LOOKUP(36, FP_HP_extension),
11108 LOOKUP(38, ABI_FP_16bit_format),
11109 LOOKUP(42, MPextension_use),
11110 LOOKUP(44, DIV_use),
11111 {64, "nodefaults", 0, NULL},
11112 {65, "also_compatible_with", 0, NULL},
11113 LOOKUP(66, T2EE_use),
11114 {67, "conformance", 1, NULL},
11115 LOOKUP(68, Virtualization_use),
11116 LOOKUP(70, MPextension_use_legacy)
11117};
11118#undef LOOKUP
11119
11120static unsigned char *
11121display_arm_attribute (unsigned char * p)
11122{
11123 int tag;
11124 unsigned int len;
11125 int val;
11126 arm_attr_public_tag * attr;
11127 unsigned i;
11128 int type;
11129
11130 tag = read_uleb128 (p, &len);
11131 p += len;
11132 attr = NULL;
11133 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11134 {
11135 if (arm_attr_public_tags[i].tag == tag)
11136 {
11137 attr = &arm_attr_public_tags[i];
11138 break;
11139 }
11140 }
11141
11142 if (attr)
11143 {
11144 printf (" Tag_%s: ", attr->name);
11145 switch (attr->type)
11146 {
11147 case 0:
11148 switch (tag)
11149 {
11150 case 7: /* Tag_CPU_arch_profile. */
11151 val = read_uleb128 (p, &len);
11152 p += len;
11153 switch (val)
11154 {
11155 case 0: printf (_("None\n")); break;
11156 case 'A': printf (_("Application\n")); break;
11157 case 'R': printf (_("Realtime\n")); break;
11158 case 'M': printf (_("Microcontroller\n")); break;
11159 case 'S': printf (_("Application or Realtime\n")); break;
11160 default: printf ("??? (%d)\n", val); break;
11161 }
11162 break;
11163
11164 case 24: /* Tag_align_needed. */
11165 val = read_uleb128 (p, &len);
11166 p += len;
11167 switch (val)
11168 {
11169 case 0: printf (_("None\n")); break;
11170 case 1: printf (_("8-byte\n")); break;
11171 case 2: printf (_("4-byte\n")); break;
11172 case 3: printf ("??? 3\n"); break;
11173 default:
11174 if (val <= 12)
11175 printf (_("8-byte and up to %d-byte extended\n"),
11176 1 << val);
11177 else
11178 printf ("??? (%d)\n", val);
11179 break;
11180 }
11181 break;
11182
11183 case 25: /* Tag_align_preserved. */
11184 val = read_uleb128 (p, &len);
11185 p += len;
11186 switch (val)
11187 {
11188 case 0: printf (_("None\n")); break;
11189 case 1: printf (_("8-byte, except leaf SP\n")); break;
11190 case 2: printf (_("8-byte\n")); break;
11191 case 3: printf ("??? 3\n"); break;
11192 default:
11193 if (val <= 12)
11194 printf (_("8-byte and up to %d-byte extended\n"),
11195 1 << val);
11196 else
11197 printf ("??? (%d)\n", val);
11198 break;
11199 }
11200 break;
11201
11202 case 32: /* Tag_compatibility. */
11203 val = read_uleb128 (p, &len);
11204 p += len;
11205 printf (_("flag = %d, vendor = %s\n"), val, p);
11206 p += strlen ((char *) p) + 1;
11207 break;
11208
11209 case 64: /* Tag_nodefaults. */
11210 p++;
11211 printf (_("True\n"));
11212 break;
11213
11214 case 65: /* Tag_also_compatible_with. */
11215 val = read_uleb128 (p, &len);
11216 p += len;
11217 if (val == 6 /* Tag_CPU_arch. */)
11218 {
11219 val = read_uleb128 (p, &len);
11220 p += len;
11221 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11222 printf ("??? (%d)\n", val);
11223 else
11224 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11225 }
11226 else
11227 printf ("???\n");
11228 while (*(p++) != '\0' /* NUL terminator. */);
11229 break;
11230
11231 default:
11232 abort ();
11233 }
11234 return p;
11235
11236 case 1:
11237 case 2:
11238 type = attr->type;
11239 break;
11240
11241 default:
11242 assert (attr->type & 0x80);
11243 val = read_uleb128 (p, &len);
11244 p += len;
11245 type = attr->type & 0x7f;
11246 if (val >= type)
11247 printf ("??? (%d)\n", val);
11248 else
11249 printf ("%s\n", attr->table[val]);
11250 return p;
11251 }
11252 }
11253 else
11254 {
11255 if (tag & 1)
11256 type = 1; /* String. */
11257 else
11258 type = 2; /* uleb128. */
11259 printf (" Tag_unknown_%d: ", tag);
11260 }
11261
11262 if (type == 1)
11263 {
11264 printf ("\"%s\"\n", p);
11265 p += strlen ((char *) p) + 1;
11266 }
11267 else
11268 {
11269 val = read_uleb128 (p, &len);
11270 p += len;
11271 printf ("%d (0x%x)\n", val, val);
11272 }
11273
11274 return p;
11275}
11276
11277static unsigned char *
11278display_gnu_attribute (unsigned char * p,
11279 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11280{
11281 int tag;
11282 unsigned int len;
11283 int val;
11284 int type;
11285
11286 tag = read_uleb128 (p, &len);
11287 p += len;
11288
11289 /* Tag_compatibility is the only generic GNU attribute defined at
11290 present. */
11291 if (tag == 32)
11292 {
11293 val = read_uleb128 (p, &len);
11294 p += len;
11295 printf (_("flag = %d, vendor = %s\n"), val, p);
11296 p += strlen ((char *) p) + 1;
11297 return p;
11298 }
11299
11300 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11301 return display_proc_gnu_attribute (p, tag);
11302
11303 if (tag & 1)
11304 type = 1; /* String. */
11305 else
11306 type = 2; /* uleb128. */
11307 printf (" Tag_unknown_%d: ", tag);
11308
11309 if (type == 1)
11310 {
11311 printf ("\"%s\"\n", p);
11312 p += strlen ((char *) p) + 1;
11313 }
11314 else
11315 {
11316 val = read_uleb128 (p, &len);
11317 p += len;
11318 printf ("%d (0x%x)\n", val, val);
11319 }
11320
11321 return p;
11322}
11323
11324static unsigned char *
11325display_power_gnu_attribute (unsigned char * p, int tag)
11326{
11327 int type;
11328 unsigned int len;
11329 int val;
11330
11331 if (tag == Tag_GNU_Power_ABI_FP)
11332 {
11333 val = read_uleb128 (p, &len);
11334 p += len;
11335 printf (" Tag_GNU_Power_ABI_FP: ");
11336
11337 switch (val)
11338 {
11339 case 0:
11340 printf (_("Hard or soft float\n"));
11341 break;
11342 case 1:
11343 printf (_("Hard float\n"));
11344 break;
11345 case 2:
11346 printf (_("Soft float\n"));
11347 break;
11348 case 3:
11349 printf (_("Single-precision hard float\n"));
11350 break;
11351 default:
11352 printf ("??? (%d)\n", val);
11353 break;
11354 }
11355 return p;
11356 }
11357
11358 if (tag == Tag_GNU_Power_ABI_Vector)
11359 {
11360 val = read_uleb128 (p, &len);
11361 p += len;
11362 printf (" Tag_GNU_Power_ABI_Vector: ");
11363 switch (val)
11364 {
11365 case 0:
11366 printf (_("Any\n"));
11367 break;
11368 case 1:
11369 printf (_("Generic\n"));
11370 break;
11371 case 2:
11372 printf ("AltiVec\n");
11373 break;
11374 case 3:
11375 printf ("SPE\n");
11376 break;
11377 default:
11378 printf ("??? (%d)\n", val);
11379 break;
11380 }
11381 return p;
11382 }
11383
11384 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11385 {
11386 val = read_uleb128 (p, &len);
11387 p += len;
11388 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11389 switch (val)
11390 {
11391 case 0:
11392 printf (_("Any\n"));
11393 break;
11394 case 1:
11395 printf ("r3/r4\n");
11396 break;
11397 case 2:
11398 printf (_("Memory\n"));
11399 break;
11400 default:
11401 printf ("??? (%d)\n", val);
11402 break;
11403 }
11404 return p;
11405 }
11406
11407 if (tag & 1)
11408 type = 1; /* String. */
11409 else
11410 type = 2; /* uleb128. */
11411 printf (" Tag_unknown_%d: ", tag);
11412
11413 if (type == 1)
11414 {
11415 printf ("\"%s\"\n", p);
11416 p += strlen ((char *) p) + 1;
11417 }
11418 else
11419 {
11420 val = read_uleb128 (p, &len);
11421 p += len;
11422 printf ("%d (0x%x)\n", val, val);
11423 }
11424
11425 return p;
11426}
11427
11428static void
11429display_sparc_hwcaps (int mask)
11430{
11431 if (mask)
11432 {
11433 int first = 1;
11434 if (mask & ELF_SPARC_HWCAP_MUL32)
11435 fputs ("mul32", stdout), first = 0;
11436 if (mask & ELF_SPARC_HWCAP_DIV32)
11437 printf ("%sdiv32", first ? "" : "|"), first = 0;
11438 if (mask & ELF_SPARC_HWCAP_FSMULD)
11439 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11440 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11441 printf ("%sv8plus", first ? "" : "|"), first = 0;
11442 if (mask & ELF_SPARC_HWCAP_POPC)
11443 printf ("%spopc", first ? "" : "|"), first = 0;
11444 if (mask & ELF_SPARC_HWCAP_VIS)
11445 printf ("%svis", first ? "" : "|"), first = 0;
11446 if (mask & ELF_SPARC_HWCAP_VIS2)
11447 printf ("%svis2", first ? "" : "|"), first = 0;
11448 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11449 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11450 if (mask & ELF_SPARC_HWCAP_FMAF)
11451 printf ("%sfmaf", first ? "" : "|"), first = 0;
11452 if (mask & ELF_SPARC_HWCAP_VIS3)
11453 printf ("%svis3", first ? "" : "|"), first = 0;
11454 if (mask & ELF_SPARC_HWCAP_HPC)
11455 printf ("%shpc", first ? "" : "|"), first = 0;
11456 if (mask & ELF_SPARC_HWCAP_RANDOM)
11457 printf ("%srandom", first ? "" : "|"), first = 0;
11458 if (mask & ELF_SPARC_HWCAP_TRANS)
11459 printf ("%strans", first ? "" : "|"), first = 0;
11460 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11461 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11462 if (mask & ELF_SPARC_HWCAP_IMA)
11463 printf ("%sima", first ? "" : "|"), first = 0;
11464 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11465 printf ("%scspare", first ? "" : "|"), first = 0;
11466 }
11467 else
11468 fputc('0', stdout);
11469 fputc('\n', stdout);
11470}
11471
11472static unsigned char *
11473display_sparc_gnu_attribute (unsigned char * p, int tag)
11474{
11475 int type;
11476 unsigned int len;
11477 int val;
11478
11479 if (tag == Tag_GNU_Sparc_HWCAPS)
11480 {
11481 val = read_uleb128 (p, &len);
11482 p += len;
11483 printf (" Tag_GNU_Sparc_HWCAPS: ");
11484
11485 display_sparc_hwcaps (val);
11486 return p;
11487 }
11488
11489 if (tag & 1)
11490 type = 1; /* String. */
11491 else
11492 type = 2; /* uleb128. */
11493 printf (" Tag_unknown_%d: ", tag);
11494
11495 if (type == 1)
11496 {
11497 printf ("\"%s\"\n", p);
11498 p += strlen ((char *) p) + 1;
11499 }
11500 else
11501 {
11502 val = read_uleb128 (p, &len);
11503 p += len;
11504 printf ("%d (0x%x)\n", val, val);
11505 }
11506
11507 return p;
11508}
11509
11510static unsigned char *
11511display_mips_gnu_attribute (unsigned char * p, int tag)
11512{
11513 int type;
11514 unsigned int len;
11515 int val;
11516
11517 if (tag == Tag_GNU_MIPS_ABI_FP)
11518 {
11519 val = read_uleb128 (p, &len);
11520 p += len;
11521 printf (" Tag_GNU_MIPS_ABI_FP: ");
11522
11523 switch (val)
11524 {
11525 case 0:
11526 printf (_("Hard or soft float\n"));
11527 break;
11528 case 1:
11529 printf (_("Hard float (double precision)\n"));
11530 break;
11531 case 2:
11532 printf (_("Hard float (single precision)\n"));
11533 break;
11534 case 3:
11535 printf (_("Soft float\n"));
11536 break;
11537 case 4:
11538 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11539 break;
11540 default:
11541 printf ("??? (%d)\n", val);
11542 break;
11543 }
11544 return p;
11545 }
11546
11547 if (tag & 1)
11548 type = 1; /* String. */
11549 else
11550 type = 2; /* uleb128. */
11551 printf (" Tag_unknown_%d: ", tag);
11552
11553 if (type == 1)
11554 {
11555 printf ("\"%s\"\n", p);
11556 p += strlen ((char *) p) + 1;
11557 }
11558 else
11559 {
11560 val = read_uleb128 (p, &len);
11561 p += len;
11562 printf ("%d (0x%x)\n", val, val);
11563 }
11564
11565 return p;
11566}
11567
11568static unsigned char *
11569display_tic6x_attribute (unsigned char * p)
11570{
11571 int tag;
11572 unsigned int len;
11573 int val;
11574
11575 tag = read_uleb128 (p, &len);
11576 p += len;
11577
11578 switch (tag)
11579 {
11580 case Tag_ISA:
11581 val = read_uleb128 (p, &len);
11582 p += len;
11583 printf (" Tag_ISA: ");
11584
11585 switch (val)
11586 {
11587 case C6XABI_Tag_ISA_none:
11588 printf (_("None\n"));
11589 break;
11590 case C6XABI_Tag_ISA_C62X:
11591 printf ("C62x\n");
11592 break;
11593 case C6XABI_Tag_ISA_C67X:
11594 printf ("C67x\n");
11595 break;
11596 case C6XABI_Tag_ISA_C67XP:
11597 printf ("C67x+\n");
11598 break;
11599 case C6XABI_Tag_ISA_C64X:
11600 printf ("C64x\n");
11601 break;
11602 case C6XABI_Tag_ISA_C64XP:
11603 printf ("C64x+\n");
11604 break;
11605 case C6XABI_Tag_ISA_C674X:
11606 printf ("C674x\n");
11607 break;
11608 default:
11609 printf ("??? (%d)\n", val);
11610 break;
11611 }
11612 return p;
11613
11614 case Tag_ABI_wchar_t:
11615 val = read_uleb128 (p, &len);
11616 p += len;
11617 printf (" Tag_ABI_wchar_t: ");
11618 switch (val)
11619 {
11620 case 0:
11621 printf (_("Not used\n"));
11622 break;
11623 case 1:
11624 printf (_("2 bytes\n"));
11625 break;
11626 case 2:
11627 printf (_("4 bytes\n"));
11628 break;
11629 default:
11630 printf ("??? (%d)\n", val);
11631 break;
11632 }
11633 return p;
11634
11635 case Tag_ABI_stack_align_needed:
11636 val = read_uleb128 (p, &len);
11637 p += len;
11638 printf (" Tag_ABI_stack_align_needed: ");
11639 switch (val)
11640 {
11641 case 0:
11642 printf (_("8-byte\n"));
11643 break;
11644 case 1:
11645 printf (_("16-byte\n"));
11646 break;
11647 default:
11648 printf ("??? (%d)\n", val);
11649 break;
11650 }
11651 return p;
11652
11653 case Tag_ABI_stack_align_preserved:
11654 val = read_uleb128 (p, &len);
11655 p += len;
11656 printf (" Tag_ABI_stack_align_preserved: ");
11657 switch (val)
11658 {
11659 case 0:
11660 printf (_("8-byte\n"));
11661 break;
11662 case 1:
11663 printf (_("16-byte\n"));
11664 break;
11665 default:
11666 printf ("??? (%d)\n", val);
11667 break;
11668 }
11669 return p;
11670
11671 case Tag_ABI_DSBT:
11672 val = read_uleb128 (p, &len);
11673 p += len;
11674 printf (" Tag_ABI_DSBT: ");
11675 switch (val)
11676 {
11677 case 0:
11678 printf (_("DSBT addressing not used\n"));
11679 break;
11680 case 1:
11681 printf (_("DSBT addressing used\n"));
11682 break;
11683 default:
11684 printf ("??? (%d)\n", val);
11685 break;
11686 }
11687 return p;
11688
11689 case Tag_ABI_PID:
11690 val = read_uleb128 (p, &len);
11691 p += len;
11692 printf (" Tag_ABI_PID: ");
11693 switch (val)
11694 {
11695 case 0:
11696 printf (_("Data addressing position-dependent\n"));
11697 break;
11698 case 1:
11699 printf (_("Data addressing position-independent, GOT near DP\n"));
11700 break;
11701 case 2:
11702 printf (_("Data addressing position-independent, GOT far from DP\n"));
11703 break;
11704 default:
11705 printf ("??? (%d)\n", val);
11706 break;
11707 }
11708 return p;
11709
11710 case Tag_ABI_PIC:
11711 val = read_uleb128 (p, &len);
11712 p += len;
11713 printf (" Tag_ABI_PIC: ");
11714 switch (val)
11715 {
11716 case 0:
11717 printf (_("Code addressing position-dependent\n"));
11718 break;
11719 case 1:
11720 printf (_("Code addressing position-independent\n"));
11721 break;
11722 default:
11723 printf ("??? (%d)\n", val);
11724 break;
11725 }
11726 return p;
11727
11728 case Tag_ABI_array_object_alignment:
11729 val = read_uleb128 (p, &len);
11730 p += len;
11731 printf (" Tag_ABI_array_object_alignment: ");
11732 switch (val)
11733 {
11734 case 0:
11735 printf (_("8-byte\n"));
11736 break;
11737 case 1:
11738 printf (_("4-byte\n"));
11739 break;
11740 case 2:
11741 printf (_("16-byte\n"));
11742 break;
11743 default:
11744 printf ("??? (%d)\n", val);
11745 break;
11746 }
11747 return p;
11748
11749 case Tag_ABI_array_object_align_expected:
11750 val = read_uleb128 (p, &len);
11751 p += len;
11752 printf (" Tag_ABI_array_object_align_expected: ");
11753 switch (val)
11754 {
11755 case 0:
11756 printf (_("8-byte\n"));
11757 break;
11758 case 1:
11759 printf (_("4-byte\n"));
11760 break;
11761 case 2:
11762 printf (_("16-byte\n"));
11763 break;
11764 default:
11765 printf ("??? (%d)\n", val);
11766 break;
11767 }
11768 return p;
11769
11770 case Tag_ABI_compatibility:
11771 val = read_uleb128 (p, &len);
11772 p += len;
11773 printf (" Tag_ABI_compatibility: ");
11774 printf (_("flag = %d, vendor = %s\n"), val, p);
11775 p += strlen ((char *) p) + 1;
11776 return p;
11777
11778 case Tag_ABI_conformance:
11779 printf (" Tag_ABI_conformance: ");
11780 printf ("\"%s\"\n", p);
11781 p += strlen ((char *) p) + 1;
11782 return p;
11783 }
11784
11785 printf (" Tag_unknown_%d: ", tag);
11786
11787 if (tag & 1)
11788 {
11789 printf ("\"%s\"\n", p);
11790 p += strlen ((char *) p) + 1;
11791 }
11792 else
11793 {
11794 val = read_uleb128 (p, &len);
11795 p += len;
11796 printf ("%d (0x%x)\n", val, val);
11797 }
11798
11799 return p;
11800}
11801
11802static int
11803process_attributes (FILE * file,
11804 const char * public_name,
11805 unsigned int proc_type,
11806 unsigned char * (* display_pub_attribute) (unsigned char *),
11807 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11808{
11809 Elf_Internal_Shdr * sect;
11810 unsigned char * contents;
11811 unsigned char * p;
11812 unsigned char * end;
11813 bfd_vma section_len;
11814 bfd_vma len;
11815 unsigned i;
11816
11817 /* Find the section header so that we get the size. */
11818 for (i = 0, sect = section_headers;
11819 i < elf_header.e_shnum;
11820 i++, sect++)
11821 {
11822 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11823 continue;
11824
11825 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11826 sect->sh_size, _("attributes"));
11827 if (contents == NULL)
11828 continue;
11829
11830 p = contents;
11831 if (*p == 'A')
11832 {
11833 len = sect->sh_size - 1;
11834 p++;
11835
11836 while (len > 0)
11837 {
11838 int namelen;
11839 bfd_boolean public_section;
11840 bfd_boolean gnu_section;
11841
11842 section_len = byte_get (p, 4);
11843 p += 4;
11844
11845 if (section_len > len)
11846 {
11847 printf (_("ERROR: Bad section length (%d > %d)\n"),
11848 (int) section_len, (int) len);
11849 section_len = len;
11850 }
11851
11852 len -= section_len;
11853 printf (_("Attribute Section: %s\n"), p);
11854
11855 if (public_name && streq ((char *) p, public_name))
11856 public_section = TRUE;
11857 else
11858 public_section = FALSE;
11859
11860 if (streq ((char *) p, "gnu"))
11861 gnu_section = TRUE;
11862 else
11863 gnu_section = FALSE;
11864
11865 namelen = strlen ((char *) p) + 1;
11866 p += namelen;
11867 section_len -= namelen + 4;
11868
11869 while (section_len > 0)
11870 {
11871 int tag = *(p++);
11872 int val;
11873 bfd_vma size;
11874
11875 size = byte_get (p, 4);
11876 if (size > section_len)
11877 {
11878 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11879 (int) size, (int) section_len);
11880 size = section_len;
11881 }
11882
11883 section_len -= size;
11884 end = p + size - 1;
11885 p += 4;
11886
11887 switch (tag)
11888 {
11889 case 1:
11890 printf (_("File Attributes\n"));
11891 break;
11892 case 2:
11893 printf (_("Section Attributes:"));
11894 goto do_numlist;
11895 case 3:
11896 printf (_("Symbol Attributes:"));
11897 do_numlist:
11898 for (;;)
11899 {
11900 unsigned int j;
11901
11902 val = read_uleb128 (p, &j);
11903 p += j;
11904 if (val == 0)
11905 break;
11906 printf (" %d", val);
11907 }
11908 printf ("\n");
11909 break;
11910 default:
11911 printf (_("Unknown tag: %d\n"), tag);
11912 public_section = FALSE;
11913 break;
11914 }
11915
11916 if (public_section)
11917 {
11918 while (p < end)
11919 p = display_pub_attribute (p);
11920 }
11921 else if (gnu_section)
11922 {
11923 while (p < end)
11924 p = display_gnu_attribute (p,
11925 display_proc_gnu_attribute);
11926 }
11927 else
11928 {
11929 /* ??? Do something sensible, like dump hex. */
11930 printf (_(" Unknown section contexts\n"));
11931 p = end;
11932 }
11933 }
11934 }
11935 }
11936 else
11937 printf (_("Unknown format '%c'\n"), *p);
11938
11939 free (contents);
11940 }
11941 return 1;
11942}
11943
11944static int
11945process_arm_specific (FILE * file)
11946{
11947 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11948 display_arm_attribute, NULL);
11949}
11950
11951static int
11952process_power_specific (FILE * file)
11953{
11954 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11955 display_power_gnu_attribute);
11956}
11957
11958static int
11959process_sparc_specific (FILE * file)
11960{
11961 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11962 display_sparc_gnu_attribute);
11963}
11964
11965static int
11966process_tic6x_specific (FILE * file)
11967{
11968 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11969 display_tic6x_attribute, NULL);
11970}
11971
11972/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11973 Print the Address, Access and Initial fields of an entry at VMA ADDR
11974 and return the VMA of the next entry. */
11975
11976static bfd_vma
11977print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11978{
11979 printf (" ");
11980 print_vma (addr, LONG_HEX);
11981 printf (" ");
11982 if (addr < pltgot + 0xfff0)
11983 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11984 else
11985 printf ("%10s", "");
11986 printf (" ");
11987 if (data == NULL)
11988 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11989 else
11990 {
11991 bfd_vma entry;
11992
11993 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11994 print_vma (entry, LONG_HEX);
11995 }
11996 return addr + (is_32bit_elf ? 4 : 8);
11997}
11998
11999/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12000 PLTGOT. Print the Address and Initial fields of an entry at VMA
12001 ADDR and return the VMA of the next entry. */
12002
12003static bfd_vma
12004print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12005{
12006 printf (" ");
12007 print_vma (addr, LONG_HEX);
12008 printf (" ");
12009 if (data == NULL)
12010 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12011 else
12012 {
12013 bfd_vma entry;
12014
12015 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12016 print_vma (entry, LONG_HEX);
12017 }
12018 return addr + (is_32bit_elf ? 4 : 8);
12019}
12020
12021static int
12022process_mips_specific (FILE * file)
12023{
12024 Elf_Internal_Dyn * entry;
12025 size_t liblist_offset = 0;
12026 size_t liblistno = 0;
12027 size_t conflictsno = 0;
12028 size_t options_offset = 0;
12029 size_t conflicts_offset = 0;
12030 size_t pltrelsz = 0;
12031 size_t pltrel = 0;
12032 bfd_vma pltgot = 0;
12033 bfd_vma mips_pltgot = 0;
12034 bfd_vma jmprel = 0;
12035 bfd_vma local_gotno = 0;
12036 bfd_vma gotsym = 0;
12037 bfd_vma symtabno = 0;
12038
12039 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12040 display_mips_gnu_attribute);
12041
12042 /* We have a lot of special sections. Thanks SGI! */
12043 if (dynamic_section == NULL)
12044 /* No information available. */
12045 return 0;
12046
12047 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12048 switch (entry->d_tag)
12049 {
12050 case DT_MIPS_LIBLIST:
12051 liblist_offset
12052 = offset_from_vma (file, entry->d_un.d_val,
12053 liblistno * sizeof (Elf32_External_Lib));
12054 break;
12055 case DT_MIPS_LIBLISTNO:
12056 liblistno = entry->d_un.d_val;
12057 break;
12058 case DT_MIPS_OPTIONS:
12059 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12060 break;
12061 case DT_MIPS_CONFLICT:
12062 conflicts_offset
12063 = offset_from_vma (file, entry->d_un.d_val,
12064 conflictsno * sizeof (Elf32_External_Conflict));
12065 break;
12066 case DT_MIPS_CONFLICTNO:
12067 conflictsno = entry->d_un.d_val;
12068 break;
12069 case DT_PLTGOT:
12070 pltgot = entry->d_un.d_ptr;
12071 break;
12072 case DT_MIPS_LOCAL_GOTNO:
12073 local_gotno = entry->d_un.d_val;
12074 break;
12075 case DT_MIPS_GOTSYM:
12076 gotsym = entry->d_un.d_val;
12077 break;
12078 case DT_MIPS_SYMTABNO:
12079 symtabno = entry->d_un.d_val;
12080 break;
12081 case DT_MIPS_PLTGOT:
12082 mips_pltgot = entry->d_un.d_ptr;
12083 break;
12084 case DT_PLTREL:
12085 pltrel = entry->d_un.d_val;
12086 break;
12087 case DT_PLTRELSZ:
12088 pltrelsz = entry->d_un.d_val;
12089 break;
12090 case DT_JMPREL:
12091 jmprel = entry->d_un.d_ptr;
12092 break;
12093 default:
12094 break;
12095 }
12096
12097 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12098 {
12099 Elf32_External_Lib * elib;
12100 size_t cnt;
12101
12102 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12103 liblistno,
12104 sizeof (Elf32_External_Lib),
12105 _("liblist section data"));
12106 if (elib)
12107 {
12108 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12109 (unsigned long) liblistno);
12110 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12111 stdout);
12112
12113 for (cnt = 0; cnt < liblistno; ++cnt)
12114 {
12115 Elf32_Lib liblist;
12116 time_t atime;
12117 char timebuf[20];
12118 struct tm * tmp;
12119
12120 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12121 atime = BYTE_GET (elib[cnt].l_time_stamp);
12122 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12123 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12124 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12125
12126 tmp = gmtime (&atime);
12127 snprintf (timebuf, sizeof (timebuf),
12128 "%04u-%02u-%02uT%02u:%02u:%02u",
12129 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12130 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12131
12132 printf ("%3lu: ", (unsigned long) cnt);
12133 if (VALID_DYNAMIC_NAME (liblist.l_name))
12134 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12135 else
12136 printf (_("<corrupt: %9ld>"), liblist.l_name);
12137 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12138 liblist.l_version);
12139
12140 if (liblist.l_flags == 0)
12141 puts (_(" NONE"));
12142 else
12143 {
12144 static const struct
12145 {
12146 const char * name;
12147 int bit;
12148 }
12149 l_flags_vals[] =
12150 {
12151 { " EXACT_MATCH", LL_EXACT_MATCH },
12152 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12153 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12154 { " EXPORTS", LL_EXPORTS },
12155 { " DELAY_LOAD", LL_DELAY_LOAD },
12156 { " DELTA", LL_DELTA }
12157 };
12158 int flags = liblist.l_flags;
12159 size_t fcnt;
12160
12161 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12162 if ((flags & l_flags_vals[fcnt].bit) != 0)
12163 {
12164 fputs (l_flags_vals[fcnt].name, stdout);
12165 flags ^= l_flags_vals[fcnt].bit;
12166 }
12167 if (flags != 0)
12168 printf (" %#x", (unsigned int) flags);
12169
12170 puts ("");
12171 }
12172 }
12173
12174 free (elib);
12175 }
12176 }
12177
12178 if (options_offset != 0)
12179 {
12180 Elf_External_Options * eopt;
12181 Elf_Internal_Shdr * sect = section_headers;
12182 Elf_Internal_Options * iopt;
12183 Elf_Internal_Options * option;
12184 size_t offset;
12185 int cnt;
12186
12187 /* Find the section header so that we get the size. */
12188 while (sect->sh_type != SHT_MIPS_OPTIONS)
12189 ++sect;
12190
12191 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12192 sect->sh_size, _("options"));
12193 if (eopt)
12194 {
12195 iopt = (Elf_Internal_Options *)
12196 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12197 if (iopt == NULL)
12198 {
12199 error (_("Out of memory\n"));
12200 return 0;
12201 }
12202
12203 offset = cnt = 0;
12204 option = iopt;
12205
12206 while (offset < sect->sh_size)
12207 {
12208 Elf_External_Options * eoption;
12209
12210 eoption = (Elf_External_Options *) ((char *) eopt + offset);
12211
12212 option->kind = BYTE_GET (eoption->kind);
12213 option->size = BYTE_GET (eoption->size);
12214 option->section = BYTE_GET (eoption->section);
12215 option->info = BYTE_GET (eoption->info);
12216
12217 offset += option->size;
12218
12219 ++option;
12220 ++cnt;
12221 }
12222
12223 printf (_("\nSection '%s' contains %d entries:\n"),
12224 SECTION_NAME (sect), cnt);
12225
12226 option = iopt;
12227
12228 while (cnt-- > 0)
12229 {
12230 size_t len;
12231
12232 switch (option->kind)
12233 {
12234 case ODK_NULL:
12235 /* This shouldn't happen. */
12236 printf (" NULL %d %lx", option->section, option->info);
12237 break;
12238 case ODK_REGINFO:
12239 printf (" REGINFO ");
12240 if (elf_header.e_machine == EM_MIPS)
12241 {
12242 /* 32bit form. */
12243 Elf32_External_RegInfo * ereg;
12244 Elf32_RegInfo reginfo;
12245
12246 ereg = (Elf32_External_RegInfo *) (option + 1);
12247 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12248 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12249 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12250 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12251 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12252 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12253
12254 printf ("GPR %08lx GP 0x%lx\n",
12255 reginfo.ri_gprmask,
12256 (unsigned long) reginfo.ri_gp_value);
12257 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12258 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12259 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12260 }
12261 else
12262 {
12263 /* 64 bit form. */
12264 Elf64_External_RegInfo * ereg;
12265 Elf64_Internal_RegInfo reginfo;
12266
12267 ereg = (Elf64_External_RegInfo *) (option + 1);
12268 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12269 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12270 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12271 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12272 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12273 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12274
12275 printf ("GPR %08lx GP 0x",
12276 reginfo.ri_gprmask);
12277 printf_vma (reginfo.ri_gp_value);
12278 printf ("\n");
12279
12280 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12281 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12282 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12283 }
12284 ++option;
12285 continue;
12286 case ODK_EXCEPTIONS:
12287 fputs (" EXCEPTIONS fpe_min(", stdout);
12288 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12289 fputs (") fpe_max(", stdout);
12290 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12291 fputs (")", stdout);
12292
12293 if (option->info & OEX_PAGE0)
12294 fputs (" PAGE0", stdout);
12295 if (option->info & OEX_SMM)
12296 fputs (" SMM", stdout);
12297 if (option->info & OEX_FPDBUG)
12298 fputs (" FPDBUG", stdout);
12299 if (option->info & OEX_DISMISS)
12300 fputs (" DISMISS", stdout);
12301 break;
12302 case ODK_PAD:
12303 fputs (" PAD ", stdout);
12304 if (option->info & OPAD_PREFIX)
12305 fputs (" PREFIX", stdout);
12306 if (option->info & OPAD_POSTFIX)
12307 fputs (" POSTFIX", stdout);
12308 if (option->info & OPAD_SYMBOL)
12309 fputs (" SYMBOL", stdout);
12310 break;
12311 case ODK_HWPATCH:
12312 fputs (" HWPATCH ", stdout);
12313 if (option->info & OHW_R4KEOP)
12314 fputs (" R4KEOP", stdout);
12315 if (option->info & OHW_R8KPFETCH)
12316 fputs (" R8KPFETCH", stdout);
12317 if (option->info & OHW_R5KEOP)
12318 fputs (" R5KEOP", stdout);
12319 if (option->info & OHW_R5KCVTL)
12320 fputs (" R5KCVTL", stdout);
12321 break;
12322 case ODK_FILL:
12323 fputs (" FILL ", stdout);
12324 /* XXX Print content of info word? */
12325 break;
12326 case ODK_TAGS:
12327 fputs (" TAGS ", stdout);
12328 /* XXX Print content of info word? */
12329 break;
12330 case ODK_HWAND:
12331 fputs (" HWAND ", stdout);
12332 if (option->info & OHWA0_R4KEOP_CHECKED)
12333 fputs (" R4KEOP_CHECKED", stdout);
12334 if (option->info & OHWA0_R4KEOP_CLEAN)
12335 fputs (" R4KEOP_CLEAN", stdout);
12336 break;
12337 case ODK_HWOR:
12338 fputs (" HWOR ", stdout);
12339 if (option->info & OHWA0_R4KEOP_CHECKED)
12340 fputs (" R4KEOP_CHECKED", stdout);
12341 if (option->info & OHWA0_R4KEOP_CLEAN)
12342 fputs (" R4KEOP_CLEAN", stdout);
12343 break;
12344 case ODK_GP_GROUP:
12345 printf (" GP_GROUP %#06lx self-contained %#06lx",
12346 option->info & OGP_GROUP,
12347 (option->info & OGP_SELF) >> 16);
12348 break;
12349 case ODK_IDENT:
12350 printf (" IDENT %#06lx self-contained %#06lx",
12351 option->info & OGP_GROUP,
12352 (option->info & OGP_SELF) >> 16);
12353 break;
12354 default:
12355 /* This shouldn't happen. */
12356 printf (" %3d ??? %d %lx",
12357 option->kind, option->section, option->info);
12358 break;
12359 }
12360
12361 len = sizeof (* eopt);
12362 while (len < option->size)
12363 if (((char *) option)[len] >= ' '
12364 && ((char *) option)[len] < 0x7f)
12365 printf ("%c", ((char *) option)[len++]);
12366 else
12367 printf ("\\%03o", ((char *) option)[len++]);
12368
12369 fputs ("\n", stdout);
12370 ++option;
12371 }
12372
12373 free (eopt);
12374 }
12375 }
12376
12377 if (conflicts_offset != 0 && conflictsno != 0)
12378 {
12379 Elf32_Conflict * iconf;
12380 size_t cnt;
12381
12382 if (dynamic_symbols == NULL)
12383 {
12384 error (_("conflict list found without a dynamic symbol table\n"));
12385 return 0;
12386 }
12387
12388 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12389 if (iconf == NULL)
12390 {
12391 error (_("Out of memory\n"));
12392 return 0;
12393 }
12394
12395 if (is_32bit_elf)
12396 {
12397 Elf32_External_Conflict * econf32;
12398
12399 econf32 = (Elf32_External_Conflict *)
12400 get_data (NULL, file, conflicts_offset, conflictsno,
12401 sizeof (* econf32), _("conflict"));
12402 if (!econf32)
12403 return 0;
12404
12405 for (cnt = 0; cnt < conflictsno; ++cnt)
12406 iconf[cnt] = BYTE_GET (econf32[cnt]);
12407
12408 free (econf32);
12409 }
12410 else
12411 {
12412 Elf64_External_Conflict * econf64;
12413
12414 econf64 = (Elf64_External_Conflict *)
12415 get_data (NULL, file, conflicts_offset, conflictsno,
12416 sizeof (* econf64), _("conflict"));
12417 if (!econf64)
12418 return 0;
12419
12420 for (cnt = 0; cnt < conflictsno; ++cnt)
12421 iconf[cnt] = BYTE_GET (econf64[cnt]);
12422
12423 free (econf64);
12424 }
12425
12426 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12427 (unsigned long) conflictsno);
12428 puts (_(" Num: Index Value Name"));
12429
12430 for (cnt = 0; cnt < conflictsno; ++cnt)
12431 {
12432 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
12433
12434 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
12435 print_vma (psym->st_value, FULL_HEX);
12436 putchar (' ');
12437 if (VALID_DYNAMIC_NAME (psym->st_name))
12438 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12439 else
12440 printf (_("<corrupt: %14ld>"), psym->st_name);
12441 putchar ('\n');
12442 }
12443
12444 free (iconf);
12445 }
12446
12447 if (pltgot != 0 && local_gotno != 0)
12448 {
12449 bfd_vma ent, local_end, global_end;
12450 size_t i, offset;
12451 unsigned char * data;
12452 int addr_size;
12453
12454 ent = pltgot;
12455 addr_size = (is_32bit_elf ? 4 : 8);
12456 local_end = pltgot + local_gotno * addr_size;
12457 global_end = local_end + (symtabno - gotsym) * addr_size;
12458
12459 offset = offset_from_vma (file, pltgot, global_end - pltgot);
12460 data = (unsigned char *) get_data (NULL, file, offset,
12461 global_end - pltgot, 1,
12462 _("Global Offset Table data"));
12463 if (data == NULL)
12464 return 0;
12465
12466 printf (_("\nPrimary GOT:\n"));
12467 printf (_(" Canonical gp value: "));
12468 print_vma (pltgot + 0x7ff0, LONG_HEX);
12469 printf ("\n\n");
12470
12471 printf (_(" Reserved entries:\n"));
12472 printf (_(" %*s %10s %*s Purpose\n"),
12473 addr_size * 2, _("Address"), _("Access"),
12474 addr_size * 2, _("Initial"));
12475 ent = print_mips_got_entry (data, pltgot, ent);
12476 printf (_(" Lazy resolver\n"));
12477 if (data
12478 && (byte_get (data + ent - pltgot, addr_size)
12479 >> (addr_size * 8 - 1)) != 0)
12480 {
12481 ent = print_mips_got_entry (data, pltgot, ent);
12482 printf (_(" Module pointer (GNU extension)\n"));
12483 }
12484 printf ("\n");
12485
12486 if (ent < local_end)
12487 {
12488 printf (_(" Local entries:\n"));
12489 printf (" %*s %10s %*s\n",
12490 addr_size * 2, _("Address"), _("Access"),
12491 addr_size * 2, _("Initial"));
12492 while (ent < local_end)
12493 {
12494 ent = print_mips_got_entry (data, pltgot, ent);
12495 printf ("\n");
12496 }
12497 printf ("\n");
12498 }
12499
12500 if (gotsym < symtabno)
12501 {
12502 int sym_width;
12503
12504 printf (_(" Global entries:\n"));
12505 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12506 addr_size * 2, _("Address"),
12507 _("Access"),
12508 addr_size * 2, _("Initial"),
12509 addr_size * 2, _("Sym.Val."),
12510 _("Type"),
12511 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12512 _("Ndx"), _("Name"));
12513
12514 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12515 for (i = gotsym; i < symtabno; i++)
12516 {
12517 Elf_Internal_Sym * psym;
12518
12519 psym = dynamic_symbols + i;
12520 ent = print_mips_got_entry (data, pltgot, ent);
12521 printf (" ");
12522 print_vma (psym->st_value, LONG_HEX);
12523 printf (" %-7s %3s ",
12524 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12525 get_symbol_index_type (psym->st_shndx));
12526 if (VALID_DYNAMIC_NAME (psym->st_name))
12527 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12528 else
12529 printf (_("<corrupt: %14ld>"), psym->st_name);
12530 printf ("\n");
12531 }
12532 printf ("\n");
12533 }
12534
12535 if (data)
12536 free (data);
12537 }
12538
12539 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12540 {
12541 bfd_vma ent, end;
12542 size_t offset, rel_offset;
12543 unsigned long count, i;
12544 unsigned char * data;
12545 int addr_size, sym_width;
12546 Elf_Internal_Rela * rels;
12547
12548 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12549 if (pltrel == DT_RELA)
12550 {
12551 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12552 return 0;
12553 }
12554 else
12555 {
12556 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12557 return 0;
12558 }
12559
12560 ent = mips_pltgot;
12561 addr_size = (is_32bit_elf ? 4 : 8);
12562 end = mips_pltgot + (2 + count) * addr_size;
12563
12564 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12565 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12566 1, _("Procedure Linkage Table data"));
12567 if (data == NULL)
12568 return 0;
12569
12570 printf ("\nPLT GOT:\n\n");
12571 printf (_(" Reserved entries:\n"));
12572 printf (_(" %*s %*s Purpose\n"),
12573 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12574 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12575 printf (_(" PLT lazy resolver\n"));
12576 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12577 printf (_(" Module pointer\n"));
12578 printf ("\n");
12579
12580 printf (_(" Entries:\n"));
12581 printf (" %*s %*s %*s %-7s %3s %s\n",
12582 addr_size * 2, _("Address"),
12583 addr_size * 2, _("Initial"),
12584 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12585 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12586 for (i = 0; i < count; i++)
12587 {
12588 Elf_Internal_Sym * psym;
12589
12590 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12591 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12592 printf (" ");
12593 print_vma (psym->st_value, LONG_HEX);
12594 printf (" %-7s %3s ",
12595 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12596 get_symbol_index_type (psym->st_shndx));
12597 if (VALID_DYNAMIC_NAME (psym->st_name))
12598 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12599 else
12600 printf (_("<corrupt: %14ld>"), psym->st_name);
12601 printf ("\n");
12602 }
12603 printf ("\n");
12604
12605 if (data)
12606 free (data);
12607 free (rels);
12608 }
12609
12610 return 1;
12611}
12612
12613static int
12614process_gnu_liblist (FILE * file)
12615{
12616 Elf_Internal_Shdr * section;
12617 Elf_Internal_Shdr * string_sec;
12618 Elf32_External_Lib * elib;
12619 char * strtab;
12620 size_t strtab_size;
12621 size_t cnt;
12622 unsigned i;
12623
12624 if (! do_arch)
12625 return 0;
12626
12627 for (i = 0, section = section_headers;
12628 i < elf_header.e_shnum;
12629 i++, section++)
12630 {
12631 switch (section->sh_type)
12632 {
12633 case SHT_GNU_LIBLIST:
12634 if (section->sh_link >= elf_header.e_shnum)
12635 break;
12636
12637 elib = (Elf32_External_Lib *)
12638 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12639 _("liblist section data"));
12640
12641 if (elib == NULL)
12642 break;
12643 string_sec = section_headers + section->sh_link;
12644
12645 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12646 string_sec->sh_size,
12647 _("liblist string table"));
12648 if (strtab == NULL
12649 || section->sh_entsize != sizeof (Elf32_External_Lib))
12650 {
12651 free (elib);
12652 free (strtab);
12653 break;
12654 }
12655 strtab_size = string_sec->sh_size;
12656
12657 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12658 SECTION_NAME (section),
12659 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12660
12661 puts (_(" Library Time Stamp Checksum Version Flags"));
12662
12663 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12664 ++cnt)
12665 {
12666 Elf32_Lib liblist;
12667 time_t atime;
12668 char timebuf[20];
12669 struct tm * tmp;
12670
12671 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12672 atime = BYTE_GET (elib[cnt].l_time_stamp);
12673 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12674 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12675 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12676
12677 tmp = gmtime (&atime);
12678 snprintf (timebuf, sizeof (timebuf),
12679 "%04u-%02u-%02uT%02u:%02u:%02u",
12680 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12681 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12682
12683 printf ("%3lu: ", (unsigned long) cnt);
12684 if (do_wide)
12685 printf ("%-20s", liblist.l_name < strtab_size
12686 ? strtab + liblist.l_name : _("<corrupt>"));
12687 else
12688 printf ("%-20.20s", liblist.l_name < strtab_size
12689 ? strtab + liblist.l_name : _("<corrupt>"));
12690 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12691 liblist.l_version, liblist.l_flags);
12692 }
12693
12694 free (elib);
12695 free (strtab);
12696 }
12697 }
12698
12699 return 1;
12700}
12701
12702static const char *
12703get_note_type (unsigned e_type)
12704{
12705 static char buff[64];
12706
12707 if (elf_header.e_type == ET_CORE)
12708 switch (e_type)
12709 {
12710 case NT_AUXV:
12711 return _("NT_AUXV (auxiliary vector)");
12712 case NT_PRSTATUS:
12713 return _("NT_PRSTATUS (prstatus structure)");
12714 case NT_FPREGSET:
12715 return _("NT_FPREGSET (floating point registers)");
12716 case NT_PRPSINFO:
12717 return _("NT_PRPSINFO (prpsinfo structure)");
12718 case NT_TASKSTRUCT:
12719 return _("NT_TASKSTRUCT (task structure)");
12720 case NT_PRXFPREG:
12721 return _("NT_PRXFPREG (user_xfpregs structure)");
12722 case NT_PPC_VMX:
12723 return _("NT_PPC_VMX (ppc Altivec registers)");
12724 case NT_PPC_VSX:
12725 return _("NT_PPC_VSX (ppc VSX registers)");
12726 case NT_386_TLS:
12727 return _("NT_386_TLS (x86 TLS information)");
12728 case NT_386_IOPERM:
12729 return _("NT_386_IOPERM (x86 I/O permissions)");
12730 case NT_X86_XSTATE:
12731 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12732 case NT_S390_HIGH_GPRS:
12733 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12734 case NT_S390_TIMER:
12735 return _("NT_S390_TIMER (s390 timer register)");
12736 case NT_S390_TODCMP:
12737 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12738 case NT_S390_TODPREG:
12739 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12740 case NT_S390_CTRS:
12741 return _("NT_S390_CTRS (s390 control registers)");
12742 case NT_S390_PREFIX:
12743 return _("NT_S390_PREFIX (s390 prefix register)");
12744 case NT_ARM_VFP:
12745 return _("NT_ARM_VFP (arm VFP registers)");
12746 case NT_PSTATUS:
12747 return _("NT_PSTATUS (pstatus structure)");
12748 case NT_FPREGS:
12749 return _("NT_FPREGS (floating point registers)");
12750 case NT_PSINFO:
12751 return _("NT_PSINFO (psinfo structure)");
12752 case NT_LWPSTATUS:
12753 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12754 case NT_LWPSINFO:
12755 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12756 case NT_WIN32PSTATUS:
12757 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12758 case NT_SIGINFO:
12759 return _("NT_SIGINFO (siginfo_t data)");
12760 case NT_FILE:
12761 return _("NT_FILE (mapped files)");
12762 default:
12763 break;
12764 }
12765 else
12766 switch (e_type)
12767 {
12768 case NT_VERSION:
12769 return _("NT_VERSION (version)");
12770 case NT_ARCH:
12771 return _("NT_ARCH (architecture)");
12772 default:
12773 break;
12774 }
12775
12776 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12777 return buff;
12778}
12779
12780static int
12781print_core_note (Elf_Internal_Note *pnote)
12782{
12783 unsigned int addr_size = is_32bit_elf ? 4 : 8;
12784 bfd_vma count, page_size;
12785 unsigned char *descdata, *filenames, *descend;
12786
12787 if (pnote->type != NT_FILE)
12788 return 1;
12789
12790#ifndef BFD64
12791 if (!is_32bit_elf)
12792 {
12793 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12794 /* Still "successful". */
12795 return 1;
12796 }
12797#endif
12798
12799 if (pnote->descsz < 2 * addr_size)
12800 {
12801 printf (_(" Malformed note - too short for header\n"));
12802 return 0;
12803 }
12804
12805 descdata = (unsigned char *) pnote->descdata;
12806 descend = descdata + pnote->descsz;
12807
12808 if (descdata[pnote->descsz - 1] != '\0')
12809 {
12810 printf (_(" Malformed note - does not end with \\0\n"));
12811 return 0;
12812 }
12813
12814 count = byte_get (descdata, addr_size);
12815 descdata += addr_size;
12816
12817 page_size = byte_get (descdata, addr_size);
12818 descdata += addr_size;
12819
12820 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
12821 {
12822 printf (_(" Malformed note - too short for supplied file count\n"));
12823 return 0;
12824 }
12825
12826 printf (_(" Page size: "));
12827 print_vma (page_size, DEC);
12828 printf ("\n");
12829
12830 printf (_(" %*s%*s%*s\n"),
12831 (int) (2 + 2 * addr_size), _("Start"),
12832 (int) (4 + 2 * addr_size), _("End"),
12833 (int) (4 + 2 * addr_size), _("Page Offset"));
12834 filenames = descdata + count * 3 * addr_size;
12835 while (--count > 0)
12836 {
12837 bfd_vma start, end, file_ofs;
12838
12839 if (filenames == descend)
12840 {
12841 printf (_(" Malformed note - filenames end too early\n"));
12842 return 0;
12843 }
12844
12845 start = byte_get (descdata, addr_size);
12846 descdata += addr_size;
12847 end = byte_get (descdata, addr_size);
12848 descdata += addr_size;
12849 file_ofs = byte_get (descdata, addr_size);
12850 descdata += addr_size;
12851
12852 printf (" ");
12853 print_vma (start, FULL_HEX);
12854 printf (" ");
12855 print_vma (end, FULL_HEX);
12856 printf (" ");
12857 print_vma (file_ofs, FULL_HEX);
12858 printf ("\n %s\n", filenames);
12859
12860 filenames += 1 + strlen ((char *) filenames);
12861 }
12862
12863 return 1;
12864}
12865
12866static const char *
12867get_gnu_elf_note_type (unsigned e_type)
12868{
12869 static char buff[64];
12870
12871 switch (e_type)
12872 {
12873 case NT_GNU_ABI_TAG:
12874 return _("NT_GNU_ABI_TAG (ABI version tag)");
12875 case NT_GNU_HWCAP:
12876 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12877 case NT_GNU_BUILD_ID:
12878 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12879 case NT_GNU_GOLD_VERSION:
12880 return _("NT_GNU_GOLD_VERSION (gold version)");
12881 default:
12882 break;
12883 }
12884
12885 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12886 return buff;
12887}
12888
12889static int
12890print_gnu_note (Elf_Internal_Note *pnote)
12891{
12892 switch (pnote->type)
12893 {
12894 case NT_GNU_BUILD_ID:
12895 {
12896 unsigned long i;
12897
12898 printf (_(" Build ID: "));
12899 for (i = 0; i < pnote->descsz; ++i)
12900 printf ("%02x", pnote->descdata[i] & 0xff);
12901 printf ("\n");
12902 }
12903 break;
12904
12905 case NT_GNU_ABI_TAG:
12906 {
12907 unsigned long os, major, minor, subminor;
12908 const char *osname;
12909
12910 os = byte_get ((unsigned char *) pnote->descdata, 4);
12911 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12912 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12913 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12914
12915 switch (os)
12916 {
12917 case GNU_ABI_TAG_LINUX:
12918 osname = "Linux";
12919 break;
12920 case GNU_ABI_TAG_HURD:
12921 osname = "Hurd";
12922 break;
12923 case GNU_ABI_TAG_SOLARIS:
12924 osname = "Solaris";
12925 break;
12926 case GNU_ABI_TAG_FREEBSD:
12927 osname = "FreeBSD";
12928 break;
12929 case GNU_ABI_TAG_NETBSD:
12930 osname = "NetBSD";
12931 break;
12932 default:
12933 osname = "Unknown";
12934 break;
12935 }
12936
12937 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12938 major, minor, subminor);
12939 }
12940 break;
12941 }
12942
12943 return 1;
12944}
12945
12946static const char *
12947get_netbsd_elfcore_note_type (unsigned e_type)
12948{
12949 static char buff[64];
12950
12951 if (e_type == NT_NETBSDCORE_PROCINFO)
12952 {
12953 /* NetBSD core "procinfo" structure. */
12954 return _("NetBSD procinfo structure");
12955 }
12956
12957 /* As of Jan 2002 there are no other machine-independent notes
12958 defined for NetBSD core files. If the note type is less
12959 than the start of the machine-dependent note types, we don't
12960 understand it. */
12961
12962 if (e_type < NT_NETBSDCORE_FIRSTMACH)
12963 {
12964 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12965 return buff;
12966 }
12967
12968 switch (elf_header.e_machine)
12969 {
12970 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12971 and PT_GETFPREGS == mach+2. */
12972
12973 case EM_OLD_ALPHA:
12974 case EM_ALPHA:
12975 case EM_SPARC:
12976 case EM_SPARC32PLUS:
12977 case EM_SPARCV9:
12978 switch (e_type)
12979 {
12980 case NT_NETBSDCORE_FIRSTMACH + 0:
12981 return _("PT_GETREGS (reg structure)");
12982 case NT_NETBSDCORE_FIRSTMACH + 2:
12983 return _("PT_GETFPREGS (fpreg structure)");
12984 default:
12985 break;
12986 }
12987 break;
12988
12989 /* On all other arch's, PT_GETREGS == mach+1 and
12990 PT_GETFPREGS == mach+3. */
12991 default:
12992 switch (e_type)
12993 {
12994 case NT_NETBSDCORE_FIRSTMACH + 1:
12995 return _("PT_GETREGS (reg structure)");
12996 case NT_NETBSDCORE_FIRSTMACH + 3:
12997 return _("PT_GETFPREGS (fpreg structure)");
12998 default:
12999 break;
13000 }
13001 }
13002
13003 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13004 e_type - NT_NETBSDCORE_FIRSTMACH);
13005 return buff;
13006}
13007
13008static const char *
13009get_stapsdt_note_type (unsigned e_type)
13010{
13011 static char buff[64];
13012
13013 switch (e_type)
13014 {
13015 case NT_STAPSDT:
13016 return _("NT_STAPSDT (SystemTap probe descriptors)");
13017
13018 default:
13019 break;
13020 }
13021
13022 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13023 return buff;
13024}
13025
13026static int
13027print_stapsdt_note (Elf_Internal_Note *pnote)
13028{
13029 int addr_size = is_32bit_elf ? 4 : 8;
13030 char *data = pnote->descdata;
13031 char *data_end = pnote->descdata + pnote->descsz;
13032 bfd_vma pc, base_addr, semaphore;
13033 char *provider, *probe, *arg_fmt;
13034
13035 pc = byte_get ((unsigned char *) data, addr_size);
13036 data += addr_size;
13037 base_addr = byte_get ((unsigned char *) data, addr_size);
13038 data += addr_size;
13039 semaphore = byte_get ((unsigned char *) data, addr_size);
13040 data += addr_size;
13041
13042 provider = data;
13043 data += strlen (data) + 1;
13044 probe = data;
13045 data += strlen (data) + 1;
13046 arg_fmt = data;
13047 data += strlen (data) + 1;
13048
13049 printf (_(" Provider: %s\n"), provider);
13050 printf (_(" Name: %s\n"), probe);
13051 printf (_(" Location: "));
13052 print_vma (pc, FULL_HEX);
13053 printf (_(", Base: "));
13054 print_vma (base_addr, FULL_HEX);
13055 printf (_(", Semaphore: "));
13056 print_vma (semaphore, FULL_HEX);
13057 printf ("\n");
13058 printf (_(" Arguments: %s\n"), arg_fmt);
13059
13060 return data == data_end;
13061}
13062
13063static const char *
13064get_ia64_vms_note_type (unsigned e_type)
13065{
13066 static char buff[64];
13067
13068 switch (e_type)
13069 {
13070 case NT_VMS_MHD:
13071 return _("NT_VMS_MHD (module header)");
13072 case NT_VMS_LNM:
13073 return _("NT_VMS_LNM (language name)");
13074 case NT_VMS_SRC:
13075 return _("NT_VMS_SRC (source files)");
13076 case NT_VMS_TITLE:
13077 return "NT_VMS_TITLE";
13078 case NT_VMS_EIDC:
13079 return _("NT_VMS_EIDC (consistency check)");
13080 case NT_VMS_FPMODE:
13081 return _("NT_VMS_FPMODE (FP mode)");
13082 case NT_VMS_LINKTIME:
13083 return "NT_VMS_LINKTIME";
13084 case NT_VMS_IMGNAM:
13085 return _("NT_VMS_IMGNAM (image name)");
13086 case NT_VMS_IMGID:
13087 return _("NT_VMS_IMGID (image id)");
13088 case NT_VMS_LINKID:
13089 return _("NT_VMS_LINKID (link id)");
13090 case NT_VMS_IMGBID:
13091 return _("NT_VMS_IMGBID (build id)");
13092 case NT_VMS_GSTNAM:
13093 return _("NT_VMS_GSTNAM (sym table name)");
13094 case NT_VMS_ORIG_DYN:
13095 return "NT_VMS_ORIG_DYN";
13096 case NT_VMS_PATCHTIME:
13097 return "NT_VMS_PATCHTIME";
13098 default:
13099 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13100 return buff;
13101 }
13102}
13103
13104static int
13105print_ia64_vms_note (Elf_Internal_Note * pnote)
13106{
13107 switch (pnote->type)
13108 {
13109 case NT_VMS_MHD:
13110 if (pnote->descsz > 36)
13111 {
13112 size_t l = strlen (pnote->descdata + 34);
13113 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13114 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13115 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13116 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13117 }
13118 else
13119 printf (_(" Invalid size\n"));
13120 break;
13121 case NT_VMS_LNM:
13122 printf (_(" Language: %s\n"), pnote->descdata);
13123 break;
13124#ifdef BFD64
13125 case NT_VMS_FPMODE:
13126 printf (_(" Floating Point mode: "));
13127 printf ("0x%016" BFD_VMA_FMT "x\n",
13128 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13129 break;
13130 case NT_VMS_LINKTIME:
13131 printf (_(" Link time: "));
13132 print_vms_time
13133 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13134 printf ("\n");
13135 break;
13136 case NT_VMS_PATCHTIME:
13137 printf (_(" Patch time: "));
13138 print_vms_time
13139 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13140 printf ("\n");
13141 break;
13142 case NT_VMS_ORIG_DYN:
13143 printf (_(" Major id: %u, minor id: %u\n"),
13144 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13145 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
13146 printf (_(" Last modified : "));
13147 print_vms_time
13148 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
13149 printf (_("\n Link flags : "));
13150 printf ("0x%016" BFD_VMA_FMT "x\n",
13151 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13152 printf (_(" Header flags: 0x%08x\n"),
13153 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13154 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13155 break;
13156#endif
13157 case NT_VMS_IMGNAM:
13158 printf (_(" Image name: %s\n"), pnote->descdata);
13159 break;
13160 case NT_VMS_GSTNAM:
13161 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13162 break;
13163 case NT_VMS_IMGID:
13164 printf (_(" Image id: %s\n"), pnote->descdata);
13165 break;
13166 case NT_VMS_LINKID:
13167 printf (_(" Linker id: %s\n"), pnote->descdata);
13168 break;
13169 default:
13170 break;
13171 }
13172 return 1;
13173}
13174
13175/* Note that by the ELF standard, the name field is already null byte
13176 terminated, and namesz includes the terminating null byte.
13177 I.E. the value of namesz for the name "FSF" is 4.
13178
13179 If the value of namesz is zero, there is no name present. */
13180static int
13181process_note (Elf_Internal_Note * pnote)
13182{
13183 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13184 const char * nt;
13185
13186 if (pnote->namesz == 0)
13187 /* If there is no note name, then use the default set of
13188 note type strings. */
13189 nt = get_note_type (pnote->type);
13190
13191 else if (const_strneq (pnote->namedata, "GNU"))
13192 /* GNU-specific object file notes. */
13193 nt = get_gnu_elf_note_type (pnote->type);
13194
13195 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
13196 /* NetBSD-specific core file notes. */
13197 nt = get_netbsd_elfcore_note_type (pnote->type);
13198
13199 else if (strneq (pnote->namedata, "SPU/", 4))
13200 {
13201 /* SPU-specific core file notes. */
13202 nt = pnote->namedata + 4;
13203 name = "SPU";
13204 }
13205
13206 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13207 /* VMS/ia64-specific file notes. */
13208 nt = get_ia64_vms_note_type (pnote->type);
13209
13210 else if (const_strneq (pnote->namedata, "stapsdt"))
13211 nt = get_stapsdt_note_type (pnote->type);
13212
13213 else
13214 /* Don't recognize this note name; just use the default set of
13215 note type strings. */
13216 nt = get_note_type (pnote->type);
13217
13218 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
13219
13220 if (const_strneq (pnote->namedata, "IPF/VMS"))
13221 return print_ia64_vms_note (pnote);
13222 else if (const_strneq (pnote->namedata, "GNU"))
13223 return print_gnu_note (pnote);
13224 else if (const_strneq (pnote->namedata, "stapsdt"))
13225 return print_stapsdt_note (pnote);
13226 else if (const_strneq (pnote->namedata, "CORE"))
13227 return print_core_note (pnote);
13228 else
13229 return 1;
13230}
13231
13232
13233static int
13234process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
13235{
13236 Elf_External_Note * pnotes;
13237 Elf_External_Note * external;
13238 int res = 1;
13239
13240 if (length <= 0)
13241 return 0;
13242
13243 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13244 _("notes"));
13245 if (pnotes == NULL)
13246 return 0;
13247
13248 external = pnotes;
13249
13250 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
13251 (unsigned long) offset, (unsigned long) length);
13252 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13253
13254 while (external < (Elf_External_Note *) ((char *) pnotes + length))
13255 {
13256 Elf_External_Note * next;
13257 Elf_Internal_Note inote;
13258 char * temp = NULL;
13259
13260 if (!is_ia64_vms ())
13261 {
13262 inote.type = BYTE_GET (external->type);
13263 inote.namesz = BYTE_GET (external->namesz);
13264 inote.namedata = external->name;
13265 inote.descsz = BYTE_GET (external->descsz);
13266 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13267 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13268
13269 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
13270 }
13271 else
13272 {
13273 Elf64_External_VMS_Note *vms_external;
13274
13275 vms_external = (Elf64_External_VMS_Note *)external;
13276 inote.type = BYTE_GET (vms_external->type);
13277 inote.namesz = BYTE_GET (vms_external->namesz);
13278 inote.namedata = vms_external->name;
13279 inote.descsz = BYTE_GET (vms_external->descsz);
13280 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13281 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13282
13283 next = (Elf_External_Note *)
13284 (inote.descdata + align_power (inote.descsz, 3));
13285 }
13286
13287 if ( ((char *) next > ((char *) pnotes) + length)
13288 || ((char *) next < (char *) pnotes))
13289 {
13290 warn (_("corrupt note found at offset %lx into core notes\n"),
13291 (unsigned long) ((char *) external - (char *) pnotes));
13292 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13293 inote.type, inote.namesz, inote.descsz);
13294 break;
13295 }
13296
13297 external = next;
13298
13299 /* Prevent out-of-bounds indexing. */
13300 if (inote.namedata + inote.namesz > (char *) pnotes + length
13301 || inote.namedata + inote.namesz < inote.namedata)
13302 {
13303 warn (_("corrupt note found at offset %lx into core notes\n"),
13304 (unsigned long) ((char *) external - (char *) pnotes));
13305 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13306 inote.type, inote.namesz, inote.descsz);
13307 break;
13308 }
13309
13310 /* Verify that name is null terminated. It appears that at least
13311 one version of Linux (RedHat 6.0) generates corefiles that don't
13312 comply with the ELF spec by failing to include the null byte in
13313 namesz. */
13314 if (inote.namedata[inote.namesz - 1] != '\0')
13315 {
13316 temp = (char *) malloc (inote.namesz + 1);
13317
13318 if (temp == NULL)
13319 {
13320 error (_("Out of memory\n"));
13321 res = 0;
13322 break;
13323 }
13324
13325 strncpy (temp, inote.namedata, inote.namesz);
13326 temp[inote.namesz] = 0;
13327
13328 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13329 inote.namedata = temp;
13330 }
13331
13332 res &= process_note (& inote);
13333
13334 if (temp != NULL)
13335 {
13336 free (temp);
13337 temp = NULL;
13338 }
13339 }
13340
13341 free (pnotes);
13342
13343 return res;
13344}
13345
13346static int
13347process_corefile_note_segments (FILE * file)
13348{
13349 Elf_Internal_Phdr * segment;
13350 unsigned int i;
13351 int res = 1;
13352
13353 if (! get_program_headers (file))
13354 return 0;
13355
13356 for (i = 0, segment = program_headers;
13357 i < elf_header.e_phnum;
13358 i++, segment++)
13359 {
13360 if (segment->p_type == PT_NOTE)
13361 res &= process_corefile_note_segment (file,
13362 (bfd_vma) segment->p_offset,
13363 (bfd_vma) segment->p_filesz);
13364 }
13365
13366 return res;
13367}
13368
13369static int
13370process_note_sections (FILE * file)
13371{
13372 Elf_Internal_Shdr * section;
13373 unsigned long i;
13374 int res = 1;
13375
13376 for (i = 0, section = section_headers;
13377 i < elf_header.e_shnum && section != NULL;
13378 i++, section++)
13379 if (section->sh_type == SHT_NOTE)
13380 res &= process_corefile_note_segment (file,
13381 (bfd_vma) section->sh_offset,
13382 (bfd_vma) section->sh_size);
13383
13384 return res;
13385}
13386
13387static int
13388process_notes (FILE * file)
13389{
13390 /* If we have not been asked to display the notes then do nothing. */
13391 if (! do_notes)
13392 return 1;
13393
13394 if (elf_header.e_type != ET_CORE)
13395 return process_note_sections (file);
13396
13397 /* No program headers means no NOTE segment. */
13398 if (elf_header.e_phnum > 0)
13399 return process_corefile_note_segments (file);
13400
13401 printf (_("No note segments present in the core file.\n"));
13402 return 1;
13403}
13404
13405static int
13406process_arch_specific (FILE * file)
13407{
13408 if (! do_arch)
13409 return 1;
13410
13411 switch (elf_header.e_machine)
13412 {
13413 case EM_ARM:
13414 return process_arm_specific (file);
13415 case EM_MIPS:
13416 case EM_MIPS_RS3_LE:
13417 return process_mips_specific (file);
13418 break;
13419 case EM_PPC:
13420 return process_power_specific (file);
13421 break;
13422 case EM_SPARC:
13423 case EM_SPARC32PLUS:
13424 case EM_SPARCV9:
13425 return process_sparc_specific (file);
13426 break;
13427 case EM_TI_C6000:
13428 return process_tic6x_specific (file);
13429 break;
13430 default:
13431 break;
13432 }
13433 return 1;
13434}
13435
13436static int
13437get_file_header (FILE * file)
13438{
13439 /* Read in the identity array. */
13440 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
13441 return 0;
13442
13443 /* Determine how to read the rest of the header. */
13444 switch (elf_header.e_ident[EI_DATA])
13445 {
13446 default: /* fall through */
13447 case ELFDATANONE: /* fall through */
13448 case ELFDATA2LSB:
13449 byte_get = byte_get_little_endian;
13450 byte_put = byte_put_little_endian;
13451 break;
13452 case ELFDATA2MSB:
13453 byte_get = byte_get_big_endian;
13454 byte_put = byte_put_big_endian;
13455 break;
13456 }
13457
13458 /* For now we only support 32 bit and 64 bit ELF files. */
13459 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
13460
13461 /* Read in the rest of the header. */
13462 if (is_32bit_elf)
13463 {
13464 Elf32_External_Ehdr ehdr32;
13465
13466 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13467 return 0;
13468
13469 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13470 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13471 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13472 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13473 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13474 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13475 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13476 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13477 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13478 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13479 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13480 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13481 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13482 }
13483 else
13484 {
13485 Elf64_External_Ehdr ehdr64;
13486
13487 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13488 we will not be able to cope with the 64bit data found in
13489 64 ELF files. Detect this now and abort before we start
13490 overwriting things. */
13491 if (sizeof (bfd_vma) < 8)
13492 {
13493 error (_("This instance of readelf has been built without support for a\n\
1349464 bit data type and so it cannot read 64 bit ELF files.\n"));
13495 return 0;
13496 }
13497
13498 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13499 return 0;
13500
13501 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13502 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13503 elf_header.e_version = BYTE_GET (ehdr64.e_version);
13504 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13505 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13506 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
13507 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13508 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13509 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13510 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13511 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13512 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13513 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13514 }
13515
13516 if (elf_header.e_shoff)
13517 {
13518 /* There may be some extensions in the first section header. Don't
13519 bomb if we can't read it. */
13520 if (is_32bit_elf)
13521 get_32bit_section_headers (file, 1);
13522 else
13523 get_64bit_section_headers (file, 1);
13524 }
13525
13526 return 1;
13527}
13528
13529/* Process one ELF object file according to the command line options.
13530 This file may actually be stored in an archive. The file is
13531 positioned at the start of the ELF object. */
13532
13533static int
13534process_object (char * file_name, FILE * file)
13535{
13536 unsigned int i;
13537
13538 if (! get_file_header (file))
13539 {
13540 error (_("%s: Failed to read file header\n"), file_name);
13541 return 1;
13542 }
13543
13544 /* Initialise per file variables. */
13545 for (i = ARRAY_SIZE (version_info); i--;)
13546 version_info[i] = 0;
13547
13548 for (i = ARRAY_SIZE (dynamic_info); i--;)
13549 dynamic_info[i] = 0;
13550 dynamic_info_DT_GNU_HASH = 0;
13551
13552 /* Process the file. */
13553 if (show_name)
13554 printf (_("\nFile: %s\n"), file_name);
13555
13556 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13557 Note we do this even if cmdline_dump_sects is empty because we
13558 must make sure that the dump_sets array is zeroed out before each
13559 object file is processed. */
13560 if (num_dump_sects > num_cmdline_dump_sects)
13561 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13562
13563 if (num_cmdline_dump_sects > 0)
13564 {
13565 if (num_dump_sects == 0)
13566 /* A sneaky way of allocating the dump_sects array. */
13567 request_dump_bynumber (num_cmdline_dump_sects, 0);
13568
13569 assert (num_dump_sects >= num_cmdline_dump_sects);
13570 memcpy (dump_sects, cmdline_dump_sects,
13571 num_cmdline_dump_sects * sizeof (* dump_sects));
13572 }
13573
13574 if (! process_file_header ())
13575 return 1;
13576
13577 if (! process_section_headers (file))
13578 {
13579 /* Without loaded section headers we cannot process lots of
13580 things. */
13581 do_unwind = do_version = do_dump = do_arch = 0;
13582
13583 if (! do_using_dynamic)
13584 do_syms = do_dyn_syms = do_reloc = 0;
13585 }
13586
13587 if (! process_section_groups (file))
13588 {
13589 /* Without loaded section groups we cannot process unwind. */
13590 do_unwind = 0;
13591 }
13592
13593 if (process_program_headers (file))
13594 process_dynamic_section (file);
13595
13596 process_relocs (file);
13597
13598 process_unwind (file);
13599
13600 process_symbol_table (file);
13601
13602 process_syminfo (file);
13603
13604 process_version_sections (file);
13605
13606 process_section_contents (file);
13607
13608 process_notes (file);
13609
13610 process_gnu_liblist (file);
13611
13612 process_arch_specific (file);
13613
13614 if (program_headers)
13615 {
13616 free (program_headers);
13617 program_headers = NULL;
13618 }
13619
13620 if (section_headers)
13621 {
13622 free (section_headers);
13623 section_headers = NULL;
13624 }
13625
13626 if (string_table)
13627 {
13628 free (string_table);
13629 string_table = NULL;
13630 string_table_length = 0;
13631 }
13632
13633 if (dynamic_strings)
13634 {
13635 free (dynamic_strings);
13636 dynamic_strings = NULL;
13637 dynamic_strings_length = 0;
13638 }
13639
13640 if (dynamic_symbols)
13641 {
13642 free (dynamic_symbols);
13643 dynamic_symbols = NULL;
13644 num_dynamic_syms = 0;
13645 }
13646
13647 if (dynamic_syminfo)
13648 {
13649 free (dynamic_syminfo);
13650 dynamic_syminfo = NULL;
13651 }
13652
13653 if (dynamic_section)
13654 {
13655 free (dynamic_section);
13656 dynamic_section = NULL;
13657 }
13658
13659 if (section_headers_groups)
13660 {
13661 free (section_headers_groups);
13662 section_headers_groups = NULL;
13663 }
13664
13665 if (section_groups)
13666 {
13667 struct group_list * g;
13668 struct group_list * next;
13669
13670 for (i = 0; i < group_count; i++)
13671 {
13672 for (g = section_groups [i].root; g != NULL; g = next)
13673 {
13674 next = g->next;
13675 free (g);
13676 }
13677 }
13678
13679 free (section_groups);
13680 section_groups = NULL;
13681 }
13682
13683 free_debug_memory ();
13684
13685 return 0;
13686}
13687
13688/* Process an ELF archive.
13689 On entry the file is positioned just after the ARMAG string. */
13690
13691static int
13692process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13693{
13694 struct archive_info arch;
13695 struct archive_info nested_arch;
13696 size_t got;
13697 int ret;
13698
13699 show_name = 1;
13700
13701 /* The ARCH structure is used to hold information about this archive. */
13702 arch.file_name = NULL;
13703 arch.file = NULL;
13704 arch.index_array = NULL;
13705 arch.sym_table = NULL;
13706 arch.longnames = NULL;
13707
13708 /* The NESTED_ARCH structure is used as a single-item cache of information
13709 about a nested archive (when members of a thin archive reside within
13710 another regular archive file). */
13711 nested_arch.file_name = NULL;
13712 nested_arch.file = NULL;
13713 nested_arch.index_array = NULL;
13714 nested_arch.sym_table = NULL;
13715 nested_arch.longnames = NULL;
13716
13717 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13718 {
13719 ret = 1;
13720 goto out;
13721 }
13722
13723 if (do_archive_index)
13724 {
13725 if (arch.sym_table == NULL)
13726 error (_("%s: unable to dump the index as none was found\n"), file_name);
13727 else
13728 {
13729 unsigned int i, l;
13730 unsigned long current_pos;
13731
13732 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13733 file_name, (long) arch.index_num, arch.sym_size);
13734 current_pos = ftell (file);
13735
13736 for (i = l = 0; i < arch.index_num; i++)
13737 {
13738 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13739 {
13740 char * member_name;
13741
13742 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13743
13744 if (member_name != NULL)
13745 {
13746 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13747
13748 if (qualified_name != NULL)
13749 {
13750 printf (_("Contents of binary %s at offset "), qualified_name);
13751 (void) print_vma (arch.index_array[i], PREFIX_HEX);
13752 putchar ('\n');
13753 free (qualified_name);
13754 }
13755 }
13756 }
13757
13758 if (l >= arch.sym_size)
13759 {
13760 error (_("%s: end of the symbol table reached before the end of the index\n"),
13761 file_name);
13762 break;
13763 }
13764 printf ("\t%s\n", arch.sym_table + l);
13765 l += strlen (arch.sym_table + l) + 1;
13766 }
13767
13768 if (arch.uses_64bit_indicies)
13769 l = (l + 7) & ~ 7;
13770 else
13771 l += l & 1;
13772
13773 if (l < arch.sym_size)
13774 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13775 file_name, arch.sym_size - l);
13776
13777 if (fseek (file, current_pos, SEEK_SET) != 0)
13778 {
13779 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
13780 ret = 1;
13781 goto out;
13782 }
13783 }
13784
13785 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13786 && !do_segments && !do_header && !do_dump && !do_version
13787 && !do_histogram && !do_debugging && !do_arch && !do_notes
13788 && !do_section_groups && !do_dyn_syms)
13789 {
13790 ret = 0; /* Archive index only. */
13791 goto out;
13792 }
13793 }
13794
13795 ret = 0;
13796
13797 while (1)
13798 {
13799 char * name;
13800 size_t namelen;
13801 char * qualified_name;
13802
13803 /* Read the next archive header. */
13804 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13805 {
13806 error (_("%s: failed to seek to next archive header\n"), file_name);
13807 return 1;
13808 }
13809 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13810 if (got != sizeof arch.arhdr)
13811 {
13812 if (got == 0)
13813 break;
13814 error (_("%s: failed to read archive header\n"), file_name);
13815 ret = 1;
13816 break;
13817 }
13818 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13819 {
13820 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13821 ret = 1;
13822 break;
13823 }
13824
13825 arch.next_arhdr_offset += sizeof arch.arhdr;
13826
13827 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13828 if (archive_file_size & 01)
13829 ++archive_file_size;
13830
13831 name = get_archive_member_name (&arch, &nested_arch);
13832 if (name == NULL)
13833 {
13834 error (_("%s: bad archive file name\n"), file_name);
13835 ret = 1;
13836 break;
13837 }
13838 namelen = strlen (name);
13839
13840 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13841 if (qualified_name == NULL)
13842 {
13843 error (_("%s: bad archive file name\n"), file_name);
13844 ret = 1;
13845 break;
13846 }
13847
13848 if (is_thin_archive && arch.nested_member_origin == 0)
13849 {
13850 /* This is a proxy for an external member of a thin archive. */
13851 FILE * member_file;
13852 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13853 if (member_file_name == NULL)
13854 {
13855 ret = 1;
13856 break;
13857 }
13858
13859 member_file = fopen (member_file_name, "rb");
13860 if (member_file == NULL)
13861 {
13862 error (_("Input file '%s' is not readable.\n"), member_file_name);
13863 free (member_file_name);
13864 ret = 1;
13865 break;
13866 }
13867
13868 archive_file_offset = arch.nested_member_origin;
13869
13870 ret |= process_object (qualified_name, member_file);
13871
13872 fclose (member_file);
13873 free (member_file_name);
13874 }
13875 else if (is_thin_archive)
13876 {
13877 /* This is a proxy for a member of a nested archive. */
13878 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13879
13880 /* The nested archive file will have been opened and setup by
13881 get_archive_member_name. */
13882 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13883 {
13884 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13885 ret = 1;
13886 break;
13887 }
13888
13889 ret |= process_object (qualified_name, nested_arch.file);
13890 }
13891 else
13892 {
13893 archive_file_offset = arch.next_arhdr_offset;
13894 arch.next_arhdr_offset += archive_file_size;
13895
13896 ret |= process_object (qualified_name, file);
13897 }
13898
13899 if (dump_sects != NULL)
13900 {
13901 free (dump_sects);
13902 dump_sects = NULL;
13903 num_dump_sects = 0;
13904 }
13905
13906 free (qualified_name);
13907 }
13908
13909 out:
13910 if (nested_arch.file != NULL)
13911 fclose (nested_arch.file);
13912 release_archive (&nested_arch);
13913 release_archive (&arch);
13914
13915 return ret;
13916}
13917
13918static int
13919process_file (char * file_name)
13920{
13921 FILE * file;
13922 struct stat statbuf;
13923 char armag[SARMAG];
13924 int ret;
13925
13926 if (stat (file_name, &statbuf) < 0)
13927 {
13928 if (errno == ENOENT)
13929 error (_("'%s': No such file\n"), file_name);
13930 else
13931 error (_("Could not locate '%s'. System error message: %s\n"),
13932 file_name, strerror (errno));
13933 return 1;
13934 }
13935
13936 if (! S_ISREG (statbuf.st_mode))
13937 {
13938 error (_("'%s' is not an ordinary file\n"), file_name);
13939 return 1;
13940 }
13941
13942 file = fopen (file_name, "rb");
13943 if (file == NULL)
13944 {
13945 error (_("Input file '%s' is not readable.\n"), file_name);
13946 return 1;
13947 }
13948
13949 if (fread (armag, SARMAG, 1, file) != 1)
13950 {
13951 error (_("%s: Failed to read file's magic number\n"), file_name);
13952 fclose (file);
13953 return 1;
13954 }
13955
13956 if (memcmp (armag, ARMAG, SARMAG) == 0)
13957 ret = process_archive (file_name, file, FALSE);
13958 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13959 ret = process_archive (file_name, file, TRUE);
13960 else
13961 {
13962 if (do_archive_index)
13963 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13964 file_name);
13965
13966 rewind (file);
13967 archive_file_size = archive_file_offset = 0;
13968 ret = process_object (file_name, file);
13969 }
13970
13971 fclose (file);
13972
13973 return ret;
13974}
13975
13976#ifdef SUPPORT_DISASSEMBLY
13977/* Needed by the i386 disassembler. For extra credit, someone could
13978 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13979 symbols. */
13980
13981void
13982print_address (unsigned int addr, FILE * outfile)
13983{
13984 fprintf (outfile,"0x%8.8x", addr);
13985}
13986
13987/* Needed by the i386 disassembler. */
13988void
13989db_task_printsym (unsigned int addr)
13990{
13991 print_address (addr, stderr);
13992}
13993#endif
13994
13995int
13996main (int argc, char ** argv)
13997{
13998 int err;
13999
14000#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14001 setlocale (LC_MESSAGES, "");
14002#endif
14003#if defined (HAVE_SETLOCALE)
14004 setlocale (LC_CTYPE, "");
14005#endif
14006 bindtextdomain (PACKAGE, LOCALEDIR);
14007 textdomain (PACKAGE);
14008
14009 expandargv (&argc, &argv);
14010
14011 parse_args (argc, argv);
14012
14013 if (num_dump_sects > 0)
14014 {
14015 /* Make a copy of the dump_sects array. */
14016 cmdline_dump_sects = (dump_type *)
14017 malloc (num_dump_sects * sizeof (* dump_sects));
14018 if (cmdline_dump_sects == NULL)
14019 error (_("Out of memory allocating dump request table.\n"));
14020 else
14021 {
14022 memcpy (cmdline_dump_sects, dump_sects,
14023 num_dump_sects * sizeof (* dump_sects));
14024 num_cmdline_dump_sects = num_dump_sects;
14025 }
14026 }
14027
14028 if (optind < (argc - 1))
14029 show_name = 1;
14030
14031 err = 0;
14032 while (optind < argc)
14033 err |= process_file (argv[optind++]);
14034
14035 if (dump_sects != NULL)
14036 free (dump_sects);
14037 if (cmdline_dump_sects != NULL)
14038 free (cmdline_dump_sects);
14039
14040 return err;
14041}
A mirror of the official binutils-gdb repository