/* dwarf.c -- display DWARF contents of a BFD binary file
- Copyright 2005, 2006, 2007, 2008
+ Copyright 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
This file is part of GNU Binutils.
#include "bfd.h"
#include "bucomm.h"
#include "elf/common.h"
-#include "elf/dwarf2.h"
+#include "dwarf2.h"
#include "dwarf.h"
static int have_frame_base;
int do_debug_abbrevs;
int do_debug_lines;
int do_debug_pubnames;
+int do_debug_pubtypes;
int do_debug_aranges;
int do_debug_ranges;
int do_debug_frames;
return ((unsigned int) (field[0]))
| (((unsigned int) (field[1])) << 8);
+ case 3:
+ return ((unsigned long) (field[0]))
+ | (((unsigned long) (field[1])) << 8)
+ | (((unsigned long) (field[2])) << 16);
+
case 4:
return ((unsigned long) (field[0]))
| (((unsigned long) (field[1])) << 8)
case 2:
return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
+ case 3:
+ return ((unsigned long) (field[2]))
+ | (((unsigned long) (field[1])) << 8)
+ | (((unsigned long) (field[0])) << 16);
+
case 4:
return ((unsigned long) (field[3]))
| (((unsigned long) (field[2])) << 8)
static void
free_abbrevs (void)
{
- abbrev_entry *abbrev;
+ abbrev_entry *abbrv;
- for (abbrev = first_abbrev; abbrev;)
+ for (abbrv = first_abbrev; abbrv;)
{
- abbrev_entry *next = abbrev->next;
+ abbrev_entry *next_abbrev = abbrv->next;
abbrev_attr *attr;
- for (attr = abbrev->first_attr; attr;)
+ for (attr = abbrv->first_attr; attr;)
{
- abbrev_attr *next = attr->next;
+ abbrev_attr *next_attr = attr->next;
free (attr);
- attr = next;
+ attr = next_attr;
}
- free (abbrev);
- abbrev = next;
+ free (abbrv);
+ abbrv = next_abbrev;
}
last_abbrev = first_abbrev = NULL;
{
abbrev_entry *entry;
- entry = malloc (sizeof (*entry));
+ entry = (abbrev_entry *) malloc (sizeof (*entry));
if (entry == NULL)
/* ugg */
{
abbrev_attr *attr;
- attr = malloc (sizeof (*attr));
+ attr = (abbrev_attr *) malloc (sizeof (*attr));
if (attr == NULL)
/* ugg */
case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
+ case DW_TAG_condition: return "DW_TAG_condition";
+ case DW_TAG_shared_type: return "DW_TAG_shared_type";
+ /* DWARF 4 values. */
+ case DW_TAG_type_unit: return "DW_TAG_type_unit";
+ case DW_TAG_rvalue_reference_type: return "DW_TAG_rvalue_reference_type";
+ case DW_TAG_template_alias: return "DW_TAG_template_alias";
/* UPC values. */
case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
case DW_FORM_ref8: return "DW_FORM_ref8";
case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
case DW_FORM_indirect: return "DW_FORM_indirect";
+ /* DWARF 4 values. */
+ case DW_FORM_sec_offset: return "DW_FORM_sec_offset";
+ case DW_FORM_exprloc: return "DW_FORM_exprloc";
+ case DW_FORM_flag_present: return "DW_FORM_flag_present";
+ case DW_FORM_ref_sig8: return "DW_FORM_ref_sig8";
default:
{
static char buffer[100];
data += bytes_read;
break;
+ /* DWARF 4 extensions. */
+ case DW_OP_stack_value:
+ printf ("DW_OP_stack_value");
+ break;
+
+ case DW_OP_implicit_value:
+ printf ("DW_OP_implicit_value");
+ uvalue = read_leb128 (data, &bytes_read, 0);
+ data += bytes_read;
+ display_block (data, uvalue);
+ data += uvalue;
+ break;
+
/* GNU extensions. */
case DW_OP_GNU_push_tls_address:
printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
/* Handled above. */
break;
+ case DW_FORM_ref_sig8:
+ if (!do_loc)
+ {
+ int i;
+ printf (" signature: ");
+ for (i = 0; i < 8; i++)
+ {
+ printf ("%02x", (unsigned) byte_get (data, 1));
+ data += 1;
+ }
+ }
+ else
+ data += 8;
+ break;
+
default:
warn (_("Unrecognized form: %lu\n"), form);
break;
if (form == DW_FORM_data4 || form == DW_FORM_data8)
{
/* Process location list. */
- unsigned int max = debug_info_p->max_loc_offsets;
+ unsigned int lmax = debug_info_p->max_loc_offsets;
unsigned int num = debug_info_p->num_loc_offsets;
- if (max == 0 || num >= max)
+ if (lmax == 0 || num >= lmax)
{
- max += 1024;
- debug_info_p->loc_offsets
- = xcrealloc (debug_info_p->loc_offsets,
- max, sizeof (*debug_info_p->loc_offsets));
- debug_info_p->have_frame_base
- = xcrealloc (debug_info_p->have_frame_base,
- max, sizeof (*debug_info_p->have_frame_base));
- debug_info_p->max_loc_offsets = max;
+ lmax += 1024;
+ debug_info_p->loc_offsets = (long unsigned int *)
+ xcrealloc (debug_info_p->loc_offsets,
+ lmax, sizeof (*debug_info_p->loc_offsets));
+ debug_info_p->have_frame_base = (int *)
+ xcrealloc (debug_info_p->have_frame_base,
+ lmax, sizeof (*debug_info_p->have_frame_base));
+ debug_info_p->max_loc_offsets = lmax;
}
debug_info_p->loc_offsets [num] = uvalue;
debug_info_p->have_frame_base [num] = have_frame_base;
if (form == DW_FORM_data4 || form == DW_FORM_data8)
{
/* Process range list. */
- unsigned int max = debug_info_p->max_range_lists;
+ unsigned int lmax = debug_info_p->max_range_lists;
unsigned int num = debug_info_p->num_range_lists;
- if (max == 0 || num >= max)
+ if (lmax == 0 || num >= lmax)
{
- max += 1024;
- debug_info_p->range_lists
- = xcrealloc (debug_info_p->range_lists,
- max, sizeof (*debug_info_p->range_lists));
- debug_info_p->max_range_lists = max;
+ lmax += 1024;
+ debug_info_p->range_lists = (long unsigned int *)
+ xcrealloc (debug_info_p->range_lists,
+ lmax, sizeof (*debug_info_p->range_lists));
+ debug_info_p->max_range_lists = lmax;
}
debug_info_p->range_lists [num] = uvalue;
debug_info_p->num_range_lists++;
case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
case DW_LANG_D: printf ("(D)"); break;
+ /* DWARF 4 values. */
+ case DW_LANG_Python: printf ("(Python)"); break;
/* MIPS extension. */
case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
/* UPC extension. */
case DW_AT_import:
{
+ if (form == DW_FORM_ref_sig8)
+ break;
+
if (form == DW_FORM_ref1
|| form == DW_FORM_ref2
|| form == DW_FORM_ref4)
case DW_AT_elemental: return "DW_AT_elemental";
case DW_AT_pure: return "DW_AT_pure";
case DW_AT_recursive: return "DW_AT_recursive";
+ /* DWARF 4 values. */
+ case DW_AT_signature: return "DW_AT_signature";
+ case DW_AT_main_subprogram: return "DW_AT_main_subprogram";
+ case DW_AT_data_bit_offset: return "DW_AT_data_bit_offset";
+ case DW_AT_const_expr: return "DW_AT_const_expr";
+ case DW_AT_enum_class: return "DW_AT_enum_class";
+ case DW_AT_linkage_name: return "DW_AT_linkage_name";
/* HP and SGI/MIPS extensions. */
case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
/* GNU extensions. */
- case DW_AT_sf_names: return "DW_AT_sf_names";
- case DW_AT_src_info: return "DW_AT_src_info";
- case DW_AT_mac_info: return "DW_AT_mac_info";
- 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";
+ case DW_AT_sf_names: return "DW_AT_sf_names";
+ case DW_AT_src_info: return "DW_AT_src_info";
+ case DW_AT_mac_info: return "DW_AT_mac_info";
+ 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";
+ case DW_AT_GNU_guarded_by: return "DW_AT_GNU_guarded_by";
+ case DW_AT_GNU_pt_guarded_by: return "DW_AT_GNU_pt_guarded_by";
+ case DW_AT_GNU_guarded: return "DW_AT_GNU_guarded";
+ case DW_AT_GNU_pt_guarded: return "DW_AT_GNU_pt_guarded";
+ case DW_AT_GNU_locks_excluded: return "DW_AT_GNU_locks_excluded";
+ case DW_AT_GNU_exclusive_locks_required: return "DW_AT_GNU_exclusive_locks_required";
+ case DW_AT_GNU_shared_locks_required: return "DW_AT_GNU_shared_locks_required";
+ case DW_AT_GNU_odr_signature: return "DW_AT_GNU_odr_signature";
/* UPC extension. */
case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
/* Process the contents of a .debug_info section. If do_loc is non-zero
then we are scanning for location lists and we do not want to display
- anything to the user. */
+ anything to the user. If do_types is non-zero, we are processing
+ a .debug_types section instead of a .debug_info section. */
static int
process_debug_info (struct dwarf_section *section,
void *file,
- int do_loc)
+ int do_loc,
+ int do_types)
{
unsigned char *start = section->start;
unsigned char *end = start + section->size;
unsigned int num_units = 0;
if ((do_loc || do_debug_loc || do_debug_ranges)
- && num_debug_info_entries == 0)
+ && num_debug_info_entries == 0
+ && ! do_types)
{
unsigned long length;
}
/* Then allocate an array to hold the information. */
- debug_information = cmalloc (num_units,
- sizeof (* debug_information));
+ debug_information = (debug_info *) cmalloc (num_units,
+ sizeof (* debug_information));
if (debug_information == NULL)
{
error (_("Not enough memory for a debug info array of %u entries"),
unsigned long cu_offset;
int offset_size;
int initial_length_size;
+ unsigned char signature[8];
+ unsigned long type_offset = 0;
hdrptr = start;
compunit.cu_pointer_size = byte_get (hdrptr, 1);
hdrptr += 1;
+
+ if (do_types)
+ {
+ int i;
+
+ for (i = 0; i < 8; i++)
+ {
+ signature[i] = byte_get (hdrptr, 1);
+ hdrptr += 1;
+ }
+
+ type_offset = byte_get (hdrptr, offset_size);
+ hdrptr += offset_size;
+ }
+
if ((do_loc || do_debug_loc || do_debug_ranges)
- && num_debug_info_entries == 0)
+ && num_debug_info_entries == 0
+ && ! do_types)
{
debug_information [unit].cu_offset = cu_offset;
debug_information [unit].pointer_size
printf (_(" Version: %d\n"), compunit.cu_version);
printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
+ if (do_types)
+ {
+ int i;
+ printf (_(" Signature: "));
+ for (i = 0; i < 8; i++)
+ printf ("%02x", signature[i]);
+ printf ("\n");
+ printf (_(" Type Offset: 0x%lx\n"), type_offset);
+ }
}
if (cu_offset + compunit.cu_length + initial_length_size
abbrev_number = read_leb128 (tags, & bytes_read, 0);
tags += bytes_read;
- /* A null DIE marks the end of a list of siblings. */
+ /* A null DIE marks the end of a list of siblings or it may also be
+ a section padding. */
if (abbrev_number == 0)
{
+ /* Check if it can be a section padding for the last CU. */
+ if (level == 0 && start == end)
+ {
+ unsigned char *chk;
+
+ for (chk = tags; chk < start; chk++)
+ if (*chk != 0)
+ break;
+ if (chk == start)
+ break;
+ }
+
--level;
if (level < 0)
{
/* Set num_debug_info_entries here so that it can be used to check if
we need to process .debug_loc and .debug_ranges sections. */
if ((do_loc || do_debug_loc || do_debug_ranges)
- && num_debug_info_entries == 0)
+ && num_debug_info_entries == 0
+ && ! do_types)
num_debug_info_entries = num_units;
if (!do_loc)
return num_debug_info_entries;
if (load_debug_section (info, file)
- && process_debug_info (&debug_displays [info].section, file, 1))
+ && process_debug_info (&debug_displays [info].section, file, 1, 0))
return num_debug_info_entries;
num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
while (data < end)
{
- DWARF2_Internal_LineInfo info;
+ DWARF2_Internal_LineInfo linfo;
unsigned char *standard_opcodes;
unsigned char *end_of_sequence;
unsigned char *hdrptr;
hdroff = hdrptr - start;
/* Check the length of the block. */
- info.li_length = byte_get (hdrptr, 4);
+ linfo.li_length = byte_get (hdrptr, 4);
hdrptr += 4;
- if (info.li_length == 0xffffffff)
+ if (linfo.li_length == 0xffffffff)
{
/* This section is 64-bit DWARF 3. */
- info.li_length = byte_get (hdrptr, 8);
+ linfo.li_length = byte_get (hdrptr, 8);
hdrptr += 8;
offset_size = 8;
initial_length_size = 12;
initial_length_size = 4;
}
- if (info.li_length + initial_length_size > section->size)
+ if (linfo.li_length + initial_length_size > section->size)
{
warn
- (_("The line info appears to be corrupt - the section is too small\n"));
+ (_("The information in section %s appears to be corrupt - the section is too small\n"),
+ section->name);
return 0;
}
/* Check its version number. */
- info.li_version = byte_get (hdrptr, 2);
+ linfo.li_version = byte_get (hdrptr, 2);
hdrptr += 2;
- if (info.li_version != 2 && info.li_version != 3)
+ if (linfo.li_version != 2 && linfo.li_version != 3)
{
warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
return 0;
}
- info.li_prologue_length = byte_get (hdrptr, offset_size);
+ linfo.li_prologue_length = byte_get (hdrptr, offset_size);
hdrptr += offset_size;
- info.li_min_insn_length = byte_get (hdrptr, 1);
+ linfo.li_min_insn_length = byte_get (hdrptr, 1);
hdrptr++;
- info.li_default_is_stmt = byte_get (hdrptr, 1);
+ linfo.li_default_is_stmt = byte_get (hdrptr, 1);
hdrptr++;
- info.li_line_base = byte_get (hdrptr, 1);
+ linfo.li_line_base = byte_get (hdrptr, 1);
hdrptr++;
- info.li_line_range = byte_get (hdrptr, 1);
+ linfo.li_line_range = byte_get (hdrptr, 1);
hdrptr++;
- info.li_opcode_base = byte_get (hdrptr, 1);
+ linfo.li_opcode_base = byte_get (hdrptr, 1);
hdrptr++;
/* Sign extend the line base field. */
- info.li_line_base <<= 24;
- info.li_line_base >>= 24;
+ linfo.li_line_base <<= 24;
+ linfo.li_line_base >>= 24;
printf (_(" Offset: 0x%lx\n"), hdroff);
- printf (_(" Length: %ld\n"), info.li_length);
- printf (_(" DWARF Version: %d\n"), info.li_version);
- printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
- printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
- printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
- printf (_(" Line Base: %d\n"), info.li_line_base);
- printf (_(" Line Range: %d\n"), info.li_line_range);
- printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
+ printf (_(" Length: %ld\n"), linfo.li_length);
+ printf (_(" DWARF Version: %d\n"), linfo.li_version);
+ printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length);
+ printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
+ printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
+ printf (_(" Line Base: %d\n"), linfo.li_line_base);
+ printf (_(" Line Range: %d\n"), linfo.li_line_range);
+ printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
- end_of_sequence = data + info.li_length + initial_length_size;
+ end_of_sequence = data + linfo.li_length + initial_length_size;
- reset_state_machine (info.li_default_is_stmt);
+ reset_state_machine (linfo.li_default_is_stmt);
/* Display the contents of the Opcodes table. */
standard_opcodes = hdrptr;
printf (_("\n Opcodes:\n"));
- for (i = 1; i < info.li_opcode_base; i++)
+ for (i = 1; i < linfo.li_opcode_base; i++)
printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
/* Display the contents of the Directory table. */
- data = standard_opcodes + info.li_opcode_base - 1;
+ data = standard_opcodes + linfo.li_opcode_base - 1;
if (*data == 0)
printf (_("\n The Directory Table is empty.\n"));
op_code = *data++;
- if (op_code >= info.li_opcode_base)
+ if (op_code >= linfo.li_opcode_base)
{
- op_code -= info.li_opcode_base;
- uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
+ op_code -= linfo.li_opcode_base;
+ uladv = (op_code / linfo.li_line_range) * linfo.li_min_insn_length;
state_machine_regs.address += uladv;
printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
op_code, uladv, state_machine_regs.address);
- adv = (op_code % info.li_line_range) + info.li_line_base;
+ adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
state_machine_regs.line += adv;
printf (_(" and Line by %d to %d\n"),
adv, state_machine_regs.line);
else switch (op_code)
{
case DW_LNS_extended_op:
- data += process_extended_line_op (data, info.li_default_is_stmt);
+ data += process_extended_line_op (data, linfo.li_default_is_stmt);
break;
case DW_LNS_copy:
case DW_LNS_advance_pc:
uladv = read_leb128 (data, & bytes_read, 0);
- uladv *= info.li_min_insn_length;
+ uladv *= linfo.li_min_insn_length;
data += bytes_read;
state_machine_regs.address += uladv;
printf (_(" Advance PC by %lu to 0x%lx\n"), uladv,
break;
case DW_LNS_const_add_pc:
- uladv = (((255 - info.li_opcode_base) / info.li_line_range)
- * info.li_min_insn_length);
+ uladv = (((255 - linfo.li_opcode_base) / linfo.li_line_range)
+ * linfo.li_min_insn_length);
state_machine_regs.address += uladv;
printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv,
state_machine_regs.address);
while (data < end)
{
/* This loop amounts to one iteration per compilation unit. */
- DWARF2_Internal_LineInfo info;
+ DWARF2_Internal_LineInfo linfo;
unsigned char *standard_opcodes;
unsigned char *end_of_sequence;
unsigned char *hdrptr;
(section 6.2.4 in the Dwarf3 doc). */
/* Get the length of this CU's line number information block. */
- info.li_length = byte_get (hdrptr, 4);
+ linfo.li_length = byte_get (hdrptr, 4);
hdrptr += 4;
- if (info.li_length == 0xffffffff)
+ if (linfo.li_length == 0xffffffff)
{
/* This section is 64-bit DWARF 3. */
- info.li_length = byte_get (hdrptr, 8);
+ linfo.li_length = byte_get (hdrptr, 8);
hdrptr += 8;
offset_size = 8;
initial_length_size = 12;
initial_length_size = 4;
}
- if (info.li_length + initial_length_size > section->size)
+ if (linfo.li_length + initial_length_size > section->size)
{
warn (_("The line info appears to be corrupt - "
"the section is too small\n"));
}
/* Get this CU's Line Number Block version number. */
- info.li_version = byte_get (hdrptr, 2);
+ linfo.li_version = byte_get (hdrptr, 2);
hdrptr += 2;
- if (info.li_version != 2 && info.li_version != 3)
+ if (linfo.li_version != 2 && linfo.li_version != 3)
{
warn (_("Only DWARF version 2 and 3 line info is currently "
"supported.\n"));
return 0;
}
- info.li_prologue_length = byte_get (hdrptr, offset_size);
+ linfo.li_prologue_length = byte_get (hdrptr, offset_size);
hdrptr += offset_size;
- info.li_min_insn_length = byte_get (hdrptr, 1);
+ linfo.li_min_insn_length = byte_get (hdrptr, 1);
hdrptr++;
- info.li_default_is_stmt = byte_get (hdrptr, 1);
+ linfo.li_default_is_stmt = byte_get (hdrptr, 1);
hdrptr++;
- info.li_line_base = byte_get (hdrptr, 1);
+ linfo.li_line_base = byte_get (hdrptr, 1);
hdrptr++;
- info.li_line_range = byte_get (hdrptr, 1);
+ linfo.li_line_range = byte_get (hdrptr, 1);
hdrptr++;
- info.li_opcode_base = byte_get (hdrptr, 1);
+ linfo.li_opcode_base = byte_get (hdrptr, 1);
hdrptr++;
/* Sign extend the line base field. */
- info.li_line_base <<= 24;
- info.li_line_base >>= 24;
+ linfo.li_line_base <<= 24;
+ linfo.li_line_base >>= 24;
/* Find the end of this CU's Line Number Information Block. */
- end_of_sequence = data + info.li_length + initial_length_size;
+ end_of_sequence = data + linfo.li_length + initial_length_size;
- reset_state_machine (info.li_default_is_stmt);
+ reset_state_machine (linfo.li_default_is_stmt);
/* Save a pointer to the contents of the Opcodes table. */
standard_opcodes = hdrptr;
/* Traverse the Directory table just to count entries. */
- data = standard_opcodes + info.li_opcode_base - 1;
+ data = standard_opcodes + linfo.li_opcode_base - 1;
if (*data != 0)
{
unsigned int n_directories = 0;
unsigned char *ptr_directory_table = data;
- int i;
while (*data != 0)
{
}
/* Go through the directory table again to save the directories. */
- directory_table = xmalloc (n_directories * sizeof (unsigned char *));
+ directory_table = (unsigned char **)
+ xmalloc (n_directories * sizeof (unsigned char *));
i = 0;
while (*ptr_directory_table != 0)
{
unsigned int n_files = 0;
unsigned char *ptr_file_name_table = data;
- int i;
while (*data != 0)
{
}
/* Go through the file table again to save the strings. */
- file_table = xmalloc (n_files * sizeof (File_Entry));
+ file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
i = 0;
while (*ptr_file_name_table != 0)
op_code = *data++;
prev_line = state_machine_regs.line;
- if (op_code >= info.li_opcode_base)
+ if (op_code >= linfo.li_opcode_base)
{
- op_code -= info.li_opcode_base;
- uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
+ op_code -= linfo.li_opcode_base;
+ uladv = (op_code / linfo.li_line_range) * linfo.li_min_insn_length;
state_machine_regs.address += uladv;
- adv = (op_code % info.li_line_range) + info.li_line_base;
+ adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
state_machine_regs.line += adv;
is_special_opcode = 1;
}
case DW_LNS_extended_op:
{
unsigned int ext_op_code_len;
- unsigned int bytes_read;
unsigned char ext_op_code;
unsigned char *op_code_data = data;
switch (ext_op_code)
{
case DW_LNE_end_sequence:
- reset_state_machine (info.li_default_is_stmt);
+ reset_state_machine (linfo.li_default_is_stmt);
break;
case DW_LNE_set_address:
state_machine_regs.address =
case DW_LNS_advance_pc:
uladv = read_leb128 (data, & bytes_read, 0);
- uladv *= info.li_min_insn_length;
+ uladv *= linfo.li_min_insn_length;
data += bytes_read;
state_machine_regs.address += uladv;
break;
break;
case DW_LNS_const_add_pc:
- uladv = (((255 - info.li_opcode_base) / info.li_line_range)
- * info.li_min_insn_length);
+ uladv = (((255 - linfo.li_opcode_base) / linfo.li_line_range)
+ * linfo.li_min_insn_length);
state_machine_regs.address += uladv;
break;
if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
{
- newFileName = xmalloc (MAX_FILENAME_LENGTH + 1);
+ newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
/* Truncate file name */
strncpy (newFileName,
fileName + fileNameLength - MAX_FILENAME_LENGTH,
}
else
{
- newFileName = xmalloc (fileNameLength + 1);
+ newFileName = (char *) xmalloc (fileNameLength + 1);
strncpy (newFileName, fileName, fileNameLength + 1);
}
return 0;
}
+ if (do_debug_lines == 0)
+ do_debug_lines |= FLAG_DEBUG_LINES_RAW;
+
if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
retValRaw = display_debug_lines_raw (section, data, end);
display_debug_pubnames (struct dwarf_section *section,
void *file ATTRIBUTE_UNUSED)
{
- DWARF2_Internal_PubNames pubnames;
+ DWARF2_Internal_PubNames names;
unsigned char *start = section->start;
unsigned char *end = start + section->size;
data = start;
- pubnames.pn_length = byte_get (data, 4);
+ names.pn_length = byte_get (data, 4);
data += 4;
- if (pubnames.pn_length == 0xffffffff)
+ if (names.pn_length == 0xffffffff)
{
- pubnames.pn_length = byte_get (data, 8);
+ names.pn_length = byte_get (data, 8);
data += 8;
offset_size = 8;
initial_length_size = 12;
initial_length_size = 4;
}
- pubnames.pn_version = byte_get (data, 2);
+ names.pn_version = byte_get (data, 2);
data += 2;
- pubnames.pn_offset = byte_get (data, offset_size);
+ names.pn_offset = byte_get (data, offset_size);
data += offset_size;
if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
&& num_debug_info_entries > 0
- && find_debug_info_for_offset (pubnames.pn_offset) == NULL)
+ && find_debug_info_for_offset (names.pn_offset) == NULL)
warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
- pubnames.pn_offset, section->name);
+ names.pn_offset, section->name);
- pubnames.pn_size = byte_get (data, offset_size);
+ names.pn_size = byte_get (data, offset_size);
data += offset_size;
- start += pubnames.pn_length + initial_length_size;
+ start += names.pn_length + initial_length_size;
- if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
+ if (names.pn_version != 2 && names.pn_version != 3)
{
static int warned = 0;
}
printf (_(" Length: %ld\n"),
- pubnames.pn_length);
+ names.pn_length);
printf (_(" Version: %d\n"),
- pubnames.pn_version);
+ names.pn_version);
printf (_(" Offset into .debug_info section: 0x%lx\n"),
- pubnames.pn_offset);
+ names.pn_offset);
printf (_(" Size of area in .debug_info section: %ld\n"),
- pubnames.pn_size);
+ names.pn_size);
printf (_("\n Offset\tName\n"));
unsigned int lineno;
const char *string;
- op = *curr;
+ op = (enum dwarf_macinfo_record_type) *curr;
curr++;
switch (op)
static int
display_debug_info (struct dwarf_section *section, void *file)
{
- return process_debug_info (section, file, 0);
+ return process_debug_info (section, file, 0, 0);
}
+static int
+display_debug_types (struct dwarf_section *section, void *file)
+{
+ return process_debug_info (section, file, 0, 1);
+}
static int
display_debug_aranges (struct dwarf_section *section,
{
unsigned char *hdrptr;
DWARF2_Internal_ARange arange;
- unsigned char *ranges;
+ unsigned char *addr_ranges;
dwarf_vma length;
dwarf_vma address;
unsigned char address_size;
else
printf (_("\n Address Length\n"));
- ranges = hdrptr;
+ addr_ranges = hdrptr;
/* Must pad to an alignment boundary that is twice the address size. */
excess = (hdrptr - start) % (2 * address_size);
if (excess)
- ranges += (2 * address_size) - excess;
+ addr_ranges += (2 * address_size) - excess;
start += arange.ar_length + initial_length_size;
- while (ranges + 2 * address_size <= start)
+ while (addr_ranges + 2 * address_size <= start)
{
- address = byte_get (ranges, address_size);
+ address = byte_get (addr_ranges, address_size);
- ranges += address_size;
+ addr_ranges += address_size;
- length = byte_get (ranges, address_size);
+ length = byte_get (addr_ranges, address_size);
- ranges += address_size;
+ addr_ranges += address_size;
printf (" ");
print_dwarf_vma (address, address_size);
return 1;
}
+/* Each debug_information[x].range_lists[y] gets this representation for
+ sorting purposes. */
+
+struct range_entry
+ {
+ /* The debug_information[x].range_lists[y] value. */
+ unsigned long ranges_offset;
+
+ /* Original debug_information to find parameters of the data. */
+ debug_info *debug_info_p;
+ };
+
+/* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
+
+static int
+range_entry_compar (const void *ap, const void *bp)
+{
+ const struct range_entry *a_re = (const struct range_entry *) ap;
+ const struct range_entry *b_re = (const struct range_entry *) bp;
+ const unsigned long a = a_re->ranges_offset;
+ const unsigned long b = b_re->ranges_offset;
+
+ return (a > b) - (b > a);
+}
+
static int
display_debug_ranges (struct dwarf_section *section,
void *file ATTRIBUTE_UNUSED)
unsigned char *section_end;
unsigned long bytes;
unsigned char *section_begin = start;
- unsigned int num_range_list = 0;
- unsigned long last_offset = 0;
- unsigned int first = 0;
- unsigned int i;
- unsigned int j;
- int seen_first_offset = 0;
- int use_debug_info = 1;
- unsigned char *next;
+ unsigned int num_range_list, i;
+ struct range_entry *range_entries, *range_entry_fill;
bytes = section->size;
section_end = start + bytes;
return 0;
}
- /* Check the order of range list in .debug_info section. If
- offsets of range lists are in the ascending order, we can
- use `debug_information' directly. */
+ num_range_list = 0;
for (i = 0; i < num_debug_info_entries; i++)
- {
- unsigned int num;
+ num_range_list += debug_information [i].num_range_lists;
- num = debug_information [i].num_range_lists;
- num_range_list += num;
+ if (num_range_list == 0)
+ error (_("No range lists in .debug_info section!\n"));
- /* Check if we can use `debug_information' directly. */
- if (use_debug_info && num != 0)
- {
- if (!seen_first_offset)
- {
- /* This is the first range list. */
- last_offset = debug_information [i].range_lists [0];
- first = i;
- seen_first_offset = 1;
- j = 1;
- }
- else
- j = 0;
+ range_entries = (struct range_entry *)
+ xmalloc (sizeof (*range_entries) * num_range_list);
+ range_entry_fill = range_entries;
- for (; j < num; j++)
- {
- if (last_offset >
- debug_information [i].range_lists [j])
- {
- use_debug_info = 0;
- break;
- }
- last_offset = debug_information [i].range_lists [j];
- }
+ for (i = 0; i < num_debug_info_entries; i++)
+ {
+ debug_info *debug_info_p = &debug_information[i];
+ unsigned int j;
+
+ for (j = 0; j < debug_info_p->num_range_lists; j++)
+ {
+ range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
+ range_entry_fill->debug_info_p = debug_info_p;
+ range_entry_fill++;
}
}
- if (!use_debug_info)
- /* FIXME: Should we handle this case? */
- error (_("Range lists in .debug_info section aren't in ascending order!\n"));
-
- if (!seen_first_offset)
- error (_("No range lists in .debug_info section!\n"));
+ qsort (range_entries, num_range_list, sizeof (*range_entries),
+ range_entry_compar);
/* DWARF sections under Mach-O have non-zero addresses. */
- if (debug_information [first].num_range_lists > 0
- && debug_information [first].range_lists [0] != section->address)
+ if (range_entries[0].ranges_offset != section->address)
warn (_("Range lists in %s section start at 0x%lx\n"),
- section->name, debug_information [first].range_lists [0]);
+ section->name, range_entries[0].ranges_offset);
printf (_("Contents of the %s section:\n\n"), section->name);
printf (_(" Offset Begin End\n"));
- seen_first_offset = 0;
- for (i = first; i < num_debug_info_entries; i++)
+ for (i = 0; i < num_range_list; i++)
{
- dwarf_vma begin;
- dwarf_vma end;
- unsigned long offset;
+ struct range_entry *range_entry = &range_entries[i];
+ debug_info *debug_info_p = range_entry->debug_info_p;
unsigned int pointer_size;
+ unsigned long offset;
+ unsigned char *next;
unsigned long base_address;
- pointer_size = debug_information [i].pointer_size;
+ pointer_size = debug_info_p->pointer_size;
+
+ /* DWARF sections under Mach-O have non-zero addresses. */
+ offset = range_entry->ranges_offset - section->address;
+ next = section_begin + offset;
+ base_address = debug_info_p->base_address;
- for (j = 0; j < debug_information [i].num_range_lists; j++)
+ if (i > 0)
{
- /* DWARF sections under Mach-O have non-zero addresses. */
- offset = debug_information [i].range_lists [j] - section->address;
- next = section_begin + offset;
- base_address = debug_information [i].base_address;
+ if (start < next)
+ warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
+ (unsigned long) (start - section_begin),
+ (unsigned long) (next - section_begin), section->name);
+ else if (start > next)
+ warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
+ (unsigned long) (start - section_begin),
+ (unsigned long) (next - section_begin), section->name);
+ }
+ start = next;
- if (!seen_first_offset)
- seen_first_offset = 1;
- else
+ while (1)
+ {
+ dwarf_vma begin;
+ dwarf_vma end;
+
+ /* Note: we use sign extension here in order to be sure that
+ we can detect the -1 escape value. Sign extension into the
+ top 32 bits of a 32-bit address will not affect the values
+ that we display since we always show hex values, and always
+ the bottom 32-bits. */
+ begin = byte_get_signed (start, pointer_size);
+ start += pointer_size;
+ end = byte_get_signed (start, pointer_size);
+ start += pointer_size;
+
+ printf (" %8.8lx ", offset);
+
+ if (begin == 0 && end == 0)
{
- if (start < next)
- warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
- (unsigned long) (start - section_begin),
- (unsigned long) (next - section_begin), section->name);
- else if (start > next)
- warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
- (unsigned long) (start - section_begin),
- (unsigned long) (next - section_begin), section->name);
+ printf (_("<End of list>\n"));
+ break;
}
- start = next;
- while (1)
+ /* Check base address specifiers. */
+ if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
{
- /* Note: we use sign extension here in order to be sure that
- we can detect the -1 escape value. Sign extension into the
- top 32 bits of a 32-bit address will not affect the values
- that we display since we always show hex values, and always
- the bottom 32-bits. */
- begin = byte_get_signed (start, pointer_size);
- start += pointer_size;
- end = byte_get_signed (start, pointer_size);
- start += pointer_size;
-
- printf (" %8.8lx ", offset);
-
- if (begin == 0 && end == 0)
- {
- printf (_("<End of list>\n"));
- break;
- }
-
- /* Check base address specifiers. */
- if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
- {
- base_address = end;
- print_dwarf_vma (begin, pointer_size);
- print_dwarf_vma (end, pointer_size);
- printf ("(base address)\n");
- continue;
- }
+ base_address = end;
+ print_dwarf_vma (begin, pointer_size);
+ print_dwarf_vma (end, pointer_size);
+ printf ("(base address)\n");
+ continue;
+ }
- print_dwarf_vma (begin + base_address, pointer_size);
- print_dwarf_vma (end + base_address, pointer_size);
+ print_dwarf_vma (begin + base_address, pointer_size);
+ print_dwarf_vma (end + base_address, pointer_size);
- if (begin == end)
- fputs (_("(start == end)"), stdout);
- else if (begin > end)
- fputs (_("(start > end)"), stdout);
+ if (begin == end)
+ fputs (_("(start == end)"), stdout);
+ else if (begin > end)
+ fputs (_("(start > end)"), stdout);
- putchar ('\n');
- }
+ putchar ('\n');
}
}
putchar ('\n');
+
+ free (range_entries);
+
return 1;
}
return -1;
fc->ncols = reg + 1;
- fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
- fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
+ fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
+ sizeof (short int));
+ fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
while (prev < fc->ncols)
{
if (*need_col_headers)
{
- static const char *loc = " LOC";
+ static const char *sloc = " LOC";
*need_col_headers = 0;
- printf ("%-*s CFA ", eh_addr_size * 2, loc);
+ printf ("%-*s CFA ", eh_addr_size * 2, sloc);
for (r = 0; r < *max_regs; r++)
if (fc->col_type[r] != DW_CFA_unreferenced)
{
int version;
- fc = xmalloc (sizeof (Frame_Chunk));
+ fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
memset (fc, 0, sizeof (Frame_Chunk));
fc->next = chunks;
chunks = fc;
fc->chunk_start = saved_start;
fc->ncols = 0;
- fc->col_type = xmalloc (sizeof (short int));
- fc->col_offset = xmalloc (sizeof (int));
+ fc->col_type = (short int *) xmalloc (sizeof (short int));
+ fc->col_offset = (int *) xmalloc (sizeof (int));
frame_need_space (fc, max_regs - 1);
version = *start++;
warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
cie_id, (unsigned long)(saved_start - section_start));
fc->ncols = 0;
- fc->col_type = xmalloc (sizeof (short int));
- fc->col_offset = xmalloc (sizeof (int));
+ fc->col_type = (short int *) xmalloc (sizeof (short int));
+ fc->col_offset = (int *) xmalloc (sizeof (int));
frame_need_space (fc, max_regs - 1);
cie = fc;
fc->augmentation = "";
else
{
fc->ncols = cie->ncols;
- fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
- fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
+ fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
+ fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
fc->augmentation = cie->augmentation;
while (start < block_end)
{
unsigned op, opa;
- unsigned long reg, tmp;
+ unsigned long reg, temp;
op = *start++;
opa = op & 0x3f;
LEB ();
break;
case DW_CFA_def_cfa_expression:
- tmp = LEB ();
- start += tmp;
+ temp = LEB ();
+ start += temp;
break;
case DW_CFA_expression:
case DW_CFA_val_expression:
reg = LEB ();
- tmp = LEB ();
- start += tmp;
+ temp = LEB ();
+ start += temp;
if (frame_need_space (fc, reg) >= 0)
fc->col_type[reg] = DW_CFA_undefined;
break;
case DW_CFA_remember_state:
if (! do_debug_frames_interp)
printf (" DW_CFA_remember_state\n");
- rs = xmalloc (sizeof (Frame_Chunk));
+ rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
rs->ncols = fc->ncols;
- rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
- rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
+ rs->col_type = (short int *) xcmalloc (rs->ncols,
+ sizeof (short int));
+ rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
memcpy (rs->col_type, fc->col_type, rs->ncols);
memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
rs->next = remembered_state;
void
free_debug_memory (void)
{
- enum dwarf_section_display_enum i;
+ unsigned int i;
free_abbrevs ();
for (i = 0; i < max; i++)
- free_debug_section (i);
+ free_debug_section ((enum dwarf_section_display_enum) i);
if (debug_information != NULL)
{
{
const char * option;
int * variable;
- int val;
+ int val;
}
debug_dump_long_opts;
{ "loc", & do_debug_loc, 1 },
{ "macro", & do_debug_macinfo, 1 },
{ "pubnames", & do_debug_pubnames, 1 },
+ { "pubtypes", & do_debug_pubtypes, 1 },
/* This entry is for compatability
with earlier versions of readelf. */
{ "ranges", & do_debug_aranges, 1 },
void
dwarf_select_sections_by_letters (const char *letters)
{
- unsigned int index = 0;
+ unsigned int lindex = 0;
- while (letters[index])
- switch (letters[index++])
+ while (letters[lindex])
+ switch (letters[lindex++])
{
case 'i':
do_debug_info = 1;
do_debug_pubnames = 1;
break;
+ case 't':
+ do_debug_pubtypes = 1;
+ break;
+
case 'r':
do_debug_aranges = 1;
break;
do_debug_abbrevs = 1;
do_debug_lines = FLAG_DEBUG_LINES_RAW;
do_debug_pubnames = 1;
+ do_debug_pubtypes = 1;
do_debug_aranges = 1;
do_debug_ranges = 1;
do_debug_frames = 1;
struct dwarf_section_display debug_displays[] =
{
{ { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0 },
- display_debug_abbrev, &do_debug_abbrevs, 0, 0 },
+ display_debug_abbrev, &do_debug_abbrevs, 0 },
{ { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0 },
- display_debug_aranges, &do_debug_aranges, 1, 0 },
+ display_debug_aranges, &do_debug_aranges, 1 },
{ { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0 },
- display_debug_frames, &do_debug_frames, 1, 0 },
+ display_debug_frames, &do_debug_frames, 1 },
{ { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0 },
- display_debug_info, &do_debug_info, 1, 0 },
+ display_debug_info, &do_debug_info, 1 },
{ { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0 },
- display_debug_lines, &do_debug_lines, 0, 0 },
+ display_debug_lines, &do_debug_lines, 1 },
{ { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0 },
- display_debug_pubnames, &do_debug_pubnames, 0, 0 },
+ display_debug_pubnames, &do_debug_pubnames, 0 },
{ { ".eh_frame", "", NULL, NULL, 0, 0 },
- display_debug_frames, &do_debug_frames, 1, 1 },
+ display_debug_frames, &do_debug_frames, 1 },
{ { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0 },
- display_debug_macinfo, &do_debug_macinfo, 0, 0 },
+ display_debug_macinfo, &do_debug_macinfo, 0 },
{ { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0 },
- display_debug_str, &do_debug_str, 0, 0 },
+ display_debug_str, &do_debug_str, 0 },
{ { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0 },
- display_debug_loc, &do_debug_loc, 1, 0 },
+ display_debug_loc, &do_debug_loc, 1 },
{ { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0 },
- display_debug_pubnames, &do_debug_pubnames, 0, 0 },
+ display_debug_pubnames, &do_debug_pubtypes, 0 },
{ { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0 },
- display_debug_ranges, &do_debug_ranges, 0, 0 },
+ display_debug_ranges, &do_debug_ranges, 1 },
{ { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0 },
- display_debug_not_supported, NULL, 0, 0 },
+ display_debug_not_supported, NULL, 0 },
{ { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0 },
- display_debug_not_supported, NULL, 0, 0 },
+ display_debug_not_supported, NULL, 0 },
{ { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0 },
- display_debug_not_supported, NULL, 0, 0 },
+ display_debug_types, &do_debug_info, 1 },
{ { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0 },
- display_debug_not_supported, NULL, 0, 0 }
+ display_debug_not_supported, NULL, 0 }
};