/* readelf.c -- display contents of an ELF format file
- Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
Originally developed by Eric Youngdale <eric@andante.jic.com>
Modifications by Nick Clifton <nickc@redhat.com>
#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/fr30.h"
+#include "elf/h8.h"
+#include "elf/hppa.h"
+#include "elf/i386.h"
+#include "elf/i860.h"
+#include "elf/i960.h"
+#include "elf/ia64.h"
+#include "elf/m32r.h"
+#include "elf/m68k.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/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;
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 const char * get_data_encoding PARAMS ((unsigned int));
static const char * get_osabi_name PARAMS ((unsigned int));
static int guess_is_rela PARAMS ((unsigned long));
-static char * get_note_type PARAMS ((unsigned int));
+static const char * get_note_type PARAMS ((unsigned int));
+static const char * get_netbsd_elfcore_note_type PARAMS ((unsigned int));
static int process_note PARAMS ((Elf32_Internal_Note *));
static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
static int process_corefile_note_segments PARAMS ((FILE *));
case EM_386:
case EM_486:
case EM_960:
+ 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:
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
}
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);
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));
+ print_symbol (22, SECTION_NAME (section_headers + psym->st_shndx));
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 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_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";
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;
case EM_68K:
if (e_flags & EF_CPU32)
strcat (buf, ", cpu32");
+ if (e_flags & EF_M68000)
+ strcat (buf, ", m68000");
break;
case EM_PPC:
{
case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
case PT_IA_64_UNWIND: return "IA_64_UNWIND";
+ case PT_HP_TLS: return "HP_TLS";
+ case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
+ case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
+ case PT_IA_64_HP_STACK: return "HP_STACK";
default:
break;
}
case EM_PARISC:
result = get_parisc_segment_type (p_type);
break;
+ case EM_IA_64:
+ result = get_ia64_segment_type (p_type);
+ break;
default:
result = NULL;
break;
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 --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);
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;
}
}
}
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);
}
}
}
+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;
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 (_("The section %s contains:\n\n"), SECTION_NAME (section));
load_debug_str (file);
+ load_debug_loc (file);
while (start < end)
{
}
free_debug_str ();
+ free_debug_loc ();
printf ("\n");
{ ".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);
return 1;
}
-static char *
+static const char *
get_note_type (e_type)
unsigned e_type;
{
}
}
+static const char *
+get_netbsd_elfcore_note_type (e_type)
+ unsigned e_type;
+{
+ static char buff[64];
+
+ if (e_type == NT_NETBSDCORE_PROCINFO)
+ {
+ /* NetBSD core "procinfo" structure. */
+ return _("NetBSD procinfo structure");
+ }
+
+ /* As of Jan 2002 there are no other machine-independent notes
+ defined for NetBSD core files. If the note type is less
+ than the start of the machine-dependent note types, we don't
+ understand it. */
+
+ if (e_type < NT_NETBSDCORE_FIRSTMACH)
+ {
+ sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
+ return buff;
+ }
+
+ switch (elf_header.e_machine)
+ {
+ /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
+ and PT_GETFPREGS == mach+2. */
+
+ case EM_OLD_ALPHA:
+ case EM_ALPHA:
+ case EM_SPARC:
+ case EM_SPARC32PLUS:
+ case EM_SPARCV9:
+ switch (e_type)
+ {
+ case NT_NETBSDCORE_FIRSTMACH+0:
+ return _("PT_GETREGS (reg structure)");
+ case NT_NETBSDCORE_FIRSTMACH+2:
+ return _("PT_GETFPREGS (fpreg structure)");
+ default:
+ break;
+ }
+ break;
+
+ /* On all other arch's, PT_GETREGS == mach+1 and
+ PT_GETFPREGS == mach+3. */
+ default:
+ switch (e_type)
+ {
+ case NT_NETBSDCORE_FIRSTMACH+1:
+ return _("PT_GETREGS (reg structure)");
+ case NT_NETBSDCORE_FIRSTMACH+3:
+ return _("PT_GETFPREGS (fpreg structure)");
+ default:
+ break;
+ }
+ }
+
+ sprintf (buff, _("PT_FIRSTMACH+%d"), e_type - NT_NETBSDCORE_FIRSTMACH);
+ return buff;
+}
+
/* Note that by the ELF standard, the name field is already null byte
terminated, and namesz includes the terminating null byte.
I.E. the value of namesz for the name "FSF" is 4.
process_note (pnote)
Elf32_Internal_Note * pnote;
{
+ const char *nt;
+
+ if (pnote->namesz == 0)
+ {
+ /* If there is no note name, then use the default set of
+ note type strings. */
+ nt = get_note_type (pnote->type);
+ }
+ else if (strncmp (pnote->namedata, "NetBSD-CORE", 11) == 0)
+ {
+ /* NetBSD-specific core file notes. */
+ nt = get_netbsd_elfcore_note_type (pnote->type);
+ }
+ else
+ {
+ /* Don't recognize this note name; just use the default set of
+ note type strings. */
+ nt = get_note_type (pnote->type);
+ }
+
printf (" %s\t\t0x%08lx\t%s\n",
pnote->namesz ? pnote->namedata : "(NONE)",
- pnote->descsz, get_note_type (pnote->type));
+ pnote->descsz, nt);
return 1;
}
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