1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
31 #include "elf/common.h"
34 #include "elf/external.h"
35 #include "elf/internal.h"
40 #ifdef ANSI_PROTOTYPES
46 char * program_name
= "readelf";
47 unsigned int dynamic_addr
;
48 unsigned int dynamic_size
;
49 unsigned int rela_addr
;
50 unsigned int rela_size
;
51 char * dynamic_strings
;
53 Elf_Internal_Sym
* dynamic_symbols
;
54 char program_interpreter
[64];
55 int dynamic_info
[DT_JMPREL
+ 1];
56 int version_info
[16];
58 Elf_Internal_Ehdr elf_header
;
59 Elf_Internal_Shdr
* section_headers
;
60 Elf_Internal_Dyn
* dynamic_segment
;
72 static unsigned long int (* byte_get
) PARAMS ((unsigned char *, int));
74 #define NUM_DUMP_SECTS 100
75 char dump_sects
[NUM_DUMP_SECTS
];
80 /* Forward declarations for dumb compilers. */
81 static const char * get_mips_dynamic_type
PARAMS ((unsigned long type
));
82 static const char * get_dynamic_type
PARAMS ((unsigned long type
));
83 static const char * elf_i386_reloc_type
PARAMS ((unsigned long rtype
));
84 static const char * elf_m68k_reloc_type
PARAMS ((unsigned long rtype
));
85 static const char * elf_sparc_reloc_type
PARAMS ((unsigned long rtype
));
86 static const char * elf_m32r_reloc_type
PARAMS ((unsigned long rtype
));
87 static const char * elf_v850_reloc_type
PARAMS ((unsigned long rtype
));
88 static const char * elf_d10v_reloc_type
PARAMS ((unsigned long rtype
));
89 /* start-sanitize-d30v */
90 static const char * elf_d30v_reloc_type
PARAMS ((unsigned long rtype
));
91 /* end-sanitize-d30v */
92 static const char * elf_sh_reloc_type
PARAMS ((unsigned long rtype
));
93 static const char * elf_mn10300_reloc_type
PARAMS ((unsigned long rtype
));
94 static const char * elf_mn10200_reloc_type
PARAMS ((unsigned long rtype
));
95 static const char * elf_ppc_reloc_type
PARAMS ((unsigned long rtype
));
96 static const char * elf_mips_reloc_type
PARAMS ((unsigned long rtype
));
97 static const char * elf_alpha_reloc_type
PARAMS ((unsigned long rtype
));
98 static const char * elf_arm_reloc_type
PARAMS ((unsigned long rtype
));
99 static int dump_relocations
100 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, char *));
101 static char * get_file_type
PARAMS ((unsigned e_type
));
102 static char * get_machine_name
PARAMS ((unsigned e_machine
));
103 static char * get_machine_data
PARAMS ((unsigned e_data
));
104 static char * get_machine_flags
PARAMS ((unsigned, unsigned e_machine
));
105 static const char * get_mips_segment_type
PARAMS ((unsigned long type
));
106 static const char * get_segment_type
PARAMS ((unsigned long p_type
));
107 static const char * get_mips_section_type_name
PARAMS ((unsigned int sh_type
));
108 static const char * get_section_type_name
PARAMS ((unsigned int sh_type
));
109 static char * get_symbol_binding
PARAMS ((unsigned int binding
));
110 static char * get_symbol_type
PARAMS ((unsigned int type
));
111 static void usage
PARAMS ((void));
112 static void parse_args
PARAMS ((int argc
, char ** argv
));
113 static int process_file_header
PARAMS ((void));
114 static int process_program_headers
PARAMS ((FILE *));
115 static int process_section_headers
PARAMS ((FILE *));
116 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*entry
));
117 static int process_dynamic_segment
PARAMS ((FILE *));
118 static int process_symbol_table
PARAMS ((FILE *));
119 static int process_section_contents
PARAMS ((FILE *));
120 static void process_file
PARAMS ((char * file_name
));
121 static int process_relocs
PARAMS ((FILE *));
122 static int process_version_sections
PARAMS ((FILE *));
123 static char * get_ver_flags
PARAMS ((unsigned int flags
));
124 static char * get_symbol_index_type
PARAMS ((unsigned int type
));
125 static int get_section_headers
PARAMS ((FILE * file
));
126 static int get_file_header
PARAMS ((FILE * file
));
127 static Elf_Internal_Sym
* get_elf_symbols
128 PARAMS ((FILE * file
, unsigned long offset
, unsigned long number
));
129 static int * get_dynamic_data
PARAMS ((FILE * file
, unsigned int number
));
131 typedef int Elf32_Word
;
133 #define SECTION_NAME(X) (string_table + (X)->sh_name)
135 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
137 #define BYTE_GET(field) byte_get (field, sizeof (field))
139 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
141 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
142 if (fseek (file, offset, SEEK_SET)) \
144 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
148 var = (type) malloc (size); \
152 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
156 if (fread (var, size, 1, file) != 1) \
158 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
165 #define GET_DATA(offset, var, reason) \
166 if (fseek (file, offset, SEEK_SET)) \
168 error (_("Unable to seek to %x for %s\n"), offset, reason); \
171 else if (fread (& var, sizeof (var), 1, file) != 1) \
173 error (_("Unable to read data at %x for %s\n"), offset, reason); \
177 #ifdef ANSI_PROTOTYPES
179 error (const char * message
, ...)
183 fprintf (stderr
, _("%s: Error: "), program_name
);
184 va_start (args
, message
);
185 vfprintf (stderr
, message
, args
);
191 warn (const char * message
, ...)
195 fprintf (stderr
, _("%s: Warning: "), program_name
);
196 va_start (args
, message
);
197 vfprintf (stderr
, message
, args
);
209 fprintf (stderr
, _("%s: Error: "), program_name
);
211 message
= va_arg (args
, char *);
212 vfprintf (stderr
, message
, args
);
224 fprintf (stderr
, _("%s: Warning: "), program_name
);
226 message
= va_arg (args
, char *);
227 vfprintf (stderr
, message
, args
);
233 static unsigned long int
234 byte_get_little_endian (field
, size
)
235 unsigned char * field
;
244 return ((unsigned int) (field
[0]))
245 | (((unsigned int) (field
[1])) << 8);
248 return ((unsigned long) (field
[0]))
249 | (((unsigned long) (field
[1])) << 8)
250 | (((unsigned long) (field
[2])) << 16)
251 | (((unsigned long) (field
[3])) << 24);
254 error (_("Unhandled data length: %d\n"), size
);
259 static unsigned long int
260 byte_get_big_endian (field
, size
)
261 unsigned char * field
;
270 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
273 return ((unsigned long) (field
[3]))
274 | (((unsigned long) (field
[2])) << 8)
275 | (((unsigned long) (field
[1])) << 16)
276 | (((unsigned long) (field
[0])) << 24);
279 error (_("Unhandled data length: %d\n"), size
);
285 /* Define the macros we need to define the relocation recognition functions. */
286 #define START_RELOC_NUMBERS(name) static const char * \
288 unsigned long rtype; \
292 # define RELOC_NUMBER(name, number) case number: return #name;
294 # define RELOC_NUMBER(name, number) case number: return "name";
296 #define END_RELOC_NUMBERS default: return NULL; \
300 /* Define the i386 relocations. */
302 elf_i386_reloc_type (rtype
)
307 case R_386_NONE
: return "R_386_NONE";
308 case R_386_32
: return "R_386_32";
309 case R_386_PC32
: return "R_386_PC32";
310 case R_386_GOT32
: return "R_386_GOT32";
311 case R_386_PLT32
: return "R_386_PLT32";
312 case R_386_COPY
: return "R_386_COPY";
313 case R_386_GLOB_DAT
: return "R_386_GLOB_DAT";
314 case R_386_JMP_SLOT
: return "R_386_JMP_SLOT";
315 case R_386_RELATIVE
: return "R_386_RELATIVE";
316 case R_386_GOTOFF
: return "R_386_GOTOFF";
317 case R_386_GOTPC
: return "R_386_GOTPC";
318 case R_386_16
: return "R_386_16";
319 case R_386_PC16
: return "R_386_PC16";
320 case R_386_PC8
: return "R_386_PC8";
321 default: return NULL
;
325 /* Define the m68k relocations. */
326 #include "elf/m68k.h"
328 /* Define the SPARC relocations. */
329 #include "elf/sparc.h"
331 /* Define the m32r relocations. */
332 #include "elf/m32r.h"
336 elf_v850_reloc_type (rtype
)
341 case R_V850_NONE
: return "R_V850_NONE";
342 case R_V850_9_PCREL
: return "R_V850_9_PCREL";
343 case R_V850_22_PCREL
: return "R_V850_22_PCREL";
344 case R_V850_HI16_S
: return "R_V850_HI16_S";
345 case R_V850_HI16
: return "R_V850_HI16";
346 case R_V850_LO16
: return "R_V850_LO16";
347 case R_V850_32
: return "R_V850_32";
348 case R_V850_16
: return "R_V850_16";
349 case R_V850_8
: return "R_V850_8";
350 case R_V850_SDA_16_16_OFFSET
: return "R_V850_SDA_16_16_OFFSET";
351 case R_V850_SDA_15_16_OFFSET
: return "R_V850_SDA_15_16_OFFSET";
352 case R_V850_ZDA_16_16_OFFSET
: return "R_V850_ZDA_16_16_OFFSET";
353 case R_V850_ZDA_15_16_OFFSET
: return "R_V850_ZDA_15_16_OFFSET";
354 case R_V850_TDA_6_8_OFFSET
: return "R_V850_TDA_6_8_OFFSET";
355 case R_V850_TDA_7_8_OFFSET
: return "R_V850_TDA_7_8_OFFSET";
356 case R_V850_TDA_7_7_OFFSET
: return "R_V850_TDA_7_7_OFFSET";
357 case R_V850_TDA_16_16_OFFSET
: return "R_V850_TDA_16_16_OFFSET";
358 /* start-sanitize-v850e */
359 case R_V850_TDA_4_5_OFFSET
: return "R_V850_TDA_4_5_OFFSET";
360 case R_V850_TDA_4_4_OFFSET
: return "R_V850_TDA_4_4_OFFSET";
361 case R_V850_SDA_16_16_SPLIT_OFFSET
: return "R_V850_SDA_16_16_SPLIT_OFFSET";
362 case R_V850_ZDA_16_16_SPLIT_OFFSET
: return "R_V850_ZDA_16_16_SPLIT_OFFSET";
363 case R_V850_CALLT_6_7_OFFSET
: return "R_V850_CALLT_6_7_OFFSET";
364 case R_V850_CALLT_16_16_OFFSET
: return "R_V850_CALLT_16_16_OFFSET";
365 /* end-sanitize-v850e */
366 default: return NULL
;
370 /* Define the function to get ARM relocations. */
371 #include "elf/d10v.h"
373 /* start-sanitize-d30v */
374 /* Define the function to get ARM relocations. */
375 #include "elf/d30v.h"
377 /* end-sanitize-d30v */
378 /* Define the function to get SH relocations. */
381 /* Define the function to get MN10300 relocations. */
382 #include "elf/mn10300.h"
384 /* Define the function to get MN10200 relocations. */
385 #include "elf/mn10200.h"
387 /* Define the function to get PPC relocations. */
390 /* Define the function to get MIPS relocations. */
391 #include "elf/mips.h"
393 /* Define the function to get MIPS relocations. */
394 #include "elf/alpha.h"
396 /* Define the function to get ARM relocations. */
400 /* Display the contents of the relocation data
401 found at the specified offset. */
403 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
)
405 unsigned long rel_offset
;
406 unsigned long rel_size
;
407 Elf_Internal_Sym
* symtab
;
412 Elf_Internal_Rel
* rels
;
413 Elf_Internal_Rela
* relas
;
416 /* Compute number of relocations and read them in. */
417 switch (elf_header
.e_machine
)
427 Elf32_External_Rel
* erels
;
429 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
430 Elf32_External_Rel
*, "relocs");
432 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
434 rels
= (Elf_Internal_Rel
*) malloc (rel_size
*
435 sizeof (Elf_Internal_Rel
));
437 for (i
= 0; i
< rel_size
; i
++)
439 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
440 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
446 relas
= (Elf_Internal_Rela
*) rels
;
454 /* start-sanitize-d30v */
456 /* end-sanitize-d30v */
457 case EM_CYGNUS_MN10200
:
458 case EM_CYGNUS_MN10300
:
462 Elf32_External_Rela
* erelas
;
464 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
465 Elf32_External_Rela
*, "relocs");
467 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
469 relas
= (Elf_Internal_Rela
*) malloc (rel_size
*
470 sizeof (Elf_Internal_Rela
));
472 for (i
= 0; i
< rel_size
; i
++)
474 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
475 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
476 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
482 rels
= (Elf_Internal_Rel
*) relas
;
487 warn (_("Don't know about relocations on this machine architecture\n"));
493 (_(" Offset Value Type Symbol's Value Symbol's Name Addend\n"));
496 (_(" Offset Value Type Symbol's Value Symbol's Name\n"));
498 for (i
= 0; i
< rel_size
; i
++)
501 unsigned long offset
;
507 offset
= relas
[i
].r_offset
;
508 info
= relas
[i
].r_info
;
512 offset
= rels
[i
].r_offset
;
513 info
= rels
[i
].r_info
;
516 printf (" %8.8lx %5.5lx ", offset
, info
);
518 switch (elf_header
.e_machine
)
525 rtype
= elf_m32r_reloc_type (ELF32_R_TYPE (info
));
530 rtype
= elf_i386_reloc_type (ELF32_R_TYPE (info
));
534 rtype
= elf_m68k_reloc_type (ELF32_R_TYPE (info
));
538 rtype
= elf_sparc_reloc_type (ELF32_R_TYPE (info
));
542 rtype
= elf_v850_reloc_type (ELF32_R_TYPE (info
));
546 rtype
= elf_d10v_reloc_type (ELF32_R_TYPE (info
));
549 /* start-sanitize-d30v */
551 rtype
= elf_d30v_reloc_type (ELF32_R_TYPE (info
));
554 /* end-sanitize-d30v */
556 rtype
= elf_sh_reloc_type (ELF32_R_TYPE (info
));
559 case EM_CYGNUS_MN10300
:
560 rtype
= elf_mn10300_reloc_type (ELF32_R_TYPE (info
));
563 case EM_CYGNUS_MN10200
:
564 rtype
= elf_mn10200_reloc_type (ELF32_R_TYPE (info
));
568 rtype
= elf_ppc_reloc_type (ELF32_R_TYPE (info
));
573 rtype
= elf_mips_reloc_type (ELF32_R_TYPE (info
));
577 rtype
= elf_alpha_reloc_type (ELF32_R_TYPE (info
));
581 rtype
= elf_arm_reloc_type (ELF32_R_TYPE (info
));
586 printf (_("unrecognised: %-7x"), ELF32_R_TYPE (info
));
588 printf ("%-21.21s", rtype
);
590 symtab_index
= ELF32_R_SYM (info
);
592 if (symtab_index
&& symtab
!= NULL
)
594 Elf_Internal_Sym
* psym
;
596 psym
= symtab
+ symtab_index
;
598 printf (" %08lx ", (unsigned long) psym
->st_value
);
600 if (psym
->st_name
== 0)
602 SECTION_NAME (section_headers
+ psym
->st_shndx
));
603 else if (strtab
== NULL
)
604 printf (_("<string table index %3d>"), psym
->st_name
);
606 printf ("%-25.25s", strtab
+ psym
->st_name
);
609 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
621 get_mips_dynamic_type (type
)
626 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
627 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
628 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
629 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
630 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
631 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
632 case DT_MIPS_MSYM
: return "MIPS_MSYM";
633 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
634 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
635 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
636 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
637 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
638 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
639 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
640 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
641 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
642 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
643 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
644 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
645 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
646 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
647 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
648 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
649 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
650 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
651 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
652 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
653 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
654 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
655 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
656 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
657 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
658 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
659 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
660 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
661 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
662 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
663 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
664 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
665 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
666 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
667 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
668 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
675 get_dynamic_type (type
)
678 static char buff
[32];
682 case DT_NULL
: return _("NULL");
683 case DT_NEEDED
: return _("NEEDED");
684 case DT_PLTRELSZ
: return _("PLTRELSZ");
685 case DT_PLTGOT
: return _("PLTGOT");
686 case DT_HASH
: return _("HASH");
687 case DT_STRTAB
: return _("STRTAB");
688 case DT_SYMTAB
: return _("SYMTAB");
689 case DT_RELA
: return _("RELA");
690 case DT_RELASZ
: return _("RELASZ");
691 case DT_RELAENT
: return _("RELAENT");
692 case DT_STRSZ
: return _("STRSZ");
693 case DT_SYMENT
: return _("SYMENT");
694 case DT_INIT
: return _("INIT");
695 case DT_FINI
: return _("FINI");
696 case DT_SONAME
: return _("SONAME");
697 case DT_RPATH
: return _("RPATH");
698 case DT_SYMBOLIC
: return _("SYMBOLIC");
699 case DT_REL
: return _("REL");
700 case DT_RELSZ
: return _("RELSZ");
701 case DT_RELENT
: return _("RELENT");
702 case DT_PLTREL
: return _("PLTREL");
703 case DT_DEBUG
: return _("DEBUG");
704 case DT_TEXTREL
: return _("TEXTREL");
705 case DT_JMPREL
: return _("JMPREL");
706 case DT_VERDEF
: return _("VERDEF");
707 case DT_VERDEFNUM
: return _("VERDEFNUM");
708 case DT_VERNEED
: return _("VERNEED");
709 case DT_VERNEEDNUM
: return _("VERNEEDNUM");
710 case DT_VERSYM
: return _("VERSYN");
711 case DT_AUXILIARY
: return _("AUXILARY");
712 case DT_FILTER
: return _("FILTER");
715 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
717 const char *result
= NULL
;
718 switch (elf_header
.e_machine
)
722 result
= get_mips_dynamic_type (type
);
728 sprintf (buff
, _("Processor Specific: (%x)"), type
);
734 sprintf (buff
, _("<unknown>: %x"), type
);
740 get_file_type (e_type
)
743 static char buff
[32];
747 case ET_NONE
: return _("NONE (None)");
748 case ET_REL
: return _("REL (Relocatable file)");
749 case ET_EXEC
: return _("EXEC (Executable file)");
750 case ET_DYN
: return _("DYN (Shared object file)");
751 case ET_CORE
: return _("CORE (Core file)");
754 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
755 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
757 sprintf (buff
, _("<unknown>: %x"), e_type
);
763 get_machine_name (e_machine
)
766 static char buff
[32];
770 case EM_NONE
: return _("None");
771 case EM_M32
: return "WE32100";
772 case EM_SPARC
: return "Sparc";
773 case EM_386
: return "Intel 80386";
774 case EM_68K
: return "MC68000";
775 case EM_88K
: return "MC88000";
776 case EM_486
: return "Intel 80486";
777 case EM_860
: return "Intel 80860";
778 case EM_MIPS
: return "MIPS R3000 big-endian";
779 case EM_S370
: return "Amdahl";
780 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
781 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
782 case EM_PARISC
: return "HPPA";
783 case EM_PPC_OLD
: return "Power PC (old)";
784 case EM_SPARC32PLUS
: return "Sparc v8+" ;
785 case EM_960
: return "Intel 90860";
786 case EM_PPC
: return "PowerPC";
787 case EM_V800
: return "NEC V800";
788 case EM_FR20
: return "Fujitsu FR20";
789 case EM_RH32
: return "TRW RH32";
790 case EM_MMA
: return "Fujitsu MMA";
791 case EM_ARM
: return "ARM";
792 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
793 case EM_SH
: return "Hitachi SH";
794 case EM_SPARCV9
: return "Sparc v9";
795 case EM_ALPHA
: return "Alpha";
796 case EM_CYGNUS_D10V
: return "d10v";
797 /* start-sanitize-d30v */
798 case EM_CYGNUS_D30V
: return "d30v";
799 /* end-sanitize-d30v */
800 case EM_CYGNUS_M32R
: return "M32r";
801 case EM_CYGNUS_V850
: return "v850";
802 case EM_CYGNUS_MN10300
: return "mn10300";
803 case EM_CYGNUS_MN10200
: return "mn10200";
806 sprintf (buff
, _("<unknown>: %x"), e_machine
);
812 get_machine_flags (e_flags
, e_machine
)
816 static char buf
[1024];
827 if (e_flags
& EF_PPC_EMB
)
828 strcat (buf
, ", emb");
830 if (e_flags
& EF_PPC_RELOCATABLE
)
831 strcat (buf
, ", relocatable");
833 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
834 strcat (buf
, ", relocatable-lib");
838 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
839 strcat (buf
, ", m32r");
841 /* start-sanitize-m32rx */
843 if ((e_flags
& EF_M32R_ARCH
) == E_M32RX_ARCH
)
844 strcat (buf
, ", m32rx");
846 /* end-sanitize-m32rx */
851 if (e_flags
& EF_MIPS_NOREORDER
)
852 strcat (buf
, ", noreorder");
854 if (e_flags
& EF_MIPS_PIC
)
855 strcat (buf
, ", pic");
857 if (e_flags
& EF_MIPS_CPIC
)
858 strcat (buf
, ", cpic");
860 if (e_flags
& EF_MIPS_ABI2
)
861 strcat (buf
, ", abi2");
863 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
864 strcat (buf
, ", mips1");
866 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
867 strcat (buf
, ", mips2");
869 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
870 strcat (buf
, ", mips3");
872 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
873 strcat (buf
, ", mips4");
882 get_machine_data (e_data
)
885 static char buff
[32];
889 case ELFDATA2LSB
: return _("ELFDATA2LSB (little endian)");
890 case ELFDATA2MSB
: return _("ELFDATA2MSB (big endian)");
892 sprintf (buff
, _("<unknown>: %x"), e_data
);
898 get_mips_segment_type (type
)
903 case PT_MIPS_REGINFO
:
907 case PT_MIPS_OPTIONS
:
917 get_segment_type (p_type
)
918 unsigned long p_type
;
920 static char buff
[32];
924 case PT_NULL
: return "NULL";
925 case PT_LOAD
: return "LOAD";
926 case PT_DYNAMIC
: return "DYNAMIC";
927 case PT_INTERP
: return "INTERP";
928 case PT_NOTE
: return "NOTE";
929 case PT_SHLIB
: return "SHLIB";
930 case PT_PHDR
: return "PHDR";
933 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
936 switch (elf_header
.e_machine
)
940 result
= get_mips_segment_type (p_type
);
948 sprintf (buff
, "LOPROC+%d", p_type
- PT_LOPROC
);
955 sprintf (buff
, _("<unknown>: %x"), p_type
);
962 get_mips_section_type_name (sh_type
)
963 unsigned int sh_type
;
967 case SHT_MIPS_LIBLIST
:
968 return "MIPS_LIBLIST";
971 case SHT_MIPS_CONFLICT
:
972 return "MIPS_CONFLICT";
979 case SHT_MIPS_REGINFO
:
980 return "MIPS_REGINFO";
981 case SHT_MIPS_PACKAGE
:
982 return "MIPS_PACKAGE";
983 case SHT_MIPS_PACKSYM
:
984 return "MIPS_PACKSYM";
989 case SHT_MIPS_CONTENT
:
990 return "MIPS_CONTENT";
991 case SHT_MIPS_OPTIONS
:
992 return "MIPS_OPTIONS";
997 case SHT_MIPS_EXTSYM
:
998 return "MIPS_EXTSYM";
1000 return "MIPS_DENSE";
1001 case SHT_MIPS_PDESC
:
1002 return "MIPS_PDESC";
1003 case SHT_MIPS_LOCSYM
:
1004 return "MIPS_LOCSYM";
1005 case SHT_MIPS_AUXSYM
:
1006 return "MIPS_AUXSYM";
1007 case SHT_MIPS_OPTSYM
:
1008 return "MIPS_OPTSYM";
1009 case SHT_MIPS_LOCSTR
:
1010 return "MIPS_LOCSTR";
1013 case SHT_MIPS_RFDESC
:
1014 return "MIPS_RFDESC";
1015 case SHT_MIPS_DELTASYM
:
1016 return "MIPS_DELTASYM";
1017 case SHT_MIPS_DELTAINST
:
1018 return "MIPS_DELTAINST";
1019 case SHT_MIPS_DELTACLASS
:
1020 return "MIPS_DELTACLASS";
1021 case SHT_MIPS_DWARF
:
1022 return "MIPS_DWARF";
1023 case SHT_MIPS_DELTADECL
:
1024 return "MIPS_DELTADECL";
1025 case SHT_MIPS_SYMBOL_LIB
:
1026 return "MIPS_SYMBOL_LIB";
1027 case SHT_MIPS_EVENTS
:
1028 return "MIPS_EVENTS";
1029 case SHT_MIPS_TRANSLATE
:
1030 return "MIPS_TRANSLATE";
1031 case SHT_MIPS_PIXIE
:
1032 return "MIPS_PIXIE";
1033 case SHT_MIPS_XLATE
:
1034 return "MIPS_XLATE";
1035 case SHT_MIPS_XLATE_DEBUG
:
1036 return "MIPS_XLATE_DEBUG";
1037 case SHT_MIPS_WHIRL
:
1038 return "MIPS_WHIRL";
1039 case SHT_MIPS_EH_REGION
:
1040 return "MIPS_EH_REGION";
1041 case SHT_MIPS_XLATE_OLD
:
1042 return "MIPS_XLATE_OLD";
1043 case SHT_MIPS_PDR_EXCEPTION
:
1044 return "MIPS_PDR_EXCEPTION";
1052 get_section_type_name (sh_type
)
1053 unsigned int sh_type
;
1055 static char buff
[32];
1059 case SHT_NULL
: return "NULL";
1060 case SHT_PROGBITS
: return "PROGBITS";
1061 case SHT_SYMTAB
: return "SYMTAB";
1062 case SHT_STRTAB
: return "STRTAB";
1063 case SHT_RELA
: return "RELA";
1064 case SHT_HASH
: return "HASH";
1065 case SHT_DYNAMIC
: return "DYNAMIC";
1066 case SHT_NOTE
: return "NOTE";
1067 case SHT_NOBITS
: return "NOBITS";
1068 case SHT_REL
: return "REL";
1069 case SHT_SHLIB
: return "SHLIB";
1070 case SHT_DYNSYM
: return "DYNSYM";
1071 case SHT_GNU_verdef
: return "VERDEF";
1072 case SHT_GNU_verneed
: return "VERNEED";
1073 case SHT_GNU_versym
: return "VERSYM";
1074 case 0x6ffffff0: return "VERSYM";
1075 case 0x6ffffffc: return "VERDEF";
1076 case 0x7ffffffd: return "AUXILIARY";
1077 case 0x7fffffff: return "FILTER";
1080 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1084 switch (elf_header
.e_machine
)
1087 case EM_MIPS_RS4_BE
:
1088 result
= get_mips_section_type_name (sh_type
);
1097 sprintf (buff
, _("SHT_LOPROC+%d"), sh_type
- SHT_LOPROC
);
1102 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1103 sprintf (buff
, _("SHT_LOUSER+%d"), sh_type
- SHT_LOUSER
);
1105 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1110 struct option options
[] =
1112 {"all", no_argument
, 0, 'a'},
1113 {"file-header", no_argument
, 0, 'h'},
1114 {"program-headers", no_argument
, 0, 'l'},
1115 {"headers", no_argument
, 0, 'e'},
1116 {"segments", no_argument
, 0, 'l'},
1117 {"sections", no_argument
, 0, 'S'},
1118 {"section-headers", no_argument
, 0, 'S'},
1119 {"symbols", no_argument
, 0, 's'},
1120 {"relocs", no_argument
, 0, 'r'},
1121 {"dynamic", no_argument
, 0, 'd'},
1122 {"version-info", no_argument
, 0, 'V'},
1123 {"use-dynamic", no_argument
, 0, 'D'},
1125 {"hex-dump", required_argument
, 0, 'x'},
1126 #ifdef SUPPORT_DISASSEMBLY
1127 {"instruction-dump", required_argument
, 0, 'i'},
1130 {"version", no_argument
, 0, 'v'},
1131 {"help", no_argument
, 0, 'H'},
1133 {0, no_argument
, 0, 0}
1139 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1140 fprintf (stdout
, _(" Options are:\n"));
1141 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V\n"));
1142 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1143 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1144 fprintf (stdout
, _(" Display the program headers\n"));
1145 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1146 fprintf (stdout
, _(" Display the sections' header\n"));
1147 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1148 fprintf (stdout
, _(" -s or --symbols Display the symbol table\n"));
1149 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1150 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1151 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1152 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1153 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1154 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1155 #ifdef SUPPORT_DISASSEMBLY
1156 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1157 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1159 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1160 fprintf (stdout
, _(" -H or --help Display this information\n"));
1161 fprintf (stdout
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1167 parse_args (argc
, argv
)
1176 while ((c
= getopt_long
1177 (argc
, argv
, "ersahldSDx:i:vV", options
, NULL
)) != EOF
)
1203 do_using_dynamic
++;
1225 section
= strtoul (optarg
, & cp
, 0);
1226 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1228 dump_sects
[section
] |= HEX_DUMP
;
1232 #ifdef SUPPORT_DISASSEMBLY
1235 section
= strtoul (optarg
, & cp
, 0);
1236 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1238 dump_sects
[section
] |= DISASS_DUMP
;
1244 print_version (program_name
);
1251 /* xgettext:c-format */
1252 error (_("Invalid option '-%c'\n"), c
);
1259 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
1260 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
)
1264 warn (_("Nothing to do.\n"));
1269 /* Decode the data held in 'elf_header'. */
1271 process_file_header ()
1273 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
1274 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
1275 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
1276 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
1279 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1283 if (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS32
)
1285 error (_("Not a 32 bit ELF file\n"));
1293 printf (_("ELF Header:\n"));
1294 printf (_(" Magic: "));
1295 for (i
= 0; i
< EI_NIDENT
; i
++)
1296 printf ("%2.2x ", elf_header
.e_ident
[i
]);
1298 printf (_(" Type: %s\n"),
1299 get_file_type (elf_header
.e_type
));
1300 printf (_(" Machine: %s\n"),
1301 get_machine_name (elf_header
.e_machine
));
1302 printf (_(" Version: 0x%lx\n"),
1303 (unsigned long) elf_header
.e_version
);
1304 printf (_(" Data: %s\n"),
1305 get_machine_data (elf_header
.e_ident
[EI_DATA
]));
1306 printf (_(" Entry point address: 0x%lx\n"),
1307 (unsigned long) elf_header
.e_entry
);
1308 printf (_(" Start of program headers: %ld (bytes into file)\n"),
1309 (long) elf_header
.e_phoff
);
1310 printf (_(" Start of section headers: %ld (bytes into file)\n"),
1311 (long) elf_header
.e_shoff
);
1312 printf (_(" Flags: 0x%lx%s\n"),
1313 (unsigned long) elf_header
.e_flags
,
1314 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
1315 printf (_(" Size of this header: %ld (bytes)\n"),
1316 (long) elf_header
.e_ehsize
);
1317 printf (_(" Size of program headers: %ld (bytes)\n"),
1318 (long) elf_header
.e_phentsize
);
1319 printf (_(" Number of program headers: %ld\n"),
1320 (long) elf_header
.e_phnum
);
1321 printf (_(" Size of section headers: %ld (bytes)\n"),
1322 (long) elf_header
.e_shentsize
);
1323 printf (_(" Number of section headers: %ld\n"),
1324 (long) elf_header
.e_shnum
);
1325 printf (_(" Section header string table index: %ld\n"),
1326 (long) elf_header
.e_shstrndx
);
1334 process_program_headers (file
)
1337 Elf32_External_Phdr
* phdrs
;
1338 Elf32_Internal_Phdr
* program_headers
;
1339 Elf32_Internal_Phdr
* segment
;
1342 if (elf_header
.e_phnum
== 0)
1345 printf (_("\nThere are no program headers in this file.\n"));
1349 if (do_segments
&& !do_header
)
1351 printf (_("\nElf file is %s\n"), get_file_type (elf_header
.e_type
));
1352 printf (_("Entry point 0x%lx\n"), (unsigned long) elf_header
.e_entry
);
1353 printf (_("There are %d program headers, starting at offset %lx:\n"),
1354 elf_header
.e_phnum
, (unsigned long) elf_header
.e_phoff
);
1357 GET_DATA_ALLOC (elf_header
.e_phoff
,
1358 elf_header
.e_phentsize
* elf_header
.e_phnum
,
1359 phdrs
, Elf32_External_Phdr
*, "program headers");
1361 program_headers
= (Elf32_Internal_Phdr
*) malloc
1362 (elf_header
.e_phnum
* sizeof (Elf32_Internal_Phdr
));
1364 if (program_headers
== NULL
)
1366 error (_("Out of memory\n"));
1370 for (i
= 0, segment
= program_headers
;
1371 i
< elf_header
.e_phnum
;
1374 segment
->p_type
= BYTE_GET (phdrs
[i
].p_type
);
1375 segment
->p_offset
= BYTE_GET (phdrs
[i
].p_offset
);
1376 segment
->p_vaddr
= BYTE_GET (phdrs
[i
].p_vaddr
);
1377 segment
->p_paddr
= BYTE_GET (phdrs
[i
].p_paddr
);
1378 segment
->p_filesz
= BYTE_GET (phdrs
[i
].p_filesz
);
1379 segment
->p_memsz
= BYTE_GET (phdrs
[i
].p_memsz
);
1380 segment
->p_flags
= BYTE_GET (phdrs
[i
].p_flags
);
1381 segment
->p_align
= BYTE_GET (phdrs
[i
].p_align
);
1389 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
1391 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
1397 for (i
= 0, segment
= program_headers
;
1398 i
< elf_header
.e_phnum
;
1403 printf (" %-11.11s ", get_segment_type (segment
->p_type
));
1404 printf ("0x%5.5lx ", (unsigned long) segment
->p_offset
);
1405 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
1406 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
1407 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
1408 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
1410 (segment
->p_flags
& PF_R
? 'R' : ' '),
1411 (segment
->p_flags
& PF_W
? 'W' : ' '),
1412 (segment
->p_flags
& PF_X
? 'E' : ' '));
1413 printf ("%#lx", (unsigned long) segment
->p_align
);
1416 switch (segment
->p_type
)
1420 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
1421 - (segment
->p_offset
& 0xfffff000);
1426 error (_("more than one dynamic segment\n"));
1428 dynamic_addr
= segment
->p_offset
;
1429 dynamic_size
= segment
->p_filesz
;
1433 if (fseek (file
, segment
->p_offset
, SEEK_SET
))
1434 error (_("Unable to find program interpreter name\n"));
1437 program_interpreter
[0] = 0;
1438 fscanf (file
, "%63s", program_interpreter
);
1441 printf (_("\n [Requesting program interpreter: %s]"),
1442 program_interpreter
);
1448 putc ('\n', stdout
);
1457 if (do_segments
&& section_headers
!= NULL
)
1459 printf (_("\n Section to Segment mapping:\n"));
1460 printf (_(" Segment Sections...\n"));
1462 assert (string_table
!= NULL
);
1464 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
1467 Elf32_Internal_Shdr
* section
;
1469 segment
= program_headers
+ i
;
1470 section
= section_headers
;
1472 printf (" %2.2d ", i
);
1474 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
1476 if (section
->sh_size
> 0
1477 /* Compare allocated sections by VMA, unallocated
1478 sections by file offset. */
1479 && (section
->sh_flags
& SHF_ALLOC
1480 ? (section
->sh_addr
>= segment
->p_vaddr
1481 && section
->sh_addr
+ section
->sh_size
1482 <= segment
->p_vaddr
+ segment
->p_memsz
)
1483 : (section
->sh_offset
>= segment
->p_offset
1484 && (section
->sh_offset
+ section
->sh_size
1485 <= segment
->p_offset
+ segment
->p_filesz
))))
1486 printf ("%s ", SECTION_NAME (section
));
1493 free (program_headers
);
1500 get_section_headers (file
)
1503 Elf32_External_Shdr
* shdrs
;
1504 Elf32_Internal_Shdr
* internal
;
1507 GET_DATA_ALLOC (elf_header
.e_shoff
,
1508 elf_header
.e_shentsize
* elf_header
.e_shnum
,
1509 shdrs
, Elf32_External_Shdr
*, "section headers");
1511 section_headers
= (Elf32_Internal_Shdr
*) malloc
1512 (elf_header
.e_shnum
* sizeof (Elf32_Internal_Shdr
));
1514 if (section_headers
== NULL
)
1516 error (_("Out of memory\n"));
1520 for (i
= 0, internal
= section_headers
;
1521 i
< elf_header
.e_shnum
;
1524 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
1525 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
1526 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
1527 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
1528 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
1529 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
1530 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
1531 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
1532 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
1533 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
1541 static Elf_Internal_Sym
*
1542 get_elf_symbols (file
, offset
, number
)
1544 unsigned long offset
;
1545 unsigned long number
;
1547 Elf32_External_Sym
* esyms
;
1548 Elf_Internal_Sym
* isyms
;
1549 Elf_Internal_Sym
* psym
;
1552 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
1553 esyms
, Elf32_External_Sym
*, "symbols");
1555 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
1559 error (_("Out of memory\n"));
1565 for (j
= 0, psym
= isyms
;
1569 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
1570 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
1571 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
1572 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
1573 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
1574 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
1583 process_section_headers (file
)
1586 Elf32_Internal_Shdr
* section
;
1589 section_headers
= NULL
;
1591 if (elf_header
.e_shnum
== 0)
1594 printf (_("\nThere are no sections in this file.\n"));
1599 if (do_sections
&& !do_header
)
1600 printf (_("There are %d section headers, starting at offset %x:\n"),
1601 elf_header
.e_shnum
, elf_header
.e_shoff
);
1603 if (! get_section_headers (file
))
1606 /* Read in the string table, so that we have names to display. */
1607 section
= section_headers
+ elf_header
.e_shstrndx
;
1609 if (section
->sh_size
!= 0)
1611 unsigned long string_table_offset
;
1613 string_table_offset
= section
->sh_offset
;
1615 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1616 string_table
, char *, "string table");
1619 /* Scan the sections for the dynamic symbol table
1620 and dynamic string table. */
1621 dynamic_symbols
= NULL
;
1622 dynamic_strings
= NULL
;
1623 for (i
= 0, section
= section_headers
;
1624 i
< elf_header
.e_shnum
;
1627 if (section
->sh_type
== SHT_DYNSYM
)
1629 if (dynamic_symbols
!= NULL
)
1631 error (_("File contains multiple dynamic symbol tables\n"));
1635 dynamic_symbols
= get_elf_symbols
1636 (file
, section
->sh_offset
, section
->sh_size
/ section
->sh_entsize
);
1638 else if (section
->sh_type
== SHT_STRTAB
1639 && strcmp (SECTION_NAME (section
), ".dynstr") == 0)
1641 if (dynamic_strings
!= NULL
)
1643 error (_("File contains multiple dynamic string tables\n"));
1647 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1648 dynamic_strings
, char *, "dynamic strings");
1655 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
1657 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
1659 for (i
= 0, section
= section_headers
;
1660 i
< elf_header
.e_shnum
;
1663 printf (" [%2d] %-17.17s %-15.15s ",
1665 SECTION_NAME (section
),
1666 get_section_type_name (section
->sh_type
));
1668 printf ( "%8.8lx %6.6lx %6.6lx %2.2lx",
1669 (unsigned long) section
->sh_addr
,
1670 (unsigned long) section
->sh_offset
,
1671 (unsigned long) section
->sh_size
,
1672 (unsigned long) section
->sh_entsize
);
1674 printf (" %c%c%c %2ld %3lx %ld \n",
1675 (section
->sh_flags
& SHF_WRITE
? 'W' : ' '),
1676 (section
->sh_flags
& SHF_ALLOC
? 'A' : ' '),
1677 (section
->sh_flags
& SHF_EXECINSTR
? 'X' : ' '),
1678 (unsigned long) section
->sh_link
,
1679 (unsigned long) section
->sh_info
,
1680 (unsigned long) section
->sh_addralign
);
1686 /* Process the reloc section. */
1688 process_relocs (file
)
1691 unsigned long rel_size
;
1692 unsigned long rel_offset
;
1698 if (do_using_dynamic
)
1703 if (dynamic_info
[DT_REL
])
1705 rel_offset
= dynamic_info
[DT_REL
];
1706 rel_size
= dynamic_info
[DT_RELSZ
];
1708 else if (dynamic_info
[DT_RELA
])
1710 rel_offset
= dynamic_info
[DT_RELA
];
1711 rel_size
= dynamic_info
[DT_RELASZ
];
1713 else if (dynamic_info
[DT_JMPREL
])
1715 rel_offset
= dynamic_info
[DT_JMPREL
];
1716 rel_size
= dynamic_info
[DT_PLTRELSZ
];
1722 (_("\nRelocation section at offset 0x%x contains %d bytes:\n"),
1723 rel_offset
, rel_size
);
1725 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
1726 dynamic_symbols
, dynamic_strings
);
1729 printf (_("\nThere are no dynamic relocations in this file.\n"));
1733 Elf32_Internal_Shdr
* section
;
1737 assert (string_table
!= NULL
);
1739 for (i
= 0, section
= section_headers
;
1740 i
< elf_header
.e_shnum
;
1743 if ( section
->sh_type
!= SHT_RELA
1744 && section
->sh_type
!= SHT_REL
)
1747 rel_offset
= section
->sh_offset
;
1748 rel_size
= section
->sh_size
;
1752 Elf32_Internal_Shdr
* strsec
;
1753 Elf32_Internal_Shdr
* symsec
;
1754 Elf_Internal_Sym
* symtab
;
1758 (_("\nRelocation section '%s' at offset 0x%x contains %d entries:\n"),
1759 SECTION_NAME (section
), rel_offset
,
1760 rel_size
/ section
->sh_entsize
);
1762 symsec
= section_headers
+ section
->sh_link
;
1764 symtab
= get_elf_symbols (file
, symsec
->sh_offset
,
1765 symsec
->sh_size
/ symsec
->sh_entsize
);
1770 strsec
= section_headers
+ symsec
->sh_link
;
1772 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
1773 char *, "string table");
1775 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
);
1785 printf (_("\nThere are no relocations in this file.\n"));
1793 dynamic_segment_mips_val (entry
)
1794 Elf_Internal_Dyn
*entry
;
1796 switch (entry
->d_tag
)
1798 case DT_MIPS_LOCAL_GOTNO
:
1799 case DT_MIPS_CONFLICTNO
:
1800 case DT_MIPS_LIBLISTNO
:
1801 case DT_MIPS_SYMTABNO
:
1802 case DT_MIPS_UNREFEXTNO
:
1803 case DT_MIPS_HIPAGENO
:
1804 case DT_MIPS_DELTA_CLASS_NO
:
1805 case DT_MIPS_DELTA_INSTANCE_NO
:
1806 case DT_MIPS_DELTA_RELOC_NO
:
1807 case DT_MIPS_DELTA_SYM_NO
:
1808 case DT_MIPS_DELTA_CLASSSYM_NO
:
1810 printf ("%#ld\n", (long) entry
->d_un
.d_ptr
);
1814 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
1818 /* Parse the dynamic segment */
1820 process_dynamic_segment (file
)
1823 Elf_Internal_Dyn
* entry
;
1824 Elf32_External_Dyn
* edyn
;
1827 if (dynamic_size
== 0)
1830 printf (_("\nThere is no dynamic segment in this file.\n"));
1835 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
1836 edyn
, Elf32_External_Dyn
*, "dynamic segment");
1838 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
1839 how large .dynamic is now. We can do this even before the byte
1840 swapping since the DT_NULL tag is recognizable. */
1842 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
1845 dynamic_segment
= (Elf_Internal_Dyn
*)
1846 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
1848 if (dynamic_segment
== NULL
)
1850 error (_("Out of memory\n"));
1855 for (i
= 0, entry
= dynamic_segment
;
1859 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
1860 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
1865 /* Find the appropriate symbol table. */
1866 if (dynamic_symbols
== NULL
)
1868 for (i
= 0, entry
= dynamic_segment
;
1872 unsigned long offset
;
1875 if (entry
->d_tag
!= DT_SYMTAB
)
1878 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
1880 /* Since we do not know how big the symbol table is,
1881 we default to reading in the entire file (!) and
1882 processing that. This is overkill, I know, but it
1885 offset
= entry
->d_un
.d_val
- loadaddr
;
1887 if (fseek (file
, 0, SEEK_END
))
1888 error (_("Unable to seek to end of file!"));
1890 num_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
1894 error (_("Unable to determine the number of symbols to load\n"));
1898 dynamic_symbols
= get_elf_symbols (file
, offset
, num_syms
);
1902 /* Similarly find a string table. */
1903 if (dynamic_strings
== NULL
)
1905 for (i
= 0, entry
= dynamic_segment
;
1909 unsigned long offset
;
1912 if (entry
->d_tag
!= DT_STRTAB
)
1915 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
1917 /* Since we do not know how big the string table is,
1918 we default to reading in the entire file (!) and
1919 processing that. This is overkill, I know, but it
1922 offset
= entry
->d_un
.d_val
- loadaddr
;
1923 if (fseek (file
, 0, SEEK_END
))
1924 error (_("Unable to seek to end of file\n"));
1925 str_tab_len
= ftell (file
) - offset
;
1927 if (str_tab_len
< 1)
1930 (_("Unable to determine the length of the dynamic string table\n"));
1934 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
1935 "dynamic string table");
1941 if (do_dynamic
&& dynamic_addr
)
1942 printf (_("\nDynamic segment at offset 0x%x contains %d entries:\n"),
1943 dynamic_addr
, dynamic_size
);
1945 printf (_(" Tag Type Name/Value\n"));
1947 for (i
= 0, entry
= dynamic_segment
;
1952 printf (_(" 0x%-8.8lx (%s)%*s"),
1953 (unsigned long) entry
->d_tag
,
1954 get_dynamic_type (entry
->d_tag
),
1955 27 - strlen (get_dynamic_type (entry
->d_tag
)),
1958 switch (entry
->d_tag
)
1964 if (entry
->d_tag
== DT_AUXILIARY
)
1965 printf (_("Auxiliary library"));
1967 printf (_("Filter library"));
1969 if (dynamic_strings
)
1970 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
1972 printf (": %#lx\n", (long) entry
->d_un
.d_val
);
2000 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
2006 if (dynamic_strings
== NULL
)
2009 name
= dynamic_strings
+ entry
->d_un
.d_val
;
2013 switch (entry
->d_tag
)
2016 printf (_("Shared library: [%s]"), name
);
2018 if (strcmp (name
, program_interpreter
))
2021 printf (_(" program interpreter\n"));
2025 printf (_("Library soname: [%s]\n"), name
);
2029 printf (_("Library rpath: [%s]\n"), name
);
2033 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2037 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2042 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
2044 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
2048 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2051 switch (elf_header
.e_machine
)
2054 case EM_MIPS_RS4_BE
:
2055 dynamic_segment_mips_val (entry
);
2059 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2069 get_ver_flags (flags
)
2072 static char buff
[32];
2079 if (flags
& VER_FLG_BASE
)
2080 strcat (buff
, "BASE ");
2082 if (flags
& VER_FLG_WEAK
)
2084 if (flags
& VER_FLG_BASE
)
2085 strcat (buff
, "| ");
2087 strcat (buff
, "WEAK ");
2090 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
2091 strcat (buff
, "| <unknown>");
2096 /* Display the contents of the version sections. */
2098 process_version_sections (file
)
2101 Elf32_Internal_Shdr
* section
;
2108 for (i
= 0, section
= section_headers
;
2109 i
< elf_header
.e_shnum
;
2112 switch (section
->sh_type
)
2114 case SHT_GNU_verdef
:
2116 Elf_External_Verdef
* edefs
;
2123 (_("\nVersion definition section '%s' contains %d entries:\n"),
2124 SECTION_NAME (section
), section
->sh_info
);
2126 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2127 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2128 SECTION_NAME (section_headers
+ section
->sh_link
));
2130 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2131 edefs
, Elf_External_Verdef
*,
2132 "version definition section");
2134 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
2137 Elf_External_Verdef
* edef
;
2138 Elf_Internal_Verdef ent
;
2139 Elf_External_Verdaux
* eaux
;
2140 Elf_Internal_Verdaux aux
;
2144 vstart
= ((char *) edefs
) + idx
;
2146 edef
= (Elf_External_Verdef
*) vstart
;
2148 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
2149 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
2150 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
2151 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
2152 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
2153 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
2154 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
2156 printf (_(" %#06x: Rev: %d Flags: %s"),
2157 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
2159 printf (_(" Index: %ld Cnt: %ld "), ent
.vd_ndx
, ent
.vd_cnt
);
2161 vstart
+= ent
.vd_aux
;
2163 eaux
= (Elf_External_Verdaux
*) vstart
;
2165 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2166 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2168 if (dynamic_strings
)
2169 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
2171 printf (_("Name index: %ld\n"), aux
.vda_name
);
2173 isum
= idx
+ ent
.vd_aux
;
2175 for (j
= 1; j
< ent
.vd_cnt
; j
++)
2177 isum
+= aux
.vda_next
;
2178 vstart
+= aux
.vda_next
;
2180 eaux
= (Elf_External_Verdaux
*) vstart
;
2182 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2183 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2185 if (dynamic_strings
)
2186 printf (_(" %#06x: Parent %d: %s\n"),
2187 isum
, j
, dynamic_strings
+ aux
.vda_name
);
2189 printf (_(" %#06x: Parent %d, name index: %ld\n"),
2190 isum
, j
, aux
.vda_name
);
2200 case SHT_GNU_verneed
:
2202 Elf_External_Verneed
* eneed
;
2208 printf (_("\nVersion needs section '%s' contains %d entries:\n"),
2209 SECTION_NAME (section
), section
->sh_info
);
2212 (_(" Addr: %#08x Offset: %#08x Link to section: %d (%s)\n"),
2213 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2214 SECTION_NAME (section_headers
+ section
->sh_link
));
2216 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2217 eneed
, Elf_External_Verneed
*,
2218 "version need section");
2220 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
2222 Elf_External_Verneed
* entry
;
2223 Elf_Internal_Verneed ent
;
2228 vstart
= ((char *) eneed
) + idx
;
2230 entry
= (Elf_External_Verneed
*) vstart
;
2232 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
2233 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
2234 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
2235 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
2236 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
2238 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
2240 if (dynamic_strings
)
2241 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
2243 printf (_(" File: %lx"), ent
.vn_file
);
2245 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
2247 vstart
+= ent
.vn_aux
;
2249 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
2251 Elf_External_Vernaux
* eaux
;
2252 Elf_Internal_Vernaux aux
;
2254 eaux
= (Elf_External_Vernaux
*) vstart
;
2256 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
2257 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
2258 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
2259 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
2260 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
2262 if (dynamic_strings
)
2263 printf (_(" %#06x: Name: %s"),
2264 isum
, dynamic_strings
+ aux
.vna_name
);
2266 printf (_(" %#06x: Name index: %lx"),
2267 isum
, aux
.vna_name
);
2269 printf (_(" Flags: %s Version: %d\n"),
2270 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
2272 isum
+= aux
.vna_next
;
2273 vstart
+= aux
.vna_next
;
2283 case SHT_GNU_versym
:
2285 Elf32_Internal_Shdr
* link_section
;
2288 unsigned char * edata
;
2289 unsigned short * data
;
2291 Elf_Internal_Sym
* symbols
;
2292 Elf32_Internal_Shdr
* string_sec
;
2294 link_section
= section_headers
+ section
->sh_link
;
2295 total
= section
->sh_size
/ section
->sh_entsize
;
2299 symbols
= get_elf_symbols
2300 (file
, link_section
->sh_offset
,
2301 link_section
->sh_size
/ link_section
->sh_entsize
);
2303 string_sec
= section_headers
+ link_section
->sh_link
;
2305 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
2306 strtab
, char *, "version string table");
2308 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
2309 SECTION_NAME (section
), total
);
2311 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2312 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2313 SECTION_NAME (link_section
));
2315 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
2317 total
* sizeof (short), edata
,
2318 char *, "version symbol data");
2320 data
= (unsigned short *) malloc (total
* sizeof (short));
2322 for (cnt
= total
; cnt
--;)
2323 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short), sizeof (short));
2327 for (cnt
= 0; cnt
< total
; cnt
+= 4)
2331 printf (" %03x:", cnt
);
2333 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
2334 switch (data
[cnt
+ j
])
2337 fputs (_(" 0 (*local*) "), stdout
);
2341 fputs (_(" 1 (*global*) "), stdout
);
2345 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
2346 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
2348 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
2349 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
2352 /* We must test both. */
2353 Elf_Internal_Verneed ivn
;
2354 unsigned long offset
;
2356 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2361 Elf_External_Verneed evn
;
2362 Elf_External_Vernaux evna
;
2363 Elf_Internal_Vernaux ivna
;
2364 unsigned long vna_off
;
2366 GET_DATA (offset
, evn
, "version need");
2368 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2369 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2371 vna_off
= offset
+ ivn
.vn_aux
;
2375 GET_DATA (vna_off
, evna
,
2376 "version need aux (1)");
2378 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2379 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2381 vna_off
+= ivna
.vna_next
;
2383 while (ivna
.vna_other
!= data
[cnt
+ j
]
2384 && ivna
.vna_next
!= 0);
2386 if (ivna
.vna_other
== data
[cnt
+ j
])
2388 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2390 nn
+= printf ("(%s%-*s",
2391 strtab
+ ivna
.vna_name
,
2397 else if (ivn
.vn_next
== 0)
2399 if (data
[cnt
+ j
] != 0x8001)
2401 Elf_Internal_Verdef ivd
;
2402 Elf_External_Verdef evd
;
2404 offset
= version_info
2405 [DT_VERSIONTAGIDX (DT_VERDEF
)]
2410 GET_DATA (offset
, evd
,
2411 "version definition");
2413 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2414 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2416 offset
+= ivd
.vd_next
;
2419 != (data
[cnt
+ j
] & 0x7fff)
2420 && ivd
.vd_next
!= 0);
2423 == (data
[cnt
+ j
] & 0x7fff))
2425 Elf_External_Verdaux evda
;
2426 Elf_Internal_Verdaux ivda
;
2428 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2430 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
2431 "version definition aux");
2434 BYTE_GET (evda
.vda_name
);
2438 strtab
+ ivda
.vda_name
,
2449 offset
+= ivn
.vn_next
;
2451 while (ivn
.vn_next
);
2453 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
2455 Elf_Internal_Verneed ivn
;
2456 unsigned long offset
;
2458 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2463 Elf_Internal_Vernaux ivna
;
2464 Elf_External_Verneed evn
;
2465 Elf_External_Vernaux evna
;
2466 unsigned long a_off
;
2468 GET_DATA (offset
, evn
, "version need");
2470 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2471 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2473 a_off
= offset
+ ivn
.vn_aux
;
2477 GET_DATA (a_off
, evna
,
2478 "version need aux (2)");
2480 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2481 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2483 a_off
+= ivna
.vna_next
;
2485 while (ivna
.vna_other
!= data
[cnt
+ j
]
2486 && ivna
.vna_next
!= 0);
2488 if (ivna
.vna_other
== data
[cnt
+ j
])
2490 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2492 nn
+= printf ("(%s%-*s",
2493 strtab
+ ivna
.vna_name
,
2500 offset
+= ivn
.vn_next
;
2502 while (ivn
.vn_next
);
2504 else if (data
[cnt
+ j
] != 0x8001)
2506 Elf_Internal_Verdef ivd
;
2507 Elf_External_Verdef evd
;
2508 unsigned long offset
;
2510 offset
= version_info
2511 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
2515 GET_DATA (offset
, evd
, "version def");
2517 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2518 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2520 offset
+= ivd
.vd_next
;
2522 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
2523 && ivd
.vd_next
!= 0);
2525 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
2527 Elf_External_Verdaux evda
;
2528 Elf_Internal_Verdaux ivda
;
2530 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2532 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
2533 evda
, "version def aux");
2535 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
2537 nn
+= printf ("(%s%-*s",
2538 strtab
+ ivda
.vda_name
,
2546 printf ("%*c", 18 - nn
, ' ');
2564 printf (_("\nNo version information found in this file.\n"));
2570 get_symbol_binding (binding
)
2571 unsigned int binding
;
2573 static char buff
[32];
2577 case STB_LOCAL
: return _("LOCAL");
2578 case STB_GLOBAL
: return _("GLOBAL");
2579 case STB_WEAK
: return _("WEAK");
2581 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
2582 sprintf (buff
, _("<processor specific>: %d"), binding
);
2584 sprintf (buff
, _("<unknown>: %d"), binding
);
2590 get_symbol_type (type
)
2593 static char buff
[32];
2597 case STT_NOTYPE
: return _("NOTYPE");
2598 case STT_OBJECT
: return _("OBJECT");
2599 case STT_FUNC
: return _("FUNC");
2600 case STT_SECTION
: return _("SECTION");
2601 case STT_FILE
: return _("FILE");
2603 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
2604 sprintf (buff
, _("<processor specific>: %d"), type
);
2606 sprintf (buff
, _("<unknown>: %d"), type
);
2612 get_symbol_index_type (type
)
2617 case SHN_UNDEF
: return "UND";
2618 case SHN_ABS
: return "ABS";
2619 case SHN_COMMON
: return "COM";
2621 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
2623 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
2627 static char buff
[32];
2629 sprintf (buff
, "%3d", type
);
2637 get_dynamic_data (file
, number
)
2639 unsigned int number
;
2644 e_data
= (char *) malloc (number
* 4);
2648 error (_("Out of memory\n"));
2652 if (fread (e_data
, 4, number
, file
) != number
)
2654 error (_("Unable to read in dynamic data\n"));
2658 i_data
= (int *) malloc (number
* sizeof (* i_data
));
2662 error (_("Out of memory\n"));
2668 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
2675 /* Dump the symbol table */
2677 process_symbol_table (file
)
2680 Elf32_Internal_Shdr
* section
;
2685 if (dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
2696 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
2698 error (_("Unable to seek to start of dynamic information"));
2702 if (fread (& nb
, sizeof (nb
), 1, file
) != 1)
2704 error (_("Failed to read in number of buckets\n"));
2708 if (fread (& nc
, sizeof (nc
), 1, file
) != 1)
2710 error (_("Failed to read in number of chains\n"));
2714 nbuckets
= byte_get (nb
, 4);
2715 nchains
= byte_get (nc
, 4);
2717 buckets
= get_dynamic_data (file
, nbuckets
);
2718 chains
= get_dynamic_data (file
, nchains
);
2720 if (buckets
== NULL
|| chains
== NULL
)
2723 printf (_("\nSymbol table for image:\n"));
2724 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
2726 for (hn
= 0; hn
< nbuckets
; hn
++)
2731 for (si
= buckets
[hn
]; si
; si
= chains
[si
])
2733 Elf_Internal_Sym
* psym
;
2735 psym
= dynamic_symbols
+ si
;
2737 printf (" %3d %3d: %8lx %5ld %6s %6s %2d ",
2739 (unsigned long) psym
->st_value
,
2740 (unsigned long) psym
->st_size
,
2741 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
2742 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
2745 printf ("%3.3s", get_symbol_index_type (psym
->st_shndx
));
2747 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
2754 else if (!do_using_dynamic
)
2758 for (i
= 0, section
= section_headers
;
2759 i
< elf_header
.e_shnum
;
2764 Elf_Internal_Sym
* symtab
;
2765 Elf_Internal_Sym
* psym
;
2768 if ( section
->sh_type
!= SHT_SYMTAB
2769 && section
->sh_type
!= SHT_DYNSYM
)
2772 printf (_("\nSymbol table '%s' contains %d entries:\n"),
2773 SECTION_NAME (section
),
2774 section
->sh_size
/ section
->sh_entsize
);
2775 fputs (_(" Num: Value Size Type Bind Ot Ndx Name\n"),
2778 symtab
= get_elf_symbols (file
, section
->sh_offset
,
2779 section
->sh_size
/ section
->sh_entsize
);
2783 if (section
->sh_link
== elf_header
.e_shstrndx
)
2784 strtab
= string_table
;
2787 Elf32_Internal_Shdr
* string_sec
;
2789 string_sec
= section_headers
+ section
->sh_link
;
2791 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
2792 strtab
, char *, "string table");
2795 for (si
= 0, psym
= symtab
;
2796 si
< section
->sh_size
/ section
->sh_entsize
;
2799 printf (" %3d: %8lx %5ld %-7s %-6s %2d ",
2801 (unsigned long) psym
->st_value
,
2802 (unsigned long) psym
->st_size
,
2803 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
2804 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
2807 if (psym
->st_shndx
== 0)
2808 fputs (" UND", stdout
);
2809 else if ((psym
->st_shndx
& 0xffff) == 0xfff1)
2810 fputs (" ABS", stdout
);
2811 else if ((psym
->st_shndx
& 0xffff) == 0xfff2)
2812 fputs (" COM", stdout
);
2814 printf ("%4x", psym
->st_shndx
);
2816 printf (" %s", strtab
+ psym
->st_name
);
2818 if (section
->sh_type
== SHT_DYNSYM
&&
2819 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
2821 unsigned char data
[2];
2822 unsigned short vers_data
;
2823 unsigned long offset
;
2827 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
2830 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
2833 vers_data
= byte_get (data
, 2);
2835 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
2836 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
2839 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
2841 if ((vers_data
& 0x8000) || vers_data
> 1)
2843 if (is_nobits
|| ! check_def
)
2845 Elf_External_Verneed evn
;
2846 Elf_Internal_Verneed ivn
;
2847 Elf_Internal_Vernaux ivna
;
2849 /* We must test both. */
2850 offset
= version_info
2851 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
2853 GET_DATA (offset
, evn
, "version need");
2855 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2856 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2860 unsigned long vna_off
;
2862 vna_off
= offset
+ ivn
.vn_aux
;
2866 Elf_External_Vernaux evna
;
2868 GET_DATA (vna_off
, evna
,
2869 "version need aux (3)");
2871 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2872 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2873 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2875 vna_off
+= ivna
.vna_next
;
2877 while (ivna
.vna_other
!= vers_data
2878 && ivna
.vna_next
!= 0);
2880 if (ivna
.vna_other
== vers_data
)
2883 offset
+= ivn
.vn_next
;
2885 while (ivn
.vn_next
!= 0);
2887 if (ivna
.vna_other
== vers_data
)
2890 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
2893 else if (! is_nobits
)
2894 error (_("bad dynamic symbol"));
2901 if (vers_data
!= 0x8001)
2903 Elf_Internal_Verdef ivd
;
2904 Elf_Internal_Verdaux ivda
;
2905 Elf_External_Verdaux evda
;
2906 unsigned long offset
;
2909 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
2914 Elf_External_Verdef evd
;
2916 GET_DATA (offset
, evd
, "version def");
2918 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2919 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2920 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2922 offset
+= ivd
.vd_next
;
2924 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
2925 && ivd
.vd_next
!= 0);
2927 offset
-= ivd
.vd_next
;
2928 offset
+= ivd
.vd_aux
;
2930 GET_DATA (offset
, evda
, "version def aux");
2932 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
2934 if (psym
->st_name
!= ivda
.vda_name
)
2935 printf ((vers_data
& 0x8000)
2937 strtab
+ ivda
.vda_name
);
2947 if (strtab
!= string_table
)
2953 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
2959 process_section_contents (file
)
2962 Elf32_Internal_Shdr
* section
;
2968 for (i
= 0, section
= section_headers
;
2969 i
< elf_header
.e_shnum
;
2972 #ifdef SUPPORT_DISASSEMBLY
2973 /* See if we need an assembly dump of this section */
2975 if ((i
< NUM_DUMP_SECTS
) && (dump_sects
[i
] & DISASS_DUMP
))
2977 printf (_("\nAssembly dump of section %s\n"),
2978 SECTION_NAME (section
));
2980 /* XXX -- to be done --- XXX */
2983 /* See if we need a hex dump of this section. */
2984 if ((i
< NUM_DUMP_SECTS
) && (dump_sects
[i
] & HEX_DUMP
))
2988 unsigned char * data
;
2991 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
2993 bytes
= section
->sh_size
;
2994 addr
= section
->sh_addr
;
2996 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, char *,
3007 lbytes
= (bytes
> 16 ? 16 : bytes
);
3009 printf (" 0x%8.8x ", addr
);
3011 switch (elf_header
.e_ident
[EI_DATA
])
3014 for (j
= 15; j
>= 0; j
--)
3017 printf ("%2.2x", data
[j
]);
3027 for (j
= 0; j
< 16; j
++)
3030 printf ("%2.2x", data
[j
]);
3040 for (j
= 0; j
< lbytes
; j
++)
3043 if (k
>= ' ' && k
< 0x80)
3064 process_mips_fpe_exception (mask
)
3070 if (mask
& OEX_FPU_INEX
)
3071 fputs ("INEX", stdout
), first
= 0;
3072 if (mask
& OEX_FPU_UFLO
)
3073 printf ("%sUFLO", first
? "" : "|"), first
= 0;
3074 if (mask
& OEX_FPU_OFLO
)
3075 printf ("%sOFLO", first
? "" : "|"), first
= 0;
3076 if (mask
& OEX_FPU_DIV0
)
3077 printf ("%sDIV0", first
? "" : "|"), first
= 0;
3078 if (mask
& OEX_FPU_INVAL
)
3079 printf ("%sINVAL", first
? "" : "|");
3082 fputs ("0", stdout
);
3086 process_mips_specific (file
)
3089 Elf_Internal_Dyn
* entry
;
3090 size_t liblist_offset
= 0;
3091 size_t liblistno
= 0;
3092 size_t options_offset
= 0;
3094 /* We have a lot of special sections. Thanks SGI! */
3095 if (dynamic_segment
== NULL
)
3096 /* No information available. */
3099 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
3100 switch (entry
->d_tag
)
3102 case DT_MIPS_LIBLIST
:
3103 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
3105 case DT_MIPS_LIBLISTNO
:
3106 liblistno
= entry
->d_un
.d_val
;
3108 case DT_MIPS_OPTIONS
:
3109 options_offset
= entry
->d_un
.d_val
- loadaddr
;
3115 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
3117 Elf32_External_Lib
*elib
;
3120 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
3121 elib
, Elf32_External_Lib
*, "liblist");
3123 printf ("\nSection '.liblist' contains %d entries:\n", liblistno
);
3124 fputs (" Library Time Stamp Checksum Version Flags\n",
3127 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
3133 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
3134 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
3135 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
3136 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
3137 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
3139 strftime (timebuf
, 17, "%Y-%m-%dT%H:%M", gmtime (&time
));
3141 printf ("%3d: %-20s %s %#10lx %-7ld %#lx\n", cnt
,
3142 dynamic_strings
+ liblist
.l_name
, timebuf
,
3143 liblist
.l_checksum
, liblist
.l_version
, liblist
.l_flags
);
3149 if (options_offset
!= 0)
3151 Elf_External_Options
*eopt
;
3152 Elf_Internal_Shdr
*sect
= section_headers
;
3153 Elf_Internal_Options
*iopt
;
3154 Elf_Internal_Options
*option
;
3158 /* Find the section header so that we get the size. */
3159 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
3162 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
3163 Elf_External_Options
*, "options");
3165 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
3169 error (_("Out of memory"));
3175 while (offset
< sect
->sh_size
)
3177 Elf_External_Options
*eoption
;
3179 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
3181 option
->kind
= BYTE_GET (eoption
->kind
);
3182 option
->size
= BYTE_GET (eoption
->size
);
3183 option
->section
= BYTE_GET (eoption
->section
);
3184 option
->info
= BYTE_GET (eoption
->info
);
3186 offset
+= option
->size
;
3191 printf (_("\nSection '%s' contains %d entries:\n"),
3192 string_table
+ sect
->sh_name
, cnt
);
3199 switch (option
->kind
)
3202 /* This shouldn't happen. */
3203 printf (" NULL %d %x", option
->section
, option
->info
);
3206 printf (" REGINFO ");
3207 if (elf_header
.e_machine
== EM_MIPS
)
3210 Elf32_External_RegInfo
*ereg
;
3211 Elf32_RegInfo reginfo
;
3213 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
3214 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
3215 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
3216 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
3217 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
3218 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
3219 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
3221 printf ("GPR %08lx GP %ld\n",
3222 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
3223 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
3224 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
3225 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
3230 Elf64_External_RegInfo
*ereg
;
3231 Elf64_Internal_RegInfo reginfo
;
3233 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
3234 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
3235 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
3236 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
3237 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
3238 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
3239 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
3241 printf ("GPR %08lx GP %ld\n",
3242 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
3243 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
3244 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
3245 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
3249 case ODK_EXCEPTIONS
:
3250 fputs (" EXCEPTIONS fpe_min(", stdout
);
3251 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
3252 fputs (") fpe_max(", stdout
);
3253 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
3254 fputs (")", stdout
);
3256 if (option
->info
& OEX_PAGE0
)
3257 fputs (" PAGE0", stdout
);
3258 if (option
->info
& OEX_SMM
)
3259 fputs (" SMM", stdout
);
3260 if (option
->info
& OEX_FPDBUG
)
3261 fputs (" FPDBUG", stdout
);
3262 if (option
->info
& OEX_DISMISS
)
3263 fputs (" DISMISS", stdout
);
3266 fputs (" PAD ", stdout
);
3267 if (option
->info
& OPAD_PREFIX
)
3268 fputs (" PREFIX", stdout
);
3269 if (option
->info
& OPAD_POSTFIX
)
3270 fputs (" POSTFIX", stdout
);
3271 if (option
->info
& OPAD_SYMBOL
)
3272 fputs (" SYMBOL", stdout
);
3275 fputs (" HWPATCH ", stdout
);
3276 if (option
->info
& OHW_R4KEOP
)
3277 fputs (" R4KEOP", stdout
);
3278 if (option
->info
& OHW_R8KPFETCH
)
3279 fputs (" R8KPFETCH", stdout
);
3280 if (option
->info
& OHW_R5KEOP
)
3281 fputs (" R5KEOP", stdout
);
3282 if (option
->info
& OHW_R5KCVTL
)
3283 fputs (" R5KCVTL", stdout
);
3286 fputs (" FILL ", stdout
);
3287 /* XXX Print content of info word? */
3290 fputs (" TAGS ", stdout
);
3291 /* XXX Print content of info word? */
3294 fputs (" HWAND ", stdout
);
3295 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
3296 fputs (" R4KEOP_CHECKED", stdout
);
3297 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
3298 fputs (" R4KEOP_CLEAN", stdout
);
3301 fputs (" HWOR ", stdout
);
3302 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
3303 fputs (" R4KEOP_CHECKED", stdout
);
3304 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
3305 fputs (" R4KEOP_CLEAN", stdout
);
3308 printf (" GP_GROUP %#06x self-contained %#06x",
3309 option
->info
& OGP_GROUP
,
3310 (option
->info
& OGP_SELF
) >> 16);
3313 printf (" IDENT %#06x self-contained %#06x",
3314 option
->info
& OGP_GROUP
,
3315 (option
->info
& OGP_SELF
) >> 16);
3318 /* This shouldn't happen. */
3319 printf (" %3d ??? %d %x",
3320 option
->kind
, option
->section
, option
->info
);
3324 len
= sizeof (*eopt
);
3325 while (len
< option
->size
)
3326 if (((char *) option
)[len
] >= ' '
3327 && ((char *) option
)[len
] < 0x7f)
3328 printf ("%c", ((char *) option
)[len
++]);
3330 printf ("\\%03o", ((char *) option
)[len
++]);
3332 fputs ("\n", stdout
);
3343 process_arch_specific (file
)
3346 switch (elf_header
.e_machine
)
3349 case EM_MIPS_RS4_BE
:
3350 return process_mips_specific (file
);
3359 get_file_header (file
)
3362 Elf32_External_Ehdr ehdr
;
3364 if (fread (& ehdr
, sizeof (ehdr
), 1, file
) != 1)
3367 memcpy (elf_header
.e_ident
, ehdr
.e_ident
, EI_NIDENT
);
3369 if (elf_header
.e_ident
[EI_DATA
] == ELFDATA2LSB
)
3370 byte_get
= byte_get_little_endian
;
3372 byte_get
= byte_get_big_endian
;
3374 elf_header
.e_entry
= BYTE_GET (ehdr
.e_entry
);
3375 elf_header
.e_phoff
= BYTE_GET (ehdr
.e_phoff
);
3376 elf_header
.e_shoff
= BYTE_GET (ehdr
.e_shoff
);
3377 elf_header
.e_version
= BYTE_GET (ehdr
.e_version
);
3378 elf_header
.e_flags
= BYTE_GET (ehdr
.e_flags
);
3379 elf_header
.e_type
= BYTE_GET (ehdr
.e_type
);
3380 elf_header
.e_machine
= BYTE_GET (ehdr
.e_machine
);
3381 elf_header
.e_ehsize
= BYTE_GET (ehdr
.e_ehsize
);
3382 elf_header
.e_phentsize
= BYTE_GET (ehdr
.e_phentsize
);
3383 elf_header
.e_phnum
= BYTE_GET (ehdr
.e_phnum
);
3384 elf_header
.e_shentsize
= BYTE_GET (ehdr
.e_shentsize
);
3385 elf_header
.e_shnum
= BYTE_GET (ehdr
.e_shnum
);
3386 elf_header
.e_shstrndx
= BYTE_GET (ehdr
.e_shstrndx
);
3392 process_file (file_name
)
3396 struct stat statbuf
;
3399 if (stat (file_name
, & statbuf
) < 0)
3401 error (_("Cannot stat input file %s.\n"), file_name
);
3405 file
= fopen (file_name
, "rb");
3408 error (_("Input file %s not found.\n"), file_name
);
3412 if (! get_file_header (file
))
3414 error (_("%s: Failed to read file header\n"), file_name
);
3419 /* Initialise per file variables. */
3420 for (i
= NUM_ELEM (version_info
); i
--;)
3421 version_info
[i
] = 0;
3423 for (i
= NUM_ELEM (dynamic_info
); i
--;)
3424 dynamic_info
[i
] = 0;
3427 /* Process the file. */
3429 printf (_("\nFile: %s\n"), file_name
);
3431 if (! process_file_header ())
3437 process_section_headers (file
);
3439 process_program_headers (file
);
3441 process_dynamic_segment (file
);
3443 process_relocs (file
);
3445 process_symbol_table (file
);
3447 process_version_sections (file
);
3449 process_section_contents (file
);
3451 process_arch_specific (file
);
3455 if (section_headers
)
3457 free (section_headers
);
3458 section_headers
= NULL
;
3463 free (string_table
);
3464 string_table
= NULL
;
3467 if (dynamic_strings
)
3469 free (dynamic_strings
);
3470 dynamic_strings
= NULL
;
3473 if (dynamic_symbols
)
3475 free (dynamic_symbols
);
3476 dynamic_symbols
= NULL
;
3480 #ifdef SUPPORT_DISASSEMBLY
3481 /* Needed by the i386 disassembler. For extra credit, someone could
3482 fix this so that we insert symbolic addresses here, esp for GOT/PLT
3486 print_address (unsigned int addr
, FILE * outfile
)
3488 fprintf (outfile
,"0x%8.8x", addr
);
3491 /* Needed by the i386 disassembler. */
3493 db_task_printsym (unsigned int addr
)
3495 print_address (addr
, stderr
);
3504 parse_args (argc
, argv
);
3506 if (optind
< (argc
- 1))
3509 while (optind
< argc
)
3510 process_file (argv
[optind
++]);