1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 1999 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
32 #include "elf/common.h"
33 #include "elf/external.h"
34 #include "elf/internal.h"
35 #include "elf/dwarf2.h"
37 /* The following headers use the elf/reloc-macros.h file to
38 automatically generate relocation recognition functions
39 such as elf_mips_reloc_type() */
41 #define RELOC_MACROS_GEN_FUNC
47 #include "elf/alpha.h"
50 #include "elf/sparc.h"
55 #include "elf/mn10200.h"
56 #include "elf/mn10300.h"
64 #ifdef ANSI_PROTOTYPES
70 char * program_name
= "readelf";
71 unsigned int dynamic_addr
;
72 unsigned int dynamic_size
;
73 unsigned int rela_addr
;
74 unsigned int rela_size
;
75 char * dynamic_strings
;
77 Elf_Internal_Sym
* dynamic_symbols
;
78 Elf_Internal_Syminfo
* dynamic_syminfo
;
79 unsigned long dynamic_syminfo_offset
;
80 unsigned int dynamic_syminfo_nent
;
81 char program_interpreter
[64];
82 int dynamic_info
[DT_JMPREL
+ 1];
85 Elf_Internal_Ehdr elf_header
;
86 Elf_Internal_Shdr
* section_headers
;
87 Elf_Internal_Dyn
* dynamic_segment
;
101 int do_debug_abbrevs
;
103 int do_debug_pubnames
;
106 static unsigned long (* byte_get
) PARAMS ((unsigned char *, int));
108 /* XXX - An arbitary constant, limiting the number of sections
109 for whcih we can display information. */
110 #define NUM_DUMP_SECTS 100
111 char dump_sects
[NUM_DUMP_SECTS
];
113 #define HEX_DUMP (1 << 0)
114 #define DISASS_DUMP (1 << 1)
115 #define DEBUG_DUMP (1 << 2)
117 /* Forward declarations for dumb compilers. */
118 static const char * get_mips_dynamic_type
PARAMS ((unsigned long type
));
119 static const char * get_dynamic_type
PARAMS ((unsigned long type
));
120 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, char *));
121 static char * get_file_type
PARAMS ((unsigned e_type
));
122 static char * get_machine_name
PARAMS ((unsigned e_machine
));
123 static char * get_machine_data
PARAMS ((unsigned e_data
));
124 static char * get_machine_flags
PARAMS ((unsigned, unsigned e_machine
));
125 static const char * get_mips_segment_type
PARAMS ((unsigned long type
));
126 static const char * get_segment_type
PARAMS ((unsigned long p_type
));
127 static const char * get_mips_section_type_name
PARAMS ((unsigned int sh_type
));
128 static const char * get_section_type_name
PARAMS ((unsigned int sh_type
));
129 static char * get_symbol_binding
PARAMS ((unsigned int binding
));
130 static char * get_symbol_type
PARAMS ((unsigned int type
));
131 static void usage
PARAMS ((void));
132 static void parse_args
PARAMS ((int argc
, char ** argv
));
133 static int process_file_header
PARAMS ((void));
134 static int process_program_headers
PARAMS ((FILE *));
135 static int process_section_headers
PARAMS ((FILE *));
136 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*entry
));
137 static int process_dynamic_segment
PARAMS ((FILE *));
138 static int process_symbol_table
PARAMS ((FILE *));
139 static int process_section_contents
PARAMS ((FILE *));
140 static void process_file
PARAMS ((char * file_name
));
141 static int process_relocs
PARAMS ((FILE *));
142 static int process_version_sections
PARAMS ((FILE *));
143 static char * get_ver_flags
PARAMS ((unsigned int flags
));
144 static char * get_symbol_index_type
PARAMS ((unsigned int type
));
145 static int get_section_headers
PARAMS ((FILE * file
));
146 static int get_file_header
PARAMS ((FILE * file
));
147 static Elf_Internal_Sym
* get_elf_symbols
PARAMS ((FILE * file
, unsigned long offset
, unsigned long number
));
148 static int * get_dynamic_data
PARAMS ((FILE * file
, unsigned int number
));
149 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
150 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
151 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
152 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
153 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
154 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
155 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
156 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
157 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
158 static int process_extended_line_op
PARAMS ((unsigned char *, long *));
159 static char * get_TAG_name
PARAMS ((unsigned long));
160 static char * get_AT_name
PARAMS ((unsigned long));
161 static char * get_FORM_name
PARAMS ((unsigned long));
162 static void free_abbrevs
PARAMS ((void));
163 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
164 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
165 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
166 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
168 typedef int Elf32_Word
;
170 #define SECTION_NAME(X) (string_table + (X)->sh_name)
172 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
174 #define BYTE_GET(field) byte_get (field, sizeof (field))
176 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
178 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
179 if (fseek (file, offset, SEEK_SET)) \
181 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
185 var = (type) malloc (size); \
189 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
193 if (fread (var, size, 1, file) != 1) \
195 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
202 #define GET_DATA(offset, var, reason) \
203 if (fseek (file, offset, SEEK_SET)) \
205 error (_("Unable to seek to %x for %s\n"), offset, reason); \
208 else if (fread (& var, sizeof (var), 1, file) != 1) \
210 error (_("Unable to read data at %x for %s\n"), offset, reason); \
214 #ifdef ANSI_PROTOTYPES
216 error (const char * message
, ...)
220 fprintf (stderr
, _("%s: Error: "), program_name
);
221 va_start (args
, message
);
222 vfprintf (stderr
, message
, args
);
228 warn (const char * message
, ...)
232 fprintf (stderr
, _("%s: Warning: "), program_name
);
233 va_start (args
, message
);
234 vfprintf (stderr
, message
, args
);
246 fprintf (stderr
, _("%s: Error: "), program_name
);
248 message
= va_arg (args
, char *);
249 vfprintf (stderr
, message
, args
);
261 fprintf (stderr
, _("%s: Warning: "), program_name
);
263 message
= va_arg (args
, char *);
264 vfprintf (stderr
, message
, args
);
270 static unsigned long int
271 byte_get_little_endian (field
, size
)
272 unsigned char * field
;
281 return ((unsigned int) (field
[0]))
282 | (((unsigned int) (field
[1])) << 8);
285 return ((unsigned long) (field
[0]))
286 | (((unsigned long) (field
[1])) << 8)
287 | (((unsigned long) (field
[2])) << 16)
288 | (((unsigned long) (field
[3])) << 24);
291 error (_("Unhandled data length: %d\n"), size
);
296 static unsigned long int
297 byte_get_big_endian (field
, size
)
298 unsigned char * field
;
307 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
310 return ((unsigned long) (field
[3]))
311 | (((unsigned long) (field
[2])) << 8)
312 | (((unsigned long) (field
[1])) << 16)
313 | (((unsigned long) (field
[0])) << 24);
316 error (_("Unhandled data length: %d\n"), size
);
322 /* Display the contents of the relocation data
323 found at the specified offset. */
325 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
)
327 unsigned long rel_offset
;
328 unsigned long rel_size
;
329 Elf_Internal_Sym
* symtab
;
334 Elf_Internal_Rel
* rels
;
335 Elf_Internal_Rela
* relas
;
338 /* Compute number of relocations and read them in. */
339 switch (elf_header
.e_machine
)
348 Elf32_External_Rel
* erels
;
350 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
351 Elf32_External_Rel
*, "relocs");
353 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
355 rels
= (Elf_Internal_Rel
*) malloc (rel_size
*
356 sizeof (Elf_Internal_Rel
));
358 for (i
= 0; i
< rel_size
; i
++)
360 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
361 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
367 relas
= (Elf_Internal_Rela
*) rels
;
377 case EM_CYGNUS_MN10200
:
378 case EM_CYGNUS_MN10300
:
383 Elf32_External_Rela
* erelas
;
385 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
386 Elf32_External_Rela
*, "relocs");
388 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
390 relas
= (Elf_Internal_Rela
*) malloc (rel_size
*
391 sizeof (Elf_Internal_Rela
));
393 for (i
= 0; i
< rel_size
; i
++)
395 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
396 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
397 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
403 rels
= (Elf_Internal_Rel
*) relas
;
408 warn (_("Don't know about relocations on this machine architecture\n"));
414 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
417 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
419 for (i
= 0; i
< rel_size
; i
++)
422 unsigned long offset
;
428 offset
= relas
[i
].r_offset
;
429 info
= relas
[i
].r_info
;
433 offset
= rels
[i
].r_offset
;
434 info
= rels
[i
].r_info
;
437 printf (" %8.8lx %5.5lx ", offset
, info
);
439 switch (elf_header
.e_machine
)
446 rtype
= elf_m32r_reloc_type (ELF32_R_TYPE (info
));
451 rtype
= elf_i386_reloc_type (ELF32_R_TYPE (info
));
455 rtype
= elf_m68k_reloc_type (ELF32_R_TYPE (info
));
459 rtype
= elf_sparc_reloc_type (ELF32_R_TYPE (info
));
463 rtype
= v850_reloc_type (ELF32_R_TYPE (info
));
467 rtype
= elf_d10v_reloc_type (ELF32_R_TYPE (info
));
471 rtype
= elf_d30v_reloc_type (ELF32_R_TYPE (info
));
475 rtype
= elf_sh_reloc_type (ELF32_R_TYPE (info
));
478 case EM_CYGNUS_MN10300
:
479 rtype
= elf_mn10300_reloc_type (ELF32_R_TYPE (info
));
482 case EM_CYGNUS_MN10200
:
483 rtype
= elf_mn10200_reloc_type (ELF32_R_TYPE (info
));
487 rtype
= elf_fr30_reloc_type (ELF32_R_TYPE (info
));
491 rtype
= elf_ppc_reloc_type (ELF32_R_TYPE (info
));
496 rtype
= elf_mips_reloc_type (ELF32_R_TYPE (info
));
500 rtype
= elf_alpha_reloc_type (ELF32_R_TYPE (info
));
504 rtype
= elf_arm_reloc_type (ELF32_R_TYPE (info
));
508 rtype
= elf_arc_reloc_type (ELF32_R_TYPE (info
));
512 rtype
= elf32_hppa_reloc_type (ELF32_R_TYPE (info
));
517 printf (_("unrecognised: %-7x"), ELF32_R_TYPE (info
));
519 printf ("%-21.21s", rtype
);
521 symtab_index
= ELF32_R_SYM (info
);
523 if (symtab_index
&& symtab
!= NULL
)
525 Elf_Internal_Sym
* psym
;
527 psym
= symtab
+ symtab_index
;
529 printf (" %08lx ", (unsigned long) psym
->st_value
);
531 if (psym
->st_name
== 0)
533 SECTION_NAME (section_headers
+ psym
->st_shndx
));
534 else if (strtab
== NULL
)
535 printf (_("<string table index %3d>"), psym
->st_name
);
537 printf ("%-25.25s", strtab
+ psym
->st_name
);
540 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
552 get_mips_dynamic_type (type
)
557 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
558 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
559 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
560 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
561 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
562 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
563 case DT_MIPS_MSYM
: return "MIPS_MSYM";
564 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
565 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
566 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
567 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
568 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
569 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
570 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
571 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
572 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
573 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
574 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
575 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
576 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
577 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
578 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
579 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
580 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
581 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
582 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
583 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
584 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
585 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
586 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
587 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
588 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
589 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
590 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
591 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
592 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
593 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
594 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
595 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
596 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
597 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
598 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
599 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
606 get_dynamic_type (type
)
609 static char buff
[32];
613 case DT_NULL
: return "NULL";
614 case DT_NEEDED
: return "NEEDED";
615 case DT_PLTRELSZ
: return "PLTRELSZ";
616 case DT_PLTGOT
: return "PLTGOT";
617 case DT_HASH
: return "HASH";
618 case DT_STRTAB
: return "STRTAB";
619 case DT_SYMTAB
: return "SYMTAB";
620 case DT_RELA
: return "RELA";
621 case DT_RELASZ
: return "RELASZ";
622 case DT_RELAENT
: return "RELAENT";
623 case DT_STRSZ
: return "STRSZ";
624 case DT_SYMENT
: return "SYMENT";
625 case DT_INIT
: return "INIT";
626 case DT_FINI
: return "FINI";
627 case DT_SONAME
: return "SONAME";
628 case DT_RPATH
: return "RPATH";
629 case DT_SYMBOLIC
: return "SYMBOLIC";
630 case DT_REL
: return "REL";
631 case DT_RELSZ
: return "RELSZ";
632 case DT_RELENT
: return "RELENT";
633 case DT_PLTREL
: return "PLTREL";
634 case DT_DEBUG
: return "DEBUG";
635 case DT_TEXTREL
: return "TEXTREL";
636 case DT_JMPREL
: return "JMPREL";
637 case DT_VERDEF
: return "VERDEF";
638 case DT_VERDEFNUM
: return "VERDEFNUM";
639 case DT_VERNEED
: return "VERNEED";
640 case DT_VERNEEDNUM
: return "VERNEEDNUM";
641 case DT_VERSYM
: return "VERSYN";
642 case DT_AUXILIARY
: return "AUXILARY";
643 case DT_FILTER
: return "FILTER";
644 case DT_POSFLAG_1
: return "POSFLAG_1";
645 case DT_SYMINSZ
: return "SYMINSZ";
646 case DT_SYMINENT
: return "SYMINENT";
647 case DT_SYMINFO
: return "SYMINFO";
648 case DT_RELACOUNT
: return "RELACOUNT";
649 case DT_RELCOUNT
: return "RELCOUNT";
650 case DT_FLAGS_1
: return "FLAGS_1";
651 case DT_USED
: return "USED";
654 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
656 const char *result
= NULL
;
657 switch (elf_header
.e_machine
)
661 result
= get_mips_dynamic_type (type
);
666 sprintf (buff
, _("Processor Specific"), type
);
672 sprintf (buff
, _("<unknown>: %x"), type
);
678 get_file_type (e_type
)
681 static char buff
[32];
685 case ET_NONE
: return _("NONE (None)");
686 case ET_REL
: return _("REL (Relocatable file)");
687 case ET_EXEC
: return _("EXEC (Executable file)");
688 case ET_DYN
: return _("DYN (Shared object file)");
689 case ET_CORE
: return _("CORE (Core file)");
692 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
693 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
695 sprintf (buff
, _("<unknown>: %x"), e_type
);
701 get_machine_name (e_machine
)
704 static char buff
[32];
708 case EM_NONE
: return _("None");
709 case EM_M32
: return "WE32100";
710 case EM_SPARC
: return "Sparc";
711 case EM_386
: return "Intel 80386";
712 case EM_68K
: return "MC68000";
713 case EM_88K
: return "MC88000";
714 case EM_486
: return "Intel 80486";
715 case EM_860
: return "Intel 80860";
716 case EM_MIPS
: return "MIPS R3000 big-endian";
717 case EM_S370
: return "Amdahl";
718 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
719 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
720 case EM_PARISC
: return "HPPA";
721 case EM_PPC_OLD
: return "Power PC (old)";
722 case EM_SPARC32PLUS
: return "Sparc v8+" ;
723 case EM_960
: return "Intel 90860";
724 case EM_PPC
: return "PowerPC";
725 case EM_V800
: return "NEC V800";
726 case EM_FR20
: return "Fujitsu FR20";
727 case EM_RH32
: return "TRW RH32";
728 case EM_MMA
: return "Fujitsu MMA";
729 case EM_ARM
: return "ARM";
730 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
731 case EM_SH
: return "Hitachi SH";
732 case EM_SPARCV9
: return "Sparc v9";
733 case EM_ALPHA
: return "Alpha";
734 case EM_CYGNUS_D10V
: return "d10v";
735 case EM_CYGNUS_D30V
: return "d30v";
736 case EM_CYGNUS_ARC
: return "Arc";
737 case EM_CYGNUS_M32R
: return "M32r";
738 case EM_CYGNUS_V850
: return "v850";
739 case EM_CYGNUS_MN10300
: return "mn10300";
740 case EM_CYGNUS_MN10200
: return "mn10200";
741 case EM_CYGNUS_FR30
: return "FR30";
744 sprintf (buff
, _("<unknown>: %x"), e_machine
);
750 get_machine_flags (e_flags
, e_machine
)
754 static char buf
[1024];
765 if (e_flags
& EF_PPC_EMB
)
766 strcat (buf
, ", emb");
768 if (e_flags
& EF_PPC_RELOCATABLE
)
769 strcat (buf
, ", relocatable");
771 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
772 strcat (buf
, ", relocatable-lib");
776 switch (e_flags
& EF_V850_ARCH
)
779 strcat (buf
, ", v850e");
782 strcat (buf
, ", v850ea");
785 strcat (buf
, ", v850");
788 strcat (buf
, ", unknown v850 architecture variant");
794 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
795 strcat (buf
, ", m32r");
797 /* start-sanitize-m32rx */
799 if ((e_flags
& EF_M32R_ARCH
) == E_M32RX_ARCH
)
800 strcat (buf
, ", m32rx");
802 /* end-sanitize-m32rx */
807 if (e_flags
& EF_MIPS_NOREORDER
)
808 strcat (buf
, ", noreorder");
810 if (e_flags
& EF_MIPS_PIC
)
811 strcat (buf
, ", pic");
813 if (e_flags
& EF_MIPS_CPIC
)
814 strcat (buf
, ", cpic");
816 if (e_flags
& EF_MIPS_ABI2
)
817 strcat (buf
, ", abi2");
819 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
820 strcat (buf
, ", mips1");
822 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
823 strcat (buf
, ", mips2");
825 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
826 strcat (buf
, ", mips3");
828 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
829 strcat (buf
, ", mips4");
838 get_machine_data (e_data
)
841 static char buff
[32];
845 case ELFDATA2LSB
: return _("ELFDATA2LSB (little endian)");
846 case ELFDATA2MSB
: return _("ELFDATA2MSB (big endian)");
848 sprintf (buff
, _("<unknown>: %x"), e_data
);
854 get_mips_segment_type (type
)
859 case PT_MIPS_REGINFO
:
863 case PT_MIPS_OPTIONS
:
873 get_segment_type (p_type
)
874 unsigned long p_type
;
876 static char buff
[32];
880 case PT_NULL
: return "NULL";
881 case PT_LOAD
: return "LOAD";
882 case PT_DYNAMIC
: return "DYNAMIC";
883 case PT_INTERP
: return "INTERP";
884 case PT_NOTE
: return "NOTE";
885 case PT_SHLIB
: return "SHLIB";
886 case PT_PHDR
: return "PHDR";
889 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
892 switch (elf_header
.e_machine
)
896 result
= get_mips_segment_type (p_type
);
904 sprintf (buff
, "LOPROC+%d", p_type
- PT_LOPROC
);
911 sprintf (buff
, _("<unknown>: %x"), p_type
);
918 get_mips_section_type_name (sh_type
)
919 unsigned int sh_type
;
923 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
924 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
925 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
926 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
927 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
928 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
929 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
930 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
931 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
932 case SHT_MIPS_RELD
: return "MIPS_RELD";
933 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
934 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
935 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
936 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
937 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
938 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
939 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
940 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
941 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
942 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
943 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
944 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
945 case SHT_MIPS_LINE
: return "MIPS_LINE";
946 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
947 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
948 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
949 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
950 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
951 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
952 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
953 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
954 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
955 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
956 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
957 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
958 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
959 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
960 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
961 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
969 get_section_type_name (sh_type
)
970 unsigned int sh_type
;
972 static char buff
[32];
976 case SHT_NULL
: return "NULL";
977 case SHT_PROGBITS
: return "PROGBITS";
978 case SHT_SYMTAB
: return "SYMTAB";
979 case SHT_STRTAB
: return "STRTAB";
980 case SHT_RELA
: return "RELA";
981 case SHT_HASH
: return "HASH";
982 case SHT_DYNAMIC
: return "DYNAMIC";
983 case SHT_NOTE
: return "NOTE";
984 case SHT_NOBITS
: return "NOBITS";
985 case SHT_REL
: return "REL";
986 case SHT_SHLIB
: return "SHLIB";
987 case SHT_DYNSYM
: return "DYNSYM";
988 case SHT_GNU_verdef
: return "VERDEF";
989 case SHT_GNU_verneed
: return "VERNEED";
990 case SHT_GNU_versym
: return "VERSYM";
991 case 0x6ffffff0: return "VERSYM";
992 case 0x6ffffffc: return "VERDEF";
993 case 0x7ffffffd: return "AUXILIARY";
994 case 0x7fffffff: return "FILTER";
997 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1001 switch (elf_header
.e_machine
)
1004 case EM_MIPS_RS4_BE
:
1005 result
= get_mips_section_type_name (sh_type
);
1014 sprintf (buff
, _("SHT_LOPROC+%d"), sh_type
- SHT_LOPROC
);
1019 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1020 sprintf (buff
, _("SHT_LOUSER+%d"), sh_type
- SHT_LOUSER
);
1022 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1027 struct option options
[] =
1029 {"all", no_argument
, 0, 'a'},
1030 {"file-header", no_argument
, 0, 'h'},
1031 {"program-headers", no_argument
, 0, 'l'},
1032 {"headers", no_argument
, 0, 'e'},
1033 {"histogram", no_argument
, & do_histogram
, 1},
1034 {"segments", no_argument
, 0, 'l'},
1035 {"sections", no_argument
, 0, 'S'},
1036 {"section-headers", no_argument
, 0, 'S'},
1037 {"symbols", no_argument
, 0, 's'},
1038 {"syms", no_argument
, 0, 's'},
1039 {"relocs", no_argument
, 0, 'r'},
1040 {"dynamic", no_argument
, 0, 'd'},
1041 {"version-info", no_argument
, 0, 'V'},
1042 {"use-dynamic", no_argument
, 0, 'D'},
1043 {"hex-dump", required_argument
, 0, 'x'},
1044 {"debug-dump", optional_argument
, 0, 'w'},
1045 #ifdef SUPPORT_DISASSEMBLY
1046 {"instruction-dump", required_argument
, 0, 'i'},
1049 {"version", no_argument
, 0, 'v'},
1050 {"help", no_argument
, 0, 'H'},
1051 {0, no_argument
, 0, 0}
1057 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1058 fprintf (stdout
, _(" Options are:\n"));
1059 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V --histogram\n"));
1060 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1061 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1062 fprintf (stdout
, _(" Display the program headers\n"));
1063 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1064 fprintf (stdout
, _(" Display the sections' header\n"));
1065 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1066 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1067 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1068 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1069 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1070 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1071 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1072 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1073 fprintf (stdout
, _(" -w[liap] or --debug-dump[=line,=info,=abbrev,=pubnames]\n"));
1074 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1075 #ifdef SUPPORT_DISASSEMBLY
1076 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1077 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1079 fprintf (stdout
, _(" --histogram Display histogram of bucket list lengths\n"));
1080 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1081 fprintf (stdout
, _(" -H or --help Display this information\n"));
1082 fprintf (stdout
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1088 parse_args (argc
, argv
)
1097 while ((c
= getopt_long
1098 (argc
, argv
, "ersahldSDw::x:i:vV", options
, NULL
)) != EOF
)
1128 do_using_dynamic
++;
1150 section
= strtoul (optarg
, & cp
, 0);
1151 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1153 dump_sects
[section
] |= HEX_DUMP
;
1173 do_debug_abbrevs
= 1;
1183 do_debug_pubnames
= 1;
1187 warn (_("Unrecognised debug option '%s'\n"), optarg
);
1192 #ifdef SUPPORT_DISASSEMBLY
1195 section
= strtoul (optarg
, & cp
, 0);
1196 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1198 dump_sects
[section
] |= DISASS_DUMP
;
1204 print_version (program_name
);
1211 /* xgettext:c-format */
1212 error (_("Invalid option '-%c'\n"), c
);
1219 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
1220 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
1221 && !do_histogram
&& !do_debugging
)
1225 warn (_("Nothing to do.\n"));
1230 /* Decode the data held in 'elf_header'. */
1232 process_file_header ()
1234 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
1235 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
1236 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
1237 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
1240 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1244 binary_class
= elf_header
.e_ident
[EI_CLASS
];
1245 if (binary_class
!= ELFCLASS32
)
1247 error (_("Not a 32 bit ELF file\n"));
1255 printf (_("ELF Header:\n"));
1256 printf (_(" Magic: "));
1257 for (i
= 0; i
< EI_NIDENT
; i
++)
1258 printf ("%2.2x ", elf_header
.e_ident
[i
]);
1260 printf (_(" Type: %s\n"),
1261 get_file_type (elf_header
.e_type
));
1262 printf (_(" Machine: %s\n"),
1263 get_machine_name (elf_header
.e_machine
));
1264 printf (_(" Version: 0x%lx\n"),
1265 (unsigned long) elf_header
.e_version
);
1266 printf (_(" Data: %s\n"),
1267 get_machine_data (elf_header
.e_ident
[EI_DATA
]));
1268 printf (_(" Entry point address: 0x%lx\n"),
1269 (unsigned long) elf_header
.e_entry
);
1270 printf (_(" Start of program headers: %ld (bytes into file)\n"),
1271 (long) elf_header
.e_phoff
);
1272 printf (_(" Start of section headers: %ld (bytes into file)\n"),
1273 (long) elf_header
.e_shoff
);
1274 printf (_(" Flags: 0x%lx%s\n"),
1275 (unsigned long) elf_header
.e_flags
,
1276 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
1277 printf (_(" Size of this header: %ld (bytes)\n"),
1278 (long) elf_header
.e_ehsize
);
1279 printf (_(" Size of program headers: %ld (bytes)\n"),
1280 (long) elf_header
.e_phentsize
);
1281 printf (_(" Number of program headers: %ld\n"),
1282 (long) elf_header
.e_phnum
);
1283 printf (_(" Size of section headers: %ld (bytes)\n"),
1284 (long) elf_header
.e_shentsize
);
1285 printf (_(" Number of section headers: %ld\n"),
1286 (long) elf_header
.e_shnum
);
1287 printf (_(" Section header string table index: %ld\n"),
1288 (long) elf_header
.e_shstrndx
);
1296 process_program_headers (file
)
1299 Elf32_External_Phdr
* phdrs
;
1300 Elf32_Internal_Phdr
* program_headers
;
1301 Elf32_Internal_Phdr
* segment
;
1304 if (elf_header
.e_phnum
== 0)
1307 printf (_("\nThere are no program headers in this file.\n"));
1311 if (do_segments
&& !do_header
)
1313 printf (_("\nElf file is %s\n"), get_file_type (elf_header
.e_type
));
1314 printf (_("Entry point 0x%lx\n"), (unsigned long) elf_header
.e_entry
);
1315 printf (_("There are %d program headers, starting at offset %lx:\n"),
1316 elf_header
.e_phnum
, (unsigned long) elf_header
.e_phoff
);
1319 GET_DATA_ALLOC (elf_header
.e_phoff
,
1320 elf_header
.e_phentsize
* elf_header
.e_phnum
,
1321 phdrs
, Elf32_External_Phdr
*, "program headers");
1323 program_headers
= (Elf32_Internal_Phdr
*) malloc
1324 (elf_header
.e_phnum
* sizeof (Elf32_Internal_Phdr
));
1326 if (program_headers
== NULL
)
1328 error (_("Out of memory\n"));
1332 for (i
= 0, segment
= program_headers
;
1333 i
< elf_header
.e_phnum
;
1336 segment
->p_type
= BYTE_GET (phdrs
[i
].p_type
);
1337 segment
->p_offset
= BYTE_GET (phdrs
[i
].p_offset
);
1338 segment
->p_vaddr
= BYTE_GET (phdrs
[i
].p_vaddr
);
1339 segment
->p_paddr
= BYTE_GET (phdrs
[i
].p_paddr
);
1340 segment
->p_filesz
= BYTE_GET (phdrs
[i
].p_filesz
);
1341 segment
->p_memsz
= BYTE_GET (phdrs
[i
].p_memsz
);
1342 segment
->p_flags
= BYTE_GET (phdrs
[i
].p_flags
);
1343 segment
->p_align
= BYTE_GET (phdrs
[i
].p_align
);
1351 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
1353 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
1359 for (i
= 0, segment
= program_headers
;
1360 i
< elf_header
.e_phnum
;
1365 printf (" %-11.11s ", get_segment_type (segment
->p_type
));
1366 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
1367 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
1368 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
1369 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
1370 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
1372 (segment
->p_flags
& PF_R
? 'R' : ' '),
1373 (segment
->p_flags
& PF_W
? 'W' : ' '),
1374 (segment
->p_flags
& PF_X
? 'E' : ' '));
1375 printf ("%#lx", (unsigned long) segment
->p_align
);
1378 switch (segment
->p_type
)
1382 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
1383 - (segment
->p_offset
& 0xfffff000);
1388 error (_("more than one dynamic segment\n"));
1390 dynamic_addr
= segment
->p_offset
;
1391 dynamic_size
= segment
->p_filesz
;
1395 if (fseek (file
, segment
->p_offset
, SEEK_SET
))
1396 error (_("Unable to find program interpreter name\n"));
1399 program_interpreter
[0] = 0;
1400 fscanf (file
, "%63s", program_interpreter
);
1403 printf (_("\n [Requesting program interpreter: %s]"),
1404 program_interpreter
);
1410 putc ('\n', stdout
);
1419 if (do_segments
&& section_headers
!= NULL
)
1421 printf (_("\n Section to Segment mapping:\n"));
1422 printf (_(" Segment Sections...\n"));
1424 assert (string_table
!= NULL
);
1426 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
1429 Elf32_Internal_Shdr
* section
;
1431 segment
= program_headers
+ i
;
1432 section
= section_headers
;
1434 printf (" %2.2d ", i
);
1436 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
1438 if (section
->sh_size
> 0
1439 /* Compare allocated sections by VMA, unallocated
1440 sections by file offset. */
1441 && (section
->sh_flags
& SHF_ALLOC
1442 ? (section
->sh_addr
>= segment
->p_vaddr
1443 && section
->sh_addr
+ section
->sh_size
1444 <= segment
->p_vaddr
+ segment
->p_memsz
)
1445 : (section
->sh_offset
>= segment
->p_offset
1446 && (section
->sh_offset
+ section
->sh_size
1447 <= segment
->p_offset
+ segment
->p_filesz
))))
1448 printf ("%s ", SECTION_NAME (section
));
1455 free (program_headers
);
1462 get_section_headers (file
)
1465 Elf32_External_Shdr
* shdrs
;
1466 Elf32_Internal_Shdr
* internal
;
1469 GET_DATA_ALLOC (elf_header
.e_shoff
,
1470 elf_header
.e_shentsize
* elf_header
.e_shnum
,
1471 shdrs
, Elf32_External_Shdr
*, "section headers");
1473 section_headers
= (Elf32_Internal_Shdr
*) malloc
1474 (elf_header
.e_shnum
* sizeof (Elf32_Internal_Shdr
));
1476 if (section_headers
== NULL
)
1478 error (_("Out of memory\n"));
1482 for (i
= 0, internal
= section_headers
;
1483 i
< elf_header
.e_shnum
;
1486 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
1487 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
1488 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
1489 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
1490 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
1491 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
1492 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
1493 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
1494 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
1495 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
1503 static Elf_Internal_Sym
*
1504 get_elf_symbols (file
, offset
, number
)
1506 unsigned long offset
;
1507 unsigned long number
;
1509 Elf32_External_Sym
* esyms
;
1510 Elf_Internal_Sym
* isyms
;
1511 Elf_Internal_Sym
* psym
;
1514 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
1515 esyms
, Elf32_External_Sym
*, "symbols");
1517 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
1521 error (_("Out of memory\n"));
1527 for (j
= 0, psym
= isyms
;
1531 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
1532 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
1533 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
1534 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
1535 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
1536 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
1545 process_section_headers (file
)
1548 Elf32_Internal_Shdr
* section
;
1551 section_headers
= NULL
;
1553 if (elf_header
.e_shnum
== 0)
1556 printf (_("\nThere are no sections in this file.\n"));
1561 if (do_sections
&& !do_header
)
1562 printf (_("There are %d section headers, starting at offset %x:\n"),
1563 elf_header
.e_shnum
, elf_header
.e_shoff
);
1565 if (! get_section_headers (file
))
1568 /* Read in the string table, so that we have names to display. */
1569 section
= section_headers
+ elf_header
.e_shstrndx
;
1571 if (section
->sh_size
!= 0)
1573 unsigned long string_table_offset
;
1575 string_table_offset
= section
->sh_offset
;
1577 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1578 string_table
, char *, "string table");
1581 /* Scan the sections for the dynamic symbol table
1582 and dynamic string table and debug sections. */
1583 dynamic_symbols
= NULL
;
1584 dynamic_strings
= NULL
;
1585 dynamic_syminfo
= NULL
;
1586 for (i
= 0, section
= section_headers
;
1587 i
< elf_header
.e_shnum
;
1590 char * name
= SECTION_NAME (section
);
1592 if (section
->sh_type
== SHT_DYNSYM
)
1594 if (dynamic_symbols
!= NULL
)
1596 error (_("File contains multiple dynamic symbol tables\n"));
1600 dynamic_symbols
= get_elf_symbols
1601 (file
, section
->sh_offset
,
1602 section
->sh_size
/ section
->sh_entsize
);
1604 else if (section
->sh_type
== SHT_STRTAB
1605 && strcmp (name
, ".dynstr") == 0)
1607 if (dynamic_strings
!= NULL
)
1609 error (_("File contains multiple dynamic string tables\n"));
1613 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1614 dynamic_strings
, char *, "dynamic strings");
1616 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
1617 || do_debug_lines
|| do_debug_pubnames
)
1618 && strncmp (name
, ".debug_", 7) == 0)
1623 || (do_debug_info
&& (strcmp (name
, "info") == 0))
1624 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
1625 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
1626 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
1628 dump_sects
[i
] |= DEBUG_DUMP
;
1635 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
1637 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
1639 for (i
= 0, section
= section_headers
;
1640 i
< elf_header
.e_shnum
;
1643 printf (" [%2d] %-17.17s %-15.15s ",
1645 SECTION_NAME (section
),
1646 get_section_type_name (section
->sh_type
));
1648 printf ( "%8.8lx %6.6lx %6.6lx %2.2lx",
1649 (unsigned long) section
->sh_addr
,
1650 (unsigned long) section
->sh_offset
,
1651 (unsigned long) section
->sh_size
,
1652 (unsigned long) section
->sh_entsize
);
1654 printf (" %c%c%c %2ld %3lx %ld\n",
1655 (section
->sh_flags
& SHF_WRITE
? 'W' : ' '),
1656 (section
->sh_flags
& SHF_ALLOC
? 'A' : ' '),
1657 (section
->sh_flags
& SHF_EXECINSTR
? 'X' : ' '),
1658 (unsigned long) section
->sh_link
,
1659 (unsigned long) section
->sh_info
,
1660 (unsigned long) section
->sh_addralign
);
1666 /* Process the reloc section. */
1668 process_relocs (file
)
1671 unsigned long rel_size
;
1672 unsigned long rel_offset
;
1678 if (do_using_dynamic
)
1683 if (dynamic_info
[DT_REL
])
1685 rel_offset
= dynamic_info
[DT_REL
];
1686 rel_size
= dynamic_info
[DT_RELSZ
];
1688 else if (dynamic_info
[DT_RELA
])
1690 rel_offset
= dynamic_info
[DT_RELA
];
1691 rel_size
= dynamic_info
[DT_RELASZ
];
1693 else if (dynamic_info
[DT_JMPREL
])
1695 rel_offset
= dynamic_info
[DT_JMPREL
];
1696 rel_size
= dynamic_info
[DT_PLTRELSZ
];
1702 (_("\nRelocation section at offset 0x%x contains %d bytes:\n"),
1703 rel_offset
, rel_size
);
1705 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
1706 dynamic_symbols
, dynamic_strings
);
1709 printf (_("\nThere are no dynamic relocations in this file.\n"));
1713 Elf32_Internal_Shdr
* section
;
1717 for (i
= 0, section
= section_headers
;
1718 i
< elf_header
.e_shnum
;
1721 if ( section
->sh_type
!= SHT_RELA
1722 && section
->sh_type
!= SHT_REL
)
1725 rel_offset
= section
->sh_offset
;
1726 rel_size
= section
->sh_size
;
1730 Elf32_Internal_Shdr
* strsec
;
1731 Elf32_Internal_Shdr
* symsec
;
1732 Elf_Internal_Sym
* symtab
;
1735 printf (_("\nRelocation section "));
1737 if (string_table
== NULL
)
1738 printf ("%d", section
->sh_name
);
1740 printf ("'%s'", SECTION_NAME (section
));
1742 printf (_(" at offset 0x%x contains %d entries:\n"),
1743 rel_offset
, rel_size
/ section
->sh_entsize
);
1745 symsec
= section_headers
+ section
->sh_link
;
1747 symtab
= get_elf_symbols (file
, symsec
->sh_offset
,
1748 symsec
->sh_size
/ symsec
->sh_entsize
);
1753 strsec
= section_headers
+ symsec
->sh_link
;
1755 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
1756 char *, "string table");
1758 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
);
1768 printf (_("\nThere are no relocations in this file.\n"));
1776 dynamic_segment_mips_val (entry
)
1777 Elf_Internal_Dyn
*entry
;
1780 switch (entry
->d_tag
)
1783 if (entry
->d_un
.d_val
== 0)
1787 static const char *opts
[] =
1789 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
1790 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
1791 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
1792 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
1797 for (cnt
= 0; cnt
< sizeof (opts
) / sizeof (opts
[0]); ++cnt
)
1798 if (entry
->d_un
.d_val
& (1 << cnt
))
1800 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
1807 case DT_MIPS_IVERSION
:
1808 if (dynamic_strings
!= NULL
)
1809 printf ("Interface Version: %s\n",
1810 dynamic_strings
+ entry
->d_un
.d_val
);
1812 printf ("%#ld\n", (long) entry
->d_un
.d_ptr
);
1815 case DT_MIPS_TIME_STAMP
:
1818 time_t time
= entry
->d_un
.d_val
;
1819 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
1820 printf ("Time Stamp: %s\n", timebuf
);
1824 case DT_MIPS_RLD_VERSION
:
1825 case DT_MIPS_LOCAL_GOTNO
:
1826 case DT_MIPS_CONFLICTNO
:
1827 case DT_MIPS_LIBLISTNO
:
1828 case DT_MIPS_SYMTABNO
:
1829 case DT_MIPS_UNREFEXTNO
:
1830 case DT_MIPS_HIPAGENO
:
1831 case DT_MIPS_DELTA_CLASS_NO
:
1832 case DT_MIPS_DELTA_INSTANCE_NO
:
1833 case DT_MIPS_DELTA_RELOC_NO
:
1834 case DT_MIPS_DELTA_SYM_NO
:
1835 case DT_MIPS_DELTA_CLASSSYM_NO
:
1836 case DT_MIPS_COMPACT_SIZE
:
1837 printf ("%#ld\n", (long) entry
->d_un
.d_ptr
);
1841 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
1845 /* Parse the dynamic segment */
1847 process_dynamic_segment (file
)
1850 Elf_Internal_Dyn
* entry
;
1851 Elf32_External_Dyn
* edyn
;
1854 if (dynamic_size
== 0)
1857 printf (_("\nThere is no dynamic segment in this file.\n"));
1862 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
1863 edyn
, Elf32_External_Dyn
*, "dynamic segment");
1865 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
1866 how large .dynamic is now. We can do this even before the byte
1867 swapping since the DT_NULL tag is recognizable. */
1869 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
1872 dynamic_segment
= (Elf_Internal_Dyn
*)
1873 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
1875 if (dynamic_segment
== NULL
)
1877 error (_("Out of memory\n"));
1882 for (i
= 0, entry
= dynamic_segment
;
1886 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
1887 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
1892 /* Find the appropriate symbol table. */
1893 if (dynamic_symbols
== NULL
)
1895 for (i
= 0, entry
= dynamic_segment
;
1899 unsigned long offset
;
1902 if (entry
->d_tag
!= DT_SYMTAB
)
1905 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
1907 /* Since we do not know how big the symbol table is,
1908 we default to reading in the entire file (!) and
1909 processing that. This is overkill, I know, but it
1912 offset
= entry
->d_un
.d_val
- loadaddr
;
1914 if (fseek (file
, 0, SEEK_END
))
1915 error (_("Unable to seek to end of file!"));
1917 num_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
1921 error (_("Unable to determine the number of symbols to load\n"));
1925 dynamic_symbols
= get_elf_symbols (file
, offset
, num_syms
);
1929 /* Similarly find a string table. */
1930 if (dynamic_strings
== NULL
)
1932 for (i
= 0, entry
= dynamic_segment
;
1936 unsigned long offset
;
1939 if (entry
->d_tag
!= DT_STRTAB
)
1942 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
1944 /* Since we do not know how big the string table is,
1945 we default to reading in the entire file (!) and
1946 processing that. This is overkill, I know, but it
1949 offset
= entry
->d_un
.d_val
- loadaddr
;
1950 if (fseek (file
, 0, SEEK_END
))
1951 error (_("Unable to seek to end of file\n"));
1952 str_tab_len
= ftell (file
) - offset
;
1954 if (str_tab_len
< 1)
1957 (_("Unable to determine the length of the dynamic string table\n"));
1961 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
1962 "dynamic string table");
1968 /* And find the syminfo section if available. */
1969 if (dynamic_syminfo
== NULL
)
1971 unsigned int syminsz
= 0;
1973 for (i
= 0, entry
= dynamic_segment
;
1977 if (entry
->d_tag
== DT_SYMINENT
)
1978 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
1979 else if (entry
->d_tag
== DT_SYMINSZ
)
1980 syminsz
= entry
->d_un
.d_val
;
1981 else if (entry
->d_tag
== DT_SYMINFO
)
1982 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
1985 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
1987 Elf_External_Syminfo
*extsyminfo
;
1988 Elf_Internal_Syminfo
*syminfo
;
1990 /* There is a syminfo section. Read the data. */
1991 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
1992 Elf_External_Syminfo
*, "symbol information");
1994 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
1995 if (dynamic_syminfo
== NULL
)
1997 error (_("Out of memory\n"));
2001 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
2002 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
2005 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
2006 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
2013 if (do_dynamic
&& dynamic_addr
)
2014 printf (_("\nDynamic segment at offset 0x%x contains %d entries:\n"),
2015 dynamic_addr
, dynamic_size
);
2017 printf (_(" Tag Type Name/Value\n"));
2019 for (i
= 0, entry
= dynamic_segment
;
2024 printf (_(" 0x%-8.8lx (%s)%*s"),
2025 (unsigned long) entry
->d_tag
,
2026 get_dynamic_type (entry
->d_tag
),
2027 27 - strlen (get_dynamic_type (entry
->d_tag
)),
2030 switch (entry
->d_tag
)
2036 if (entry
->d_tag
== DT_AUXILIARY
)
2037 printf (_("Auxiliary library"));
2039 printf (_("Filter library"));
2041 if (dynamic_strings
)
2042 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
2044 printf (": %#lx\n", (long) entry
->d_un
.d_val
);
2051 printf (_("Flags:"));
2052 if (entry
->d_un
.d_val
== 0)
2053 printf (_(" None\n"));
2056 if (entry
->d_un
.d_val
& DF_P1_LAZYLOAD
)
2057 printf (" LAZYLOAD");
2058 if (entry
->d_un
.d_val
& DF_P1_LAZYLOAD
)
2059 printf (" GROUPPERM");
2068 printf (_("Flags:"));
2069 if (entry
->d_un
.d_val
== 0)
2070 printf (_(" None\n"));
2073 if (entry
->d_un
.d_val
& DF_1_NOW
)
2075 if (entry
->d_un
.d_val
& DF_1_GLOBAL
)
2077 if (entry
->d_un
.d_val
& DF_1_GROUP
)
2079 if (entry
->d_un
.d_val
& DF_1_NODELETE
)
2080 printf (" NODELETE");
2081 if (entry
->d_un
.d_val
& DF_1_LOADFLTR
)
2082 printf (" LOADFLTR");
2083 if (entry
->d_un
.d_val
& DF_1_INITFIRST
)
2084 printf (" INITFIRST");
2085 if (entry
->d_un
.d_val
& DF_1_NOOPEN
)
2087 if (entry
->d_un
.d_val
& DF_1_ORIGIN
)
2089 if (entry
->d_un
.d_val
& DF_1_DIRECT
)
2091 if (entry
->d_un
.d_val
& DF_1_TRANS
)
2093 if (entry
->d_un
.d_val
& DF_1_INTERPOSE
)
2094 printf (" INTERPOSE");
2101 puts (get_dynamic_type (entry
->d_un
.d_val
));
2120 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
2126 if (dynamic_strings
== NULL
)
2129 name
= dynamic_strings
+ entry
->d_un
.d_val
;
2133 switch (entry
->d_tag
)
2136 printf (_("Shared library: [%s]"), name
);
2138 if (strcmp (name
, program_interpreter
))
2141 printf (_(" program interpreter\n"));
2145 printf (_("Library soname: [%s]\n"), name
);
2149 printf (_("Library rpath: [%s]\n"), name
);
2153 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2157 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2169 printf ("%ld (bytes)\n", entry
->d_un
.d_val
);
2177 printf ("%ld\n", entry
->d_un
.d_val
);
2188 if (dynamic_strings
== NULL
)
2191 name
= dynamic_strings
+ entry
->d_un
.d_val
;
2197 switch (entry
->d_tag
)
2200 printf (_("Not needed object: [%s]\n"), name
);
2204 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2208 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2213 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
2215 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
2219 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2222 switch (elf_header
.e_machine
)
2225 case EM_MIPS_RS4_BE
:
2226 dynamic_segment_mips_val (entry
);
2230 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2240 get_ver_flags (flags
)
2243 static char buff
[32];
2250 if (flags
& VER_FLG_BASE
)
2251 strcat (buff
, "BASE ");
2253 if (flags
& VER_FLG_WEAK
)
2255 if (flags
& VER_FLG_BASE
)
2256 strcat (buff
, "| ");
2258 strcat (buff
, "WEAK ");
2261 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
2262 strcat (buff
, "| <unknown>");
2267 /* Display the contents of the version sections. */
2269 process_version_sections (file
)
2272 Elf32_Internal_Shdr
* section
;
2279 for (i
= 0, section
= section_headers
;
2280 i
< elf_header
.e_shnum
;
2283 switch (section
->sh_type
)
2285 case SHT_GNU_verdef
:
2287 Elf_External_Verdef
* edefs
;
2294 (_("\nVersion definition section '%s' contains %d entries:\n"),
2295 SECTION_NAME (section
), section
->sh_info
);
2297 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2298 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2299 SECTION_NAME (section_headers
+ section
->sh_link
));
2301 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2302 edefs
, Elf_External_Verdef
*,
2303 "version definition section");
2305 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
2308 Elf_External_Verdef
* edef
;
2309 Elf_Internal_Verdef ent
;
2310 Elf_External_Verdaux
* eaux
;
2311 Elf_Internal_Verdaux aux
;
2315 vstart
= ((char *) edefs
) + idx
;
2317 edef
= (Elf_External_Verdef
*) vstart
;
2319 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
2320 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
2321 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
2322 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
2323 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
2324 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
2325 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
2327 printf (_(" %#06x: Rev: %d Flags: %s"),
2328 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
2330 printf (_(" Index: %ld Cnt: %ld "),
2331 ent
.vd_ndx
, ent
.vd_cnt
);
2333 vstart
+= ent
.vd_aux
;
2335 eaux
= (Elf_External_Verdaux
*) vstart
;
2337 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2338 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2340 if (dynamic_strings
)
2341 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
2343 printf (_("Name index: %ld\n"), aux
.vda_name
);
2345 isum
= idx
+ ent
.vd_aux
;
2347 for (j
= 1; j
< ent
.vd_cnt
; j
++)
2349 isum
+= aux
.vda_next
;
2350 vstart
+= aux
.vda_next
;
2352 eaux
= (Elf_External_Verdaux
*) vstart
;
2354 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2355 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2357 if (dynamic_strings
)
2358 printf (_(" %#06x: Parent %d: %s\n"),
2359 isum
, j
, dynamic_strings
+ aux
.vda_name
);
2361 printf (_(" %#06x: Parent %d, name index: %ld\n"),
2362 isum
, j
, aux
.vda_name
);
2372 case SHT_GNU_verneed
:
2374 Elf_External_Verneed
* eneed
;
2380 printf (_("\nVersion needs section '%s' contains %d entries:\n"),
2381 SECTION_NAME (section
), section
->sh_info
);
2384 (_(" Addr: %#08x Offset: %#08x Link to section: %d (%s)\n"),
2385 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2386 SECTION_NAME (section_headers
+ section
->sh_link
));
2388 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2389 eneed
, Elf_External_Verneed
*,
2390 "version need section");
2392 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
2394 Elf_External_Verneed
* entry
;
2395 Elf_Internal_Verneed ent
;
2400 vstart
= ((char *) eneed
) + idx
;
2402 entry
= (Elf_External_Verneed
*) vstart
;
2404 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
2405 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
2406 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
2407 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
2408 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
2410 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
2412 if (dynamic_strings
)
2413 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
2415 printf (_(" File: %lx"), ent
.vn_file
);
2417 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
2419 vstart
+= ent
.vn_aux
;
2421 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
2423 Elf_External_Vernaux
* eaux
;
2424 Elf_Internal_Vernaux aux
;
2426 eaux
= (Elf_External_Vernaux
*) vstart
;
2428 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
2429 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
2430 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
2431 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
2432 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
2434 if (dynamic_strings
)
2435 printf (_(" %#06x: Name: %s"),
2436 isum
, dynamic_strings
+ aux
.vna_name
);
2438 printf (_(" %#06x: Name index: %lx"),
2439 isum
, aux
.vna_name
);
2441 printf (_(" Flags: %s Version: %d\n"),
2442 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
2444 isum
+= aux
.vna_next
;
2445 vstart
+= aux
.vna_next
;
2455 case SHT_GNU_versym
:
2457 Elf32_Internal_Shdr
* link_section
;
2460 unsigned char * edata
;
2461 unsigned short * data
;
2463 Elf_Internal_Sym
* symbols
;
2464 Elf32_Internal_Shdr
* string_sec
;
2466 link_section
= section_headers
+ section
->sh_link
;
2467 total
= section
->sh_size
/ section
->sh_entsize
;
2471 symbols
= get_elf_symbols
2472 (file
, link_section
->sh_offset
,
2473 link_section
->sh_size
/ link_section
->sh_entsize
);
2475 string_sec
= section_headers
+ link_section
->sh_link
;
2477 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
2478 strtab
, char *, "version string table");
2480 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
2481 SECTION_NAME (section
), total
);
2483 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2484 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2485 SECTION_NAME (link_section
));
2487 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
2489 total
* sizeof (short), edata
,
2490 char *, "version symbol data");
2492 data
= (unsigned short *) malloc (total
* sizeof (short));
2494 for (cnt
= total
; cnt
--;)
2495 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
2500 for (cnt
= 0; cnt
< total
; cnt
+= 4)
2504 printf (" %03x:", cnt
);
2506 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
2507 switch (data
[cnt
+ j
])
2510 fputs (_(" 0 (*local*) "), stdout
);
2514 fputs (_(" 1 (*global*) "), stdout
);
2518 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
2519 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
2521 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
2522 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
2525 /* We must test both. */
2526 Elf_Internal_Verneed ivn
;
2527 unsigned long offset
;
2529 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2534 Elf_External_Verneed evn
;
2535 Elf_External_Vernaux evna
;
2536 Elf_Internal_Vernaux ivna
;
2537 unsigned long vna_off
;
2539 GET_DATA (offset
, evn
, "version need");
2541 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2542 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2544 vna_off
= offset
+ ivn
.vn_aux
;
2548 GET_DATA (vna_off
, evna
,
2549 "version need aux (1)");
2551 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2552 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2554 vna_off
+= ivna
.vna_next
;
2556 while (ivna
.vna_other
!= data
[cnt
+ j
]
2557 && ivna
.vna_next
!= 0);
2559 if (ivna
.vna_other
== data
[cnt
+ j
])
2561 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2563 nn
+= printf ("(%s%-*s",
2564 strtab
+ ivna
.vna_name
,
2570 else if (ivn
.vn_next
== 0)
2572 if (data
[cnt
+ j
] != 0x8001)
2574 Elf_Internal_Verdef ivd
;
2575 Elf_External_Verdef evd
;
2577 offset
= version_info
2578 [DT_VERSIONTAGIDX (DT_VERDEF
)]
2583 GET_DATA (offset
, evd
,
2584 "version definition");
2586 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2587 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2589 offset
+= ivd
.vd_next
;
2592 != (data
[cnt
+ j
] & 0x7fff)
2593 && ivd
.vd_next
!= 0);
2596 == (data
[cnt
+ j
] & 0x7fff))
2598 Elf_External_Verdaux evda
;
2599 Elf_Internal_Verdaux ivda
;
2601 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2603 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
2604 "version definition aux");
2607 BYTE_GET (evda
.vda_name
);
2611 strtab
+ ivda
.vda_name
,
2622 offset
+= ivn
.vn_next
;
2624 while (ivn
.vn_next
);
2626 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
2628 Elf_Internal_Verneed ivn
;
2629 unsigned long offset
;
2631 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2636 Elf_Internal_Vernaux ivna
;
2637 Elf_External_Verneed evn
;
2638 Elf_External_Vernaux evna
;
2639 unsigned long a_off
;
2641 GET_DATA (offset
, evn
, "version need");
2643 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2644 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2646 a_off
= offset
+ ivn
.vn_aux
;
2650 GET_DATA (a_off
, evna
,
2651 "version need aux (2)");
2653 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2654 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2656 a_off
+= ivna
.vna_next
;
2658 while (ivna
.vna_other
!= data
[cnt
+ j
]
2659 && ivna
.vna_next
!= 0);
2661 if (ivna
.vna_other
== data
[cnt
+ j
])
2663 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2665 nn
+= printf ("(%s%-*s",
2666 strtab
+ ivna
.vna_name
,
2673 offset
+= ivn
.vn_next
;
2675 while (ivn
.vn_next
);
2677 else if (data
[cnt
+ j
] != 0x8001)
2679 Elf_Internal_Verdef ivd
;
2680 Elf_External_Verdef evd
;
2681 unsigned long offset
;
2683 offset
= version_info
2684 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
2688 GET_DATA (offset
, evd
, "version def");
2690 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2691 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2693 offset
+= ivd
.vd_next
;
2695 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
2696 && ivd
.vd_next
!= 0);
2698 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
2700 Elf_External_Verdaux evda
;
2701 Elf_Internal_Verdaux ivda
;
2703 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2705 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
2706 evda
, "version def aux");
2708 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
2710 nn
+= printf ("(%s%-*s",
2711 strtab
+ ivda
.vda_name
,
2719 printf ("%*c", 18 - nn
, ' ');
2737 printf (_("\nNo version information found in this file.\n"));
2743 get_symbol_binding (binding
)
2744 unsigned int binding
;
2746 static char buff
[32];
2750 case STB_LOCAL
: return _("LOCAL");
2751 case STB_GLOBAL
: return _("GLOBAL");
2752 case STB_WEAK
: return _("WEAK");
2754 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
2755 sprintf (buff
, _("<processor specific>: %d"), binding
);
2757 sprintf (buff
, _("<unknown>: %d"), binding
);
2763 get_symbol_type (type
)
2766 static char buff
[32];
2770 case STT_NOTYPE
: return _("NOTYPE");
2771 case STT_OBJECT
: return _("OBJECT");
2772 case STT_FUNC
: return _("FUNC");
2773 case STT_SECTION
: return _("SECTION");
2774 case STT_FILE
: return _("FILE");
2776 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
2777 sprintf (buff
, _("<processor specific>: %d"), type
);
2779 sprintf (buff
, _("<unknown>: %d"), type
);
2785 get_symbol_index_type (type
)
2790 case SHN_UNDEF
: return "UND";
2791 case SHN_ABS
: return "ABS";
2792 case SHN_COMMON
: return "COM";
2794 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
2796 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
2800 static char buff
[32];
2802 sprintf (buff
, "%3d", type
);
2810 get_dynamic_data (file
, number
)
2812 unsigned int number
;
2817 e_data
= (char *) malloc (number
* 4);
2821 error (_("Out of memory\n"));
2825 if (fread (e_data
, 4, number
, file
) != number
)
2827 error (_("Unable to read in dynamic data\n"));
2831 i_data
= (int *) malloc (number
* sizeof (* i_data
));
2835 error (_("Out of memory\n"));
2841 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
2848 /* Dump the symbol table */
2850 process_symbol_table (file
)
2853 Elf32_Internal_Shdr
* section
;
2858 int * buckets
= NULL
;
2859 int * chains
= NULL
;
2861 if (! do_syms
&& !do_histogram
)
2864 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
2867 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
2869 error (_("Unable to seek to start of dynamic information"));
2873 if (fread (& nb
, sizeof (nb
), 1, file
) != 1)
2875 error (_("Failed to read in number of buckets\n"));
2879 if (fread (& nc
, sizeof (nc
), 1, file
) != 1)
2881 error (_("Failed to read in number of chains\n"));
2885 nbuckets
= byte_get (nb
, 4);
2886 nchains
= byte_get (nc
, 4);
2888 buckets
= get_dynamic_data (file
, nbuckets
);
2889 chains
= get_dynamic_data (file
, nchains
);
2891 if (buckets
== NULL
|| chains
== NULL
)
2896 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
2901 printf (_("\nSymbol table for image:\n"));
2902 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
2904 for (hn
= 0; hn
< nbuckets
; hn
++)
2909 for (si
= buckets
[hn
]; si
; si
= chains
[si
])
2911 Elf_Internal_Sym
* psym
;
2913 psym
= dynamic_symbols
+ si
;
2915 printf (" %3d %3d: %8lx %5ld %6s %6s %2d ",
2917 (unsigned long) psym
->st_value
,
2918 (unsigned long) psym
->st_size
,
2919 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
2920 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
2923 printf ("%3.3s", get_symbol_index_type (psym
->st_shndx
));
2925 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
2929 else if (do_syms
&& !do_using_dynamic
)
2933 for (i
= 0, section
= section_headers
;
2934 i
< elf_header
.e_shnum
;
2939 Elf_Internal_Sym
* symtab
;
2940 Elf_Internal_Sym
* psym
;
2943 if ( section
->sh_type
!= SHT_SYMTAB
2944 && section
->sh_type
!= SHT_DYNSYM
)
2947 printf (_("\nSymbol table '%s' contains %d entries:\n"),
2948 SECTION_NAME (section
),
2949 section
->sh_size
/ section
->sh_entsize
);
2950 fputs (_(" Num: Value Size Type Bind Ot Ndx Name\n"),
2953 symtab
= get_elf_symbols (file
, section
->sh_offset
,
2954 section
->sh_size
/ section
->sh_entsize
);
2958 if (section
->sh_link
== elf_header
.e_shstrndx
)
2959 strtab
= string_table
;
2962 Elf32_Internal_Shdr
* string_sec
;
2964 string_sec
= section_headers
+ section
->sh_link
;
2966 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
2967 strtab
, char *, "string table");
2970 for (si
= 0, psym
= symtab
;
2971 si
< section
->sh_size
/ section
->sh_entsize
;
2974 printf (" %3d: %8lx %5ld %-7s %-6s %2d ",
2976 (unsigned long) psym
->st_value
,
2977 (unsigned long) psym
->st_size
,
2978 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
2979 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
2982 if (psym
->st_shndx
== 0)
2983 fputs (" UND", stdout
);
2984 else if ((psym
->st_shndx
& 0xffff) == 0xfff1)
2985 fputs (" ABS", stdout
);
2986 else if ((psym
->st_shndx
& 0xffff) == 0xfff2)
2987 fputs (" COM", stdout
);
2989 printf ("%4x", psym
->st_shndx
);
2991 printf (" %s", strtab
+ psym
->st_name
);
2993 if (section
->sh_type
== SHT_DYNSYM
&&
2994 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
2996 unsigned char data
[2];
2997 unsigned short vers_data
;
2998 unsigned long offset
;
3002 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3005 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
3008 vers_data
= byte_get (data
, 2);
3010 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
3011 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
3014 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
3016 if ((vers_data
& 0x8000) || vers_data
> 1)
3018 if (is_nobits
|| ! check_def
)
3020 Elf_External_Verneed evn
;
3021 Elf_Internal_Verneed ivn
;
3022 Elf_Internal_Vernaux ivna
;
3024 /* We must test both. */
3025 offset
= version_info
3026 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
3028 GET_DATA (offset
, evn
, "version need");
3030 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3031 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3035 unsigned long vna_off
;
3037 vna_off
= offset
+ ivn
.vn_aux
;
3041 Elf_External_Vernaux evna
;
3043 GET_DATA (vna_off
, evna
,
3044 "version need aux (3)");
3046 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3047 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3048 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3050 vna_off
+= ivna
.vna_next
;
3052 while (ivna
.vna_other
!= vers_data
3053 && ivna
.vna_next
!= 0);
3055 if (ivna
.vna_other
== vers_data
)
3058 offset
+= ivn
.vn_next
;
3060 while (ivn
.vn_next
!= 0);
3062 if (ivna
.vna_other
== vers_data
)
3065 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
3068 else if (! is_nobits
)
3069 error (_("bad dynamic symbol"));
3076 if (vers_data
!= 0x8001)
3078 Elf_Internal_Verdef ivd
;
3079 Elf_Internal_Verdaux ivda
;
3080 Elf_External_Verdaux evda
;
3081 unsigned long offset
;
3084 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
3089 Elf_External_Verdef evd
;
3091 GET_DATA (offset
, evd
, "version def");
3093 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3094 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3095 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3097 offset
+= ivd
.vd_next
;
3099 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
3100 && ivd
.vd_next
!= 0);
3102 offset
-= ivd
.vd_next
;
3103 offset
+= ivd
.vd_aux
;
3105 GET_DATA (offset
, evda
, "version def aux");
3107 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
3109 if (psym
->st_name
!= ivda
.vda_name
)
3110 printf ((vers_data
& 0x8000)
3112 strtab
+ ivda
.vda_name
);
3122 if (strtab
!= string_table
)
3128 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
3130 if (do_histogram
&& buckets
!= NULL
)
3137 int nzero_counts
= 0;
3140 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
3142 printf (_(" Length Number %% of total Coverage\n"));
3144 lengths
= (int *) calloc (nbuckets
, sizeof (int));
3145 if (lengths
== NULL
)
3147 error (_("Out of memory"));
3150 for (hn
= 0; hn
< nbuckets
; ++hn
)
3155 for (si
= buckets
[hn
]; si
; si
= chains
[si
])
3158 if (maxlength
< ++lengths
[hn
])
3163 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
3166 error (_("Out of memory"));
3170 for (hn
= 0; hn
< nbuckets
; ++hn
)
3171 ++counts
[lengths
[hn
]];
3173 printf (" 0 %-10d (%5.1f%%)\n",
3174 counts
[0], (counts
[0] * 100.0) / nbuckets
);
3175 for (si
= 1; si
<= maxlength
; ++si
)
3177 nzero_counts
+= counts
[si
] * si
;
3178 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
3179 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
3180 (nzero_counts
* 100.0) / nsyms
);
3187 if (buckets
!= NULL
)
3197 process_syminfo (file
)
3202 if (dynamic_syminfo
== NULL
3204 /* No syminfo, this is ok. */
3207 /* There better should be a dynamic symbol section. */
3208 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
3212 printf (_("\nDynamic info segment at offset 0x%x contains %d entries:\n"),
3213 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
3215 printf (_(" Num: Name BoundTo Flags\n"));
3216 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
3218 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
3220 printf ("%4d: %-30s ", i
,
3221 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
3223 switch (dynamic_syminfo
[i
].si_boundto
)
3225 case SYMINFO_BT_SELF
:
3226 fputs ("SELF ", stdout
);
3228 case SYMINFO_BT_PARENT
:
3229 fputs ("PARENT ", stdout
);
3232 if (dynamic_syminfo
[i
].si_boundto
> 0
3233 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
3236 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
3238 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
3242 if (flags
& SYMINFO_FLG_DIRECT
)
3244 if (flags
& SYMINFO_FLG_PASSTHRU
)
3245 printf (" PASSTHRU");
3246 if (flags
& SYMINFO_FLG_COPY
)
3248 if (flags
& SYMINFO_FLG_LAZYLOAD
)
3249 printf (" LAZYLOAD");
3257 #ifdef SUPPORT_DISASSEMBLY
3259 disassemble_section (section
, file
)
3260 Elf32_Internal_Shdr
* section
;
3263 printf (_("\nAssembly dump of section %s\n"),
3264 SECTION_NAME (section
));
3266 /* XXX -- to be done --- XXX */
3273 dump_section (section
, file
)
3274 Elf32_Internal_Shdr
* section
;
3279 unsigned char * data
;
3282 bytes
= section
->sh_size
;
3286 printf (_("\nSection '%s' has no data to dump.\n"),
3287 SECTION_NAME (section
));
3291 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
3293 addr
= section
->sh_addr
;
3295 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, char *,
3306 lbytes
= (bytes
> 16 ? 16 : bytes
);
3308 printf (" 0x%8.8x ", addr
);
3310 switch (elf_header
.e_ident
[EI_DATA
])
3313 for (j
= 15; j
>= 0; j
--)
3316 printf ("%2.2x", data
[j
]);
3326 for (j
= 0; j
< 16; j
++)
3329 printf ("%2.2x", data
[j
]);
3339 for (j
= 0; j
< lbytes
; j
++)
3342 if (k
>= ' ' && k
< 0x80)
3361 static unsigned long int
3362 read_leb128 (data
, length_return
, sign
)
3363 unsigned char * data
;
3364 int * length_return
;
3367 unsigned long int result
= 0;
3368 unsigned int num_read
= 0;
3377 result
|= (byte
& 0x7f) << shift
;
3382 while (byte
& 0x80);
3384 * length_return
= num_read
;
3386 if (sign
&& (shift
< 32) && (byte
& 0x40))
3387 result
|= -1 << shift
;
3394 process_extended_line_op (data
, address
)
3395 unsigned char * data
;
3398 unsigned char op_code
;
3401 unsigned char * orig_data
= data
;
3403 length
= read_leb128 (data
, & bytes_read
, 0);
3405 length
+= bytes_read
;
3407 op_code
= * data
++;
3411 case DW_LNE_end_sequence
:
3412 printf (_(" End Sequence\n\n"));
3415 case DW_LNE_set_address
:
3416 /* XXX - assumption here that address size is 4! */
3417 * address
= byte_get (data
, 4);
3418 printf (_(" Set Address to %lx\n"), * address
);
3421 case DW_LNE_define_file
:
3422 printf (_(" Define File: %s"), data
);
3423 data
+= strlen (data
) + 1;
3424 printf (_(" Dir: %d"), read_leb128 (data
, & bytes_read
, 0));
3426 printf (_(" Time: %d"), read_leb128 (data
, & bytes_read
, 0));
3428 printf (_(" Size: %d"), read_leb128 (data
, & bytes_read
, 0));
3432 warn (_("Unknown extended line op: %d of length %d\n"),
3433 op_code
, length
- bytes_read
);
3442 display_debug_lines (section
, start
, file
)
3443 Elf32_Internal_Shdr
* section
;
3444 unsigned char * start
;
3447 DWARF2_External_LineInfo
* external
;
3448 DWARF2_Internal_LineInfo info
;
3449 unsigned char * standard_opcodes
;
3451 unsigned char * data
= start
;
3452 unsigned char * end
= start
+ section
->sh_size
;
3453 unsigned long address
;
3458 printf (_("\nDump of debug contents of section %s:\n\n"),
3459 SECTION_NAME (section
));
3461 external
= (DWARF2_External_LineInfo
*) start
;
3463 /* Check the length of the block. */
3464 info
.li_length
= BYTE_GET (external
->li_length
);
3465 if (info
.li_length
> section
->sh_size
)
3468 (_("The line info appears to be corrupt - the section is too small\n"));
3472 /* Check its version number. */
3473 info
.li_version
= BYTE_GET (external
->li_version
);
3474 if (info
.li_version
!= 2)
3476 warn (_("Only DWARF version 2 line info is currently supported.\n"));
3480 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
3481 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
3482 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
3483 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
3484 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
3485 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
3487 /* Sign extend the line base field. */
3488 info
.li_line_base
<<= 24;
3489 info
.li_line_base
>>= 24;
3491 printf (_(" Length: %d\n"), info
.li_length
);
3492 printf (_(" DWARF Version: %d\n"), info
.li_version
);
3493 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
3494 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
3495 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
3496 printf (_(" Line Base: %d\n"), info
.li_line_base
);
3497 printf (_(" Line Range: %d\n"), info
.li_line_range
);
3498 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
3500 /* Display the contents of the Opcodes table. */
3501 standard_opcodes
= start
+ sizeof (* external
);
3503 printf (_("\n Opcodes:\n"));
3505 for (i
= 1; i
< info
.li_opcode_base
; i
++)
3506 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
]);
3509 /* Display the contents of the Directory table. */
3510 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
3513 printf (_("\n The Directory Table is empty\n"));
3516 printf (_("\n The Directory Table:\n"));
3520 printf (_(" %s\n"), data
);
3522 data
+= strlen (data
) + 1;
3526 /* Skip the NUL at the end of the table. */
3529 /* Display the contents of the File Name table. */
3531 printf (_("\n The File Name Table is empty\n"));
3534 printf (_("\n The File Name Table:\n"));
3535 printf (_(" Name\t\tDir\tTime\tSize\n"));
3541 printf (_(" %s"), data
);
3543 data
+= strlen (data
) + 1;
3545 printf (_("\t%lu"), read_leb128 (data
, & bytes_read
, 0));
3547 printf (_("\t%lu"), read_leb128 (data
, & bytes_read
, 0));
3549 printf (_("\t%lu\n"), read_leb128 (data
, & bytes_read
, 0));
3554 /* Skip the NUL at the end of the table. */
3557 /* Now display the statements: */
3558 printf (_("\n Line Number Statements:\n"));
3562 is_stmt
= info
.li_default_is_stmt
;
3566 unsigned char op_code
;
3570 op_code
= * data
++;
3574 case DW_LNS_extended_op
:
3575 data
+= process_extended_line_op (data
, & address
);
3579 printf (_(" Copy\n"));
3582 case DW_LNS_advance_pc
:
3583 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
3586 printf (_(" Advance PC by %x to %x\n"), adv
, address
);
3589 case DW_LNS_advance_line
:
3590 adv
= read_leb128 (data
, & bytes_read
, 0);
3593 printf (_(" Advance Line by %d to %d\n"), adv
, line
);
3596 case DW_LNS_set_file
:
3597 adv
= read_leb128 (data
, & bytes_read
, 0);
3599 printf (_(" Set File Name to entry %d in the File Name Table\n"),
3603 case DW_LNS_set_column
:
3604 adv
= read_leb128 (data
, & bytes_read
, 0);
3606 printf (_(" Set column to %d\n"), adv
);
3609 case DW_LNS_negate_stmt
:
3610 printf (_(" Set is_stmt to %d\n"), is_stmt
);
3613 case DW_LNS_set_basic_block
:
3614 printf (_(" Set basic block\n"));
3617 case DW_LNS_const_add_pc
:
3618 adv
= (255 - info
.li_opcode_base
) / info
.li_line_range
;
3620 printf (_(" Advance PC by constant %d to %x\n"), adv
, address
);
3623 case DW_LNS_fixed_advance_pc
:
3624 adv
= byte_get (data
, 2);
3627 printf (_(" Advance PC by fixed size amount %d to %x\n"),
3632 op_code
-= info
.li_opcode_base
;
3633 address
+= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
,
3634 line
+= (op_code
% info
.li_line_range
) + info
.li_line_base
;
3636 (_(" Increase by %d, setting address to %lx and line to %d:\n"),
3637 op_code
, address
, line
);
3646 display_debug_pubnames (section
, start
, file
)
3647 Elf32_Internal_Shdr
* section
;
3648 unsigned char * start
;
3651 DWARF2_External_PubNames
* external
;
3652 DWARF2_Internal_PubNames pubnames
;
3653 unsigned char * end
;
3655 end
= start
+ section
->sh_size
;
3657 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
3661 unsigned char * data
;
3662 unsigned long offset
;
3664 external
= (DWARF2_External_PubNames
*) start
;
3666 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
3667 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
3668 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
3669 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
3671 data
= start
+ sizeof (* external
);
3672 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
3674 if (pubnames
.pn_version
!= 2)
3676 warn (_("Only DWARF 2 pubnames are currently supported"));
3680 printf (_(" Length: %d\n"),
3681 pubnames
.pn_length
);
3682 printf (_(" Version: %d\n"),
3683 pubnames
.pn_version
);
3684 printf (_(" Offset into .debug_info section: %d\n"),
3685 pubnames
.pn_offset
);
3686 printf (_(" Size of area in .debug_info section: %d\n"),
3689 printf (_("\n Offset\tName\n"));
3693 offset
= byte_get (data
, 4);
3698 printf (" %d\t\t%s\n", offset
, data
);
3699 data
+= strlen (data
) + 1;
3702 while (offset
!= 0);
3714 case DW_TAG_padding
: return "DW_TAG_padding";
3715 case DW_TAG_array_type
: return "DW_TAG_array_type";
3716 case DW_TAG_class_type
: return "DW_TAG_class_type";
3717 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
3718 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
3719 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
3720 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
3721 case DW_TAG_label
: return "DW_TAG_label";
3722 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
3723 case DW_TAG_member
: return "DW_TAG_member";
3724 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
3725 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
3726 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
3727 case DW_TAG_string_type
: return "DW_TAG_string_type";
3728 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
3729 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
3730 case DW_TAG_typedef
: return "DW_TAG_typedef";
3731 case DW_TAG_union_type
: return "DW_TAG_union_type";
3732 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
3733 case DW_TAG_variant
: return "DW_TAG_variant";
3734 case DW_TAG_common_block
: return "DW_TAG_common_block";
3735 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
3736 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
3737 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
3738 case DW_TAG_module
: return "DW_TAG_module";
3739 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
3740 case DW_TAG_set_type
: return "DW_TAG_set_type";
3741 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
3742 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
3743 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
3744 case DW_TAG_base_type
: return "DW_TAG_base_type";
3745 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
3746 case DW_TAG_const_type
: return "DW_TAG_const_type";
3747 case DW_TAG_constant
: return "DW_TAG_constant";
3748 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
3749 case DW_TAG_file_type
: return "DW_TAG_file_type";
3750 case DW_TAG_friend
: return "DW_TAG_friend";
3751 case DW_TAG_namelist
: return "DW_TAG_namelist";
3752 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
3753 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
3754 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
3755 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
3756 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
3757 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
3758 case DW_TAG_try_block
: return "DW_TAG_try_block";
3759 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
3760 case DW_TAG_variable
: return "DW_TAG_variable";
3761 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
3762 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
3763 case DW_TAG_format_label
: return "DW_TAG_format_label";
3764 case DW_TAG_function_template
: return "DW_TAG_function_template";
3765 case DW_TAG_class_template
: return "DW_TAG_class_template";
3768 static char buffer
[100];
3770 sprintf (buffer
, _("Unknown TAG value: %x"), tag
);
3777 get_AT_name (attribute
)
3778 unsigned long attribute
;
3782 case DW_AT_sibling
: return "DW_AT_sibling";
3783 case DW_AT_location
: return "DW_AT_location";
3784 case DW_AT_name
: return "DW_AT_name";
3785 case DW_AT_ordering
: return "DW_AT_ordering";
3786 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
3787 case DW_AT_byte_size
: return "DW_AT_byte_size";
3788 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
3789 case DW_AT_bit_size
: return "DW_AT_bit_size";
3790 case DW_AT_element_list
: return "DW_AT_element_list";
3791 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
3792 case DW_AT_low_pc
: return "DW_AT_low_pc";
3793 case DW_AT_high_pc
: return "DW_AT_high_pc";
3794 case DW_AT_language
: return "DW_AT_language";
3795 case DW_AT_member
: return "DW_AT_member";
3796 case DW_AT_discr
: return "DW_AT_discr";
3797 case DW_AT_discr_value
: return "DW_AT_discr_value";
3798 case DW_AT_visibility
: return "DW_AT_visibility";
3799 case DW_AT_import
: return "DW_AT_import";
3800 case DW_AT_string_length
: return "DW_AT_string_length";
3801 case DW_AT_common_reference
: return "DW_AT_common_reference";
3802 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
3803 case DW_AT_const_value
: return "DW_AT_const_value";
3804 case DW_AT_containing_type
: return "DW_AT_containing_type";
3805 case DW_AT_default_value
: return "DW_AT_default_value";
3806 case DW_AT_inline
: return "DW_AT_inline";
3807 case DW_AT_is_optional
: return "DW_AT_is_optional";
3808 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
3809 case DW_AT_producer
: return "DW_AT_producer";
3810 case DW_AT_prototyped
: return "DW_AT_prototyped";
3811 case DW_AT_return_addr
: return "DW_AT_return_addr";
3812 case DW_AT_start_scope
: return "DW_AT_start_scope";
3813 case DW_AT_stride_size
: return "DW_AT_stride_size";
3814 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
3815 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
3816 case DW_AT_accessibility
: return "DW_AT_accessibility";
3817 case DW_AT_address_class
: return "DW_AT_address_class";
3818 case DW_AT_artificial
: return "DW_AT_artificial";
3819 case DW_AT_base_types
: return "DW_AT_base_types";
3820 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
3821 case DW_AT_count
: return "DW_AT_count";
3822 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
3823 case DW_AT_decl_column
: return "DW_AT_decl_column";
3824 case DW_AT_decl_file
: return "DW_AT_decl_file";
3825 case DW_AT_decl_line
: return "DW_AT_decl_line";
3826 case DW_AT_declaration
: return "DW_AT_declaration";
3827 case DW_AT_discr_list
: return "DW_AT_discr_list";
3828 case DW_AT_encoding
: return "DW_AT_encoding";
3829 case DW_AT_external
: return "DW_AT_external";
3830 case DW_AT_frame_base
: return "DW_AT_frame_base";
3831 case DW_AT_friend
: return "DW_AT_friend";
3832 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
3833 case DW_AT_macro_info
: return "DW_AT_macro_info";
3834 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
3835 case DW_AT_priority
: return "DW_AT_priority";
3836 case DW_AT_segment
: return "DW_AT_segment";
3837 case DW_AT_specification
: return "DW_AT_specification";
3838 case DW_AT_static_link
: return "DW_AT_static_link";
3839 case DW_AT_type
: return "DW_AT_type";
3840 case DW_AT_use_location
: return "DW_AT_use_location";
3841 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
3842 case DW_AT_virtuality
: return "DW_AT_virtuality";
3843 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
3844 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
3845 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
3846 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
3847 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
3848 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
3849 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
3850 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
3851 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
3852 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
3853 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
3854 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
3855 case DW_AT_sf_names
: return "DW_AT_sf_names";
3856 case DW_AT_src_info
: return "DW_AT_src_info";
3857 case DW_AT_mac_info
: return "DW_AT_mac_info";
3858 case DW_AT_src_coords
: return "DW_AT_src_coords";
3859 case DW_AT_body_begin
: return "DW_AT_body_begin";
3860 case DW_AT_body_end
: return "DW_AT_body_end";
3863 static char buffer
[100];
3865 sprintf (buffer
, _("Unknown AT value: %x"), attribute
);
3872 get_FORM_name (form
)
3877 case DW_FORM_addr
: return "DW_FORM_addr";
3878 case DW_FORM_block2
: return "DW_FORM_block2";
3879 case DW_FORM_block4
: return "DW_FORM_block4";
3880 case DW_FORM_data2
: return "DW_FORM_data2";
3881 case DW_FORM_data4
: return "DW_FORM_data4";
3882 case DW_FORM_data8
: return "DW_FORM_data8";
3883 case DW_FORM_string
: return "DW_FORM_string";
3884 case DW_FORM_block
: return "DW_FORM_block";
3885 case DW_FORM_block1
: return "DW_FORM_block1";
3886 case DW_FORM_data1
: return "DW_FORM_data1";
3887 case DW_FORM_flag
: return "DW_FORM_flag";
3888 case DW_FORM_sdata
: return "DW_FORM_sdata";
3889 case DW_FORM_strp
: return "DW_FORM_strp";
3890 case DW_FORM_udata
: return "DW_FORM_udata";
3891 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
3892 case DW_FORM_ref1
: return "DW_FORM_ref1";
3893 case DW_FORM_ref2
: return "DW_FORM_ref2";
3894 case DW_FORM_ref4
: return "DW_FORM_ref4";
3895 case DW_FORM_ref8
: return "DW_FORM_ref8";
3896 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
3897 case DW_FORM_indirect
: return "DW_FORM_indirect";
3900 static char buffer
[100];
3902 sprintf (buffer
, _("Unknown FORM value: %x"), form
);
3908 /* FIXME: There are better and more effiecint ways to handle
3909 these structures. For now though, I just want something that
3910 is simple to implement. */
3911 typedef struct abbrev_attr
3913 unsigned long attribute
;
3915 struct abbrev_attr
* next
;
3919 typedef struct abbrev_entry
3921 unsigned long entry
;
3924 struct abbrev_attr
* first_attr
;
3925 struct abbrev_attr
* last_attr
;
3926 struct abbrev_entry
* next
;
3930 static abbrev_entry
* first_abbrev
= NULL
;
3931 static abbrev_entry
* last_abbrev
= NULL
;
3934 free_abbrevs
PARAMS ((void))
3936 abbrev_entry
* abbrev
;
3938 for (abbrev
= first_abbrev
; abbrev
;)
3940 abbrev_entry
* next
= abbrev
->next
;
3943 for (attr
= abbrev
->first_attr
; attr
;)
3945 abbrev_attr
* next
= attr
->next
;
3955 last_abbrev
= first_abbrev
= NULL
;
3959 add_abbrev (number
, tag
, children
)
3960 unsigned long number
;
3964 abbrev_entry
* entry
;
3966 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
3972 entry
->entry
= number
;
3974 entry
->children
= children
;
3975 entry
->first_attr
= NULL
;
3976 entry
->last_attr
= NULL
;
3979 if (first_abbrev
== NULL
)
3980 first_abbrev
= entry
;
3982 last_abbrev
->next
= entry
;
3984 last_abbrev
= entry
;
3988 add_abbrev_attr (attribute
, form
)
3989 unsigned long attribute
;
3994 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
4000 attr
->attribute
= attribute
;
4004 if (last_abbrev
->first_attr
== NULL
)
4005 last_abbrev
->first_attr
= attr
;
4007 last_abbrev
->last_attr
->next
= attr
;
4009 last_abbrev
->last_attr
= attr
;
4012 /* Processes the (partial) contents of a .debug_abbrev section.
4013 Returns NULL if the end of the section was encountered.
4014 Returns the address after the last byte read if the end of
4015 an abbreviation set was found. */
4017 static unsigned char *
4018 process_abbrev_section (start
, end
)
4019 unsigned char * start
;
4020 unsigned char * end
;
4022 if (first_abbrev
!= NULL
)
4028 unsigned long entry
;
4030 unsigned long attribute
;
4033 entry
= read_leb128 (start
, & bytes_read
, 0);
4034 start
+= bytes_read
;
4039 tag
= read_leb128 (start
, & bytes_read
, 0);
4040 start
+= bytes_read
;
4042 children
= * start
++;
4044 add_abbrev (entry
, tag
, children
);
4050 attribute
= read_leb128 (start
, & bytes_read
, 0);
4051 start
+= bytes_read
;
4053 form
= read_leb128 (start
, & bytes_read
, 0);
4054 start
+= bytes_read
;
4057 add_abbrev_attr (attribute
, form
);
4059 while (attribute
!= 0);
4067 display_debug_abbrev (section
, start
, file
)
4068 Elf32_Internal_Shdr
* section
;
4069 unsigned char * start
;
4072 abbrev_entry
* entry
;
4073 unsigned char * end
= start
+ section
->sh_size
;
4075 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
4079 start
= process_abbrev_section (start
, end
);
4081 printf (_(" Number TAG\n"));
4083 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4087 printf (_(" %d %s [%s]\n"),
4089 get_TAG_name (entry
->tag
),
4090 entry
->children
? _("has children") : _("no children"));
4092 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4094 printf (_(" %-18s %s\n"),
4095 get_AT_name (attr
->attribute
),
4096 get_FORM_name (attr
->form
));
4108 static unsigned char *
4109 display_block (data
, length
)
4110 unsigned char * data
;
4111 unsigned long length
;
4113 printf (_(" %d byte block: "), length
);
4116 printf ("%x ", byte_get (data
++, 1));
4121 static unsigned char *
4122 read_and_display_attr (attribute
, form
, data
, pointer_size
)
4123 unsigned long attribute
;
4125 unsigned char * data
;
4126 unsigned long pointer_size
;
4128 unsigned long uvalue
;
4131 printf (" %-18s:", get_AT_name (attribute
));
4135 case DW_FORM_ref_addr
:
4137 uvalue
= byte_get (data
, pointer_size
);
4138 printf (" %x", uvalue
);
4139 data
+= pointer_size
;
4145 uvalue
= byte_get (data
++, 1);
4146 printf (" %x", uvalue
);
4151 uvalue
= byte_get (data
, 2);
4153 printf (" %x", uvalue
);
4158 uvalue
= byte_get (data
, 4);
4160 printf (" %x", uvalue
);
4165 uvalue
= byte_get (data
, 4);
4166 printf (" %x", uvalue
);
4167 printf (" %x", byte_get (data
+ 4, 4));
4171 case DW_FORM_string
:
4172 printf (" %s", data
);
4173 data
+= strlen (data
) + 1;
4177 uvalue
= read_leb128 (data
, & bytes_read
, 1);
4179 printf (" %ld", (long) uvalue
);
4182 case DW_FORM_ref_udata
:
4184 uvalue
= read_leb128 (data
, & bytes_read
, 0);
4186 printf (" %lx", uvalue
);
4190 uvalue
= read_leb128 (data
, & bytes_read
, 0);
4191 data
= display_block (data
+ bytes_read
, uvalue
);
4192 uvalue
= * (data
- uvalue
);
4195 case DW_FORM_block1
:
4196 uvalue
= byte_get (data
++, 1);
4197 data
= display_block (data
, uvalue
);
4198 uvalue
= * (data
- uvalue
);
4201 case DW_FORM_block2
:
4202 uvalue
= byte_get (data
, 2);
4203 data
= display_block (data
+ 2, uvalue
);
4204 uvalue
= * (data
- uvalue
);
4207 case DW_FORM_block4
:
4208 uvalue
= byte_get (data
, 4);
4209 data
= display_block (data
+ 4, uvalue
);
4210 uvalue
= * (data
- uvalue
);
4214 case DW_FORM_indirect
:
4215 warn (_("Unable to handle FORM: %d"), form
);
4219 warn (_("Unrecognised form: %d"), form
);
4223 /* For some attributes we can display futher information. */
4232 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
4233 case DW_INL_inlined
: printf (_("(inlined)")); break;
4234 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
4235 case DW_INL_declared_inlined
: printf (_("(declared as inline and implemented)")); break;
4236 defailt
: printf (_(" (Unknown inline attribute value: %x)"), uvalue
); break;
4240 case DW_AT_frame_base
:
4241 if (uvalue
>= DW_OP_reg0
&& uvalue
<= DW_OP_reg31
)
4242 printf ("(reg %d)", uvalue
- DW_OP_reg0
);
4245 case DW_AT_language
:
4248 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
4249 case DW_LANG_C89
: printf ("(ANSI C)"); break;
4250 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
4251 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
4252 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
4253 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
4254 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
4255 case DW_LANG_Ada83
: printf ("(Ada)"); break;
4256 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
4257 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
4258 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
4259 default: printf ("(Unknown: %x)", uvalue
); break;
4272 display_debug_info (section
, start
, file
)
4273 Elf32_Internal_Shdr
* section
;
4274 unsigned char * start
;
4277 unsigned char * end
= start
+ section
->sh_size
;
4279 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
4283 DWARF2_External_CompUnit
* external
;
4284 DWARF2_Internal_CompUnit compunit
;
4285 unsigned char * tags
;
4288 external
= (DWARF2_External_CompUnit
*) start
;
4290 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
4291 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
4292 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
4293 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
4295 tags
= start
+ sizeof (* external
);
4296 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
4298 if (compunit
.cu_version
!= 2)
4300 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
4304 printf (_(" Compilation Unit:\n"));
4305 printf (_(" Length: %d\n"), compunit
.cu_length
);
4306 printf (_(" Version: %d\n"), compunit
.cu_version
);
4307 printf (_(" Abbrev Offset: %d\n"), compunit
.cu_abbrev_offset
);
4308 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
4310 if (first_abbrev
!= NULL
)
4313 /* Read in the abbrevs used by this compilation unit. */
4316 Elf32_Internal_Shdr
* sec
;
4317 unsigned char * begin
;
4319 /* Locate the .debug_abbrev section and process it. */
4320 for (i
= 0, sec
= section_headers
;
4321 i
< elf_header
.e_shnum
;
4323 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
4326 if (i
== -1 || sec
->sh_size
== 0)
4328 warn (_("Unable to locate .debug_abbrev section!\n"));
4332 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, char *,
4333 "debug_abbrev section data");
4335 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
4336 begin
+ sec
->sh_size
);
4341 while (tags
< start
)
4345 abbrev_entry
* entry
;
4348 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
4351 if (abbrev_number
== 0)
4354 /* Scan through the abbreviation list until we reach the
4356 for (entry
= first_abbrev
;
4357 entry
&& entry
->entry
!= abbrev_number
;
4358 entry
= entry
->next
)
4363 warn (_("Unable to locate entry %d in the abbreviation table\n"),
4368 printf (_(" Abbrev Number: %d (%s)\n"),
4370 get_TAG_name (entry
->tag
));
4372 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4373 tags
= read_and_display_attr (attr
->attribute
,
4376 compunit
.cu_pointer_size
);
4384 display_debug_not_supported (section
, start
, file
)
4385 Elf32_Internal_Shdr
* section
;
4386 unsigned char * start
;
4389 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4390 SECTION_NAME (section
));
4395 /* A structure containing the name of a debug section and a pointer
4396 to a function that can decode it. */
4400 int (* display
) PARAMS((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
4404 { ".debug_info", display_debug_info
},
4405 { ".debug_abbrev", display_debug_abbrev
},
4406 { ".debug_line", display_debug_lines
},
4407 { ".debug_aranges", display_debug_not_supported
},
4408 { ".debug_pubnames", display_debug_pubnames
},
4409 { ".debug_macinfo", display_debug_not_supported
},
4410 { ".debug_frame", display_debug_not_supported
},
4411 { ".debug_loc", display_debug_not_supported
},
4412 { ".debug_str", display_debug_not_supported
}
4416 display_debug_section (section
, file
)
4417 Elf32_Internal_Shdr
* section
;
4420 char * name
= SECTION_NAME (section
);
4421 bfd_size_type length
;
4422 unsigned char * start
;
4425 length
= section
->sh_size
;
4428 printf (_("\nSection '%s' has no debugging data.\n"), name
);
4432 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, char *,
4433 "debug section data");
4435 /* See if we know how to display the contents of this section. */
4436 for (i
= NUM_ELEM (debug_displays
); i
--;)
4437 if (strcmp (debug_displays
[i
].name
, name
) == 0)
4439 debug_displays
[i
].display (section
, start
, file
);
4444 printf (_("Unrecognised debug section: %s\n"), name
);
4448 /* If we loaded in the abbrev section at some point,
4449 we must release it here. */
4450 if (first_abbrev
!= NULL
)
4457 process_section_contents (file
)
4460 Elf32_Internal_Shdr
* section
;
4466 for (i
= 0, section
= section_headers
;
4467 i
< elf_header
.e_shnum
4468 && i
< NUM_DUMP_SECTS
;
4471 #ifdef SUPPORT_DISASSEMBLY
4472 if (dump_sects
[i
] & DISASS_DUMP
)
4473 disassemble_section (section
, file
);
4475 if (dump_sects
[i
] & HEX_DUMP
)
4476 dump_section (section
, file
);
4478 if (dump_sects
[i
] & DEBUG_DUMP
)
4479 display_debug_section (section
, file
);
4486 process_mips_fpe_exception (mask
)
4492 if (mask
& OEX_FPU_INEX
)
4493 fputs ("INEX", stdout
), first
= 0;
4494 if (mask
& OEX_FPU_UFLO
)
4495 printf ("%sUFLO", first
? "" : "|"), first
= 0;
4496 if (mask
& OEX_FPU_OFLO
)
4497 printf ("%sOFLO", first
? "" : "|"), first
= 0;
4498 if (mask
& OEX_FPU_DIV0
)
4499 printf ("%sDIV0", first
? "" : "|"), first
= 0;
4500 if (mask
& OEX_FPU_INVAL
)
4501 printf ("%sINVAL", first
? "" : "|");
4504 fputs ("0", stdout
);
4508 process_mips_specific (file
)
4511 Elf_Internal_Dyn
*entry
;
4512 size_t liblist_offset
= 0;
4513 size_t liblistno
= 0;
4514 size_t conflictsno
= 0;
4515 size_t options_offset
= 0;
4516 size_t conflicts_offset
= 0;
4518 /* We have a lot of special sections. Thanks SGI! */
4519 if (dynamic_segment
== NULL
)
4520 /* No information available. */
4523 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
4524 switch (entry
->d_tag
)
4526 case DT_MIPS_LIBLIST
:
4527 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
4529 case DT_MIPS_LIBLISTNO
:
4530 liblistno
= entry
->d_un
.d_val
;
4532 case DT_MIPS_OPTIONS
:
4533 options_offset
= entry
->d_un
.d_val
- loadaddr
;
4535 case DT_MIPS_CONFLICT
:
4536 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
4538 case DT_MIPS_CONFLICTNO
:
4539 conflictsno
= entry
->d_un
.d_val
;
4545 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
4547 Elf32_External_Lib
*elib
;
4550 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
4551 elib
, Elf32_External_Lib
*, "liblist");
4553 printf ("\nSection '.liblist' contains %d entries:\n", liblistno
);
4554 fputs (" Library Time Stamp Checksum Version Flags\n",
4557 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
4563 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
4564 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
4565 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
4566 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
4567 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
4569 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
4571 printf ("%3d: %-20s %s %#10lx %-7ld", cnt
,
4572 dynamic_strings
+ liblist
.l_name
, timebuf
,
4573 liblist
.l_checksum
, liblist
.l_version
);
4575 if (liblist
.l_flags
== 0)
4585 { " EXACT_MATCH", LL_EXACT_MATCH
},
4586 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
4587 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
4588 { " EXPORTS", LL_EXPORTS
},
4589 { " DELAY_LOAD", LL_DELAY_LOAD
},
4590 { " DELTA", LL_DELTA
}
4592 int flags
= liblist
.l_flags
;
4596 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
4598 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
4600 fputs (l_flags_vals
[fcnt
].name
, stdout
);
4601 flags
^= l_flags_vals
[fcnt
].bit
;
4604 printf (" %#lx", flags
);
4613 if (options_offset
!= 0)
4615 Elf_External_Options
*eopt
;
4616 Elf_Internal_Shdr
*sect
= section_headers
;
4617 Elf_Internal_Options
*iopt
;
4618 Elf_Internal_Options
*option
;
4622 /* Find the section header so that we get the size. */
4623 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
4626 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
4627 Elf_External_Options
*, "options");
4629 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
4633 error (_("Out of memory"));
4639 while (offset
< sect
->sh_size
)
4641 Elf_External_Options
*eoption
;
4643 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
4645 option
->kind
= BYTE_GET (eoption
->kind
);
4646 option
->size
= BYTE_GET (eoption
->size
);
4647 option
->section
= BYTE_GET (eoption
->section
);
4648 option
->info
= BYTE_GET (eoption
->info
);
4650 offset
+= option
->size
;
4655 printf (_("\nSection '%s' contains %d entries:\n"),
4656 string_table
+ sect
->sh_name
, cnt
);
4663 switch (option
->kind
)
4666 /* This shouldn't happen. */
4667 printf (" NULL %d %x", option
->section
, option
->info
);
4670 printf (" REGINFO ");
4671 if (elf_header
.e_machine
== EM_MIPS
)
4674 Elf32_External_RegInfo
*ereg
;
4675 Elf32_RegInfo reginfo
;
4677 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
4678 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
4679 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
4680 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
4681 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
4682 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
4683 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
4685 printf ("GPR %08lx GP %ld\n",
4686 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
4687 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
4688 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
4689 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
4694 Elf64_External_RegInfo
*ereg
;
4695 Elf64_Internal_RegInfo reginfo
;
4697 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
4698 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
4699 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
4700 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
4701 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
4702 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
4703 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
4705 printf ("GPR %08lx GP %ld\n",
4706 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
4707 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
4708 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
4709 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
4713 case ODK_EXCEPTIONS
:
4714 fputs (" EXCEPTIONS fpe_min(", stdout
);
4715 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
4716 fputs (") fpe_max(", stdout
);
4717 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
4718 fputs (")", stdout
);
4720 if (option
->info
& OEX_PAGE0
)
4721 fputs (" PAGE0", stdout
);
4722 if (option
->info
& OEX_SMM
)
4723 fputs (" SMM", stdout
);
4724 if (option
->info
& OEX_FPDBUG
)
4725 fputs (" FPDBUG", stdout
);
4726 if (option
->info
& OEX_DISMISS
)
4727 fputs (" DISMISS", stdout
);
4730 fputs (" PAD ", stdout
);
4731 if (option
->info
& OPAD_PREFIX
)
4732 fputs (" PREFIX", stdout
);
4733 if (option
->info
& OPAD_POSTFIX
)
4734 fputs (" POSTFIX", stdout
);
4735 if (option
->info
& OPAD_SYMBOL
)
4736 fputs (" SYMBOL", stdout
);
4739 fputs (" HWPATCH ", stdout
);
4740 if (option
->info
& OHW_R4KEOP
)
4741 fputs (" R4KEOP", stdout
);
4742 if (option
->info
& OHW_R8KPFETCH
)
4743 fputs (" R8KPFETCH", stdout
);
4744 if (option
->info
& OHW_R5KEOP
)
4745 fputs (" R5KEOP", stdout
);
4746 if (option
->info
& OHW_R5KCVTL
)
4747 fputs (" R5KCVTL", stdout
);
4750 fputs (" FILL ", stdout
);
4751 /* XXX Print content of info word? */
4754 fputs (" TAGS ", stdout
);
4755 /* XXX Print content of info word? */
4758 fputs (" HWAND ", stdout
);
4759 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
4760 fputs (" R4KEOP_CHECKED", stdout
);
4761 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
4762 fputs (" R4KEOP_CLEAN", stdout
);
4765 fputs (" HWOR ", stdout
);
4766 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
4767 fputs (" R4KEOP_CHECKED", stdout
);
4768 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
4769 fputs (" R4KEOP_CLEAN", stdout
);
4772 printf (" GP_GROUP %#06x self-contained %#06x",
4773 option
->info
& OGP_GROUP
,
4774 (option
->info
& OGP_SELF
) >> 16);
4777 printf (" IDENT %#06x self-contained %#06x",
4778 option
->info
& OGP_GROUP
,
4779 (option
->info
& OGP_SELF
) >> 16);
4782 /* This shouldn't happen. */
4783 printf (" %3d ??? %d %x",
4784 option
->kind
, option
->section
, option
->info
);
4788 len
= sizeof (*eopt
);
4789 while (len
< option
->size
)
4790 if (((char *) option
)[len
] >= ' '
4791 && ((char *) option
)[len
] < 0x7f)
4792 printf ("%c", ((char *) option
)[len
++]);
4794 printf ("\\%03o", ((char *) option
)[len
++]);
4796 fputs ("\n", stdout
);
4803 if (conflicts_offset
!= 0 && conflictsno
!= 0)
4805 Elf32_External_Conflict
*econf32
;
4806 Elf64_External_Conflict
*econf64
;
4807 Elf32_Conflict
*iconf
;
4810 if (dynamic_symbols
== NULL
)
4812 error (_("conflict list with without table"));
4816 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
4819 error (_("Out of memory"));
4823 if (binary_class
== ELFCLASS32
)
4825 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
4826 econf32
, Elf32_External_Conflict
*, "conflict");
4828 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
4829 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
4833 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
4834 econf64
, Elf64_External_Conflict
*, "conflict");
4836 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
4837 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
4840 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
4841 puts (_(" Num: Index Value Name"));
4843 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
4845 Elf_Internal_Sym
*psym
= &dynamic_symbols
[iconf
[cnt
]];
4847 printf ("%5u: %8u %#10x %s\n",
4848 cnt
, iconf
[cnt
], (unsigned long) psym
->st_value
,
4849 dynamic_strings
+ psym
->st_name
);
4860 process_arch_specific (file
)
4863 switch (elf_header
.e_machine
)
4866 case EM_MIPS_RS4_BE
:
4867 return process_mips_specific (file
);
4876 get_file_header (file
)
4879 Elf32_External_Ehdr ehdr
;
4881 if (fread (& ehdr
, sizeof (ehdr
), 1, file
) != 1)
4884 memcpy (elf_header
.e_ident
, ehdr
.e_ident
, EI_NIDENT
);
4886 if (elf_header
.e_ident
[EI_DATA
] == ELFDATA2LSB
)
4887 byte_get
= byte_get_little_endian
;
4889 byte_get
= byte_get_big_endian
;
4891 elf_header
.e_entry
= BYTE_GET (ehdr
.e_entry
);
4892 elf_header
.e_phoff
= BYTE_GET (ehdr
.e_phoff
);
4893 elf_header
.e_shoff
= BYTE_GET (ehdr
.e_shoff
);
4894 elf_header
.e_version
= BYTE_GET (ehdr
.e_version
);
4895 elf_header
.e_flags
= BYTE_GET (ehdr
.e_flags
);
4896 elf_header
.e_type
= BYTE_GET (ehdr
.e_type
);
4897 elf_header
.e_machine
= BYTE_GET (ehdr
.e_machine
);
4898 elf_header
.e_ehsize
= BYTE_GET (ehdr
.e_ehsize
);
4899 elf_header
.e_phentsize
= BYTE_GET (ehdr
.e_phentsize
);
4900 elf_header
.e_phnum
= BYTE_GET (ehdr
.e_phnum
);
4901 elf_header
.e_shentsize
= BYTE_GET (ehdr
.e_shentsize
);
4902 elf_header
.e_shnum
= BYTE_GET (ehdr
.e_shnum
);
4903 elf_header
.e_shstrndx
= BYTE_GET (ehdr
.e_shstrndx
);
4909 process_file (file_name
)
4913 struct stat statbuf
;
4916 if (stat (file_name
, & statbuf
) < 0)
4918 error (_("Cannot stat input file %s.\n"), file_name
);
4922 file
= fopen (file_name
, "rb");
4925 error (_("Input file %s not found.\n"), file_name
);
4929 if (! get_file_header (file
))
4931 error (_("%s: Failed to read file header\n"), file_name
);
4936 /* Initialise per file variables. */
4937 for (i
= NUM_ELEM (version_info
); i
--;)
4938 version_info
[i
] = 0;
4940 for (i
= NUM_ELEM (dynamic_info
); i
--;)
4941 dynamic_info
[i
] = 0;
4943 /* Process the file. */
4945 printf (_("\nFile: %s\n"), file_name
);
4947 if (! process_file_header ())
4953 process_section_headers (file
);
4955 process_program_headers (file
);
4957 process_dynamic_segment (file
);
4959 process_relocs (file
);
4961 process_symbol_table (file
);
4963 process_syminfo (file
);
4965 process_version_sections (file
);
4967 process_section_contents (file
);
4969 process_arch_specific (file
);
4973 if (section_headers
)
4975 free (section_headers
);
4976 section_headers
= NULL
;
4981 free (string_table
);
4982 string_table
= NULL
;
4985 if (dynamic_strings
)
4987 free (dynamic_strings
);
4988 dynamic_strings
= NULL
;
4991 if (dynamic_symbols
)
4993 free (dynamic_symbols
);
4994 dynamic_symbols
= NULL
;
4997 if (dynamic_syminfo
)
4999 free (dynamic_syminfo
);
5000 dynamic_syminfo
= NULL
;
5004 #ifdef SUPPORT_DISASSEMBLY
5005 /* Needed by the i386 disassembler. For extra credit, someone could
5006 fix this so that we insert symbolic addresses here, esp for GOT/PLT
5010 print_address (unsigned int addr
, FILE * outfile
)
5012 fprintf (outfile
,"0x%8.8x", addr
);
5015 /* Needed by the i386 disassembler. */
5017 db_task_printsym (unsigned int addr
)
5019 print_address (addr
, stderr
);
5028 parse_args (argc
, argv
);
5030 if (optind
< (argc
- 1))
5033 while (optind
< argc
)
5034 process_file (argv
[optind
++]);