#define RELOC_MACROS_GEN_FUNC
-#include "elf/i386.h"
-#include "elf/v850.h"
-#include "elf/ppc.h"
-#include "elf/mips.h"
#include "elf/alpha.h"
+#include "elf/arc.h"
#include "elf/arm.h"
-#include "elf/m68k.h"
-#include "elf/sparc.h"
-#include "elf/m32r.h"
+#include "elf/avr.h"
+#include "elf/cris.h"
#include "elf/d10v.h"
#include "elf/d30v.h"
-#include "elf/sh.h"
-#include "elf/mn10200.h"
-#include "elf/mn10300.h"
-#include "elf/hppa.h"
-#include "elf/h8.h"
-#include "elf/arc.h"
+#include "elf/dlx.h"
#include "elf/fr30.h"
+#include "elf/frv.h"
+#include "elf/h8.h"
+#include "elf/hppa.h"
+#include "elf/i386.h"
+#include "elf/i370.h"
+#include "elf/i860.h"
+#include "elf/i960.h"
+#include "elf/ia64.h"
+#include "elf/ip2k.h"
+#include "elf/m32r.h"
+#include "elf/m68k.h"
+#include "elf/m68hc11.h"
#include "elf/mcore.h"
+#include "elf/mips.h"
#include "elf/mmix.h"
-#include "elf/i960.h"
+#include "elf/mn10200.h"
+#include "elf/mn10300.h"
+#include "elf/or32.h"
#include "elf/pj.h"
-#include "elf/avr.h"
-#include "elf/ia64.h"
-#include "elf/cris.h"
-#include "elf/i860.h"
-#include "elf/x86-64.h"
+#include "elf/ppc.h"
#include "elf/s390.h"
+#include "elf/sh.h"
+#include "elf/sparc.h"
+#include "elf/v850.h"
+#include "elf/vax.h"
+#include "elf/x86-64.h"
#include "elf/xstormy16.h"
#include "bucomm.h"
int do_debug_frames_interp;
int do_debug_macinfo;
int do_debug_str;
+int do_debug_loc;
int do_arch;
int do_notes;
int is_32bit_elf;
/* Forward declarations for dumb compilers. */
static void print_vma PARAMS ((bfd_vma, print_mode));
-static void print_symbol PARAMS ((int, char *));
+static void print_symbol PARAMS ((int, const char *));
static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
static const char * get_mips_dynamic_type PARAMS ((unsigned long));
static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
+static const char * get_ppc64_dynamic_type PARAMS ((unsigned long));
static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
static const char * get_dynamic_type PARAMS ((unsigned long));
static int slurp_rela_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **, unsigned long *));
static int display_debug_frames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
static int display_debug_macinfo PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
static int display_debug_str PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
+static int display_debug_loc PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
static void load_debug_str PARAMS ((FILE *));
static void free_debug_str PARAMS ((void));
static const char * fetch_indirect_string PARAMS ((unsigned long));
+static void load_debug_loc PARAMS ((FILE *));
+static void free_debug_loc PARAMS ((void));
static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
static int process_extended_line_op PARAMS ((unsigned char *, int, int));
static void reset_state_machine PARAMS ((int));
static int process_corefile_note_segments PARAMS ((FILE *));
static int process_corefile_contents PARAMS ((FILE *));
static int process_arch_specific PARAMS ((FILE *));
+static int process_gnu_liblist PARAMS ((FILE *));
typedef int Elf32_Word;
case 8:
/* We want to extract data from an 8 byte wide field and
place it into a 4 byte wide field. Since this is a little
- endian source we can juts use the 4 byte extraction code. */
+ endian source we can just use the 4 byte extraction code. */
/* Fall through. */
#endif
case 4:
/* Display a symbol on stdout. If do_wide is not true then
format the symbol to be at most WIDTH characters,
- truhncating as necessary. If WIDTH is negative then
+ truncating as necessary. If WIDTH is negative then
format the string to be exactly - WIDTH characters,
truncating or padding as necessary. */
static void
print_symbol (width, symbol)
int width;
- char * symbol;
+ const char * symbol;
{
if (do_wide)
- printf (symbol);
+ printf ("%s", symbol);
else if (width < 0)
printf ("%-*.*s", width, width, symbol);
- else
+ else
printf ("%-.*s", width, symbol);
}
case EM_386:
case EM_486:
case EM_960:
+ case EM_DLX:
+ case EM_OPENRISC:
+ case EM_OR32:
case EM_M32R:
case EM_CYGNUS_M32R:
case EM_D10V:
case EM_SPARCV9:
case EM_SPARC:
case EM_PPC:
+ case EM_PPC64:
case EM_V850:
case EM_CYGNUS_V850:
case EM_D30V:
case EM_CYGNUS_MN10300:
case EM_FR30:
case EM_CYGNUS_FR30:
+ case EM_CYGNUS_FRV:
case EM_SH:
case EM_ALPHA:
case EM_MCORE:
case EM_S390_OLD:
case EM_MMIX:
case EM_XSTORMY16:
+ case EM_VAX:
+ case EM_IP2K:
+ case EM_IP2K_OLD:
return TRUE;
case EM_MMA:
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;
if (is_32bit_elf)
{
if (is_rela)
- printf
- (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
+ {
+ if (do_wide)
+ printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
+ else
+ printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
+ }
else
- printf
- (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
+ {
+ if (do_wide)
+ printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
+ else
+ printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
+ }
}
else
{
if (is_rela)
- printf
- (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
+ {
+ if (do_wide)
+ printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
+ else
+ printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
+ }
else
- printf
- (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
+ {
+ if (do_wide)
+ printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
+ else
+ printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
+ }
}
for (i = 0; i < rel_size; i++)
{
const char * rtype;
+ const char * rtype2 = NULL;
+ const char * rtype3 = NULL;
bfd_vma offset;
bfd_vma info;
bfd_vma symtab_index;
bfd_vma type;
+ bfd_vma type2 = (bfd_vma) NULL;
+ bfd_vma type3 = (bfd_vma) NULL;
if (is_rela)
{
}
else
{
- if (elf_header.e_machine == EM_SPARCV9)
- type = ELF64_R_TYPE_ID (info);
+ if (elf_header.e_machine == EM_MIPS)
+ {
+ type = ELF64_MIPS_R_TYPE (info);
+ type2 = ELF64_MIPS_R_TYPE2 (info);
+ type3 = ELF64_MIPS_R_TYPE3 (info);
+ }
+ else if (elf_header.e_machine == EM_SPARCV9)
+ type = ELF64_R_TYPE_ID (info);
else
- type = ELF64_R_TYPE (info);
+ type = ELF64_R_TYPE (info);
/* The #ifdef BFD64 below is to prevent a compile time warning.
We know that if we do not have a 64 bit data type that we
will never execute this code anyway. */
else
{
#ifdef _bfd_int64_low
- printf ("%8.8lx%8.8lx %8.8lx%8.8lx ",
+ printf (do_wide
+ ? "%8.8lx%8.8lx %8.8lx%8.8lx "
+ : "%4.4lx%8.8lx %4.4lx%8.8lx ",
_bfd_int64_high (offset),
_bfd_int64_low (offset),
_bfd_int64_high (info),
_bfd_int64_low (info));
#else
- printf ("%16.16lx %16.16lx ", offset, info);
+ printf (do_wide
+ ? "%16.16lx %16.16lx "
+ : "%12.12lx %12.12lx ",
+ offset, info);
#endif
}
rtype = elf_i386_reloc_type (type);
break;
+ case EM_68HC11:
+ case EM_68HC12:
+ rtype = elf_m68hc11_reloc_type (type);
+ break;
+
case EM_68K:
rtype = elf_m68k_reloc_type (type);
break;
rtype = elf_d30v_reloc_type (type);
break;
+ case EM_DLX:
+ rtype = elf_dlx_reloc_type (type);
+ break;
+
case EM_SH:
rtype = elf_sh_reloc_type (type);
break;
rtype = elf_fr30_reloc_type (type);
break;
+ case EM_CYGNUS_FRV:
+ rtype = elf_frv_reloc_type (type);
+ break;
+
case EM_MCORE:
rtype = elf_mcore_reloc_type (type);
break;
case EM_MIPS:
case EM_MIPS_RS3_LE:
rtype = elf_mips_reloc_type (type);
+ if (!is_32bit_elf)
+ {
+ rtype2 = elf_mips_reloc_type (type2);
+ rtype3 = elf_mips_reloc_type (type3);
+ }
break;
case EM_ALPHA:
rtype = elf_h8_reloc_type (type);
break;
+ case EM_OPENRISC:
+ case EM_OR32:
+ rtype = elf_or32_reloc_type (type);
+ break;
+
case EM_PJ:
case EM_PJ_OLD:
rtype = elf_pj_reloc_type (type);
rtype = elf_x86_64_reloc_type (type);
break;
- case EM_S390_OLD:
- case EM_S390:
- rtype = elf_s390_reloc_type (type);
- break;
+ case EM_S370:
+ rtype = i370_reloc_type (type);
+ break;
+
+ case EM_S390_OLD:
+ case EM_S390:
+ rtype = elf_s390_reloc_type (type);
+ break;
case EM_XSTORMY16:
rtype = elf_xstormy16_reloc_type (type);
break;
+
+ case EM_VAX:
+ rtype = elf_vax_reloc_type (type);
+ break;
+
+ case EM_IP2K:
+ case EM_IP2K_OLD:
+ rtype = elf_ip2k_reloc_type (type);
+ break;
}
if (rtype == NULL)
#ifdef _bfd_int64_low
- printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
+ printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
#else
- printf (_("unrecognised: %-7lx"), type);
+ printf (_("unrecognized: %-7lx"), type);
#endif
else
- printf ("%-21.21s", rtype);
+ printf (do_wide ? "%-21.21s" : "%-17.17s", rtype);
if (symtab_index)
{
printf (" ");
print_vma (psym->st_value, LONG_HEX);
- printf (" ");
+ printf (is_32bit_elf ? " " : " ");
if (psym->st_name == 0)
- print_symbol (-25, SECTION_NAME (section_headers + psym->st_shndx));
+ {
+ const char *sec_name = "<null>";
+ char name_buf[40];
+
+ if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
+ {
+ bfd_vma sec_index = (bfd_vma) -1;
+
+ if (psym->st_shndx < SHN_LORESERVE)
+ sec_index = psym->st_shndx;
+ else if (psym->st_shndx > SHN_LORESERVE)
+ sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
+ - SHN_LORESERVE);
+
+ if (sec_index != (bfd_vma) -1)
+ sec_name = SECTION_NAME (section_headers + sec_index);
+ else if (psym->st_shndx == SHN_ABS)
+ sec_name = "ABS";
+ else if (psym->st_shndx == SHN_COMMON)
+ sec_name = "COMMON";
+ else
+ {
+ sprintf (name_buf, "<section 0x%x>",
+ (unsigned int) psym->st_shndx);
+ sec_name = name_buf;
+ }
+ }
+ print_symbol (22, sec_name);
+ }
else if (strtab == NULL)
printf (_("<string table index %3ld>"), psym->st_name);
else
- print_symbol (-25, strtab + psym->st_name);
+ print_symbol (22, strtab + psym->st_name);
if (is_rela)
printf (" + %lx", (unsigned long) relas [i].r_addend);
}
else if (is_rela)
{
- printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
+ printf ("%*c", is_32bit_elf ? (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
print_vma (relas[i].r_addend, LONG_HEX);
}
printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
putchar ('\n');
+
+ if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
+ {
+ printf (" Type2: ");
+
+ if (rtype2 == NULL)
+#ifdef _bfd_int64_low
+ printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
+#else
+ printf (_("unrecognized: %-7lx"), type2);
+#endif
+ else
+ printf ("%-17.17s", rtype2);
+
+ printf("\n Type3: ");
+
+ if (rtype3 == NULL)
+#ifdef _bfd_int64_low
+ printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
+#else
+ printf (_("unrecognized: %-7lx"), type3);
+#endif
+ else
+ printf ("%-17.17s", rtype3);
+
+ putchar ('\n');
+ }
}
if (is_rela)
}
}
+static const char *
+get_ppc64_dynamic_type (type)
+ unsigned long type;
+{
+ switch (type)
+ {
+ case DT_PPC64_GLINK: return "PPC64_GLINK";
+ case DT_PPC64_OPD: return "PPC64_OPD";
+ case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
+ default:
+ return NULL;
+ }
+}
+
static const char *
get_parisc_dynamic_type (type)
unsigned long type;
case DT_USED: return "USED";
case DT_FILTER: return "FILTER";
+ case DT_GNU_PRELINKED: return "GNU_PRELINKED";
+ case DT_GNU_CONFLICT: return "GNU_CONFLICT";
+ case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
+ case DT_GNU_LIBLIST: return "GNU_LIBLIST";
+ case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
+
default:
if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
{
case EM_SPARCV9:
result = get_sparc64_dynamic_type (type);
break;
+ case EM_PPC64:
+ result = get_ppc64_dynamic_type (type);
+ break;
default:
result = NULL;
break;
case EM_SPARC32PLUS: return "Sparc v8+" ;
case EM_960: return "Intel 90860";
case EM_PPC: return "PowerPC";
+ case EM_PPC64: return "PowerPC64";
case EM_V800: return "NEC V800";
case EM_FR20: return "Fujitsu FR20";
case EM_RH32: return "TRW RH32";
case EM_MN10200: return "mn10200";
case EM_CYGNUS_FR30:
case EM_FR30: return "Fujitsu FR30";
+ case EM_CYGNUS_FRV: return "Fujitsu FR-V";
case EM_PJ_OLD:
case EM_PJ: return "picoJava";
case EM_MMA: return "Fujitsu Multimedia Accelerator";
case EM_S390_OLD:
case EM_S390: return "IBM S/390";
case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
+ case EM_OPENRISC:
+ case EM_OR32: return "OpenRISC";
+ case EM_DLX: return "OpenDLX";
+ case EM_IP2K_OLD:
+ case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
default:
sprintf (buff, _("<unknown>: %x"), e_machine);
return buff;
switch (eabi)
{
default:
- strcat (buf, ", <unrecognised EABI>");
+ strcat (buf, ", <unrecognized EABI>");
if (e_flags)
unknown = 1;
break;
decode_ARM_machine_flags (e_flags, buf);
break;
- case EM_68K:
- if (e_flags & EF_CPU32)
- strcat (buf, ", cpu32");
- break;
+ case EM_68K:
+ if (e_flags & EF_CPU32)
+ strcat (buf, ", cpu32");
+ if (e_flags & EF_M68000)
+ strcat (buf, ", m68000");
+ break;
case EM_PPC:
if (e_flags & EF_PPC_EMB)
case E_V850E_ARCH:
strcat (buf, ", v850e");
break;
- case E_V850EA_ARCH:
- strcat (buf, ", v850ea");
- break;
case E_V850_ARCH:
strcat (buf, ", v850");
break;
case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
- case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
+ case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
+ case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
+ case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
+ case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
case 0:
/* We simply ignore the field in this case to avoid confusion:
if ((e_flags & EF_IA_64_ABSOLUTE))
strcat (buf, ", absolute");
break;
+
+ case EM_VAX:
+ if ((e_flags & EF_VAX_NONPIC))
+ strcat (buf, ", non-PIC");
+ if ((e_flags & EF_VAX_DFLOAT))
+ strcat (buf, ", D-Float");
+ if ((e_flags & EF_VAX_GFLOAT))
+ strcat (buf, ", G-Float");
+ break;
}
}
case PT_NOTE: return "NOTE";
case PT_SHLIB: return "SHLIB";
case PT_PHDR: return "PHDR";
+ case PT_TLS: return "TLS";
case PT_GNU_EH_FRAME:
return "GNU_EH_FRAME";
case 0x6ffffffc: return "VERDEF";
case 0x7ffffffd: return "AUXILIARY";
case 0x7fffffff: return "FILTER";
+ case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
default:
if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
}
}
+#define OPTION_DEBUG_DUMP 512
+
struct option options [] =
{
{"all", no_argument, 0, 'a'},
{"version-info", no_argument, 0, 'V'},
{"use-dynamic", no_argument, 0, 'D'},
{"hex-dump", required_argument, 0, 'x'},
- {"debug-dump", optional_argument, 0, 'w'},
+ {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
{"unwind", no_argument, 0, 'u'},
#ifdef SUPPORT_DISASSEMBLY
{"instruction-dump", required_argument, 0, 'i'},
static void
usage ()
{
- fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
- fprintf (stdout, _(" Options are:\n"));
- fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
- fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
- fprintf (stdout, _(" -l or --program-headers or --segments\n"));
- fprintf (stdout, _(" Display the program headers\n"));
- fprintf (stdout, _(" -S or --section-headers or --sections\n"));
- fprintf (stdout, _(" Display the sections' header\n"));
- fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
- fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
- fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
- fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
- fprintf (stdout, _(" -u or --unwind Display the unwind info (if present)\n"));
- fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
- fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
- fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
- 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[liaprmfs] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str]\n"));
- fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
+ fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
+ fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
+ fprintf (stdout, _(" Options are:\n\
+ -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
+ -h --file-header Display the ELF file header\n\
+ -l --program-headers Display the program headers\n\
+ --segments An alias for --program-headers\n\
+ -S --section-headers Display the sections' header\n\
+ --sections An alias for --section-headers\n\
+ -e --headers Equivalent to: -h -l -S\n\
+ -s --syms Display the symbol table\n\
+ --symbols An alias for --syms\n\
+ -n --notes Display the core notes (if present)\n\
+ -r --relocs Display the relocations (if present)\n\
+ -u --unwind Display the unwind info (if present)\n\
+ -d --dynamic Display the dynamic segment (if present)\n\
+ -V --version-info Display the version sections (if present)\n\
+ -A --arch-specific Display architecture specific information (if any).\n\
+ -D --use-dynamic Use the dynamic section info when displaying symbols\n\
+ -x --hex-dump=<number> Dump the contents of section <number>\n\
+ -w[liaprmfFso] or\n\
+ --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
+ Display the contents of DWARF2 debug sections\n"));
#ifdef SUPPORT_DISASSEMBLY
- fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
- fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
+ fprintf (stdout, _("\
+ -i --instruction-dump=<number>\n\
+ Disassemble the contents of section <number>\n"));
#endif
- 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, _(" -W or --wide Don't split lines or truncate symbols to fit into 80 columns\n"));
- fprintf (stdout, _(" -H or --help Display this information\n"));
+ fprintf (stdout, _("\
+ -I --histogram Display histogram of bucket list lengths\n\
+ -W --wide Allow output width to exceed 80 characters\n\
+ -H --help Display this information\n\
+ -v --version Display the version number of readelf\n"));
fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
exit (0);
else
{
unsigned int index = 0;
-
+
do_debugging = 0;
while (optarg[index])
do_debug_str = 1;
break;
+ case 'o':
+ case 'O':
+ do_debug_loc = 1;
+ break;
+
default:
- warn (_("Unrecognised debug option '%s'\n"), optarg);
+ warn (_("Unrecognized debug option '%s'\n"), optarg);
break;
}
}
break;
+ case OPTION_DEBUG_DUMP:
+ do_dump ++;
+ if (optarg == 0)
+ do_debugging = 1;
+ else
+ {
+ static const char *debug_dump_opt[]
+ = { "line", "info", "abbrev", "pubnames", "ranges",
+ "macro", "frames", "frames-interp", "str", "loc", NULL };
+ unsigned int index;
+ const char *p;
+
+ do_debugging = 0;
+
+ p = optarg;
+ while (*p)
+ {
+ for (index = 0; debug_dump_opt[index]; index++)
+ {
+ size_t len = strlen (debug_dump_opt[index]);
+
+ if (strncmp (p, debug_dump_opt[index], len) == 0
+ && (p[len] == ',' || p[len] == '\0'))
+ {
+ switch (p[0])
+ {
+ case 'i':
+ do_debug_info = 1;
+ break;
+
+ case 'a':
+ do_debug_abbrevs = 1;
+ break;
+
+ case 'l':
+ if (p[1] == 'i')
+ do_debug_lines = 1;
+ else
+ do_debug_loc = 1;
+ break;
+
+ case 'p':
+ do_debug_pubnames = 1;
+ break;
+
+ case 'r':
+ do_debug_aranges = 1;
+ break;
+
+ case 'f':
+ if (len > 6)
+ do_debug_frames_interp = 1;
+ do_debug_frames = 1;
+ break;
+
+ case 'm':
+ do_debug_macinfo = 1;
+ break;
+
+ case 's':
+ do_debug_str = 1;
+ break;
+ }
+
+ p += len;
+ break;
+ }
+ }
+
+ if (debug_dump_opt[index] == NULL)
+ {
+ warn (_("Unrecognized debug option '%s'\n"), p);
+ p = strchr (p, ',');
+ if (p == NULL)
+ break;
+ }
+
+ if (*p == ',')
+ p++;
+ }
+ }
+ break;
#ifdef SUPPORT_DISASSEMBLY
case 'i':
do_dump ++;
return 1;
}
+/* Returns 1 if the program headers were loaded. */
+
static int
process_program_headers (file)
FILE * file;
{
if (do_segments)
printf (_("\nThere are no program headers in this file.\n"));
- return 1;
+ return 0;
}
if (do_segments && !do_header)
if (do_segments)
{
- printf
- (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
+ if (elf_header.e_phnum > 1)
+ printf (_("\nProgram Headers:\n"));
+ else
+ printf (_("\nProgram Headers:\n"));
if (is_32bit_elf)
printf
case SHF_LINK_ORDER: strcat (buff, "L"); break;
case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
case SHF_GROUP: strcat (buff, "G"); break;
+ case SHF_TLS: strcat (buff, "T"); break;
default:
if (flag & SHF_MASKOS)
dynamic_symbols = NULL;
dynamic_strings = NULL;
dynamic_syminfo = NULL;
+ symtab_shndx_hdr = NULL;
for (i = 0, section = section_headers;
i < elf_header.e_shnum;
}
else if ((do_debugging || do_debug_info || do_debug_abbrevs
|| do_debug_lines || do_debug_pubnames || do_debug_aranges
- || do_debug_frames || do_debug_macinfo || do_debug_str)
+ || do_debug_frames || do_debug_macinfo || do_debug_str
+ || do_debug_loc)
&& strncmp (name, ".debug_", 7) == 0)
{
name += 7;
|| (do_debug_frames && (strcmp (name, "frame") == 0))
|| (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
|| (do_debug_str && (strcmp (name, "str") == 0))
+ || (do_debug_loc && (strcmp (name, "loc") == 0))
)
request_dump (i, DEBUG_DUMP);
}
if (! do_sections)
return 1;
- printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
+ if (elf_header.e_shnum > 1)
+ printf (_("\nSection Headers:\n"));
+ else
+ printf (_("\nSection Header:\n"));
if (is_32bit_elf)
printf
{
putchar (' ');
print_vma (section->sh_addr, LONG_HEX);
- if ((long) section->sh_offset == section->sh_offset)
- printf (" %8.8lx", (unsigned long) section->sh_offset);
- else
- {
- printf (" ");
- print_vma (section->sh_offset, LONG_HEX);
- }
+ if ((long) section->sh_offset == section->sh_offset)
+ printf (" %8.8lx", (unsigned long) section->sh_offset);
+ else
+ {
+ printf (" ");
+ print_vma (section->sh_offset, LONG_HEX);
+ }
printf ("\n ");
print_vma (section->sh_size, LONG_HEX);
printf (" ");
if (string_table == NULL)
printf ("%d", section->sh_name);
else
- printf ("'%s'", SECTION_NAME (section));
+ printf (_("'%s'"), SECTION_NAME (section));
printf (_(" at offset 0x%lx contains %lu entries:\n"),
rel_offset, (unsigned long) (rel_size / section->sh_entsize));
print_vma (tp->start.offset, PREFIX_HEX);
fputc ('-', stdout);
print_vma (tp->end.offset, PREFIX_HEX);
- printf ("), info at +0x%lx\n",
+ printf ("], info at +0x%lx\n",
(unsigned long) (tp->info.offset - aux->seg_base));
head = aux->info + (tp->info.offset - aux->info_addr);
stamp = BYTE_GET8 ((unsigned char *) head);
- printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
+ printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
(unsigned) UNW_VER (stamp),
(unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
if (string_table == NULL)
printf ("%d", unwsec->sh_name);
else
- printf ("'%s'", SECTION_NAME (unwsec));
+ printf (_("'%s'"), SECTION_NAME (unwsec));
}
else
{
if (string_table == NULL)
printf ("%d", unwsec->sh_name);
else
- printf ("'%s'", SECTION_NAME (unwsec));
+ printf (_("'%s'"), SECTION_NAME (unwsec));
printf (_(" at offset 0x%lx contains %lu entries:\n"),
(unsigned long) unwsec->sh_offset,
print_vma (entry->d_un.d_ptr, PREFIX_HEX);
break;
}
+ putchar ('\n');
}
static int
get_dynamic_flags (flags)
bfd_vma flags;
{
- static char buff [64];
+ static char buff [128];
+ char *p = buff;
+
+ *p = '\0';
while (flags)
{
bfd_vma flag;
flag = flags & - flags;
flags &= ~ flag;
+ if (p != buff)
+ *p++ = ' ';
+
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;
+ case DF_ORIGIN: strcpy (p, "ORIGIN"); break;
+ case DF_SYMBOLIC: strcpy (p, "SYMBOLIC"); break;
+ case DF_TEXTREL: strcpy (p, "TEXTREL"); break;
+ case DF_BIND_NOW: strcpy (p, "BIND_NOW"); break;
+ case DF_STATIC_TLS: strcpy (p, "STATIC_TLS"); break;
+ default: strcpy (p, "unknown"); break;
}
+
+ p = strchr (p, '\0');
}
return buff;
}
{
case DT_FLAGS:
if (do_dynamic)
- printf ("%s", get_dynamic_flags (entry->d_un.d_val));
+ puts (get_dynamic_flags (entry->d_un.d_val));
break;
case DT_AUXILIARY:
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");
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 & DF_P1_LAZYLOAD)
{
printf (" LAZYLOAD");
else
{
unsigned long int val = entry->d_un.d_val;
+
if (val & DF_1_NOW)
{
printf (" NOW");
case DT_MOVESZ :
case DT_INIT_ARRAYSZ:
case DT_FINI_ARRAYSZ:
+ case DT_GNU_CONFLICTSZ:
+ case DT_GNU_LIBLISTSZ:
if (do_dynamic)
{
print_vma (entry->d_un.d_val, UNSIGNED);
case DT_BIND_NOW:
/* The value of this entry is ignored. */
+ if (do_dynamic)
+ putchar ('\n');
+ break;
+
+ case DT_GNU_PRELINKED:
+ if (do_dynamic)
+ {
+ struct tm * tmp;
+ time_t time = entry->d_un.d_val;
+
+ tmp = gmtime (&time);
+ printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
+ tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
+ tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
+
+ }
break;
default:
case STT_SECTION: return "SECTION";
case STT_FILE: return "FILE";
case STT_COMMON: return "COMMON";
+ case STT_TLS: return "TLS";
default:
if (type >= STT_LOPROC && type <= STT_HIPROC)
{
get_symbol_index_type (type)
unsigned int type;
{
+ static char buff [32];
+
switch (type)
{
case SHN_UNDEF: return "UND";
case SHN_COMMON: return "COM";
default:
if (type >= SHN_LOPROC && type <= SHN_HIPROC)
- return "PRC";
+ sprintf (buff, "PRC[0x%04x]", type);
else if (type >= SHN_LOOS && type <= SHN_HIOS)
- return "OS ";
+ sprintf (buff, "OS [0x%04x]", type);
else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
- return "RSV";
+ sprintf (buff, "RSV[0x%04x]", type);
else
- {
- static char buff [32];
-
- sprintf (buff, "%3d", type);
- return buff;
- }
+ sprintf (buff, "%3d", type);
+ break;
}
+
+ return buff;
}
static int *
state_machine_regs.line += adv;
printf (_(" and Line by %d to %d\n"),
adv, state_machine_regs.line);
- }
- else switch (op_code)
+ }
+ else switch (op_code)
{
case DW_LNS_extended_op:
data += process_extended_line_op (data, info.li_default_is_stmt,
- debug_line_pointer_size);
+ debug_line_pointer_size);
break;
case DW_LNS_copy:
case DW_LNS_set_prologue_end:
printf (_(" Set prologue_end to true\n"));
break;
-
+
case DW_LNS_set_epilogue_begin:
printf (_(" Set epilogue_begin to true\n"));
break;
-
+
case DW_LNS_set_isa:
adv = read_leb128 (data, & bytes_read, 0);
data += bytes_read;
printf (_(" Set ISA to %d\n"), adv);
break;
-
+
default:
printf (_(" Unknown opcode %d with operands: "), op_code);
{
case DW_AT_src_coords: return "DW_AT_src_coords";
case DW_AT_body_begin: return "DW_AT_body_begin";
case DW_AT_body_end: return "DW_AT_body_end";
+ case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
default:
{
static char buffer [100];
printf ("DW_OP_nop");
break;
- /* DWARF 2.1 extensions. */
+ /* DWARF 3 extensions. */
case DW_OP_push_object_address:
printf ("DW_OP_push_object_address");
break;
printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
data += 4;
break;
- case DW_OP_calli:
- printf ("DW_OP_calli");
+ case DW_OP_call_ref:
+ printf ("DW_OP_call_ref");
+ break;
+
+ /* GNU extensions. */
+ case DW_OP_GNU_push_tls_address:
+ printf ("DW_OP_GNU_push_tls_address");
break;
default:
}
}
+static const char * debug_loc_contents;
+static bfd_vma debug_loc_size;
+
+static void
+load_debug_loc (file)
+ FILE * file;
+{
+ Elf32_Internal_Shdr * sec;
+ unsigned int i;
+
+ /* If it is already loaded, do nothing. */
+ if (debug_loc_contents != NULL)
+ return;
+
+ /* Locate the .debug_loc section. */
+ for (i = 0, sec = section_headers;
+ i < elf_header.e_shnum;
+ i ++, sec ++)
+ if (strcmp (SECTION_NAME (sec), ".debug_loc") == 0)
+ break;
+
+ if (i == elf_header.e_shnum || sec->sh_size == 0)
+ return;
+
+ debug_loc_size = sec->sh_size;
+
+ debug_loc_contents = ((char *)
+ get_data (NULL, file, sec->sh_offset, sec->sh_size,
+ _("debug_loc section data")));
+}
+
+static void
+free_debug_loc ()
+{
+ if (debug_loc_contents == NULL)
+ return;
+
+ free ((char *) debug_loc_contents);
+ debug_loc_contents = NULL;
+ debug_loc_size = 0;
+}
+
+
+static int
+display_debug_loc (section, start, file)
+ Elf32_Internal_Shdr * section;
+ unsigned char * start;
+ FILE * file ATTRIBUTE_UNUSED;
+{
+ unsigned char *section_end;
+ unsigned long bytes;
+ unsigned char *section_begin = start;
+ bfd_vma addr;
+
+ addr = section->sh_addr;
+ bytes = section->sh_size;
+ section_end = start + bytes;
+
+ if (bytes == 0)
+ {
+ printf (_("\nThe .debug_loc section is empty.\n"));
+ return 0;
+ }
+
+ printf (_("Contents of the .debug_loc section:\n\n"));
+ printf (_("\n Offset Begin End Expression\n"));
+
+ while (start < section_end)
+ {
+ unsigned long begin;
+ unsigned long end;
+ unsigned short length;
+ unsigned long offset;
+
+ offset = start - section_begin;
+
+ while (1)
+ {
+ /* Normally, the lists in the debug_loc section are related to a
+ given compilation unit, and thus, we would use the
+ pointer size of that compilation unit. However, since we are
+ displaying it seperately here, we either have to store
+ pointer sizes of all compilation units, or assume they don't
+ change. We assume, like the debug_line display, that
+ it doesn't change. */
+ begin = byte_get (start, debug_line_pointer_size);
+ start += debug_line_pointer_size;
+ end = byte_get (start, debug_line_pointer_size);
+ start += debug_line_pointer_size;
+
+ if (begin == 0 && end == 0)
+ break;
+
+ begin += addr;
+ end += addr;
+
+ length = byte_get (start, 2);
+ start += 2;
+
+ printf (" %8.8lx %8.8lx %8.8lx (", offset, begin, end);
+ decode_location_expression (start, debug_line_pointer_size, length);
+ printf (")\n");
+
+ start += length;
+ }
+ printf ("\n");
+ }
+ return 1;
+}
static const char * debug_str_contents;
static bfd_vma debug_str_size;
return debug_str_contents + offset;
}
-
static int
display_debug_str (section, start, file)
Elf32_Internal_Shdr * section;
return 1;
}
-
static unsigned char *
read_and_display_attr_value (attribute, form, data, cu_offset, pointer_size)
unsigned long attribute;
data += bytes_read;
printf (" %s", get_FORM_name (form));
return read_and_display_attr_value (attribute, form, data, cu_offset,
- pointer_size);
+ pointer_size);
}
switch (form)
break;
case DW_FORM_strp:
- printf (_(" (indirect string, offset: 0x%lx): "), uvalue);
- printf (fetch_indirect_string (uvalue));
+ printf (_(" (indirect string, offset: 0x%lx): %s"),
+ uvalue, fetch_indirect_string (uvalue));
break;
case DW_FORM_indirect:
break;
default:
- warn (_("Unrecognised form: %d\n"), form);
+ warn (_("Unrecognized form: %d\n"), form);
break;
}
decode_location_expression (block_start, pointer_size, uvalue);
printf (")");
}
+ else if (form == DW_FORM_data4)
+ {
+ printf ("(");
+ printf ("location list");
+ printf (")");
+ }
break;
default:
{
printf (" %-18s:", get_AT_name (attribute));
data = read_and_display_attr_value (attribute, form, data, cu_offset,
- pointer_size);
+ pointer_size);
printf ("\n");
return data;
}
printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
load_debug_str (file);
+ load_debug_loc (file);
while (start < end)
{
break;
}
- /* Check for RELA relocations in the abbrev_offset address, and
- apply them. */
+ /* Check for RELA relocations in the
+ abbrev_offset address, and apply them. */
for (relsec = section_headers;
relsec < section_headers + elf_header.e_shnum;
++relsec)
Elf_Internal_Sym *sym;
if (relsec->sh_type != SHT_RELA
- || SECTION_HEADER (relsec->sh_info) != section)
+ || SECTION_HEADER (relsec->sh_info) != section
+ || relsec->sh_size == 0)
continue;
if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
{
sym = symtab + ELF32_R_SYM (rp->r_info);
- if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
+ if (ELF32_R_SYM (rp->r_info) != 0
+ && ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
{
warn (_("Skipping unexpected symbol type %u\n"),
ELF32_ST_TYPE (sym->st_info));
{
sym = symtab + ELF64_R_SYM (rp->r_info);
- if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
+ if (ELF64_R_SYM (rp->r_info) != 0
+ && ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
{
warn (_("Skipping unexpected symbol type %u\n"),
ELF64_ST_TYPE (sym->st_info));
}
}
- compunit.cu_abbrev_offset += rp->r_addend;
+ compunit.cu_abbrev_offset = rp->r_addend;
break;
}
free_abbrevs ();
/* Read in the abbrevs used by this compilation unit. */
-
{
Elf32_Internal_Shdr * sec;
unsigned char * begin;
}
free_debug_str ();
+ free_debug_loc ();
printf ("\n");
length = byte_get (start, 4); start += 4;
if (length == 0)
- return 1;
+ {
+ printf ("\n%08lx ZERO terminator\n\n",
+ (unsigned long)(saved_start - section_start));
+ return 1;
+ }
if (length == 0xffffffff)
{
encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
fc->pc_begin = byte_get (start, encoded_ptr_size);
+ if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
+ fc->pc_begin += section->sh_addr + (start - section_start);
start += encoded_ptr_size;
fc->pc_range = byte_get (start, encoded_ptr_size);
start += encoded_ptr_size;
about to interpret instructions for the chunk. */
if (do_debug_frames_interp)
- {
- /* Start by making a pass over the chunk, allocating storage
- and taking note of what registers are used. */
- unsigned char * tmp = start;
+ {
+ /* Start by making a pass over the chunk, allocating storage
+ and taking note of what registers are used. */
+ unsigned char * tmp = start;
- while (start < block_end)
- {
- unsigned op, opa;
- unsigned long reg;
+ while (start < block_end)
+ {
+ unsigned op, opa;
+ unsigned long reg;
- op = * start ++;
- opa = op & 0x3f;
- if (op & 0xc0)
- op &= 0xc0;
+ op = * start ++;
+ opa = op & 0x3f;
+ if (op & 0xc0)
+ op &= 0xc0;
- /* Warning: if you add any more cases to this switch, be
- sure to add them to the corresponding switch below. */
- switch (op)
- {
- case DW_CFA_advance_loc:
- break;
- case DW_CFA_offset:
- LEB ();
- frame_need_space (fc, opa);
- fc->col_type[opa] = DW_CFA_undefined;
- break;
- case DW_CFA_restore:
- frame_need_space (fc, opa);
- fc->col_type[opa] = DW_CFA_undefined;
- break;
- case DW_CFA_set_loc:
- start += encoded_ptr_size;
- break;
- case DW_CFA_advance_loc1:
- start += 1;
- break;
- case DW_CFA_advance_loc2:
- start += 2;
- break;
- case DW_CFA_advance_loc4:
- start += 4;
- break;
- case DW_CFA_offset_extended:
- reg = LEB (); LEB ();
- frame_need_space (fc, reg);
- fc->col_type[reg] = DW_CFA_undefined;
- break;
- case DW_CFA_restore_extended:
- reg = LEB ();
- frame_need_space (fc, reg);
- fc->col_type[reg] = DW_CFA_undefined;
- break;
- case DW_CFA_undefined:
- reg = LEB ();
- frame_need_space (fc, reg);
- fc->col_type[reg] = DW_CFA_undefined;
- break;
- case DW_CFA_same_value:
- reg = LEB ();
- frame_need_space (fc, reg);
- fc->col_type[reg] = DW_CFA_undefined;
- break;
- case DW_CFA_register:
- reg = LEB (); LEB ();
- frame_need_space (fc, reg);
- fc->col_type[reg] = DW_CFA_undefined;
- break;
- case DW_CFA_def_cfa:
- LEB (); LEB ();
- break;
- case DW_CFA_def_cfa_register:
- LEB ();
- break;
- case DW_CFA_def_cfa_offset:
- LEB ();
- break;
-#ifndef DW_CFA_GNU_args_size
-#define DW_CFA_GNU_args_size 0x2e
-#endif
- case DW_CFA_GNU_args_size:
- LEB ();
- break;
-#ifndef DW_CFA_GNU_negative_offset_extended
-#define DW_CFA_GNU_negative_offset_extended 0x2f
-#endif
- case DW_CFA_GNU_negative_offset_extended:
- reg = LEB (); LEB ();
- frame_need_space (fc, reg);
- fc->col_type[reg] = DW_CFA_undefined;
+ /* Warning: if you add any more cases to this switch, be
+ sure to add them to the corresponding switch below. */
+ switch (op)
+ {
+ case DW_CFA_advance_loc:
+ break;
+ case DW_CFA_offset:
+ LEB ();
+ frame_need_space (fc, opa);
+ fc->col_type[opa] = DW_CFA_undefined;
+ break;
+ case DW_CFA_restore:
+ frame_need_space (fc, opa);
+ fc->col_type[opa] = DW_CFA_undefined;
+ break;
+ case DW_CFA_set_loc:
+ start += encoded_ptr_size;
+ break;
+ case DW_CFA_advance_loc1:
+ start += 1;
+ break;
+ case DW_CFA_advance_loc2:
+ start += 2;
+ break;
+ case DW_CFA_advance_loc4:
+ start += 4;
+ break;
+ case DW_CFA_offset_extended:
+ reg = LEB (); LEB ();
+ frame_need_space (fc, reg);
+ fc->col_type[reg] = DW_CFA_undefined;
+ break;
+ case DW_CFA_restore_extended:
+ reg = LEB ();
+ frame_need_space (fc, reg);
+ fc->col_type[reg] = DW_CFA_undefined;
+ break;
+ case DW_CFA_undefined:
+ reg = LEB ();
+ frame_need_space (fc, reg);
+ fc->col_type[reg] = DW_CFA_undefined;
+ break;
+ case DW_CFA_same_value:
+ reg = LEB ();
+ frame_need_space (fc, reg);
+ fc->col_type[reg] = DW_CFA_undefined;
+ break;
+ case DW_CFA_register:
+ reg = LEB (); LEB ();
+ frame_need_space (fc, reg);
+ fc->col_type[reg] = DW_CFA_undefined;
+ break;
+ case DW_CFA_def_cfa:
+ LEB (); LEB ();
+ break;
+ case DW_CFA_def_cfa_register:
+ LEB ();
+ break;
+ case DW_CFA_def_cfa_offset:
+ LEB ();
+ break;
+ case DW_CFA_offset_extended_sf:
+ reg = LEB (); SLEB ();
+ frame_need_space (fc, reg);
+ fc->col_type[reg] = DW_CFA_undefined;
+ break;
+ case DW_CFA_def_cfa_sf:
+ LEB (); SLEB ();
+ break;
+ case DW_CFA_def_cfa_offset_sf:
+ SLEB ();
+ break;
+ case DW_CFA_GNU_args_size:
+ LEB ();
+ break;
+ case DW_CFA_GNU_negative_offset_extended:
+ reg = LEB (); LEB ();
+ frame_need_space (fc, reg);
+ fc->col_type[reg] = DW_CFA_undefined;
- default:
- break;
- }
- }
- start = tmp;
- }
+ default:
+ break;
+ }
+ }
+ start = tmp;
+ }
/* Now we know what registers are used, make a second pass over
the chunk, this time actually printing out the info. */
if (op & 0xc0)
op &= 0xc0;
- /* Warning: if you add any more cases to this switch, be
- sure to add them to the corresponding switch above. */
+ /* Warning: if you add any more cases to this switch, be
+ sure to add them to the corresponding switch above. */
switch (op)
{
case DW_CFA_advance_loc:
if (do_debug_frames_interp)
- frame_display_row (fc, &need_col_headers, &max_regs);
+ frame_display_row (fc, &need_col_headers, &max_regs);
else
- printf (" DW_CFA_advance_loc: %d to %08lx\n",
- opa * fc->code_factor,
+ printf (" DW_CFA_advance_loc: %d to %08lx\n",
+ opa * fc->code_factor,
fc->pc_begin + opa * fc->code_factor);
fc->pc_begin += opa * fc->code_factor;
break;
case DW_CFA_offset:
roffs = LEB ();
if (! do_debug_frames_interp)
- printf (" DW_CFA_offset: r%d at cfa%+ld\n",
+ printf (" DW_CFA_offset: r%d at cfa%+ld\n",
opa, roffs * fc->data_factor);
fc->col_type[opa] = DW_CFA_offset;
fc->col_offset[opa] = roffs * fc->data_factor;
case DW_CFA_restore:
if (! do_debug_frames_interp)
- printf (" DW_CFA_restore: r%d\n", opa);
+ printf (" DW_CFA_restore: r%d\n", opa);
fc->col_type[opa] = cie->col_type[opa];
fc->col_offset[opa] = cie->col_offset[opa];
break;
case DW_CFA_set_loc:
vma = byte_get (start, encoded_ptr_size);
+ if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
+ vma += section->sh_addr + (start - section_start);
start += encoded_ptr_size;
if (do_debug_frames_interp)
- frame_display_row (fc, &need_col_headers, &max_regs);
+ frame_display_row (fc, &need_col_headers, &max_regs);
else
- printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
+ printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
fc->pc_begin = vma;
break;
case DW_CFA_advance_loc1:
ofs = byte_get (start, 1); start += 1;
if (do_debug_frames_interp)
- frame_display_row (fc, &need_col_headers, &max_regs);
+ frame_display_row (fc, &need_col_headers, &max_regs);
else
- printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
- ofs * fc->code_factor,
+ printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
+ ofs * fc->code_factor,
fc->pc_begin + ofs * fc->code_factor);
fc->pc_begin += ofs * fc->code_factor;
break;
case DW_CFA_advance_loc2:
ofs = byte_get (start, 2); start += 2;
if (do_debug_frames_interp)
- frame_display_row (fc, &need_col_headers, &max_regs);
+ frame_display_row (fc, &need_col_headers, &max_regs);
else
- printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
- ofs * fc->code_factor,
+ printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
+ ofs * fc->code_factor,
fc->pc_begin + ofs * fc->code_factor);
fc->pc_begin += ofs * fc->code_factor;
break;
case DW_CFA_advance_loc4:
ofs = byte_get (start, 4); start += 4;
if (do_debug_frames_interp)
- frame_display_row (fc, &need_col_headers, &max_regs);
+ frame_display_row (fc, &need_col_headers, &max_regs);
else
- printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
- ofs * fc->code_factor,
+ printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
+ ofs * fc->code_factor,
fc->pc_begin + ofs * fc->code_factor);
fc->pc_begin += ofs * fc->code_factor;
break;
case DW_CFA_restore_extended:
reg = LEB ();
if (! do_debug_frames_interp)
- printf (" DW_CFA_restore_extended: r%ld\n", reg);
+ printf (" DW_CFA_restore_extended: r%ld\n", reg);
fc->col_type[reg] = cie->col_type[reg];
fc->col_offset[reg] = cie->col_offset[reg];
break;
case DW_CFA_undefined:
reg = LEB ();
if (! do_debug_frames_interp)
- printf (" DW_CFA_undefined: r%ld\n", reg);
+ printf (" DW_CFA_undefined: r%ld\n", reg);
fc->col_type[reg] = DW_CFA_undefined;
fc->col_offset[reg] = 0;
break;
case DW_CFA_same_value:
reg = LEB ();
if (! do_debug_frames_interp)
- printf (" DW_CFA_same_value: r%ld\n", reg);
+ printf (" DW_CFA_same_value: r%ld\n", reg);
fc->col_type[reg] = DW_CFA_same_value;
fc->col_offset[reg] = 0;
break;
reg = LEB ();
roffs = LEB ();
if (! do_debug_frames_interp)
- printf (" DW_CFA_register: r%ld\n", reg);
+ printf (" DW_CFA_register: r%ld\n", reg);
fc->col_type[reg] = DW_CFA_register;
fc->col_offset[reg] = roffs;
break;
case DW_CFA_remember_state:
if (! do_debug_frames_interp)
- printf (" DW_CFA_remember_state\n");
+ printf (" DW_CFA_remember_state\n");
rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
rs->ncols = fc->ncols;
rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
case DW_CFA_restore_state:
if (! do_debug_frames_interp)
- printf (" DW_CFA_restore_state\n");
+ printf (" DW_CFA_restore_state\n");
rs = remembered_state;
remembered_state = rs->next;
frame_need_space (fc, rs->ncols-1);
fc->cfa_reg = LEB ();
fc->cfa_offset = LEB ();
if (! do_debug_frames_interp)
- printf (" DW_CFA_def_cfa: r%d ofs %d\n",
+ printf (" DW_CFA_def_cfa: r%d ofs %d\n",
fc->cfa_reg, fc->cfa_offset);
break;
case DW_CFA_def_cfa_register:
fc->cfa_reg = LEB ();
if (! do_debug_frames_interp)
- printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
+ printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
break;
case DW_CFA_def_cfa_offset:
fc->cfa_offset = LEB ();
if (! do_debug_frames_interp)
- printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
+ printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
break;
case DW_CFA_nop:
if (! do_debug_frames_interp)
- printf (" DW_CFA_nop\n");
+ printf (" DW_CFA_nop\n");
+ break;
+
+ case DW_CFA_offset_extended_sf:
+ reg = LEB ();
+ l = SLEB ();
+ frame_need_space (fc, reg);
+ if (! do_debug_frames_interp)
+ printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
+ reg, l * fc->data_factor);
+ fc->col_type[reg] = DW_CFA_offset;
+ fc->col_offset[reg] = l * fc->data_factor;
+ break;
+
+ case DW_CFA_def_cfa_sf:
+ fc->cfa_reg = LEB ();
+ fc->cfa_offset = SLEB ();
+ if (! do_debug_frames_interp)
+ printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
+ fc->cfa_reg, fc->cfa_offset);
+ break;
+
+ case DW_CFA_def_cfa_offset_sf:
+ fc->cfa_offset = SLEB ();
+ if (! do_debug_frames_interp)
+ printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
break;
-#ifndef DW_CFA_GNU_window_save
-#define DW_CFA_GNU_window_save 0x2d
-#endif
case DW_CFA_GNU_window_save:
if (! do_debug_frames_interp)
- printf (" DW_CFA_GNU_window_save\n");
+ printf (" DW_CFA_GNU_window_save\n");
break;
case DW_CFA_GNU_args_size:
ul = LEB ();
if (! do_debug_frames_interp)
- printf (" DW_CFA_GNU_args_size: %ld\n", ul);
+ printf (" DW_CFA_GNU_args_size: %ld\n", ul);
break;
case DW_CFA_GNU_negative_offset_extended:
l = - LEB ();
frame_need_space (fc, reg);
if (! do_debug_frames_interp)
- printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
+ printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
reg, l * fc->data_factor);
fc->col_type[reg] = DW_CFA_offset;
fc->col_offset[reg] = l * fc->data_factor;
break;
+ /* FIXME: How do we handle these? */
+ case DW_CFA_def_cfa_expression:
+ fprintf (stderr, "unsupported DW_CFA_def_cfa_expression\n");
+ start = block_end;
+ break;
+
+ case DW_CFA_expression:
+ fprintf (stderr, "unsupported DW_CFA_expression\n");
+ start = block_end;
+ break;
+
default:
fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
start = block_end;
}
if (do_debug_frames_interp)
- frame_display_row (fc, &need_col_headers, &max_regs);
+ frame_display_row (fc, &need_col_headers, &max_regs);
start = block_end;
}
{ ".eh_frame", display_debug_frames, NULL },
{ ".debug_macinfo", display_debug_macinfo, NULL },
{ ".debug_str", display_debug_str, NULL },
-
+ { ".debug_loc", display_debug_loc, NULL },
{ ".debug_pubtypes", display_debug_not_supported, NULL },
{ ".debug_ranges", display_debug_not_supported, NULL },
{ ".debug_static_func", display_debug_not_supported, NULL },
}
if (i == -1)
- printf (_("Unrecognised debug section: %s\n"), name);
+ printf (_("Unrecognized debug section: %s\n"), name);
free (start);
int j;
if (section->sh_size == 0)
- continue;
+ continue;
/* See if there is some pre-scan operation for this section. */
for (j = NUM_ELEM (debug_displays); j--;)
- if (strcmp (debug_displays[j].name, name) == 0)
+ if (strcmp (debug_displays[j].name, name) == 0)
{
if (debug_displays[j].prescan != NULL)
{
free (start);
}
- break;
- }
+ break;
+ }
}
for (i = 0, section = section_headers;
if (dynamic_symbols == NULL)
{
- error (_("conflict list with without table"));
+ error (_("conflict list found without a dynamic symbol table"));
return 0;
}
return 1;
}
+static int
+process_gnu_liblist (file)
+ FILE * file;
+{
+ Elf_Internal_Shdr * section, * string_sec;
+ Elf32_External_Lib * elib;
+ char * strtab;
+ size_t cnt;
+ unsigned i;
+
+ if (! do_arch)
+ return 0;
+
+ for (i = 0, section = section_headers;
+ i < elf_header.e_shnum;
+ i++, section ++)
+ {
+ switch (section->sh_type)
+ {
+ case SHT_GNU_LIBLIST:
+ elib = ((Elf32_External_Lib *)
+ get_data (NULL, file, section->sh_offset, section->sh_size,
+ _("liblist")));
+
+ if (elib == NULL)
+ break;
+ string_sec = SECTION_HEADER (section->sh_link);
+
+ strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
+ string_sec->sh_size,
+ _("liblist string table"));
+
+ if (strtab == NULL
+ || section->sh_entsize != sizeof (Elf32_External_Lib))
+ {
+ free (elib);
+ break;
+ }
+
+ printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
+ SECTION_NAME (section),
+ (long) (section->sh_size / sizeof (Elf32_External_Lib)));
+
+ puts (" Library Time Stamp Checksum Version Flags");
+
+ for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
+ ++cnt)
+ {
+ 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_checksum = BYTE_GET (elib[cnt].l_checksum);
+ liblist.l_version = BYTE_GET (elib[cnt].l_version);
+ liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
+
+ 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 ("%3lu: ", (unsigned long) cnt);
+ if (do_wide)
+ printf ("%-20s", strtab + liblist.l_name);
+ else
+ printf ("%-20.20s", strtab + liblist.l_name);
+ printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
+ liblist.l_version, liblist.l_flags);
+ }
+
+ free (elib);
+ }
+ }
+
+ return 1;
+}
+
static const char *
get_note_type (e_type)
unsigned e_type;
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)");
+ case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
default:
sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
return buff;
If the value of namesz is zero, there is no name present. */
static int
process_note (pnote)
- Elf32_Internal_Note * pnote;
+ Elf32_Internal_Note * pnote;
{
const char *nt;
while (external < (Elf_External_Note *)((char *) pnotes + length))
{
+ Elf_External_Note * next;
Elf32_Internal_Note inote;
char * temp = NULL;
inote.descdata = inote.namedata + align_power (inote.namesz, 2);
inote.descpos = offset + (inote.descdata - (char *) pnotes);
- external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
+ next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
+
+ if (((char *) next) > (((char *) pnotes) + length))
+ {
+ warn (_("corrupt note found at offset %x into core notes\n"),
+ ((char *) external) - ((char *) pnotes));
+ warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
+ inote.type, inote.namesz, inote.descsz);
+ break;
+ }
+
+ external = next;
/* Verify that name is null terminated. It appears that at least
one version of Linux (RedHat 6.0) generates corefiles that don't
elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
}
- /* There may be some extensions in the first section header. Don't
- bomb if we can't read it. */
- if (is_32bit_elf)
- get_32bit_section_headers (file, 1);
- else
- get_64bit_section_headers (file, 1);
+ if (elf_header.e_shoff)
+ {
+ /* There may be some extensions in the first section header. Don't
+ bomb if we can't read it. */
+ if (is_32bit_elf)
+ get_32bit_section_headers (file, 1);
+ else
+ get_64bit_section_headers (file, 1);
+ }
return 1;
}
return 1;
}
- process_section_headers (file);
+ if (! process_section_headers (file))
+ {
+ /* Without loaded section headers we
+ cannot process lots of things. */
+ do_unwind = do_version = do_dump = do_arch = 0;
- process_program_headers (file);
+ if (! do_using_dynamic)
+ do_syms = do_reloc = 0;
+ }
- process_dynamic_segment (file);
+ if (process_program_headers (file))
+ process_dynamic_segment (file);
process_relocs (file);
process_corefile_contents (file);
+ process_gnu_liblist (file);
+
process_arch_specific (file);
fclose (file);