#include "elf/hppa.h"
#include "elf/arc.h"
#include "elf/fr30.h"
+#include "elf/mcore.h"
#include "bucomm.h"
#include "getopt.h"
int do_debug_abbrevs;
int do_debug_lines;
int do_debug_pubnames;
+int do_debug_aranges;
int binary_class;
-static unsigned long (* byte_get) PARAMS ((unsigned char *, int));
-
-/* XXX - An arbitary constant, limiting the number of sections
- for whcih we can display information. */
-#define NUM_DUMP_SECTS 100
-char dump_sects [NUM_DUMP_SECTS];
+/* A dynamic array of flags indicating which sections require dumping. */
+char * dump_sects = NULL;
+unsigned int num_dump_sects = 0;
#define HEX_DUMP (1 << 0)
#define DISASS_DUMP (1 << 1)
#define DEBUG_DUMP (1 << 2)
/* Forward declarations for dumb compilers. */
+static unsigned long (* byte_get) PARAMS ((unsigned char *, int));
static const char * get_mips_dynamic_type PARAMS ((unsigned long type));
static const char * get_dynamic_type PARAMS ((unsigned long type));
static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, char *));
static int get_file_header PARAMS ((FILE * file));
static Elf_Internal_Sym * get_elf_symbols PARAMS ((FILE * file, unsigned long offset, unsigned long number));
static int * get_dynamic_data PARAMS ((FILE * file, unsigned int number));
+#ifdef SUPPORT_DISASSEMBLY
static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
+#endif
static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
+static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
-static int process_extended_line_op PARAMS ((unsigned char *, long *));
+static int process_extended_line_op PARAMS ((unsigned char *, int));
+static void reset_state_machine PARAMS ((int));
static char * get_TAG_name PARAMS ((unsigned long));
static char * get_AT_name PARAMS ((unsigned long));
static char * get_FORM_name PARAMS ((unsigned long));
static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
+static void decode_location_expression PARAMS ((unsigned char *, unsigned int));
+static void request_dump PARAMS ((unsigned int, char));
+static const char * get_elf_class PARAMS ((unsigned char));
+static const char * get_data_encoding PARAMS ((unsigned char));
+static const char * get_osabi_name PARAMS ((unsigned char));
typedef int Elf32_Word;
/* Compute number of relocations and read them in. */
switch (elf_header.e_machine)
{
+ /* Targets that use REL relocations. */
+ case EM_ARM:
case EM_386:
case EM_486:
case EM_CYGNUS_M32R:
}
break;
- case EM_ARM:
+ /* Targets that use RELA relocations. */
case EM_68K:
case EM_SPARC:
case EM_PPC:
case EM_CYGNUS_FR30:
case EM_SH:
case EM_ALPHA:
+ case EM_MCORE:
{
Elf32_External_Rela * erelas;
rtype = elf_fr30_reloc_type (ELF32_R_TYPE (info));
break;
+ case EM_MCORE:
+ rtype = elf_mcore_reloc_type (ELF32_R_TYPE (info));
+ break;
+
case EM_PPC:
rtype = elf_ppc_reloc_type (ELF32_R_TYPE (info));
break;
}
if (rtype == NULL)
- printf (_("unrecognised: %-7x"), ELF32_R_TYPE (info));
+ printf (_("unrecognised: %-7lx"), ELF32_R_TYPE (info));
else
printf ("%-21.21s", rtype);
printf ("%-25.25s",
SECTION_NAME (section_headers + psym->st_shndx));
else if (strtab == NULL)
- printf (_("<string table index %3d>"), psym->st_name);
+ printf (_("<string table index %3ld>"), psym->st_name);
else
printf ("%-25.25s", strtab + psym->st_name);
case DT_DEBUG: return "DEBUG";
case DT_TEXTREL: return "TEXTREL";
case DT_JMPREL: return "JMPREL";
- case DT_VERDEF: return "VERDEF";
- case DT_VERDEFNUM: return "VERDEFNUM";
- case DT_VERNEED: return "VERNEED";
- case DT_VERNEEDNUM: return "VERNEEDNUM";
- case DT_VERSYM: return "VERSYN";
- case DT_AUXILIARY: return "AUXILARY";
- case DT_FILTER: return "FILTER";
+ case DT_BIND_NOW: return "BIND_NOW";
+ case DT_INIT_ARRAY: return "INIT_ARRAY";
+ case DT_FINI_ARRAY: return "FINI_ARRAY";
+ case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
+ case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
+
+ case DT_PLTPADSZ: return "PLTPADSZ";
+ case DT_MOVEENT: return "MOVEENT";
+ case DT_MOVESZ: return "MOVESZ";
+ case DT_FEATURE_1: return "FEATURE_1";
case DT_POSFLAG_1: return "POSFLAG_1";
case DT_SYMINSZ: return "SYMINSZ";
- case DT_SYMINENT: return "SYMINENT";
- case DT_SYMINFO: return "SYMINFO";
+ case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
+
+ case DT_ADDRRNGLO: return "ADDRRNGLO";
+ case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
+
+ case DT_VERSYM: return "VERSYM";
+
case DT_RELACOUNT: return "RELACOUNT";
case DT_RELCOUNT: return "RELCOUNT";
case DT_FLAGS_1: return "FLAGS_1";
+ case DT_VERDEF: return "VERDEF";
+ case DT_VERDEFNUM: return "VERDEFNUM";
+ case DT_VERNEED: return "VERNEED";
+ case DT_VERNEEDNUM: return "VERNEEDNUM";
+
+ case DT_AUXILIARY: return "AUXILARY";
case DT_USED: return "USED";
-
+ case DT_FILTER: return "FILTER";
+
default:
if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
{
- const char *result = NULL;
+ const char * result;
+
switch (elf_header.e_machine)
{
case EM_MIPS:
case EM_MIPS_RS4_BE:
result = get_mips_dynamic_type (type);
+ break;
+ default:
+ result = NULL;
+ break;
}
- if (result == NULL)
- {
- sprintf (buff, _("Processor Specific"), type);
- result = buff;
- }
- return result;
+ if (result != NULL)
+ return result;
+
+ sprintf (buff, _("Processor Specific: %lx"), type);
}
+ else if ((type >= DT_LOOS) && (type <= DT_HIOS))
+ sprintf (buff, _("Operating System specific: %lx"), type);
else
- sprintf (buff, _("<unknown>: %x"), type);
+ sprintf (buff, _("<unknown>: %lx"), type);
+
return buff;
}
}
default:
if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
sprintf (buff, _("Processor Specific: (%x)"), e_type);
+ else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
+ sprintf (buff, _("OS Specific: (%x)"), e_type);
else
sprintf (buff, _("<unknown>: %x"), e_type);
return buff;
case EM_V800: return "NEC V800";
case EM_FR20: return "Fujitsu FR20";
case EM_RH32: return "TRW RH32";
- case EM_MMA: return "Fujitsu MMA";
+ case EM_MCORE: return "MCORE";
case EM_ARM: return "ARM";
case EM_OLD_ALPHA: return "Digital Alpha (old)";
case EM_SH: return "Hitachi SH";
case EM_SPARCV9: return "Sparc v9";
+ case EM_TRICORE: return "Siemens Tricore";
+ case EM_ARC: return "Argonaut RISC Core";
+ case EM_H8_300: return "Hitachi H8/300";
+ case EM_H8_300H: return "Hitachi H8/300H";
+ case EM_H8S: return "Hitachi H8S";
+ case EM_H8_500: return "Hitachi H8/500";
+ case EM_IA_64: return "Intel Merced";
+ case EM_MIPS_X: return "Stanford MIPS-X";
+ case EM_COLDFIRE: return "Motorola Coldfire";
+ case EM_68HC12: return "Motorola M68HC12";
case EM_ALPHA: return "Alpha";
case EM_CYGNUS_D10V: return "d10v";
case EM_CYGNUS_D30V: return "d30v";
case EM_CYGNUS_ARC: return "Arc";
- case EM_CYGNUS_M32R: return "M32r";
- case EM_CYGNUS_V850: return "v850";
+ case EM_CYGNUS_M32R: return "Mitsubishi M32r";
+ case EM_CYGNUS_V850: return "NEC v850";
case EM_CYGNUS_MN10300: return "mn10300";
case EM_CYGNUS_MN10200: return "mn10200";
- case EM_CYGNUS_FR30: return "FR30";
+ case EM_CYGNUS_FR30: return "Fujitsu FR30";
default:
sprintf (buff, _("<unknown>: %x"), e_machine);
strcat (buf, ", relocatable-lib");
break;
+ case EM_CYGNUS_V850:
+ switch (e_flags & EF_V850_ARCH)
+ {
+ case E_V850E_ARCH:
+ strcat (buf, ", v850e");
+ break;
+ case E_V850EA_ARCH:
+ strcat (buf, ", v850ea");
+ break;
+ case E_V850_ARCH:
+ strcat (buf, ", v850");
+ break;
+ default:
+ strcat (buf, ", unknown v850 architecture variant");
+ break;
+ }
+ break;
+
case EM_CYGNUS_M32R:
if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
strcat (buf, ", m32r");
- /* start-sanitize-m32rx */
-#ifdef E_M32RX_ARCH
- if ((e_flags & EF_M32R_ARCH) == E_M32RX_ARCH)
- strcat (buf, ", m32rx");
-#endif
- /* end-sanitize-m32rx */
break;
case EM_MIPS:
default:
if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
{
- const char *result;
+ const char * result;
+
switch (elf_header.e_machine)
{
case EM_MIPS:
result = NULL;
break;
}
- if (result == NULL)
- {
- sprintf (buff, "LOPROC+%d", p_type - PT_LOPROC);
- result = buff;
- }
- return result;
+
+ if (result != NULL)
+ return result;
+
+ sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
}
+ else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
+ sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
else
- {
- sprintf (buff, _("<unknown>: %x"), p_type);
- return buff;
- }
+ sprintf (buff, _("<unknown>: %lx"), p_type);
+
+ return buff;
}
}
default:
if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
{
- const char *result;
+ const char * result;
switch (elf_header.e_machine)
{
break;
}
- if (result == NULL)
- {
- sprintf (buff, _("SHT_LOPROC+%d"), sh_type - SHT_LOPROC);
- result = buff;
- }
- return result;
+ if (result != NULL)
+ return result;
+
+ sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
}
+ else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
+ sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
- sprintf (buff, _("SHT_LOUSER+%d"), sh_type - SHT_LOUSER);
+ sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
else
sprintf (buff, _("<unknown>: %x"), sh_type);
+
return buff;
}
}
fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
fprintf (stdout, _(" Dump the contents of section <number>\n"));
- fprintf (stdout, _(" -w[liap] or --debug-dump[=line,=info,=abbrev,=pubnames]\n"));
+ fprintf (stdout, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
#ifdef SUPPORT_DISASSEMBLY
fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
exit (0);
}
+static void
+request_dump (section, type)
+ unsigned int section;
+ char type;
+{
+ if (section >= num_dump_sects)
+ {
+ char * new_dump_sects;
+
+ new_dump_sects = (char *) calloc (section + 1, 1);
+
+ if (new_dump_sects == NULL)
+ error (_("Out of memory allocating dump request table."));
+ else
+ {
+ /* Copy current flag settings. */
+ memcpy (new_dump_sects, dump_sects, num_dump_sects);
+
+ free (dump_sects);
+
+ dump_sects = new_dump_sects;
+ num_dump_sects = section + 1;
+ }
+ }
+
+ if (dump_sects)
+ dump_sects [section] |= type;
+
+ return;
+}
+
static void
parse_args (argc, argv)
int argc;
case 'x':
do_dump ++;
section = strtoul (optarg, & cp, 0);
- if (! * cp && section >= 0 && section < NUM_DUMP_SECTS)
+ if (! * cp && section >= 0)
{
- dump_sects [section] |= HEX_DUMP;
+ request_dump (section, HEX_DUMP);
break;
}
goto oops;
case 'I':
do_debug_info = 1;
break;
-
+
case 'a':
case 'A':
do_debug_abbrevs = 1;
break;
-
+
case 'l':
case 'L':
do_debug_lines = 1;
case 'P':
do_debug_pubnames = 1;
break;
-
+
+ case 'r':
+ case 'R':
+ do_debug_aranges = 1;
+ break;
+
default:
warn (_("Unrecognised debug option '%s'\n"), optarg);
break;
case 'i':
do_dump ++;
section = strtoul (optarg, & cp, 0);
- if (! * cp && section >= 0 && section < NUM_DUMP_SECTS)
+ if (! * cp && section >= 0)
{
- dump_sects [section] |= DISASS_DUMP;
+ request_dump (section, DISASS_DUMP);
break;
}
goto oops;
}
}
+static const char *
+get_elf_class (elf_class)
+ unsigned char elf_class;
+{
+ switch (elf_class)
+ {
+ case ELFCLASSNONE: return _("none");
+ case ELFCLASS32: return _("ELF32");
+ case ELFCLASS64: return _("ELF64");
+ default: return _("<unknown>");
+ }
+}
+
+static const char *
+get_data_encoding (encoding)
+ unsigned char encoding;
+{
+ switch (encoding)
+ {
+ case ELFDATANONE: return _("none");
+ case ELFDATA2LSB: return _("2's compilment, little endian");
+ case ELFDATA2MSB: return _("2's compilment, big endian");
+ default: return _("<unknown>");
+ }
+}
+
+static const char *
+get_osabi_name (osabi)
+ unsigned char osabi;
+{
+ switch (osabi)
+ {
+ case ELFOSABI_SYSV: return _("UNIX - System V");
+ case ELFOSABI_HPUX: return _("UNIX - HP-UX");
+ case ELFOSABI_STANDALONE: return _("Standalone App");
+ default: return _("<unknown>");
+ }
+}
+
/* Decode the data held in 'elf_header'. */
static int
process_file_header ()
return 0;
}
- binary_class = elf_header.e_ident [EI_CLASS];
- if (binary_class != ELFCLASS32)
- {
- error (_("Not a 32 bit ELF file\n"));
- return 0;
- }
-
if (do_header)
{
int i;
for (i = 0; i < EI_NIDENT; i ++)
printf ("%2.2x ", elf_header.e_ident [i]);
printf ("\n");
+ printf (_(" Class: %s\n"),
+ get_elf_class (elf_header.e_ident [EI_CLASS]));
+ printf (_(" Data: %s\n"),
+ get_data_encoding (elf_header.e_ident [EI_DATA]));
+ printf (_(" Version: %d %s\n"),
+ elf_header.e_ident [EI_VERSION],
+ elf_header.e_ident [EI_VERSION] == EV_CURRENT ? "(current)" :
+ elf_header.e_ident [EI_VERSION] != EV_NONE ? "<unknown>" : "");
+ printf (_(" OS/ABI: %s\n"),
+ get_osabi_name (elf_header.e_ident [EI_OSABI]));
+ printf (_(" ABI Version: %d\n"),
+ elf_header.e_ident [EI_ABIVERSION]);
printf (_(" Type: %s\n"),
get_file_type (elf_header.e_type));
printf (_(" Machine: %s\n"),
(long) elf_header.e_shstrndx);
}
+ /* Test class after dumping header so that at least the header can be
+ display on 64 bit binaries. */
+
+ binary_class = elf_header.e_ident [EI_CLASS];
+ if (binary_class != ELFCLASS32)
+ {
+ error (_("Not a 32 bit ELF file\n"));
+ return 0;
+ }
+
return 1;
}
{
Elf32_Internal_Shdr * section;
int i;
-
+
section_headers = NULL;
if (elf_header.e_shnum == 0)
}
if (do_sections && !do_header)
- printf (_("There are %d section headers, starting at offset %x:\n"),
- elf_header.e_shnum, elf_header.e_shoff);
+ printf (_("There are %d section headers, starting at offset %lx:\n"),
+ elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
if (! get_section_headers (file))
return 0;
i ++, section ++)
{
char * name = SECTION_NAME (section);
-
+
if (section->sh_type == SHT_DYNSYM)
{
if (dynamic_symbols != NULL)
dynamic_strings, char *, "dynamic strings");
}
else if ((do_debugging || do_debug_info || do_debug_abbrevs
- || do_debug_lines || do_debug_pubnames)
+ || do_debug_lines || do_debug_pubnames || do_debug_aranges)
&& strncmp (name, ".debug_", 7) == 0)
{
name += 7;
-
+
if (do_debugging
|| (do_debug_info && (strcmp (name, "info") == 0))
|| (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
|| (do_debug_lines && (strcmp (name, "line") == 0))
|| (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
+ || (do_debug_aranges && (strcmp (name, "aranges") == 0))
)
- dump_sects [i] |= DEBUG_DUMP;
+ request_dump (i, DEBUG_DUMP);
}
}
if (rel_size)
{
printf
- (_("\nRelocation section at offset 0x%x contains %d bytes:\n"),
+ (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
rel_offset, rel_size);
dump_relocations (file, rel_offset - loadaddr, rel_size,
else
printf ("'%s'", SECTION_NAME (section));
- printf (_(" at offset 0x%x contains %d entries:\n"),
- rel_offset, rel_size / section->sh_entsize);
+ printf (_(" at offset 0x%lx contains %lu entries:\n"),
+ rel_offset, (unsigned long) (rel_size / section->sh_entsize));
symsec = section_headers + section->sh_link;
static void
dynamic_segment_mips_val (entry)
- Elf_Internal_Dyn *entry;
+ Elf_Internal_Dyn * entry;
{
- if (do_dynamic)
- switch (entry->d_tag)
- {
- case DT_MIPS_FLAGS:
- if (entry->d_un.d_val == 0)
- printf ("NONE\n");
- else
- {
- static const char *opts[] =
- {
- "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
- "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
- "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
- "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
- "RLD_ORDER_SAFE"
- };
- unsigned int cnt;
- int first = 1;
- for (cnt = 0; cnt < sizeof (opts) / sizeof (opts[0]); ++cnt)
- if (entry->d_un.d_val & (1 << cnt))
- {
- printf ("%s%s", first ? "" : " ", opts[cnt]);
- first = 0;
- }
- puts ("");
- }
- break;
-
- case DT_MIPS_IVERSION:
- if (dynamic_strings != NULL)
- printf ("Interface Version: %s\n",
- dynamic_strings + entry->d_un.d_val);
- else
- printf ("%#ld\n", (long) entry->d_un.d_ptr);
- break;
-
- case DT_MIPS_TIME_STAMP:
+ switch (entry->d_tag)
+ {
+ case DT_MIPS_FLAGS:
+ if (entry->d_un.d_val == 0)
+ printf ("NONE\n");
+ else
{
- char timebuf[20];
- time_t time = entry->d_un.d_val;
- strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
- printf ("Time Stamp: %s\n", timebuf);
+ static const char * opts[] =
+ {
+ "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
+ "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
+ "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
+ "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
+ "RLD_ORDER_SAFE"
+ };
+ unsigned int cnt;
+ int first = 1;
+ for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
+ if (entry->d_un.d_val & (1 << cnt))
+ {
+ printf ("%s%s", first ? "" : " ", opts[cnt]);
+ first = 0;
+ }
+ puts ("");
}
- break;
-
- case DT_MIPS_RLD_VERSION:
- case DT_MIPS_LOCAL_GOTNO:
- case DT_MIPS_CONFLICTNO:
- case DT_MIPS_LIBLISTNO:
- case DT_MIPS_SYMTABNO:
- case DT_MIPS_UNREFEXTNO:
- case DT_MIPS_HIPAGENO:
- case DT_MIPS_DELTA_CLASS_NO:
- case DT_MIPS_DELTA_INSTANCE_NO:
- case DT_MIPS_DELTA_RELOC_NO:
- case DT_MIPS_DELTA_SYM_NO:
- case DT_MIPS_DELTA_CLASSSYM_NO:
- case DT_MIPS_COMPACT_SIZE:
- printf ("%#ld\n", (long) entry->d_un.d_ptr);
- break;
-
- default:
- printf ("%#lx\n", (long) entry->d_un.d_ptr);
+ break;
+
+ case DT_MIPS_IVERSION:
+ if (dynamic_strings != NULL)
+ printf ("Interface Version: %s\n",
+ dynamic_strings + entry->d_un.d_val);
+ else
+ printf ("%ld\n", (long) entry->d_un.d_ptr);
+ break;
+
+ case DT_MIPS_TIME_STAMP:
+ {
+ char timebuf[20];
+ time_t time = entry->d_un.d_val;
+ strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
+ printf ("Time Stamp: %s\n", timebuf);
}
+ break;
+
+ case DT_MIPS_RLD_VERSION:
+ case DT_MIPS_LOCAL_GOTNO:
+ case DT_MIPS_CONFLICTNO:
+ case DT_MIPS_LIBLISTNO:
+ case DT_MIPS_SYMTABNO:
+ case DT_MIPS_UNREFEXTNO:
+ case DT_MIPS_HIPAGENO:
+ case DT_MIPS_DELTA_CLASS_NO:
+ case DT_MIPS_DELTA_INSTANCE_NO:
+ case DT_MIPS_DELTA_RELOC_NO:
+ case DT_MIPS_DELTA_SYM_NO:
+ case DT_MIPS_DELTA_CLASSSYM_NO:
+ case DT_MIPS_COMPACT_SIZE:
+ printf ("%ld\n", (long) entry->d_un.d_ptr);
+ break;
+
+ default:
+ printf ("%#lx\n", (long) entry->d_un.d_ptr);
+ }
}
/* Parse the dynamic segment */
GET_DATA_ALLOC (dynamic_addr, dynamic_size,
edyn, Elf32_External_Dyn *, "dynamic segment");
-
+
/* SGI's ELF has more than one section in the DYNAMIC segment. Determine
how large .dynamic is now. We can do this even before the byte
swapping since the DT_NULL tag is recognizable. */
++i, ++ entry)
{
if (entry->d_tag == DT_SYMINENT)
- assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
+ {
+ /* Note: these braces are necessary to avoid a syntax
+ error from the SunOS4 C compiler. */
+ assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
+ }
else if (entry->d_tag == DT_SYMINSZ)
syminsz = entry->d_un.d_val;
else if (entry->d_tag == DT_SYMINFO)
}
break;
+ case DT_FEATURE_1:
+ if (do_dynamic)
+ {
+ printf (_("Flags:"));
+ if (entry->d_un.d_val == 0)
+ printf (_(" None\n"));
+ else
+ {
+ unsigned long int val = entry->d_un.d_val;
+ if (val & DTF_1_PARINIT)
+ {
+ printf (" PARINIT");
+ val ^= DTF_1_PARINIT;
+ }
+ if (val != 0)
+ printf (" %lx", val);
+ puts ("");
+ }
+ }
+ break;
+
case DT_POSFLAG_1:
if (do_dynamic)
{
printf (_(" None\n"));
else
{
- if (entry->d_un.d_val & DF_P1_LAZYLOAD)
- printf (" LAZYLOAD");
- if (entry->d_un.d_val & DF_P1_LAZYLOAD)
- printf (" GROUPPERM");
+ unsigned long int val = entry->d_un.d_val;
+ if (val & DF_P1_LAZYLOAD)
+ {
+ printf (" LAZYLOAD");
+ val ^= DF_P1_LAZYLOAD;
+ }
+ if (val & DF_P1_GROUPPERM)
+ {
+ printf (" GROUPPERM");
+ val ^= DF_P1_GROUPPERM;
+ }
+ if (val != 0)
+ printf (" %lx", val);
puts ("");
}
}
printf (_(" None\n"));
else
{
- if (entry->d_un.d_val & DF_1_NOW)
- printf (" NOW");
- if (entry->d_un.d_val & DF_1_GLOBAL)
- printf (" GLOBAL");
- if (entry->d_un.d_val & DF_1_GROUP)
- printf (" GROUP");
- if (entry->d_un.d_val & DF_1_NODELETE)
- printf (" NODELETE");
- if (entry->d_un.d_val & DF_1_LOADFLTR)
- printf (" LOADFLTR");
- if (entry->d_un.d_val & DF_1_INITFIRST)
- printf (" INITFIRST");
- if (entry->d_un.d_val & DF_1_NOOPEN)
- printf (" NOOPEN");
- if (entry->d_un.d_val & DF_1_ORIGIN)
- printf (" ORIGIN");
- if (entry->d_un.d_val & DF_1_DIRECT)
- printf (" DIRECT");
- if (entry->d_un.d_val & DF_1_TRANS)
- printf (" TRANS");
- if (entry->d_un.d_val & DF_1_INTERPOSE)
- printf (" INTERPOSE");
+ unsigned long int val = entry->d_un.d_val;
+ if (val & DF_1_NOW)
+ {
+ printf (" NOW");
+ val ^= DF_1_NOW;
+ }
+ if (val & DF_1_GLOBAL)
+ {
+ printf (" GLOBAL");
+ val ^= DF_1_GLOBAL;
+ }
+ if (val & DF_1_GROUP)
+ {
+ printf (" GROUP");
+ val ^= DF_1_GROUP;
+ }
+ if (val & DF_1_NODELETE)
+ {
+ printf (" NODELETE");
+ val ^= DF_1_NODELETE;
+ }
+ if (val & DF_1_LOADFLTR)
+ {
+ printf (" LOADFLTR");
+ val ^= DF_1_LOADFLTR;
+ }
+ if (val & DF_1_INITFIRST)
+ {
+ printf (" INITFIRST");
+ val ^= DF_1_INITFIRST;
+ }
+ if (val & DF_1_NOOPEN)
+ {
+ printf (" NOOPEN");
+ val ^= DF_1_NOOPEN;
+ }
+ if (val & DF_1_ORIGIN)
+ {
+ printf (" ORIGIN");
+ val ^= DF_1_ORIGIN;
+ }
+ if (val & DF_1_DIRECT)
+ {
+ printf (" DIRECT");
+ val ^= DF_1_DIRECT;
+ }
+ if (val & DF_1_TRANS)
+ {
+ printf (" TRANS");
+ val ^= DF_1_TRANS;
+ }
+ if (val & DF_1_INTERPOSE)
+ {
+ printf (" INTERPOSE");
+ val ^= DF_1_INTERPOSE;
+ }
+ if (val != 0)
+ printf (" %lx", val);
puts ("");
}
}
break;
case DT_PLTREL:
- puts (get_dynamic_type (entry->d_un.d_val));
+ if (do_dynamic)
+ puts (get_dynamic_type (entry->d_un.d_val));
break;
case DT_NULL :
case DT_RELAENT :
case DT_SYMENT :
case DT_RELENT :
+ case DT_PLTPADSZ:
+ case DT_MOVEENT :
+ case DT_MOVESZ :
+ case DT_INIT_ARRAYSZ:
+ case DT_FINI_ARRAYSZ:
if (do_dynamic)
- printf ("%ld (bytes)\n", entry->d_un.d_val);
+ printf ("%lu (bytes)\n", (unsigned long) entry->d_un.d_val);
break;
case DT_VERDEFNUM:
case DT_RELACOUNT:
case DT_RELCOUNT:
if (do_dynamic)
- printf ("%ld\n", entry->d_un.d_val);
+ printf ("%lu\n", (unsigned long) entry->d_un.d_val);
break;
- case DT_SYMINSZ :
+ case DT_SYMINSZ:
case DT_SYMINENT:
- case DT_SYMINFO :
+ case DT_SYMINFO:
case DT_USED:
+ case DT_INIT_ARRAY:
+ case DT_FINI_ARRAY:
if (do_dynamic)
{
- char * name;
-
- if (dynamic_strings == NULL)
- name = NULL;
- else
- name = dynamic_strings + entry->d_un.d_val;
-
+ if (dynamic_strings != NULL && entry->d_tag == DT_USED)
+ {
+ char * name;
+ name = dynamic_strings + entry->d_un.d_val;
- if (name)
- {
- switch (entry->d_tag)
+ if (* name)
{
- case DT_USED:
printf (_("Not needed object: [%s]\n"), name);
break;
-
- default:
- printf ("%#lx\n", (long) entry->d_un.d_val);
}
}
- else
- printf ("%#lx\n", (long) entry->d_un.d_val);
+
+ printf ("%#lx\n", (long) entry->d_un.d_val);
}
break;
+ case DT_BIND_NOW:
+ /* The value of this entry is ignored. */
+ break;
+
default:
if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
- {
- version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
- entry->d_un.d_val;
+ version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
+ entry->d_un.d_val;
- if (do_dynamic)
- printf ("%#lx\n", (long) entry->d_un.d_ptr);
- }
- else
- switch (elf_header.e_machine)
- {
- case EM_MIPS:
- case EM_MIPS_RS4_BE:
- dynamic_segment_mips_val (entry);
- break;
- default:
- if (do_dynamic)
+ if (do_dynamic)
+ {
+ switch (elf_header.e_machine)
+ {
+ case EM_MIPS:
+ case EM_MIPS_RS4_BE:
+ dynamic_segment_mips_val (entry);
+ break;
+ default:
printf ("%#lx\n", (long) entry->d_un.d_ptr);
- }
+ }
+ }
break;
}
}
found = 1;
printf
- (_("\nVersion definition section '%s' contains %d entries:\n"),
+ (_("\nVersion definition section '%s' contains %ld entries:\n"),
SECTION_NAME (section), section->sh_info);
- printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
- section->sh_addr, section->sh_offset, section->sh_link,
+ printf (_(" Addr: 0x"));
+ printf_vma (section->sh_addr);
+ printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
+ section->sh_offset, section->sh_link,
SECTION_NAME (section_headers + section->sh_link));
GET_DATA_ALLOC (section->sh_offset, section->sh_size,
Elf_Internal_Verdaux aux;
int j;
int isum;
-
+
vstart = ((char *) edefs) + idx;
edef = (Elf_External_Verdef *) vstart;
printf (_(" %#06x: Rev: %d Flags: %s"),
idx, ent.vd_version, get_ver_flags (ent.vd_flags));
- printf (_(" Index: %ld Cnt: %ld "),
+ printf (_(" Index: %d Cnt: %d "),
ent.vd_ndx, ent.vd_cnt);
vstart += ent.vd_aux;
free (edefs);
}
- break;
-
+ break;
+
case SHT_GNU_verneed:
{
Elf_External_Verneed * eneed;
found = 1;
- printf (_("\nVersion needs section '%s' contains %d entries:\n"),
+ printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
SECTION_NAME (section), section->sh_info);
- printf
- (_(" Addr: %#08x Offset: %#08x Link to section: %d (%s)\n"),
- section->sh_addr, section->sh_offset, section->sh_link,
- SECTION_NAME (section_headers + section->sh_link));
+ printf (_(" Addr: 0x"));
+ printf_vma (section->sh_addr);
+ printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
+ section->sh_offset, section->sh_link,
+ SECTION_NAME (section_headers + section->sh_link));
GET_DATA_ALLOC (section->sh_offset, section->sh_size,
eneed, Elf_External_Verneed *,
idx += ent.vn_next;
}
-
+
free (eneed);
}
- break;
+ break;
case SHT_GNU_versym:
{
printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
SECTION_NAME (section), total);
- printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
- section->sh_addr, section->sh_offset, section->sh_link,
+ printf (_(" Addr: "));
+ printf_vma (section->sh_addr);
+ printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
+ section->sh_offset, section->sh_link,
SECTION_NAME (link_section));
GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
- loadaddr,
total * sizeof (short), edata,
- char *, "version symbol data");
+ unsigned char *, "version symbol data");
data = (unsigned short *) malloc (total * sizeof (short));
free (strtab);
free (symbols);
}
- break;
-
+ break;
+
default:
- break;
+ break;
}
}
default:
if (binding >= STB_LOPROC && binding <= STB_HIPROC)
sprintf (buff, _("<processor specific>: %d"), binding);
+ else if (binding >= STB_LOOS && binding <= STB_HIOS)
+ sprintf (buff, _("<OS specific>: %d"), binding);
else
sprintf (buff, _("<unknown>: %d"), binding);
return buff;
default:
if (type >= STT_LOPROC && type <= STT_HIPROC)
sprintf (buff, _("<processor specific>: %d"), type);
+ else if (type >= STT_LOOS && type <= STT_HIOS)
+ sprintf (buff, _("<OS specific>: %d"), type);
else
sprintf (buff, _("<unknown>: %d"), type);
return buff;
return "PRC";
else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
return "RSV";
+ else if (type >= SHN_LOOS && type <= SHN_HIOS)
+ return "OS ";
else
{
static char buff [32];
return 0;
}
- if (fread (& nb, sizeof (nb), 1, file) != 1)
+ if (fread (nb, sizeof (nb), 1, file) != 1)
{
error (_("Failed to read in number of buckets\n"));
return 0;
}
- if (fread (& nc, sizeof (nc), 1, file) != 1)
+ if (fread (nc, sizeof (nc), 1, file) != 1)
{
error (_("Failed to read in number of chains\n"));
return 0;
&& section->sh_type != SHT_DYNSYM)
continue;
- printf (_("\nSymbol table '%s' contains %d entries:\n"),
+ printf (_("\nSymbol table '%s' contains %lu entries:\n"),
SECTION_NAME (section),
- section->sh_size / section->sh_entsize);
+ (unsigned long) (section->sh_size / section->sh_entsize));
fputs (_(" Num: Value Size Type Bind Ot Ndx Name\n"),
stdout);
}
for (hn = 0; hn < nbuckets; ++hn)
- ++counts[lengths[hn]];
+ ++ counts [lengths [hn]];
printf (" 0 %-10d (%5.1f%%)\n",
counts[0], (counts[0] * 100.0) / nbuckets);
return 0;
if (dynamic_addr)
- printf (_("\nDynamic info segment at offset 0x%x contains %d entries:\n"),
+ printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
dynamic_syminfo_offset, dynamic_syminfo_nent);
printf (_(" Num: Name BoundTo Flags\n"));
int bytes;
int addr;
unsigned char * data;
- char * start;
-
+ unsigned char * start;
+
bytes = section->sh_size;
-
+
if (bytes == 0)
{
printf (_("\nSection '%s' has no data to dump.\n"),
}
else
printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
-
- addr = section->sh_addr;
-
- GET_DATA_ALLOC (section->sh_offset, bytes, start, char *,
+
+ addr = section->sh_addr;
+
+ GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
"section data");
-
+
data = start;
-
+
while (bytes)
{
int j;
int k;
int lbytes;
-
+
lbytes = (bytes > 16 ? 16 : bytes);
-
+
printf (" 0x%8.8x ", addr);
-
+
switch (elf_header.e_ident [EI_DATA])
{
case ELFDATA2LSB:
printf ("%2.2x", data [j]);
else
printf (" ");
-
+
if (!(j & 0x3))
printf (" ");
}
break;
-
+
case ELFDATA2MSB:
for (j = 0; j < 16; j++)
{
printf ("%2.2x", data [j]);
else
printf (" ");
-
+
if ((j & 3) == 3)
printf (" ");
}
break;
}
-
+
for (j = 0; j < lbytes; j++)
{
k = data [j];
else
printf (".");
}
-
+
putchar ('\n');
-
+
data += lbytes;
addr += lbytes;
bytes -= lbytes;
}
-
+
free (start);
return 1;
unsigned int num_read = 0;
int shift = 0;
unsigned char byte;
-
+
do
{
byte = * data ++;
result |= (byte & 0x7f) << shift;
shift += 7;
-
+
}
while (byte & 0x80);
- * length_return = num_read;
+ if (length_return != NULL)
+ * length_return = num_read;
if (sign && (shift < 32) && (byte & 0x40))
result |= -1 << shift;
-
+
return result;
}
+typedef struct State_Machine_Registers
+{
+ unsigned long address;
+ unsigned int file;
+ unsigned int line;
+ unsigned int column;
+ int is_stmt;
+ int basic_block;
+ int end_sequence;
+/* This variable hold the number of the last entry seen
+ in the File Table. */
+ unsigned int last_file_entry;
+} SMR;
+
+static SMR state_machine_regs;
+static void
+reset_state_machine (is_stmt)
+ int is_stmt;
+{
+ state_machine_regs.address = 0;
+ state_machine_regs.file = 1;
+ state_machine_regs.line = 1;
+ state_machine_regs.column = 0;
+ state_machine_regs.is_stmt = is_stmt;
+ state_machine_regs.basic_block = 0;
+ state_machine_regs.end_sequence = 0;
+ state_machine_regs.last_file_entry = 0;
+}
+
+/* Handled an extend line op. Returns true if this is the end
+ of sequence. */
static int
-process_extended_line_op (data, address)
+process_extended_line_op (data, is_stmt)
unsigned char * data;
- long * address;
+ int is_stmt;
{
unsigned char op_code;
int bytes_read;
- int length;
- unsigned char * orig_data = data;
-
- length = read_leb128 (data, & bytes_read, 0);
- data += bytes_read;
- length += bytes_read;
+ unsigned int len;
+ unsigned char * name;
+ unsigned long adr;
+ len = read_leb128 (data, & bytes_read, 0);
+ data += bytes_read;
+
+ if (len == 0)
+ {
+ warn (_("badly formed extended line op encountered!"));
+ return bytes_read;
+ }
+
+ len += bytes_read;
op_code = * data ++;
+ printf (_(" Extended opcode %d: "), op_code);
+
switch (op_code)
{
case DW_LNE_end_sequence:
- printf (_(" End Sequence\n\n"));
+ printf (_("End of Sequence\n\n"));
+ reset_state_machine (is_stmt);
break;
-
+
case DW_LNE_set_address:
/* XXX - assumption here that address size is 4! */
- * address = byte_get (data, 4);
- printf (_(" Set Address to %lx\n"), * address);
+ adr = byte_get (data, 4);
+ printf (_("set Address to 0x%lx\n"), adr);
+ state_machine_regs.address = adr;
break;
-
+
case DW_LNE_define_file:
- printf (_(" Define File: %s"), data);
+ printf (_(" define new File Table entry\n"));
+ printf (_(" Entry\tDir\tTime\tSize\tName\n"));
+
+ printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
+ name = data;
data += strlen (data) + 1;
- printf (_(" Dir: %d"), read_leb128 (data, & bytes_read, 0));
+ printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
data += bytes_read;
- printf (_(" Time: %d"), read_leb128 (data, & bytes_read, 0));
+ printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
data += bytes_read;
- printf (_(" Size: %d"), read_leb128 (data, & bytes_read, 0));
+ printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+ printf (_("%s\n\n"), name);
break;
-
+
default:
- warn (_("Unknown extended line op: %d of length %d\n"),
- op_code, length - bytes_read);
+ printf (_("UNKNOWN: length %d\n"), len - bytes_read);
break;
}
- return length;
+ return len;
}
DWARF2_External_LineInfo * external;
DWARF2_Internal_LineInfo info;
unsigned char * standard_opcodes;
- int i;
unsigned char * data = start;
unsigned char * end = start + section->sh_size;
- unsigned long address;
- unsigned int line;
- int is_stmt;
-
-
+ unsigned char * end_of_sequence;
+ int i;
+
printf (_("\nDump of debug contents of section %s:\n\n"),
SECTION_NAME (section));
-
- external = (DWARF2_External_LineInfo *) start;
- /* Check the length of the block. */
- info.li_length = BYTE_GET (external->li_length);
- if (info.li_length > section->sh_size)
- {
- warn
- (_("The line info appears to be corrupt - the section is too small\n"));
- return 0;
- }
-
- /* Check its version number. */
- info.li_version = BYTE_GET (external->li_version);
- if (info.li_version != 2)
+ while (data < end)
{
- warn (_("Only DWARF version 2 line info is currently supported.\n"));
- return 0;
- }
-
- info.li_prologue_length = BYTE_GET (external->li_prologue_length);
- info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
- info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
- info.li_line_base = BYTE_GET (external->li_line_base);
- info.li_line_range = BYTE_GET (external->li_line_range);
- info.li_opcode_base = BYTE_GET (external->li_opcode_base);
-
- /* Sign extend the line base field. */
- info.li_line_base <<= 24;
- info.li_line_base >>= 24;
-
- printf (_(" Length: %d\n"), info.li_length);
- printf (_(" DWARF Version: %d\n"), info.li_version);
- printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
- printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
- printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
- printf (_(" Line Base: %d\n"), info.li_line_base);
- printf (_(" Line Range: %d\n"), info.li_line_range);
- printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
-
- /* Display the contents of the Opcodes table. */
- standard_opcodes = start + sizeof (* external);
-
- printf (_("\n Opcodes:\n"));
-
- for (i = 1; i < info.li_opcode_base; i++)
- printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i]);
+ external = (DWARF2_External_LineInfo *) data;
-
- /* Display the contents of the Directory table. */
- data = standard_opcodes + info.li_opcode_base - 1;
-
- if (* data == 0)
- printf (_("\n The Directory Table is empty\n"));
- else
- {
- printf (_("\n The Directory Table:\n"));
+ /* Check the length of the block. */
+ info.li_length = BYTE_GET (external->li_length);
+ if (info.li_length > section->sh_size)
+ {
+ warn
+ (_("The line info appears to be corrupt - the section is too small\n"));
+ return 0;
+ }
- while (* data != 0)
+ /* Check its version number. */
+ info.li_version = BYTE_GET (external->li_version);
+ if (info.li_version != 2)
{
- printf (_(" %s\n"), data);
-
- data += strlen (data) + 1;
+ warn (_("Only DWARF version 2 line info is currently supported.\n"));
+ return 0;
}
- }
-
- /* Skip the NUL at the end of the table. */
- data ++;
-
- /* Display the contents of the File Name table. */
- if (* data == 0)
- printf (_("\n The File Name Table is empty\n"));
- else
- {
- printf (_("\n The File Name Table:\n"));
- printf (_(" Name\t\tDir\tTime\tSize\n"));
- while (* data != 0)
+ info.li_prologue_length = BYTE_GET (external->li_prologue_length);
+ info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
+ info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
+ info.li_line_base = BYTE_GET (external->li_line_base);
+ info.li_line_range = BYTE_GET (external->li_line_range);
+ info.li_opcode_base = BYTE_GET (external->li_opcode_base);
+
+ /* Sign extend the line base field. */
+ info.li_line_base <<= 24;
+ info.li_line_base >>= 24;
+
+ printf (_(" Length: %ld\n"), info.li_length);
+ printf (_(" DWARF Version: %d\n"), info.li_version);
+ printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
+ printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
+ printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
+ printf (_(" Line Base: %d\n"), info.li_line_base);
+ printf (_(" Line Range: %d\n"), info.li_line_range);
+ printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
+
+ end_of_sequence = data + info.li_length + sizeof (info.li_length);
+
+ reset_state_machine (info.li_default_is_stmt);
+
+ /* Display the contents of the Opcodes table. */
+ standard_opcodes = data + sizeof (* external);
+
+ printf (_("\n Opcodes:\n"));
+
+ for (i = 1; i < info.li_opcode_base; i++)
+ printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i]);
+
+ /* Display the contents of the Directory table. */
+ data = standard_opcodes + info.li_opcode_base - 1;
+
+ if (* data == 0)
+ printf (_("\n The Directory Table is empty.\n"));
+ else
{
- int bytes_read;
+ printf (_("\n The Directory Table:\n"));
- printf (_(" %s"), data);
-
- data += strlen (data) + 1;
-
- printf (_("\t%lu"), read_leb128 (data, & bytes_read, 0));
- data += bytes_read;
- printf (_("\t%lu"), read_leb128 (data, & bytes_read, 0));
- data += bytes_read;
- printf (_("\t%lu\n"), read_leb128 (data, & bytes_read, 0));
- data += bytes_read;
+ while (* data != 0)
+ {
+ printf (_(" %s\n"), data);
+
+ data += strlen (data) + 1;
+ }
}
- }
-
- /* Skip the NUL at the end of the table. */
- data ++;
-
- /* Now display the statements: */
- printf (_("\n Line Number Statements:\n"));
-
- address = 0;
- line = 1;
- is_stmt = info.li_default_is_stmt;
-
- while (data < end)
- {
- unsigned char op_code;
- int adv;
- int bytes_read;
- op_code = * data ++;
-
- switch (op_code)
+ /* Skip the NUL at the end of the table. */
+ data ++;
+
+ /* Display the contents of the File Name table. */
+ if (* data == 0)
+ printf (_("\n The File Name Table is empty.\n"));
+ else
{
- case DW_LNS_extended_op:
- data += process_extended_line_op (data, & address);
- break;
-
- case DW_LNS_copy:
- printf (_(" Copy\n"));
- break;
-
- case DW_LNS_advance_pc:
- adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
- data += bytes_read;
- address += adv;
- printf (_(" Advance PC by %x to %x\n"), adv, address);
- break;
+ printf (_("\n The File Name Table:\n"));
+ printf (_(" Entry\tDir\tTime\tSize\tName\n"));
- case DW_LNS_advance_line:
- adv = read_leb128 (data, & bytes_read, 0);
- data += bytes_read;
- line += adv;
- printf (_(" Advance Line by %d to %d\n"), adv, line);
- break;
-
- case DW_LNS_set_file:
- adv = read_leb128 (data, & bytes_read, 0);
- data += bytes_read;
- printf (_(" Set File Name to entry %d in the File Name Table\n"),
- adv);
- break;
-
- case DW_LNS_set_column:
- adv = read_leb128 (data, & bytes_read, 0);
- data += bytes_read;
- printf (_(" Set column to %d\n"), adv);
- break;
-
- case DW_LNS_negate_stmt:
- printf (_(" Set is_stmt to %d\n"), is_stmt);
- break;
-
- case DW_LNS_set_basic_block:
- printf (_(" Set basic block\n"));
- break;
-
- case DW_LNS_const_add_pc:
- adv = (255 - info.li_opcode_base) / info.li_line_range;
- address += adv;
- printf (_(" Advance PC by constant %d to %x\n"), adv, address);
- break;
+ while (* data != 0)
+ {
+ char * name;
+ int bytes_read;
+
+ printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
+ name = data;
+
+ data += strlen (data) + 1;
+
+ printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+ data += bytes_read;
+ printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+ data += bytes_read;
+ printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
+ data += bytes_read;
+ printf (_("%s\n"), name);
+ }
+ }
+
+ /* Skip the NUL at the end of the table. */
+ data ++;
+
+ /* Now display the statements. */
+ printf (_("\n Line Number Statements:\n"));
+
+
+ while (data < end_of_sequence)
+ {
+ unsigned char op_code;
+ int adv;
+ int bytes_read;
- case DW_LNS_fixed_advance_pc:
- adv = byte_get (data, 2);
- data += 2;
- address += adv;
- printf (_(" Advance PC by fixed size amount %d to %x\n"),
- adv, address);
- break;
+ op_code = * data ++;
- default:
- op_code -= info.li_opcode_base;
- address += (op_code / info.li_line_range) * info.li_min_insn_length,
- line += (op_code % info.li_line_range) + info.li_line_base;
- printf
- (_(" Increase by %d, setting address to %lx and line to %d:\n"),
- op_code, address, line);
- break;
+ switch (op_code)
+ {
+ case DW_LNS_extended_op:
+ data += process_extended_line_op (data, info.li_default_is_stmt);
+ break;
+
+ case DW_LNS_copy:
+ printf (_(" Copy\n"));
+ break;
+
+ case DW_LNS_advance_pc:
+ adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
+ data += bytes_read;
+ state_machine_regs.address += adv;
+ printf (_(" Advance PC by %d to %lx\n"), adv,
+ state_machine_regs.address);
+ break;
+
+ case DW_LNS_advance_line:
+ adv = read_leb128 (data, & bytes_read, 1);
+ data += bytes_read;
+ state_machine_regs.line += adv;
+ printf (_(" Advance Line by %d to %d\n"), adv,
+ state_machine_regs.line);
+ break;
+
+ case DW_LNS_set_file:
+ adv = read_leb128 (data, & bytes_read, 0);
+ data += bytes_read;
+ printf (_(" Set File Name to entry %d in the File Name Table\n"),
+ adv);
+ state_machine_regs.file = adv;
+ break;
+
+ case DW_LNS_set_column:
+ adv = read_leb128 (data, & bytes_read, 0);
+ data += bytes_read;
+ printf (_(" Set column to %d\n"), adv);
+ state_machine_regs.column = adv;
+ break;
+
+ case DW_LNS_negate_stmt:
+ adv = state_machine_regs.is_stmt;
+ adv = ! adv;
+ printf (_(" Set is_stmt to %d\n"), adv);
+ state_machine_regs.is_stmt = adv;
+ break;
+
+ case DW_LNS_set_basic_block:
+ printf (_(" Set basic block\n"));
+ state_machine_regs.basic_block = 1;
+ break;
+
+ case DW_LNS_const_add_pc:
+ adv = (255 - info.li_opcode_base) / info.li_line_range;
+ state_machine_regs.address += adv;
+ printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
+ state_machine_regs.address);
+ break;
+
+ case DW_LNS_fixed_advance_pc:
+ adv = byte_get (data, 2);
+ data += 2;
+ state_machine_regs.address += adv;
+ printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
+ adv, state_machine_regs.address);
+ break;
+
+ default:
+ op_code -= info.li_opcode_base;
+ adv = (op_code / info.li_line_range) * info.li_min_insn_length;
+ state_machine_regs.address += adv;
+ printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
+ op_code, adv, state_machine_regs.address);
+ adv += (op_code % info.li_line_range) + info.li_line_base;
+ state_machine_regs.line += adv;
+ printf (_(" and Line by %d to %d\n"),
+ adv, state_machine_regs.line);
+ break;
+ }
}
+ printf ("\n");
}
return 1;
end = start + section->sh_size;
printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
-
+
while (start < end)
{
unsigned char * data;
unsigned long offset;
-
+
external = (DWARF2_External_PubNames *) start;
-
+
pubnames.pn_length = BYTE_GET (external->pn_length);
pubnames.pn_version = BYTE_GET (external->pn_version);
pubnames.pn_offset = BYTE_GET (external->pn_offset);
data = start + sizeof (* external);
start += pubnames.pn_length + sizeof (external->pn_length);
-
+
if (pubnames.pn_version != 2)
{
warn (_("Only DWARF 2 pubnames are currently supported"));
continue;
}
-
- printf (_(" Length: %d\n"),
+
+ printf (_(" Length: %ld\n"),
pubnames.pn_length);
printf (_(" Version: %d\n"),
pubnames.pn_version);
- printf (_(" Offset into .debug_info section: %d\n"),
+ printf (_(" Offset into .debug_info section: %ld\n"),
pubnames.pn_offset);
- printf (_(" Size of area in .debug_info section: %d\n"),
+ printf (_(" Size of area in .debug_info section: %ld\n"),
pubnames.pn_size);
printf (_("\n Offset\tName\n"));
if (offset != 0)
{
data += 4;
- printf (" %d\t\t%s\n", offset, data);
+ printf (" %ld\t\t%s\n", offset, data);
data += strlen (data) + 1;
}
}
while (offset != 0);
}
-
+
+ printf ("\n");
return 1;
}
default:
{
static char buffer [100];
-
- sprintf (buffer, _("Unknown TAG value: %x"), tag);
+
+ sprintf (buffer, _("Unknown TAG value: %lx"), tag);
return buffer;
}
}
default:
{
static char buffer [100];
-
- sprintf (buffer, _("Unknown AT value: %x"), attribute);
+
+ sprintf (buffer, _("Unknown AT value: %lx"), attribute);
return buffer;
}
}
default:
{
static char buffer [100];
-
- sprintf (buffer, _("Unknown FORM value: %x"), form);
+
+ sprintf (buffer, _("Unknown FORM value: %lx"), form);
return buffer;
}
}
free_abbrevs PARAMS ((void))
{
abbrev_entry * abbrev;
-
+
for (abbrev = first_abbrev; abbrev;)
{
abbrev_entry * next = abbrev->next;
abbrev_attr * attr;
-
+
for (attr = abbrev->first_attr; attr;)
{
abbrev_attr * next = attr->next;
-
+
free (attr);
attr = next;
}
-
+
free (abbrev);
abbrev = next;
}
first_abbrev = entry;
else
last_abbrev->next = entry;
-
+
last_abbrev = entry;
}
last_abbrev->first_attr = attr;
else
last_abbrev->last_attr->next = attr;
-
+
last_abbrev->last_attr = attr;
}
/* Processes the (partial) contents of a .debug_abbrev section.
- Returns NULL if the end of the section was encountered.
+ Returns NULL if the end of the section was encountered.
Returns the address after the last byte read if the end of
an abbreviation set was found. */
unsigned char * end;
{
if (first_abbrev != NULL)
- return;
-
+ return NULL;
+
while (start < end)
{
int bytes_read;
unsigned long tag;
unsigned long attribute;
int children;
-
+
entry = read_leb128 (start, & bytes_read, 0);
start += bytes_read;
if (entry == 0)
return start;
-
+
tag = read_leb128 (start, & bytes_read, 0);
start += bytes_read;
do
{
unsigned long form;
-
+
attribute = read_leb128 (start, & bytes_read, 0);
start += bytes_read;
}
while (attribute != 0);
}
-
+
return NULL;
}
{
abbrev_entry * entry;
unsigned char * end = start + section->sh_size;
-
+
printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
do
{
start = process_abbrev_section (start, end);
-
+
printf (_(" Number TAG\n"));
for (entry = first_abbrev; entry; entry = entry->next)
{
abbrev_attr * attr;
-
- printf (_(" %d %s [%s]\n"),
- entry->entry,
+
+ printf (_(" %ld %s [%s]\n"),
+ entry->entry,
get_TAG_name (entry->tag),
entry->children ? _("has children") : _("no children"));
-
+
for (attr = entry->first_attr; attr; attr = attr->next)
{
printf (_(" %-18s %s\n"),
}
}
while (start);
-
+
printf ("\n");
-
+
return 1;
}
unsigned char * data;
unsigned long length;
{
- printf (_(" %d byte block: "), length);
-
+ printf (_(" %lu byte block: "), length);
+
while (length --)
- printf ("%x ", byte_get (data ++, 1));
+ printf ("%lx ", byte_get (data ++, 1));
return data;
}
+static void
+decode_location_expression (data, pointer_size)
+ unsigned char * data;
+ unsigned int pointer_size;
+{
+ unsigned char op;
+ int bytes_read;
+
+ op = * data ++;
+
+ switch (op)
+ {
+ case DW_OP_addr: printf ("DW_OP_addr: %lx", byte_get (data, pointer_size)); break;
+ case DW_OP_deref: printf ("DW_OP_deref"); break;
+ case DW_OP_const1u: printf ("DW_OP_const1u: %lu", byte_get (data, 1)); break;
+ case DW_OP_const1s: printf ("DW_OP_const1s: %ld", (long) byte_get (data, 1)); break;
+ case DW_OP_const2u: printf ("DW_OP_const2u: %lu", byte_get (data, 2)); break;
+ case DW_OP_const2s: printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2)); break;
+ case DW_OP_const4u: printf ("DW_OP_const4u: %lu", byte_get (data, 4)); break;
+ case DW_OP_const4s: printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4)); break;
+ case DW_OP_const8u: printf ("DW_OP_const8u: %lu %lu", byte_get (data, 4), byte_get (data + 4, 4)); break;
+ case DW_OP_const8s: printf ("DW_OP_const8s: %ld %ld", byte_get (data, 4), byte_get (data + 4, 4)); break;
+ case DW_OP_constu: printf ("DW_OP_constu: %lu", read_leb128 (data, NULL, 0)); break;
+ case DW_OP_consts: printf ("DW_OP_consts: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_dup: printf ("DW_OP_dup"); break;
+ case DW_OP_drop: printf ("DW_OP_drop"); break;
+ case DW_OP_over: printf ("DW_OP_over"); break;
+ case DW_OP_pick: printf ("DW_OP_pick: %ld", byte_get (data, 1)); break;
+ case DW_OP_swap: printf ("DW_OP_swap"); break;
+ case DW_OP_rot: printf ("DW_OP_rot"); break;
+ case DW_OP_xderef: printf ("DW_OP_xderef"); break;
+ case DW_OP_abs: printf ("DW_OP_abs"); break;
+ case DW_OP_and: printf ("DW_OP_and"); break;
+ case DW_OP_div: printf ("DW_OP_div"); break;
+ case DW_OP_minus: printf ("DW_OP_minus"); break;
+ case DW_OP_mod: printf ("DW_OP_mod"); break;
+ case DW_OP_mul: printf ("DW_OP_mul"); break;
+ case DW_OP_neg: printf ("DW_OP_neg"); break;
+ case DW_OP_not: printf ("DW_OP_not"); break;
+ case DW_OP_or: printf ("DW_OP_or"); break;
+ case DW_OP_plus: printf ("DW_OP_plus"); break;
+ case DW_OP_plus_uconst: printf ("DW_OP_plus_uconst: %lu", read_leb128 (data, NULL, 0)); break;
+ case DW_OP_shl: printf ("DW_OP_shl"); break;
+ case DW_OP_shr: printf ("DW_OP_shr"); break;
+ case DW_OP_shra: printf ("DW_OP_shra"); break;
+ case DW_OP_xor: printf ("DW_OP_xor"); break;
+ case DW_OP_bra: printf ("DW_OP_bra: %ld", byte_get (data, 2)); break;
+ case DW_OP_eq: printf ("DW_OP_eq"); break;
+ case DW_OP_ge: printf ("DW_OP_ge"); break;
+ case DW_OP_gt: printf ("DW_OP_gt"); break;
+ case DW_OP_le: printf ("DW_OP_le"); break;
+ case DW_OP_lt: printf ("DW_OP_lt"); break;
+ case DW_OP_ne: printf ("DW_OP_ne"); break;
+ case DW_OP_skip: printf ("DW_OP_skip: %ld", byte_get (data, 2)); break;
+ case DW_OP_lit0: printf ("DW_OP_lit0"); break;
+ case DW_OP_lit1: printf ("DW_OP_lit1"); break;
+ case DW_OP_lit2: printf ("DW_OP_lit2"); break;
+ case DW_OP_lit3: printf ("DW_OP_lit3"); break;
+ case DW_OP_lit4: printf ("DW_OP_lit4"); break;
+ case DW_OP_lit5: printf ("DW_OP_lit5"); break;
+ case DW_OP_lit6: printf ("DW_OP_lit6"); break;
+ case DW_OP_lit7: printf ("DW_OP_lit7"); break;
+ case DW_OP_lit8: printf ("DW_OP_lit8"); break;
+ case DW_OP_lit9: printf ("DW_OP_lit9"); break;
+ case DW_OP_lit10: printf ("DW_OP_lit10"); break;
+ case DW_OP_lit11: printf ("DW_OP_lit11"); break;
+ case DW_OP_lit12: printf ("DW_OP_lit12"); break;
+ case DW_OP_lit13: printf ("DW_OP_lit13"); break;
+ case DW_OP_lit14: printf ("DW_OP_lit14"); break;
+ case DW_OP_lit15: printf ("DW_OP_lit15"); break;
+ case DW_OP_lit16: printf ("DW_OP_lit16"); break;
+ case DW_OP_lit17: printf ("DW_OP_lit17"); break;
+ case DW_OP_lit18: printf ("DW_OP_lit18"); break;
+ case DW_OP_lit19: printf ("DW_OP_lit19"); break;
+ case DW_OP_lit20: printf ("DW_OP_lit20"); break;
+ case DW_OP_lit21: printf ("DW_OP_lit21"); break;
+ case DW_OP_lit22: printf ("DW_OP_lit22"); break;
+ case DW_OP_lit23: printf ("DW_OP_lit23"); break;
+ case DW_OP_lit24: printf ("DW_OP_lit24"); break;
+ case DW_OP_lit25: printf ("DW_OP_lit25"); break;
+ case DW_OP_lit26: printf ("DW_OP_lit26"); break;
+ case DW_OP_lit27: printf ("DW_OP_lit27"); break;
+ case DW_OP_lit28: printf ("DW_OP_lit28"); break;
+ case DW_OP_lit29: printf ("DW_OP_lit29"); break;
+ case DW_OP_lit30: printf ("DW_OP_lit30"); break;
+ case DW_OP_lit31: printf ("DW_OP_lit31"); break;
+ case DW_OP_reg0: printf ("DW_OP_reg0"); break;
+ case DW_OP_reg1: printf ("DW_OP_reg1"); break;
+ case DW_OP_reg2: printf ("DW_OP_reg2"); break;
+ case DW_OP_reg3: printf ("DW_OP_reg3"); break;
+ case DW_OP_reg4: printf ("DW_OP_reg4"); break;
+ case DW_OP_reg5: printf ("DW_OP_reg5"); break;
+ case DW_OP_reg6: printf ("DW_OP_reg6"); break;
+ case DW_OP_reg7: printf ("DW_OP_reg7"); break;
+ case DW_OP_reg8: printf ("DW_OP_reg8"); break;
+ case DW_OP_reg9: printf ("DW_OP_reg9"); break;
+ case DW_OP_reg10: printf ("DW_OP_reg10"); break;
+ case DW_OP_reg11: printf ("DW_OP_reg11"); break;
+ case DW_OP_reg12: printf ("DW_OP_reg12"); break;
+ case DW_OP_reg13: printf ("DW_OP_reg13"); break;
+ case DW_OP_reg14: printf ("DW_OP_reg14"); break;
+ case DW_OP_reg15: printf ("DW_OP_reg15"); break;
+ case DW_OP_reg16: printf ("DW_OP_reg16"); break;
+ case DW_OP_reg17: printf ("DW_OP_reg17"); break;
+ case DW_OP_reg18: printf ("DW_OP_reg18"); break;
+ case DW_OP_reg19: printf ("DW_OP_reg19"); break;
+ case DW_OP_reg20: printf ("DW_OP_reg20"); break;
+ case DW_OP_reg21: printf ("DW_OP_reg21"); break;
+ case DW_OP_reg22: printf ("DW_OP_reg22"); break;
+ case DW_OP_reg23: printf ("DW_OP_reg23"); break;
+ case DW_OP_reg24: printf ("DW_OP_reg24"); break;
+ case DW_OP_reg25: printf ("DW_OP_reg25"); break;
+ case DW_OP_reg26: printf ("DW_OP_reg26"); break;
+ case DW_OP_reg27: printf ("DW_OP_reg27"); break;
+ case DW_OP_reg28: printf ("DW_OP_reg28"); break;
+ case DW_OP_reg29: printf ("DW_OP_reg29"); break;
+ case DW_OP_reg30: printf ("DW_OP_reg30"); break;
+ case DW_OP_reg31: printf ("DW_OP_reg31"); break;
+ case DW_OP_breg0: printf ("DW_OP_breg0: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg1: printf ("DW_OP_breg1: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg2: printf ("DW_OP_breg2: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg3: printf ("DW_OP_breg3: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg4: printf ("DW_OP_breg4: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg5: printf ("DW_OP_breg5: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg6: printf ("DW_OP_breg6: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg7: printf ("DW_OP_breg7: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg8: printf ("DW_OP_breg8: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg9: printf ("DW_OP_breg9: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg10: printf ("DW_OP_breg10: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg11: printf ("DW_OP_breg11: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg12: printf ("DW_OP_breg12: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg13: printf ("DW_OP_breg13: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg14: printf ("DW_OP_breg14: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg15: printf ("DW_OP_breg15: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg16: printf ("DW_OP_breg16: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg17: printf ("DW_OP_breg17: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg18: printf ("DW_OP_breg18: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg19: printf ("DW_OP_breg19: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg20: printf ("DW_OP_breg20: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg21: printf ("DW_OP_breg21: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg22: printf ("DW_OP_breg22: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg23: printf ("DW_OP_breg23: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg24: printf ("DW_OP_breg24: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg25: printf ("DW_OP_breg25: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg26: printf ("DW_OP_breg26: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg27: printf ("DW_OP_breg27: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg28: printf ("DW_OP_breg28: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg29: printf ("DW_OP_breg29: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg30: printf ("DW_OP_breg30: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_breg31: printf ("DW_OP_breg31: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_regx: printf ("DW_OP_regx: %lu", read_leb128 (data, NULL, 0)); break;
+ case DW_OP_fbreg: printf ("DW_OP_fbreg: %ld", read_leb128 (data, NULL, 1)); break;
+ case DW_OP_bregx: printf ("DW_OP_bregx: %lu %ld", read_leb128 (data, & bytes_read, 0), read_leb128 (data + bytes_read, NULL, 1)); break;
+ case DW_OP_piece: printf ("DW_OP_piece: %lu", read_leb128 (data, NULL, 0)); break;
+ case DW_OP_deref_size: printf ("DW_OP_deref_size: %ld", byte_get (data, 1)); break;
+ case DW_OP_xderef_size: printf ("DW_OP_xderef_size: %ld", byte_get (data, 1)); break;
+ case DW_OP_nop: printf ("DW_OP_nop"); break;
+
+ default:
+ if (op >= DW_OP_lo_user
+ && op <= DW_OP_hi_user)
+ printf (_("(User defined location op)"));
+ else
+ printf (_("(Unknown location op)"));
+ break;
+ }
+}
+
+
static unsigned char *
read_and_display_attr (attribute, form, data, pointer_size)
unsigned long attribute;
unsigned char * data;
unsigned long pointer_size;
{
- unsigned long uvalue;
- int bytes_read;
-
+ unsigned long uvalue;
+ unsigned char * block_start;
+ int bytes_read;
+ int is_ref = 0;
+
printf (" %-18s:", get_AT_name (attribute));
-
+
+ switch (form)
+ {
+ case DW_FORM_ref_addr:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ case DW_FORM_ref_udata:
+ is_ref = 1;
+ }
+
switch (form)
{
case DW_FORM_ref_addr:
case DW_FORM_addr:
uvalue = byte_get (data, pointer_size);
- printf (" %x", uvalue);
+ printf (is_ref ? " <%x>" : " %#x", uvalue);
data += pointer_size;
break;
-
- case DW_FORM_ref1:
- case DW_FORM_flag:
+
+ case DW_FORM_ref1:
+ case DW_FORM_flag:
case DW_FORM_data1:
uvalue = byte_get (data ++, 1);
- printf (" %x", uvalue);
+ printf (is_ref ? " <%x>" : " %d", uvalue);
break;
-
- case DW_FORM_ref2:
+
+ case DW_FORM_ref2:
case DW_FORM_data2:
uvalue = byte_get (data, 2);
data += 2;
- printf (" %x", uvalue);
+ printf (is_ref ? " <%x>" : " %d", uvalue);
break;
-
- case DW_FORM_ref4:
+
+ case DW_FORM_ref4:
case DW_FORM_data4:
uvalue = byte_get (data, 4);
data += 4;
- printf (" %x", uvalue);
+ printf (is_ref ? " <%x>" : " %d", uvalue);
break;
-
- case DW_FORM_ref8:
+
+ case DW_FORM_ref8:
case DW_FORM_data8:
uvalue = byte_get (data, 4);
- printf (" %x", uvalue);
- printf (" %x", byte_get (data + 4, 4));
+ printf (" %lx", uvalue);
+ printf (" %lx", byte_get (data + 4, 4));
data += 8;
break;
-
+
case DW_FORM_string:
printf (" %s", data);
data += strlen (data) + 1;
break;
-
+
case DW_FORM_sdata:
uvalue = read_leb128 (data, & bytes_read, 1);
data += bytes_read;
printf (" %ld", (long) uvalue);
break;
-
- case DW_FORM_ref_udata:
- case DW_FORM_udata:
+
+ case DW_FORM_ref_udata:
+ case DW_FORM_udata:
uvalue = read_leb128 (data, & bytes_read, 0);
data += bytes_read;
- printf (" %lx", uvalue);
+ printf (is_ref ? " <%lx>" : " %ld", uvalue);
break;
-
+
case DW_FORM_block:
uvalue = read_leb128 (data, & bytes_read, 0);
- data = display_block (data + bytes_read, uvalue);
- uvalue = * (data - uvalue);
+ block_start = data + bytes_read;
+ data = display_block (block_start, uvalue);
+ uvalue = * block_start;
break;
-
- case DW_FORM_block1:
- uvalue = byte_get (data ++, 1);
- data = display_block (data, uvalue);
- uvalue = * (data - uvalue);
+
+ case DW_FORM_block1:
+ uvalue = byte_get (data, 1);
+ block_start = data + 1;
+ data = display_block (block_start, uvalue);
+ uvalue = * block_start;
break;
-
+
case DW_FORM_block2:
uvalue = byte_get (data, 2);
- data = display_block (data + 2, uvalue);
- uvalue = * (data - uvalue);
+ block_start = data + 2;
+ data = display_block (block_start, uvalue);
+ uvalue = * block_start;
break;
-
+
case DW_FORM_block4:
uvalue = byte_get (data, 4);
- data = display_block (data + 4, uvalue);
- uvalue = * (data - uvalue);
+ block_start = data + 4;
+ data = display_block (block_start, uvalue);
+ uvalue = * block_start;
break;
-
- case DW_FORM_strp:
- case DW_FORM_indirect:
+
+ case DW_FORM_strp:
+ case DW_FORM_indirect:
warn (_("Unable to handle FORM: %d"), form);
break;
-
+
default:
warn (_("Unrecognised form: %d"), form);
break;
/* For some attributes we can display futher information. */
printf ("\t");
-
+
switch (attribute)
{
case DW_AT_inline:
case DW_INL_not_inlined: printf (_("(not inlined)")); break;
case DW_INL_inlined: printf (_("(inlined)")); break;
case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
- case DW_INL_declared_inlined: printf (_("(declared as inline and implemented)")); break;
- defailt: printf (_(" (Unknown inline attribute value: %x)"), uvalue); break;
+ case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
+ default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
}
break;
-
+
case DW_AT_frame_base:
if (uvalue >= DW_OP_reg0 && uvalue <= DW_OP_reg31)
- printf ("(reg %d)", uvalue - DW_OP_reg0);
+ printf ("(reg %ld)", uvalue - DW_OP_reg0);
break;
-
+
case DW_AT_language:
switch (uvalue)
{
case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
- default: printf ("(Unknown: %x)", uvalue); break;
+ default: printf ("(Unknown: %lx)", uvalue); break;
}
break;
-
+
+ case DW_AT_encoding:
+ switch (uvalue)
+ {
+ case DW_ATE_void: printf ("(void)"); break;
+ case DW_ATE_address: printf ("(machine address)"); break;
+ case DW_ATE_boolean: printf ("(boolean)"); break;
+ case DW_ATE_complex_float: printf ("(complex float)"); break;
+ case DW_ATE_float: printf ("(float)"); break;
+ case DW_ATE_signed: printf ("(signed)"); break;
+ case DW_ATE_signed_char: printf ("(signed char)"); break;
+ case DW_ATE_unsigned: printf ("(unsigned)"); break;
+ case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
+ default:
+ if (uvalue >= DW_ATE_lo_user
+ && uvalue <= DW_ATE_hi_user)
+ printf ("(user defined type)");
+ else
+ printf ("(unknown type)");
+ break;
+ }
+ break;
+
+ case DW_AT_accessibility:
+ switch (uvalue)
+ {
+ case DW_ACCESS_public: printf ("(public)"); break;
+ case DW_ACCESS_protected: printf ("(protected)"); break;
+ case DW_ACCESS_private: printf ("(private)"); break;
+ default: printf ("(unknown accessibility)"); break;
+ }
+ break;
+
+ case DW_AT_visibility:
+ switch (uvalue)
+ {
+ case DW_VIS_local: printf ("(local)"); break;
+ case DW_VIS_exported: printf ("(exported)"); break;
+ case DW_VIS_qualified: printf ("(qualified)"); break;
+ default: printf ("(unknown visibility)"); break;
+ }
+ break;
+
+ case DW_AT_virtuality:
+ switch (uvalue)
+ {
+ case DW_VIRTUALITY_none: printf ("(none)"); break;
+ case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
+ case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
+ default: printf ("(unknown virtuality)"); break;
+ }
+ break;
+
+ case DW_AT_identifier_case:
+ switch (uvalue)
+ {
+ case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
+ case DW_ID_up_case: printf ("(up_case)"); break;
+ case DW_ID_down_case: printf ("(down_case)"); break;
+ case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
+ default: printf ("(unknown case)"); break;
+ }
+ break;
+
+ case DW_AT_calling_convention:
+ switch (uvalue)
+ {
+ case DW_CC_normal: printf ("(normal)"); break;
+ case DW_CC_program: printf ("(program)"); break;
+ case DW_CC_nocall: printf ("(nocall)"); break;
+ default:
+ if (uvalue >= DW_CC_lo_user
+ && uvalue <= DW_CC_hi_user)
+ printf ("(user defined)");
+ else
+ printf ("(unknown convention)");
+ }
+ break;
+
+ case DW_AT_location:
+ case DW_AT_data_member_location:
+ case DW_AT_vtable_elem_location:
+ printf ("(");
+ decode_location_expression (block_start, pointer_size);
+ printf (")");
+ break;
+
default:
break;
}
FILE * file;
{
unsigned char * end = start + section->sh_size;
+ unsigned char * section_begin = start;
printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
DWARF2_Internal_CompUnit compunit;
unsigned char * tags;
int i;
-
+ int level;
+
external = (DWARF2_External_CompUnit *) start;
compunit.cu_length = BYTE_GET (external->cu_length);
tags = start + sizeof (* external);
start += compunit.cu_length + sizeof (external->cu_length);
-
+
if (compunit.cu_version != 2)
{
warn (_("Only version 2 DWARF debug information is currently supported.\n"));
}
printf (_(" Compilation Unit:\n"));
- printf (_(" Length: %d\n"), compunit.cu_length);
+ printf (_(" Length: %ld\n"), compunit.cu_length);
printf (_(" Version: %d\n"), compunit.cu_version);
- printf (_(" Abbrev Offset: %d\n"), compunit.cu_abbrev_offset);
+ printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
-
+
if (first_abbrev != NULL)
free_abbrevs ();
/* Read in the abbrevs used by this compilation unit. */
-
+
{
Elf32_Internal_Shdr * sec;
unsigned char * begin;
-
+
/* Locate the .debug_abbrev section and process it. */
for (i = 0, sec = section_headers;
i < elf_header.e_shnum;
i ++, sec ++)
if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
break;
-
+
if (i == -1 || sec->sh_size == 0)
{
warn (_("Unable to locate .debug_abbrev section!\n"));
return 0;
}
-
- GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, char *,
+
+ GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
"debug_abbrev section data");
-
+
process_abbrev_section (begin + compunit.cu_abbrev_offset,
begin + sec->sh_size);
-
+
free (begin);
}
-
+
+ level = 0;
while (tags < start)
{
int bytes_read;
int abbrev_number;
abbrev_entry * entry;
abbrev_attr * attr;
-
+
abbrev_number = read_leb128 (tags, & bytes_read, 0);
tags += bytes_read;
+ /* A null DIE marks the end of a list of children. */
if (abbrev_number == 0)
- break;
-
+ {
+ --level;
+ continue;
+ }
+
/* Scan through the abbreviation list until we reach the
correct entry. */
for (entry = first_abbrev;
return 0;
}
- printf (_(" Abbrev Number: %d (%s)\n"),
+ printf (_(" <%d><%x>: Abbrev Number: %d (%s)\n"),
+ level, tags - section_begin - bytes_read,
abbrev_number,
get_TAG_name (entry->tag));
attr->form,
tags,
compunit.cu_pointer_size);
+
+ if (entry->children)
+ ++level;
}
}
-
+
+ printf ("\n");
+
return 1;
}
+static int
+display_debug_aranges (section, start, file)
+ Elf32_Internal_Shdr * section;
+ unsigned char * start;
+ FILE * file;
+{
+ unsigned char * end = start + section->sh_size;
+
+ printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
+
+ while (start < end)
+ {
+ DWARF2_External_ARange * external;
+ DWARF2_Internal_ARange arange;
+ unsigned char * ranges;
+ unsigned long length;
+ unsigned long address;
+
+ external = (DWARF2_External_ARange *) start;
+
+ arange.ar_length = BYTE_GET (external->ar_length);
+ arange.ar_version = BYTE_GET (external->ar_version);
+ arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
+ arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
+ arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
+
+ printf (_(" Length: %ld\n"), arange.ar_length);
+ printf (_(" Version: %d\n"), arange.ar_version);
+ printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
+ printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
+ printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
+
+ printf (_("\n Address Length\n"));
+
+ ranges = start + sizeof (* external);
+
+ for (;;)
+ {
+ address = byte_get (ranges, arange.ar_pointer_size);
+
+ if (address == 0)
+ break;
+
+ ranges += arange.ar_pointer_size;
+
+ length = byte_get (ranges, arange.ar_pointer_size);
+
+ ranges += arange.ar_pointer_size;
+
+ printf (" %8.8lx %lu\n", address, length);
+ }
+
+ start += arange.ar_length + sizeof (external->ar_length);
+ }
+
+ printf ("\n");
+
+ return 1;
+}
+
+
static int
display_debug_not_supported (section, start, file)
Elf32_Internal_Shdr * section;
{
printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
SECTION_NAME (section));
-
+
return 1;
}
}
debug_displays[] =
{
- { ".debug_info", display_debug_info },
- { ".debug_abbrev", display_debug_abbrev },
- { ".debug_line", display_debug_lines },
- { ".debug_aranges", display_debug_not_supported },
- { ".debug_pubnames", display_debug_pubnames },
- { ".debug_macinfo", display_debug_not_supported },
- { ".debug_frame", display_debug_not_supported },
- { ".debug_loc", display_debug_not_supported },
- { ".debug_str", display_debug_not_supported }
+ { ".debug_info", display_debug_info },
+ { ".debug_abbrev", display_debug_abbrev },
+ { ".debug_line", display_debug_lines },
+ { ".debug_aranges", display_debug_aranges },
+ { ".debug_pubnames", display_debug_pubnames },
+ { ".debug_macinfo", display_debug_not_supported },
+ { ".debug_frame", display_debug_not_supported },
+ { ".debug_str", display_debug_not_supported },
+ { ".debug_static_func", display_debug_not_supported },
+ { ".debug_static_vars", display_debug_not_supported },
+ { ".debug_types", display_debug_not_supported },
+ { ".debug_weaknames", display_debug_not_supported }
};
static int
bfd_size_type length;
unsigned char * start;
int i;
-
+
length = section->sh_size;
if (length == 0)
{
return 0;
}
- GET_DATA_ALLOC (section->sh_offset, length, start, char *,
+ GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
"debug section data");
-
+
/* See if we know how to display the contents of this section. */
for (i = NUM_ELEM (debug_displays); i--;)
if (strcmp (debug_displays[i].name, name) == 0)
if (i == -1)
printf (_("Unrecognised debug section: %s\n"), name);
-
+
free (start);
/* If we loaded in the abbrev section at some point,
we must release it here. */
if (first_abbrev != NULL)
free_abbrevs ();
-
+
return 1;
}
if (! do_dump)
return 1;
-
+
for (i = 0, section = section_headers;
i < elf_header.e_shnum
- && i < NUM_DUMP_SECTS;
+ && i < num_dump_sects;
i ++, section ++)
{
#ifdef SUPPORT_DISASSEMBLY
display_debug_section (section, file);
}
+ if (i < num_dump_sects)
+ warn (_("Some sections were not dumped because they do not exist!\n"));
+
return 1;
}
flags ^= l_flags_vals[fcnt].bit;
}
if (flags != 0)
- printf (" %#lx", flags);
+ printf (" %#x", (unsigned int) flags);
puts ("");
}
{
case ODK_NULL:
/* This shouldn't happen. */
- printf (" NULL %d %x", option->section, option->info);
+ printf (" NULL %d %lx", option->section, option->info);
break;
case ODK_REGINFO:
printf (" REGINFO ");
reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
- printf ("GPR %08lx GP %ld\n",
- reginfo.ri_gprmask, reginfo.ri_gp_value);
+ printf ("GPR %08lx GP 0x%lx\n",
+ reginfo.ri_gprmask,
+ (unsigned long) reginfo.ri_gp_value);
printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
- printf ("GPR %08lx GP %ld\n",
- reginfo.ri_gprmask, reginfo.ri_gp_value);
+ printf ("GPR %08lx GP 0x",
+ reginfo.ri_gprmask);
+ printf_vma (reginfo.ri_gp_value);
+ printf ("\n");
+
printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
fputs (" R4KEOP_CLEAN", stdout);
break;
case ODK_GP_GROUP:
- printf (" GP_GROUP %#06x self-contained %#06x",
+ printf (" GP_GROUP %#06lx self-contained %#06lx",
option->info & OGP_GROUP,
(option->info & OGP_SELF) >> 16);
break;
case ODK_IDENT:
- printf (" IDENT %#06x self-contained %#06x",
+ printf (" IDENT %#06lx self-contained %#06lx",
option->info & OGP_GROUP,
(option->info & OGP_SELF) >> 16);
break;
default:
/* This shouldn't happen. */
- printf (" %3d ??? %d %x",
+ printf (" %3d ??? %d %lx",
option->kind, option->section, option->info);
break;
}
{
Elf_Internal_Sym *psym = &dynamic_symbols[iconf[cnt]];
- printf ("%5u: %8u %#10x %s\n",
+ printf ("%5u: %8lu %#10lx %s\n",
cnt, iconf[cnt], (unsigned long) psym->st_value,
dynamic_strings + psym->st_name);
}
int argc;
char ** argv;
{
+#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
+ setlocale (LC_MESSAGES, "");
+#endif
+ bindtextdomain (PACKAGE, LOCALEDIR);
+ textdomain (PACKAGE);
+
parse_args (argc, argv);
if (optind < (argc - 1))
while (optind < argc)
process_file (argv [optind ++]);
+ if (dump_sects != NULL)
+ free (dump_sects);
+
return 0;
}
projects / thirdparty / binutils-gdb.git / blobdiff