#include "elf/cris.h"
#include "elf/d10v.h"
#include "elf/d30v.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/sh.h"
#include "elf/sparc.h"
#include "elf/v850.h"
+#include "elf/vax.h"
#include "elf/x86-64.h"
#include "elf/xstormy16.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 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;
/* 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. */
printf (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_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;
}
else
{
- if (elf_header.e_machine == EM_MIPS)
+ if (elf_header.e_machine == EM_MIPS)
{
type = ELF64_MIPS_R_TYPE (info);
type2 = ELF64_MIPS_R_TYPE2 (info);
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)
+ if (!is_32bit_elf)
{
rtype2 = elf_mips_reloc_type (type2);
rtype3 = elf_mips_reloc_type (type3);
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)
putchar ('\n');
- if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
+ if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
{
printf (" Type2: ");
else
printf ("%-17.17s", rtype3);
- putchar ('\n');
+ putchar ('\n');
}
}
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_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_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;
decode_ARM_machine_flags (e_flags, buf);
break;
- case EM_68K:
- if (e_flags & EF_CPU32)
- strcat (buf, ", cpu32");
+ case EM_68K:
+ if (e_flags & EF_CPU32)
+ strcat (buf, ", cpu32");
if (e_flags & EF_M68000)
strcat (buf, ", m68000");
- break;
+ 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'},
-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]\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, _("\
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 (_("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 ++;
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)
}
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)
{
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)
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");
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;
vma = byte_get (start, encoded_ptr_size);
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 },
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;
}
process_corefile_contents (file);
+ process_gnu_liblist (file);
+
process_arch_specific (file);
fclose (file);