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