/* readelf.c -- display contents of an ELF format file
- Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1998, 99, 2000 Free Software Foundation, Inc.
Originally developed by Eric Youngdale <eric@andante.jic.com>
Modifications by Nick Clifton <nickc@cygnus.com>
\f
#include <assert.h>
+#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <time.h>
#include "elf/mcore.h"
#include "elf/i960.h"
#include "elf/pj.h"
+#include "elf/avr.h"
+#include "elf/ia64.h"
#include "bucomm.h"
#include "getopt.h"
-#ifdef ANSI_PROTOTYPES
-#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
-
char * program_name = "readelf";
unsigned int dynamic_addr;
bfd_size_type dynamic_size;
static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
static char * get_file_type PARAMS ((unsigned));
static char * get_machine_name PARAMS ((unsigned));
+static void decode_ARM_machine_flags PARAMS ((unsigned, char []));
static char * get_machine_flags PARAMS ((unsigned, unsigned));
static const char * get_mips_segment_type PARAMS ((unsigned long));
static const char * get_parisc_segment_type PARAMS ((unsigned long));
static const char * get_mips_section_type_name PARAMS ((unsigned int));
static const char * get_parisc_section_type_name PARAMS ((unsigned int));
static const char * get_section_type_name PARAMS ((unsigned int));
-static char * get_symbol_binding PARAMS ((unsigned int));
-static char * get_symbol_type PARAMS ((unsigned int));
+static const char * get_symbol_binding PARAMS ((unsigned int));
+static const char * get_symbol_type PARAMS ((unsigned int));
+static const char * get_symbol_visibility PARAMS ((unsigned int));
+static const char * get_symbol_index_type PARAMS ((unsigned int));
+static const char * get_dynamic_flags PARAMS ((bfd_vma));
static void usage PARAMS ((void));
static void parse_args PARAMS ((int, char **));
static int process_file_header PARAMS ((void));
static int process_relocs PARAMS ((FILE *));
static int process_version_sections PARAMS ((FILE *));
static char * get_ver_flags PARAMS ((unsigned int));
-static char * get_symbol_index_type PARAMS ((unsigned int));
static int get_32bit_section_headers PARAMS ((FILE *));
static int get_64bit_section_headers PARAMS ((FILE *));
static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
static void free_abbrevs PARAMS ((void));
static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
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 * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
-static void decode_location_expression PARAMS ((unsigned char *, unsigned int));
+static void decode_location_expression PARAMS ((unsigned char *, unsigned int, unsigned long));
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));
case EM_SH:
case EM_ALPHA:
case EM_MCORE:
+ case EM_IA_64:
+ case EM_AVR:
return TRUE;
+ case EM_MMA:
+ case EM_PCP:
+ case EM_NCPU:
+ case EM_NDR1:
+ case EM_STARCORE:
+ case EM_ME16:
+ case EM_ST100:
+ case EM_TINYJ:
+ case EM_FX66:
+ case EM_ST9PLUS:
+ case EM_ST7:
+ case EM_68HC16:
+ case EM_68HC11:
+ case EM_68HC08:
+ case EM_68HC05:
+ case EM_SVX:
+ case EM_ST19:
+ case EM_VAX:
default:
warn (_("Don't know about relocations on this machine architecture\n"));
return FALSE;
rtype = elf_i960_reloc_type (type);
break;
+ case EM_AVR:
+ rtype = elf_avr_reloc_type (type);
+ break;
+
case EM_OLD_SPARCV9:
case EM_SPARC32PLUS:
case EM_SPARCV9:
case EM_PJ:
rtype = elf_pj_reloc_type (type);
break;
+ case EM_IA_64:
+ rtype = elf_ia64_reloc_type (type);
+ break;
}
if (rtype == NULL)
case DT_FINI_ARRAY: return "FINI_ARRAY";
case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
+ case DT_RUNPATH: return "RUNPATH";
+ case DT_FLAGS: return "FLAGS";
+
+ case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
+ case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
case DT_PLTPADSZ: return "PLTPADSZ";
case DT_MOVEENT: return "MOVEENT";
get_machine_name (e_machine)
unsigned e_machine;
{
- static char buff [32];
+ static char buff [64]; /* XXX */
switch (e_machine)
{
case EM_88K: return "MC88000";
case EM_486: return "Intel 80486";
case EM_860: return "Intel 80860";
- case EM_MIPS: return "MIPS R3000 big-endian";
- case EM_S370: return "Amdahl";
+ case EM_MIPS: return "MIPS R3000";
+ case EM_S370: return "IBM System/370";
case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
case EM_OLD_SPARCV9: return "Sparc v9 (old)";
case EM_PARISC: return "HPPA";
case EM_CYGNUS_MN10200: return "mn10200";
case EM_CYGNUS_FR30: return "Fujitsu FR30";
case EM_PJ: return "picoJava";
+ case EM_MMA: return "Fujitsu Multimedia Accelerator";
+ case EM_PCP: return "Siemens PCP";
+ case EM_NCPU: return "Sony nCPU embedded RISC processor";
+ case EM_NDR1: return "Denso NDR1 microprocesspr";
+ case EM_STARCORE: return "Motorola Star*Core processor";
+ case EM_ME16: return "Toyota ME16 processor";
+ case EM_ST100: return "STMicroelectronics ST100 processor";
+ case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
+ case EM_FX66: return "Siemens FX66 microcontroller";
+ case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
+ case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
+ case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
+ case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
+ case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
+ case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
+ case EM_SVX: return "Silicon Graphics SVx";
+ case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
+ case EM_VAX: return "Digital VAX";
+ case EM_AVR: return "Atmel AVR 8-bit microcontroller";
default:
sprintf (buff, _("<unknown>: %x"), e_machine);
return buff;
}
}
+static void
+decode_ARM_machine_flags (e_flags, buf)
+ unsigned e_flags;
+ char buf[];
+{
+ unsigned eabi;
+ int unknown = 0;
+
+ eabi = EF_ARM_EABI_VERSION (e_flags);
+ e_flags &= ~ EF_ARM_EABIMASK;
+
+ /* Handle "generic" ARM flags. */
+ if (e_flags & EF_ARM_RELEXEC)
+ {
+ strcat (buf, ", relocatable executable");
+ e_flags &= ~ EF_ARM_RELEXEC;
+ }
+
+ if (e_flags & EF_ARM_HASENTRY)
+ {
+ strcat (buf, ", has entry point");
+ e_flags &= ~ EF_ARM_HASENTRY;
+ }
+
+ /* Now handle EABI specific flags. */
+ switch (eabi)
+ {
+ default:
+ strcat (buf, ", <unknown EABI>");
+ if (e_flags)
+ unknown = 1;
+ break;
+
+ case EF_ARM_EABI_VER1:
+ while (e_flags)
+ {
+ unsigned flag;
+
+ /* Process flags one bit at a time. */
+ flag = e_flags & - e_flags;
+ e_flags &= ~ flag;
+
+ switch (flag)
+ {
+ case EF_ARM_SYMSARESORTED: /* Conflicts with EF_INTERWORK. */
+ strcat (buf, ", sorted symbol tables");
+ break;
+
+ default:
+ unknown = 1;
+ break;
+ }
+ }
+ break;
+
+ case EF_ARM_EABI_UNKNOWN:
+ while (e_flags)
+ {
+ unsigned flag;
+
+ /* Process flags one bit at a time. */
+ flag = e_flags & - e_flags;
+ e_flags &= ~ flag;
+
+ switch (flag)
+ {
+ case EF_INTERWORK:
+ strcat (buf, ", interworking enabled");
+ break;
+
+ case EF_APCS_26:
+ strcat (buf, ", uses APCS/26");
+ break;
+
+ case EF_APCS_FLOAT:
+ strcat (buf, ", uses APCS/float");
+ break;
+
+ case EF_PIC:
+ strcat (buf, ", position independent");
+ break;
+
+ case EF_ALIGN8:
+ strcat (buf, ", 8 bit structure alignment");
+ break;
+
+ case EF_NEW_ABI:
+ strcat (buf, ", uses new ABI");
+ break;
+
+ case EF_OLD_ABI:
+ strcat (buf, ", uses old ABI");
+ break;
+
+ case EF_SOFT_FLOAT:
+ strcat (buf, ", software FP");
+ break;
+
+ default:
+ unknown = 1;
+ break;
+ }
+ }
+ }
+
+ if (unknown)
+ strcat (buf,", <unknown>");
+}
+
static char *
get_machine_flags (e_flags, e_machine)
unsigned e_flags;
static char buf [1024];
buf[0] = '\0';
+
if (e_flags)
{
switch (e_machine)
default:
break;
+ case EM_ARM:
+ decode_ARM_machine_flags (e_flags, buf);
+ break;
+
case EM_68K:
if (e_flags & EF_CPU32)
strcat (buf, ", cpu32");
case SHT_REL: return "REL";
case SHT_SHLIB: return "SHLIB";
case SHT_DYNSYM: return "DYNSYM";
+ case SHT_INIT_ARRAY: return "INIT_ARRAY";
+ case SHT_FINI_ARRAY: return "FINI_ARRAY";
+ case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
case SHT_GNU_verdef: return "VERDEF";
case SHT_GNU_verneed: return "VERNEED";
case SHT_GNU_versym: return "VERSYM";
fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
fprintf (stdout, _(" -H or --help Display this information\n"));
- fprintf (stdout, _("Report bugs to bug-gnu-utils@gnu.org\n"));
+ fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
exit (0);
}
switch (osabi)
{
- case ELFOSABI_SYSV: return _("UNIX - System V");
+ case ELFOSABI_NONE: return _("UNIX - System V");
case ELFOSABI_HPUX: return _("UNIX - HP-UX");
+ case ELFOSABI_NETBSD: return _("UNIX - NetBSD");
+ case ELFOSABI_LINUX: return _("UNIX - Linux");
+ case ELFOSABI_HURD: return _("GNU/Hurd");
+ case ELFOSABI_SOLARIS: return _("UNIX - Solaris");
+ case ELFOSABI_MONTEREY: return _("UNIX - Monterey");
+ case ELFOSABI_IRIX: return _("UNIX - IRIX");
+ case ELFOSABI_FREEBSD: return _("UNIX - FreeBSD");
+ case ELFOSABI_TRU64: return _("UNIX - TRU64");
+ case ELFOSABI_MODESTO: return _("Novell - Modesto");
+ case ELFOSABI_OPENBSD: return _("UNIX - OpenBSD");
case ELFOSABI_STANDALONE: return _("Standalone App");
+ case ELFOSABI_ARM: return _("ARM");
default:
sprintf (buff, _("<unknown: %x>"), osabi);
return buff;
return isyms;
}
+static const char *
+get_elf_section_flags (sh_flags)
+ bfd_vma sh_flags;
+{
+ static char buff [32];
+
+ * buff = 0;
+
+ while (sh_flags)
+ {
+ bfd_vma flag;
+
+ flag = sh_flags & - sh_flags;
+ sh_flags &= ~ flag;
+
+ switch (flag)
+ {
+ case SHF_WRITE: strcat (buff, "W"); break;
+ case SHF_ALLOC: strcat (buff, "A"); break;
+ case SHF_EXECINSTR: strcat (buff, "X"); break;
+ case SHF_MERGE: strcat (buff, "M"); break;
+ case SHF_STRINGS: strcat (buff, "S"); break;
+ case SHF_INFO_LINK: strcat (buff, "I"); break;
+ case SHF_LINK_ORDER: strcat (buff, "L"); break;
+ case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
+
+ default:
+ if (flag & SHF_MASKOS)
+ {
+ strcat (buff, "o");
+ sh_flags &= ~ SHF_MASKOS;
+ }
+ else if (flag & SHF_MASKPROC)
+ {
+ strcat (buff, "p");
+ sh_flags &= ~ SHF_MASKPROC;
+ }
+ else
+ strcat (buff, "x");
+ break;
+ }
+ }
+
+ return buff;
+}
+
static int
process_section_headers (file)
FILE * file;
return 1;
printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
+
if (is_32bit_elf)
printf
(_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
(unsigned long) section->sh_offset,
(unsigned long) section->sh_size,
(unsigned long) section->sh_entsize);
-
- printf (" %c%c%c %2ld %3lx %ld\n",
- (section->sh_flags & SHF_WRITE ? 'W' : ' '),
- (section->sh_flags & SHF_ALLOC ? 'A' : ' '),
- (section->sh_flags & SHF_EXECINSTR ? 'X' : ' '),
+
+ printf (" %3s ", get_elf_section_flags (section->sh_flags));
+
+ printf (" %2ld %3lx %ld\n",
(unsigned long) section->sh_link,
(unsigned long) section->sh_info,
(unsigned long) section->sh_addralign);
printf (" ");
print_vma (section->sh_entsize, LONG_HEX);
- printf (" %c%c%c",
- (section->sh_flags & SHF_WRITE ? 'W' : ' '),
- (section->sh_flags & SHF_ALLOC ? 'A' : ' '),
- (section->sh_flags & SHF_EXECINSTR ? 'X' : ' '));
-
+ printf (" %3s ", get_elf_section_flags (section->sh_flags));
+
printf (" %2ld %3lx %ld\n",
(unsigned long) section->sh_link,
(unsigned long) section->sh_info,
}
}
+ printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
+ printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
+ printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
+
return 1;
}
case DT_MIPS_TIME_STAMP:
{
char timebuf[20];
+ struct tm * tmp;
+
time_t time = entry->d_un.d_val;
- strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
+ tmp = gmtime (&time);
+ sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
+ tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
+ tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
printf ("Time Stamp: %s\n", timebuf);
}
break;
return 1;
}
+static const char *
+get_dynamic_flags (flags)
+ bfd_vma flags;
+{
+ static char buff [64];
+ while (flags)
+ {
+ bfd_vma flag;
+
+ flag = flags & - flags;
+ flags &= ~ flag;
+
+ switch (flag)
+ {
+ case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
+ case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
+ case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
+ case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
+ default: strcat (buff, "unknown "); break;
+ }
+ }
+ return buff;
+}
+
/* Parse and display the contents of the dynamic segment. */
static int
process_dynamic_segment (file)
{
if (do_dynamic)
{
+ const char * dtype;
+
putchar (' ');
print_vma (entry->d_tag, FULL_HEX);
- printf (" (%s)%*s",
- get_dynamic_type (entry->d_tag),
- (is_32bit_elf ? 27 : 19) - strlen (get_dynamic_type (entry->d_tag)),
+ dtype = get_dynamic_type (entry->d_tag);
+ printf (" (%s)%*s", dtype,
+ ((is_32bit_elf ? 27 : 19)
+ - (int) strlen (dtype)),
" ");
}
switch (entry->d_tag)
{
+ case DT_FLAGS:
+ if (do_dynamic)
+ printf ("%s", get_dynamic_flags (entry->d_un.d_val));
+ break;
+
case DT_AUXILIARY:
case DT_FILTER:
if (do_dynamic)
for (cnt = 0; cnt < total; cnt += 4)
{
int j, nn;
+ char * name;
printf (" %03x:", cnt);
{
Elf_External_Verneed evn;
Elf_External_Vernaux evna;
- Elf_Internal_Vernaux ivna;
- unsigned long vna_off;
+ Elf_Internal_Vernaux ivna;
+ unsigned long vna_off;
GET_DATA (offset, evn, "version need");
{
ivna.vna_name = BYTE_GET (evna.vna_name);
+ name = strtab + ivna.vna_name;
nn += printf ("(%s%-*s",
- strtab + ivna.vna_name,
- 12 - strlen (strtab
- + ivna.vna_name),
+ name,
+ 12 - (int) strlen (name),
")");
break;
}
ivda.vda_name =
BYTE_GET (evda.vda_name);
+ name = strtab + ivda.vda_name;
nn +=
printf ("(%s%-*s",
- strtab + ivda.vda_name,
- 12
- - strlen (strtab
- + ivda.vda_name),
+ name,
+ 12 - (int) strlen (name),
")");
}
}
do
{
- Elf_Internal_Vernaux ivna;
+ Elf_Internal_Vernaux ivna;
Elf_External_Verneed evn;
Elf_External_Vernaux evna;
- unsigned long a_off;
+ unsigned long a_off;
GET_DATA (offset, evn, "version need");
{
ivna.vna_name = BYTE_GET (evna.vna_name);
+ name = strtab + ivna.vna_name;
nn += printf ("(%s%-*s",
- strtab + ivna.vna_name,
- 12 - strlen (strtab
- + ivna.vna_name),
+ name,
+ 12 - (int) strlen (name),
")");
break;
}
ivda.vda_name = BYTE_GET (evda.vda_name);
+ name = strtab + ivda.vda_name;
nn += printf ("(%s%-*s",
- strtab + ivda.vda_name,
- 12 - strlen (strtab
- + ivda.vda_name),
+ name,
+ 12 - (int) strlen (name),
")");
}
}
return 1;
}
-static char *
+static const char *
get_symbol_binding (binding)
unsigned int binding;
{
}
}
-static char *
+static const char *
get_symbol_type (type)
unsigned int type;
{
case STT_FUNC: return "FUNC";
case STT_SECTION: return "SECTION";
case STT_FILE: return "FILE";
+ case STT_COMMON: return "COMMON";
default:
if (type >= STT_LOPROC && type <= STT_HIPROC)
{
}
}
-static char *
+static const char *
+get_symbol_visibility (visibility)
+ unsigned int visibility;
+{
+ switch (visibility)
+ {
+ case STV_DEFAULT: return "DEFAULT";
+ case STV_INTERNAL: return "INTERNAL";
+ case STV_HIDDEN: return "HIDDEN";
+ case STV_PROTECTED: return "PROTECTED";
+ default: abort ();
+ }
+}
+
+static const char *
get_symbol_index_type (type)
unsigned int type;
{
}
}
-
static int *
get_dynamic_data (file, number)
FILE * file;
printf (_("\nSymbol table for image:\n"));
if (is_32bit_elf)
- printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
+ printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
else
- printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
+ printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
for (hn = 0; hn < nbuckets; hn++)
{
printf (" %3d %3d: ", si, hn);
print_vma (psym->st_value, LONG_HEX);
putchar (' ' );
- print_vma (psym->st_size, DEC_5);
+ print_vma (psym->st_size, DEC_5);
- printf (" %6s %6s %2d ",
- get_symbol_type (ELF_ST_TYPE (psym->st_info)),
- get_symbol_binding (ELF_ST_BIND (psym->st_info)),
- psym->st_other);
-
- printf ("%3.3s", get_symbol_index_type (psym->st_shndx));
-
+ printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
+ printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
+ printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
+ printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
printf (" %s\n", dynamic_strings + psym->st_name);
}
}
SECTION_NAME (section),
(unsigned long) (section->sh_size / section->sh_entsize));
if (is_32bit_elf)
- printf (_(" Num: Value Size Type Bind Ot Ndx Name\n"));
+ printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
else
- printf (_(" Num: Value Size Type Bind Ot Ndx Name\n"));
+ printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
section->sh_size / section->sh_entsize);
print_vma (psym->st_value, LONG_HEX);
putchar (' ');
print_vma (psym->st_size, DEC_5);
- printf (" %-7s %-6s %2d ",
- get_symbol_type (ELF_ST_TYPE (psym->st_info)),
- get_symbol_binding (ELF_ST_BIND (psym->st_info)),
- psym->st_other);
-
- printf ("%4s", get_symbol_index_type (psym->st_shndx));
-
+ printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
+ printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
+ printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
+ printf (" %4s", get_symbol_index_type (psym->st_shndx));
printf (" %s", strtab + psym->st_name);
if (section->sh_type == SHT_DYNSYM &&
offset = version_info
[DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
- GET_DATA (offset, evn, "version need");
-
- ivn.vn_aux = BYTE_GET (evn.vn_aux);
- ivn.vn_next = BYTE_GET (evn.vn_next);
-
do
{
unsigned long vna_off;
+ GET_DATA (offset, evn, "version need");
+
+ ivn.vn_aux = BYTE_GET (evn.vn_aux);
+ ivn.vn_next = BYTE_GET (evn.vn_next);
+
vna_off = offset + ivn.vn_aux;
do
}
static void
-decode_location_expression (data, pointer_size)
+decode_location_expression (data, pointer_size, length)
unsigned char * data;
unsigned int pointer_size;
+ unsigned long length;
{
- unsigned char op;
+ unsigned op;
int bytes_read;
unsigned long uvalue;
+ unsigned char *end = data + length;
- op = * data ++;
-
- switch (op)
+ while (data < end)
{
- case DW_OP_addr:
- printf ("DW_OP_addr: %lx", (unsigned long) byte_get (data, pointer_size));
- break;
- case DW_OP_deref:
- printf ("DW_OP_deref");
- break;
- case DW_OP_const1u:
- printf ("DW_OP_const1u: %lu", (unsigned long) 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", (unsigned long) 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", (unsigned long) 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", (unsigned long) byte_get (data, 4),
- (unsigned long) byte_get (data + 4, 4));
- break;
- case DW_OP_const8s:
- printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
- (long) 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", (unsigned long) 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", (long) 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", (long) 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:
- uvalue = read_leb128 (data, &bytes_read, 0);
- printf ("DW_OP_bregx: %lu %ld", uvalue,
- 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", (long) byte_get (data, 1));
- break;
- case DW_OP_xderef_size:
- printf ("DW_OP_xderef_size: %ld", (long) byte_get (data, 1));
- break;
- case DW_OP_nop:
- printf ("DW_OP_nop");
- break;
+ op = * data ++;
- default:
- if (op >= DW_OP_lo_user
- && op <= DW_OP_hi_user)
- printf (_("(User defined location op)"));
- else
- printf (_("(Unknown location op)"));
- break;
+ switch (op)
+ {
+ case DW_OP_addr:
+ printf ("DW_OP_addr: %lx",
+ (unsigned long) byte_get (data, pointer_size));
+ data += pointer_size;
+ break;
+ case DW_OP_deref:
+ printf ("DW_OP_deref");
+ break;
+ case DW_OP_const1u:
+ printf ("DW_OP_const1u: %lu", (unsigned long) 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", (unsigned long) byte_get (data, 2));
+ data += 2;
+ break;
+ case DW_OP_const2s:
+ printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
+ data += 2;
+ break;
+ case DW_OP_const4u:
+ printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
+ data += 4;
+ break;
+ case DW_OP_const4s:
+ printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
+ data += 4;
+ break;
+ case DW_OP_const8u:
+ printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
+ (unsigned long) byte_get (data + 4, 4));
+ data += 8;
+ break;
+ case DW_OP_const8s:
+ printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
+ (long) byte_get (data + 4, 4));
+ data += 8;
+ break;
+ case DW_OP_constu:
+ printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
+ data += bytes_read;
+ break;
+ case DW_OP_consts:
+ printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
+ data += bytes_read;
+ 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", (unsigned long) 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, &bytes_read, 0));
+ data += bytes_read;
+ 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", (long) byte_get (data, 2));
+ 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", (long) byte_get (data, 2));
+ data += 2;
+ break;
+
+ case DW_OP_lit0:
+ case DW_OP_lit1:
+ case DW_OP_lit2:
+ case DW_OP_lit3:
+ case DW_OP_lit4:
+ case DW_OP_lit5:
+ case DW_OP_lit6:
+ case DW_OP_lit7:
+ case DW_OP_lit8:
+ case DW_OP_lit9:
+ case DW_OP_lit10:
+ case DW_OP_lit11:
+ case DW_OP_lit12:
+ case DW_OP_lit13:
+ case DW_OP_lit14:
+ case DW_OP_lit15:
+ case DW_OP_lit16:
+ case DW_OP_lit17:
+ case DW_OP_lit18:
+ case DW_OP_lit19:
+ case DW_OP_lit20:
+ case DW_OP_lit21:
+ case DW_OP_lit22:
+ case DW_OP_lit23:
+ case DW_OP_lit24:
+ case DW_OP_lit25:
+ case DW_OP_lit26:
+ case DW_OP_lit27:
+ case DW_OP_lit28:
+ case DW_OP_lit29:
+ case DW_OP_lit30:
+ case DW_OP_lit31:
+ printf ("DW_OP_lit%d", op - DW_OP_lit0);
+ break;
+
+ case DW_OP_reg0:
+ case DW_OP_reg1:
+ case DW_OP_reg2:
+ case DW_OP_reg3:
+ case DW_OP_reg4:
+ case DW_OP_reg5:
+ case DW_OP_reg6:
+ case DW_OP_reg7:
+ case DW_OP_reg8:
+ case DW_OP_reg9:
+ case DW_OP_reg10:
+ case DW_OP_reg11:
+ case DW_OP_reg12:
+ case DW_OP_reg13:
+ case DW_OP_reg14:
+ case DW_OP_reg15:
+ case DW_OP_reg16:
+ case DW_OP_reg17:
+ case DW_OP_reg18:
+ case DW_OP_reg19:
+ case DW_OP_reg20:
+ case DW_OP_reg21:
+ case DW_OP_reg22:
+ case DW_OP_reg23:
+ case DW_OP_reg24:
+ case DW_OP_reg25:
+ case DW_OP_reg26:
+ case DW_OP_reg27:
+ case DW_OP_reg28:
+ case DW_OP_reg29:
+ case DW_OP_reg30:
+ case DW_OP_reg31:
+ printf ("DW_OP_reg%d", op - DW_OP_reg0);
+ break;
+
+ case DW_OP_breg0:
+ case DW_OP_breg1:
+ case DW_OP_breg2:
+ case DW_OP_breg3:
+ case DW_OP_breg4:
+ case DW_OP_breg5:
+ case DW_OP_breg6:
+ case DW_OP_breg7:
+ case DW_OP_breg8:
+ case DW_OP_breg9:
+ case DW_OP_breg10:
+ case DW_OP_breg11:
+ case DW_OP_breg12:
+ case DW_OP_breg13:
+ case DW_OP_breg14:
+ case DW_OP_breg15:
+ case DW_OP_breg16:
+ case DW_OP_breg17:
+ case DW_OP_breg18:
+ case DW_OP_breg19:
+ case DW_OP_breg20:
+ case DW_OP_breg21:
+ case DW_OP_breg22:
+ case DW_OP_breg23:
+ case DW_OP_breg24:
+ case DW_OP_breg25:
+ case DW_OP_breg26:
+ case DW_OP_breg27:
+ case DW_OP_breg28:
+ case DW_OP_breg29:
+ case DW_OP_breg30:
+ case DW_OP_breg31:
+ printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
+ read_leb128 (data, &bytes_read, 1));
+ data += bytes_read;
+ break;
+
+ case DW_OP_regx:
+ printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
+ data += bytes_read;
+ break;
+ case DW_OP_fbreg:
+ printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
+ data += bytes_read;
+ break;
+ case DW_OP_bregx:
+ uvalue = read_leb128 (data, &bytes_read, 0);
+ data += bytes_read;
+ printf ("DW_OP_bregx: %lu %ld", uvalue,
+ read_leb128 (data, &bytes_read, 1));
+ data += bytes_read;
+ break;
+ case DW_OP_piece:
+ printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
+ data += bytes_read;
+ break;
+ case DW_OP_deref_size:
+ printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
+ break;
+ case DW_OP_xderef_size:
+ printf ("DW_OP_xderef_size: %ld", (long) 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)"));
+ /* No way to tell where the next op is, so just bail. */
+ return;
+ }
}
}
static unsigned char *
-read_and_display_attr (attribute, form, data, pointer_size)
+read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
unsigned long attribute;
unsigned long form;
unsigned char * data;
+ unsigned long cu_offset;
unsigned long pointer_size;
{
unsigned long uvalue = 0;
unsigned char * block_start = NULL;
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 (is_ref ? " <%x>" : " %#x", uvalue);
data += pointer_size;
break;
case DW_FORM_flag:
case DW_FORM_data1:
uvalue = byte_get (data ++, 1);
- printf (is_ref ? " <%x>" : " %d", uvalue);
break;
case DW_FORM_ref2:
case DW_FORM_data2:
uvalue = byte_get (data, 2);
data += 2;
- printf (is_ref ? " <%x>" : " %d", uvalue);
break;
case DW_FORM_ref4:
case DW_FORM_data4:
uvalue = byte_get (data, 4);
data += 4;
- printf (is_ref ? " <%x>" : " %d", uvalue);
+ break;
+
+ case DW_FORM_sdata:
+ uvalue = read_leb128 (data, & bytes_read, 1);
+ data += bytes_read;
+ break;
+
+ case DW_FORM_ref_udata:
+ case DW_FORM_udata:
+ uvalue = read_leb128 (data, & bytes_read, 0);
+ data += bytes_read;
+ break;
+ }
+
+ switch (form)
+ {
+ case DW_FORM_ref_addr:
+ printf (" <#%lx>", uvalue);
+ break;
+
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref_udata:
+ printf (" <%lx>", uvalue + cu_offset);
+ break;
+
+ case DW_FORM_addr:
+ printf (" %#lx", uvalue);
+
+ case DW_FORM_flag:
+ case DW_FORM_data1:
+ case DW_FORM_data2:
+ case DW_FORM_data4:
+ case DW_FORM_sdata:
+ case DW_FORM_udata:
+ printf (" %ld", uvalue);
break;
case DW_FORM_ref8:
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:
- uvalue = read_leb128 (data, & bytes_read, 0);
- data += bytes_read;
- printf (is_ref ? " <%lx>" : " %ld", uvalue);
- break;
-
case DW_FORM_block:
uvalue = read_leb128 (data, & bytes_read, 0);
block_start = data + bytes_read;
data = display_block (block_start, uvalue);
- uvalue = * block_start;
break;
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);
block_start = data + 2;
data = display_block (block_start, uvalue);
- uvalue = * block_start;
break;
case DW_FORM_block4:
uvalue = byte_get (data, 4);
block_start = data + 4;
data = display_block (block_start, uvalue);
- uvalue = * block_start;
break;
case DW_FORM_strp:
}
break;
- case DW_AT_frame_base:
- if (uvalue >= DW_OP_reg0 && uvalue <= DW_OP_reg31)
- printf ("(reg %ld)", uvalue - DW_OP_reg0);
- break;
-
case DW_AT_language:
switch (uvalue)
{
}
break;
+ case DW_AT_frame_base:
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 (")");
+ if (block_start)
+ {
+ printf ("(");
+ decode_location_expression (block_start, pointer_size, uvalue);
+ printf (")");
+ }
break;
default:
unsigned char * tags;
int i;
int level;
+ unsigned long cu_offset;
external = (DWARF2_External_CompUnit *) start;
compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
tags = start + sizeof (* external);
+ cu_offset = start - section_begin;
start += compunit.cu_length + sizeof (external->cu_length);
if (compunit.cu_version != 2)
for (attr = entry->first_attr; attr; attr = attr->next)
tags = read_and_display_attr (attr->attribute,
attr->form,
- tags,
+ tags, cu_offset,
compunit.cu_pointer_size);
if (entry->children)
GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
elib, Elf32_External_Lib *, "liblist");
- printf ("\nSection '.liblist' contains %d entries:\n", liblistno);
+ printf ("\nSection '.liblist' contains %lu entries:\n",
+ (unsigned long) liblistno);
fputs (" Library Time Stamp Checksum Version Flags\n",
stdout);
Elf32_Lib liblist;
time_t time;
char timebuf[20];
+ struct tm * tmp;
liblist.l_name = BYTE_GET (elib[cnt].l_name);
time = BYTE_GET (elib[cnt].l_time_stamp);
liblist.l_version = BYTE_GET (elib[cnt].l_version);
liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
- strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
+ tmp = gmtime (&time);
+ sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
+ tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
+ tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
- printf ("%3d: %-20s %s %#10lx %-7ld", cnt,
+ printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
dynamic_strings + liblist.l_name, timebuf,
liblist.l_checksum, liblist.l_version);
if (options_offset != 0)
{
Elf_External_Options * eopt;
- Elf_Internal_Shdr * sect = section_headers;
+ Elf_Internal_Shdr * sect = section_headers;
Elf_Internal_Options * iopt;
Elf_Internal_Options * option;
size_t offset;
/* Find the section header so that we get the size. */
while (sect->sh_type != SHT_MIPS_OPTIONS)
- ++sect;
+ ++ sect;
GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
Elf_External_Options *, "options");
offset = cnt = 0;
option = iopt;
+
while (offset < sect->sh_size)
{
Elf_External_Options * eoption;
option->info = BYTE_GET (eoption->info);
offset += option->size;
+
++option;
++cnt;
}
string_table + sect->sh_name, cnt);
option = iopt;
+
while (cnt-- > 0)
{
size_t len;
{
Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
- printf ("%5u: %8lu ", cnt, iconf[cnt]);
+ printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
print_vma (psym->st_value, FULL_HEX);
printf (" %s\n", dynamic_strings + psym->st_name);
}
case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
+ case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
+ case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
default:
sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
return buff;
external = pnotes;
- printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"), offset, length);
+ printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
+ (unsigned long) offset, (unsigned long) length);
printf (_(" Owner\t\tData size\tDescription\n"));
while (external < (Elf_External_Note *)((char *) pnotes + length))