1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "libiberty.h"
25 #include "bfd_stdint.h"
28 #include "elf/common.h"
32 static const char *regname (unsigned int regno, int row);
34 static int have_frame_base;
35 static int need_base_address;
37 static unsigned int last_pointer_size = 0;
38 static int warned_about_missing_comp_units = FALSE;
40 static unsigned int num_debug_info_entries = 0;
41 static debug_info *debug_information = NULL;
42 /* Special value for num_debug_info_entries to indicate
43 that the .debug_info section could not be loaded/parsed. */
44 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
51 int do_debug_pubnames;
52 int do_debug_pubtypes;
56 int do_debug_frames_interp;
66 int dwarf_cutoff_level = -1;
67 unsigned long dwarf_start_die;
69 /* Values for do_debug_lines. */
70 #define FLAG_DEBUG_LINES_RAW 1
71 #define FLAG_DEBUG_LINES_DECODED 2
74 size_of_encoded_value (int encoding)
76 switch (encoding & 0x7)
79 case 0: return eh_addr_size;
87 get_encoded_value (unsigned char *data,
89 struct dwarf_section *section)
91 int size = size_of_encoded_value (encoding);
94 if (encoding & DW_EH_PE_signed)
95 val = byte_get_signed (data, size);
97 val = byte_get (data, size);
99 if ((encoding & 0x70) == DW_EH_PE_pcrel)
100 val += section->address + (data - section->start);
104 /* Print a dwarf_vma value (typically an address, offset or length) in
105 hexadecimal format, followed by a space. The length of the value (and
106 hence the precision displayed) is determined by the byte_size parameter. */
109 print_dwarf_vma (dwarf_vma val, unsigned byte_size)
111 static char buff[18];
114 /* Printf does not have a way of specifiying a maximum field width for an
115 integer value, so we print the full value into a buffer and then select
116 the precision we need. */
117 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
119 snprintf (buff, sizeof (buff), "%16.16llx ", val);
121 snprintf (buff, sizeof (buff), "%016I64x ", val);
124 snprintf (buff, sizeof (buff), "%16.16lx ", val);
129 if (byte_size > 0 && byte_size <= 8)
130 offset = 16 - 2 * byte_size;
132 error ("Wrong size in print_dwarf_vma");
135 fputs (buff + offset, stdout);
138 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
140 #define DWARF_VMA_FMT "ll"
142 #define DWARF_VMA_FMT "I64"
145 #define DWARF_VMA_FMT "l"
149 dwarf_vmatoa (const char *fmtch, dwarf_vma value)
151 /* As dwarf_vmatoa is used more then once in a printf call
152 for output, we are cycling through an fixed array of pointers
153 for return address. */
154 static int buf_pos = 0;
155 static struct dwarf_vmatoa_buf
162 sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
164 ret = buf[buf_pos++].place;
165 buf_pos %= ARRAY_SIZE (buf);
167 snprintf (ret, sizeof (buf[0].place), fmt, value);
173 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
175 dwarf_vma result = 0;
176 unsigned int num_read = 0;
177 unsigned int shift = 0;
185 result |= ((dwarf_vma) (byte & 0x7f)) << shift;
192 if (length_return != NULL)
193 *length_return = num_read;
195 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
196 result |= -1L << shift;
201 /* Create a signed version to avoid painful typecasts. */
202 static dwarf_signed_vma
203 read_sleb128 (unsigned char *data, unsigned int *length_return)
205 return (dwarf_signed_vma) read_leb128 (data, length_return, 1);
208 typedef struct State_Machine_Registers
216 unsigned char op_index;
217 unsigned char end_sequence;
218 /* This variable hold the number of the last entry seen
219 in the File Table. */
220 unsigned int last_file_entry;
223 static SMR state_machine_regs;
226 reset_state_machine (int is_stmt)
228 state_machine_regs.address = 0;
229 state_machine_regs.op_index = 0;
230 state_machine_regs.file = 1;
231 state_machine_regs.line = 1;
232 state_machine_regs.column = 0;
233 state_machine_regs.is_stmt = is_stmt;
234 state_machine_regs.basic_block = 0;
235 state_machine_regs.end_sequence = 0;
236 state_machine_regs.last_file_entry = 0;
239 /* Handled an extend line op.
240 Returns the number of bytes read. */
243 process_extended_line_op (unsigned char *data, int is_stmt)
245 unsigned char op_code;
246 unsigned int bytes_read;
251 len = read_leb128 (data, & bytes_read, 0);
256 warn (_("badly formed extended line op encountered!\n"));
263 printf (_(" Extended opcode %d: "), op_code);
267 case DW_LNE_end_sequence:
268 printf (_("End of Sequence\n\n"));
269 reset_state_machine (is_stmt);
272 case DW_LNE_set_address:
273 adr = byte_get (data, len - bytes_read - 1);
274 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
275 state_machine_regs.address = adr;
276 state_machine_regs.op_index = 0;
279 case DW_LNE_define_file:
280 printf (_(" define new File Table entry\n"));
281 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
283 printf (" %d\t", ++state_machine_regs.last_file_entry);
285 data += strlen ((char *) data) + 1;
286 printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
288 printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
290 printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
291 printf ("%s\n\n", name);
294 case DW_LNE_set_discriminator:
295 printf (_("set Discriminator to %s\n"),
296 dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
300 case DW_LNE_HP_negate_is_UV_update:
301 printf ("DW_LNE_HP_negate_is_UV_update\n");
303 case DW_LNE_HP_push_context:
304 printf ("DW_LNE_HP_push_context\n");
306 case DW_LNE_HP_pop_context:
307 printf ("DW_LNE_HP_pop_context\n");
309 case DW_LNE_HP_set_file_line_column:
310 printf ("DW_LNE_HP_set_file_line_column\n");
312 case DW_LNE_HP_set_routine_name:
313 printf ("DW_LNE_HP_set_routine_name\n");
315 case DW_LNE_HP_set_sequence:
316 printf ("DW_LNE_HP_set_sequence\n");
318 case DW_LNE_HP_negate_post_semantics:
319 printf ("DW_LNE_HP_negate_post_semantics\n");
321 case DW_LNE_HP_negate_function_exit:
322 printf ("DW_LNE_HP_negate_function_exit\n");
324 case DW_LNE_HP_negate_front_end_logical:
325 printf ("DW_LNE_HP_negate_front_end_logical\n");
327 case DW_LNE_HP_define_proc:
328 printf ("DW_LNE_HP_define_proc\n");
330 case DW_LNE_HP_source_file_correlation:
332 unsigned char *edata = data + len - bytes_read - 1;
334 printf ("DW_LNE_HP_source_file_correlation\n");
340 opc = read_leb128 (data, & bytes_read, 0);
345 case DW_LNE_HP_SFC_formfeed:
346 printf (" DW_LNE_HP_SFC_formfeed\n");
348 case DW_LNE_HP_SFC_set_listing_line:
349 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
351 read_leb128 (data, & bytes_read, 0)));
354 case DW_LNE_HP_SFC_associate:
355 printf (" DW_LNE_HP_SFC_associate ");
358 read_leb128 (data, & bytes_read, 0)));
362 read_leb128 (data, & bytes_read, 0)));
366 read_leb128 (data, & bytes_read, 0)));
370 printf (" UNKNOW DW_LNE_HP_SFC opcode (%u)\n", opc);
380 unsigned int rlen = len - bytes_read - 1;
382 if (op_code >= DW_LNE_lo_user
383 /* The test against DW_LNW_hi_user is redundant due to
384 the limited range of the unsigned char data type used
386 /*&& op_code <= DW_LNE_hi_user*/)
387 printf (_("user defined: "));
389 printf (_("UNKNOWN: "));
390 printf (_("length %d ["), rlen);
392 printf (" %02x", *data++);
402 fetch_indirect_string (dwarf_vma offset)
404 struct dwarf_section *section = &debug_displays [str].section;
406 if (section->start == NULL)
407 return _("<no .debug_str section>");
409 /* DWARF sections under Mach-O have non-zero addresses. */
410 offset -= section->address;
411 if (offset > section->size)
413 warn (_("DW_FORM_strp offset too big: %s\n"),
414 dwarf_vmatoa ("x", offset));
415 return _("<offset is too big>");
418 return (const char *) section->start + offset;
421 /* FIXME: There are better and more efficient ways to handle
422 these structures. For now though, I just want something that
423 is simple to implement. */
424 typedef struct abbrev_attr
426 unsigned long attribute;
428 struct abbrev_attr *next;
432 typedef struct abbrev_entry
437 struct abbrev_attr *first_attr;
438 struct abbrev_attr *last_attr;
439 struct abbrev_entry *next;
443 static abbrev_entry *first_abbrev = NULL;
444 static abbrev_entry *last_abbrev = NULL;
451 for (abbrv = first_abbrev; abbrv;)
453 abbrev_entry *next_abbrev = abbrv->next;
456 for (attr = abbrv->first_attr; attr;)
458 abbrev_attr *next_attr = attr->next;
468 last_abbrev = first_abbrev = NULL;
472 add_abbrev (unsigned long number, unsigned long tag, int children)
476 entry = (abbrev_entry *) malloc (sizeof (*entry));
481 entry->entry = number;
483 entry->children = children;
484 entry->first_attr = NULL;
485 entry->last_attr = NULL;
488 if (first_abbrev == NULL)
489 first_abbrev = entry;
491 last_abbrev->next = entry;
497 add_abbrev_attr (unsigned long attribute, unsigned long form)
501 attr = (abbrev_attr *) malloc (sizeof (*attr));
506 attr->attribute = attribute;
510 if (last_abbrev->first_attr == NULL)
511 last_abbrev->first_attr = attr;
513 last_abbrev->last_attr->next = attr;
515 last_abbrev->last_attr = attr;
518 /* Processes the (partial) contents of a .debug_abbrev section.
519 Returns NULL if the end of the section was encountered.
520 Returns the address after the last byte read if the end of
521 an abbreviation set was found. */
523 static unsigned char *
524 process_abbrev_section (unsigned char *start, unsigned char *end)
526 if (first_abbrev != NULL)
531 unsigned int bytes_read;
534 unsigned long attribute;
537 entry = read_leb128 (start, & bytes_read, 0);
540 /* A single zero is supposed to end the section according
541 to the standard. If there's more, then signal that to
544 return start == end ? NULL : start;
546 tag = read_leb128 (start, & bytes_read, 0);
551 add_abbrev (entry, tag, children);
557 attribute = read_leb128 (start, & bytes_read, 0);
560 form = read_leb128 (start, & bytes_read, 0);
564 add_abbrev_attr (attribute, form);
566 while (attribute != 0);
573 get_TAG_name (unsigned long tag)
577 case DW_TAG_padding: return "DW_TAG_padding";
578 case DW_TAG_array_type: return "DW_TAG_array_type";
579 case DW_TAG_class_type: return "DW_TAG_class_type";
580 case DW_TAG_entry_point: return "DW_TAG_entry_point";
581 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
582 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
583 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
584 case DW_TAG_label: return "DW_TAG_label";
585 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
586 case DW_TAG_member: return "DW_TAG_member";
587 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
588 case DW_TAG_reference_type: return "DW_TAG_reference_type";
589 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
590 case DW_TAG_string_type: return "DW_TAG_string_type";
591 case DW_TAG_structure_type: return "DW_TAG_structure_type";
592 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
593 case DW_TAG_typedef: return "DW_TAG_typedef";
594 case DW_TAG_union_type: return "DW_TAG_union_type";
595 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
596 case DW_TAG_variant: return "DW_TAG_variant";
597 case DW_TAG_common_block: return "DW_TAG_common_block";
598 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
599 case DW_TAG_inheritance: return "DW_TAG_inheritance";
600 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
601 case DW_TAG_module: return "DW_TAG_module";
602 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
603 case DW_TAG_set_type: return "DW_TAG_set_type";
604 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
605 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
606 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
607 case DW_TAG_base_type: return "DW_TAG_base_type";
608 case DW_TAG_catch_block: return "DW_TAG_catch_block";
609 case DW_TAG_const_type: return "DW_TAG_const_type";
610 case DW_TAG_constant: return "DW_TAG_constant";
611 case DW_TAG_enumerator: return "DW_TAG_enumerator";
612 case DW_TAG_file_type: return "DW_TAG_file_type";
613 case DW_TAG_friend: return "DW_TAG_friend";
614 case DW_TAG_namelist: return "DW_TAG_namelist";
615 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
616 case DW_TAG_packed_type: return "DW_TAG_packed_type";
617 case DW_TAG_subprogram: return "DW_TAG_subprogram";
618 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
619 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
620 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
621 case DW_TAG_try_block: return "DW_TAG_try_block";
622 case DW_TAG_variant_part: return "DW_TAG_variant_part";
623 case DW_TAG_variable: return "DW_TAG_variable";
624 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
625 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
626 case DW_TAG_format_label: return "DW_TAG_format_label";
627 case DW_TAG_function_template: return "DW_TAG_function_template";
628 case DW_TAG_class_template: return "DW_TAG_class_template";
629 /* DWARF 2.1 values. */
630 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
631 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
632 case DW_TAG_interface_type: return "DW_TAG_interface_type";
633 case DW_TAG_namespace: return "DW_TAG_namespace";
634 case DW_TAG_imported_module: return "DW_TAG_imported_module";
635 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
636 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
637 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
638 case DW_TAG_condition: return "DW_TAG_condition";
639 case DW_TAG_shared_type: return "DW_TAG_shared_type";
640 /* DWARF 4 values. */
641 case DW_TAG_type_unit: return "DW_TAG_type_unit";
642 case DW_TAG_rvalue_reference_type: return "DW_TAG_rvalue_reference_type";
643 case DW_TAG_template_alias: return "DW_TAG_template_alias";
645 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
646 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
647 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
649 case DW_TAG_GNU_call_site: return "DW_TAG_GNU_call_site";
650 case DW_TAG_GNU_call_site_parameter:return "DW_TAG_GNU_call_site_parameter";
653 static char buffer[100];
655 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
662 get_FORM_name (unsigned long form)
666 case DW_FORM_addr: return "DW_FORM_addr";
667 case DW_FORM_block2: return "DW_FORM_block2";
668 case DW_FORM_block4: return "DW_FORM_block4";
669 case DW_FORM_data2: return "DW_FORM_data2";
670 case DW_FORM_data4: return "DW_FORM_data4";
671 case DW_FORM_data8: return "DW_FORM_data8";
672 case DW_FORM_string: return "DW_FORM_string";
673 case DW_FORM_block: return "DW_FORM_block";
674 case DW_FORM_block1: return "DW_FORM_block1";
675 case DW_FORM_data1: return "DW_FORM_data1";
676 case DW_FORM_flag: return "DW_FORM_flag";
677 case DW_FORM_sdata: return "DW_FORM_sdata";
678 case DW_FORM_strp: return "DW_FORM_strp";
679 case DW_FORM_udata: return "DW_FORM_udata";
680 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
681 case DW_FORM_ref1: return "DW_FORM_ref1";
682 case DW_FORM_ref2: return "DW_FORM_ref2";
683 case DW_FORM_ref4: return "DW_FORM_ref4";
684 case DW_FORM_ref8: return "DW_FORM_ref8";
685 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
686 case DW_FORM_indirect: return "DW_FORM_indirect";
687 /* DWARF 4 values. */
688 case DW_FORM_sec_offset: return "DW_FORM_sec_offset";
689 case DW_FORM_exprloc: return "DW_FORM_exprloc";
690 case DW_FORM_flag_present: return "DW_FORM_flag_present";
691 case DW_FORM_ref_sig8: return "DW_FORM_ref_sig8";
694 static char buffer[100];
696 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
702 static unsigned char *
703 display_block (unsigned char *data, dwarf_vma length)
705 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
708 printf ("%lx ", (unsigned long) byte_get (data++, 1));
714 decode_location_expression (unsigned char * data,
715 unsigned int pointer_size,
716 unsigned int offset_size,
720 struct dwarf_section * section)
723 unsigned int bytes_read;
725 unsigned char *end = data + length;
726 int need_frame_base = 0;
735 printf ("DW_OP_addr: %s",
736 dwarf_vmatoa ("x", byte_get (data, pointer_size)));
737 data += pointer_size;
740 printf ("DW_OP_deref");
743 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
746 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
749 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
753 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
757 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
761 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
765 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
766 (unsigned long) byte_get (data + 4, 4));
770 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
771 (long) byte_get (data + 4, 4));
775 printf ("DW_OP_constu: %s",
776 dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
780 printf ("DW_OP_consts: %s",
781 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
785 printf ("DW_OP_dup");
788 printf ("DW_OP_drop");
791 printf ("DW_OP_over");
794 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
797 printf ("DW_OP_swap");
800 printf ("DW_OP_rot");
803 printf ("DW_OP_xderef");
806 printf ("DW_OP_abs");
809 printf ("DW_OP_and");
812 printf ("DW_OP_div");
815 printf ("DW_OP_minus");
818 printf ("DW_OP_mod");
821 printf ("DW_OP_mul");
824 printf ("DW_OP_neg");
827 printf ("DW_OP_not");
833 printf ("DW_OP_plus");
835 case DW_OP_plus_uconst:
836 printf ("DW_OP_plus_uconst: %s",
837 dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
841 printf ("DW_OP_shl");
844 printf ("DW_OP_shr");
847 printf ("DW_OP_shra");
850 printf ("DW_OP_xor");
853 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
875 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
911 printf ("DW_OP_lit%d", op - DW_OP_lit0);
946 printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
947 regname (op - DW_OP_reg0, 1));
982 printf ("DW_OP_breg%d (%s): %s",
984 regname (op - DW_OP_breg0, 1),
985 dwarf_vmatoa ("d", (dwarf_signed_vma)
986 read_leb128 (data, &bytes_read, 1)));
991 uvalue = read_leb128 (data, &bytes_read, 0);
993 printf ("DW_OP_regx: %s (%s)",
994 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
998 printf ("DW_OP_fbreg: %s",
999 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
1003 uvalue = read_leb128 (data, &bytes_read, 0);
1005 printf ("DW_OP_bregx: %s (%s) %s",
1006 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1007 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
1011 printf ("DW_OP_piece: %s",
1012 dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1015 case DW_OP_deref_size:
1016 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
1018 case DW_OP_xderef_size:
1019 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
1022 printf ("DW_OP_nop");
1025 /* DWARF 3 extensions. */
1026 case DW_OP_push_object_address:
1027 printf ("DW_OP_push_object_address");
1030 /* XXX: Strictly speaking for 64-bit DWARF3 files
1031 this ought to be an 8-byte wide computation. */
1032 printf ("DW_OP_call2: <0x%s>",
1033 dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 2)
1038 /* XXX: Strictly speaking for 64-bit DWARF3 files
1039 this ought to be an 8-byte wide computation. */
1040 printf ("DW_OP_call4: <0x%s>",
1041 dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 4)
1045 case DW_OP_call_ref:
1046 /* XXX: Strictly speaking for 64-bit DWARF3 files
1047 this ought to be an 8-byte wide computation. */
1048 if (dwarf_version == -1)
1050 printf (_("(DW_OP_call_ref in frame info)"));
1051 /* No way to tell where the next op is, so just bail. */
1052 return need_frame_base;
1054 if (dwarf_version == 2)
1056 printf ("DW_OP_call_ref: <0x%s>",
1057 dwarf_vmatoa ("x", byte_get (data, pointer_size)));
1058 data += pointer_size;
1062 printf ("DW_OP_call_ref: <0x%s>",
1063 dwarf_vmatoa ("x", byte_get (data, offset_size)));
1064 data += offset_size;
1067 case DW_OP_form_tls_address:
1068 printf ("DW_OP_form_tls_address");
1070 case DW_OP_call_frame_cfa:
1071 printf ("DW_OP_call_frame_cfa");
1073 case DW_OP_bit_piece:
1074 printf ("DW_OP_bit_piece: ");
1075 printf ("size: %s ",
1076 dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1078 printf ("offset: %s ",
1079 dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1083 /* DWARF 4 extensions. */
1084 case DW_OP_stack_value:
1085 printf ("DW_OP_stack_value");
1088 case DW_OP_implicit_value:
1089 printf ("DW_OP_implicit_value");
1090 uvalue = read_leb128 (data, &bytes_read, 0);
1092 display_block (data, uvalue);
1096 /* GNU extensions. */
1097 case DW_OP_GNU_push_tls_address:
1098 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1100 case DW_OP_GNU_uninit:
1101 printf ("DW_OP_GNU_uninit");
1102 /* FIXME: Is there data associated with this OP ? */
1104 case DW_OP_GNU_encoded_addr:
1110 addr = get_encoded_value (data, encoding, section);
1111 data += size_of_encoded_value (encoding);
1113 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1114 print_dwarf_vma (addr, pointer_size);
1117 case DW_OP_GNU_implicit_pointer:
1118 /* XXX: Strictly speaking for 64-bit DWARF3 files
1119 this ought to be an 8-byte wide computation. */
1120 if (dwarf_version == -1)
1122 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1123 /* No way to tell where the next op is, so just bail. */
1124 return need_frame_base;
1126 if (dwarf_version == 2)
1128 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1129 dwarf_vmatoa ("x", byte_get (data, pointer_size)),
1130 dwarf_vmatoa ("d", read_sleb128 (data + pointer_size,
1132 data += pointer_size + bytes_read;
1136 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1137 dwarf_vmatoa ("x", byte_get (data, offset_size)),
1138 dwarf_vmatoa ("d", read_sleb128 (data + offset_size,
1140 data += offset_size + bytes_read;
1143 case DW_OP_GNU_entry_value:
1144 uvalue = read_leb128 (data, &bytes_read, 0);
1146 printf ("DW_OP_GNU_entry_value: (");
1147 if (decode_location_expression (data, pointer_size, offset_size,
1148 dwarf_version, uvalue,
1149 cu_offset, section))
1150 need_frame_base = 1;
1154 case DW_OP_GNU_const_type:
1155 uvalue = read_leb128 (data, &bytes_read, 0);
1157 printf ("DW_OP_GNU_const_type: <0x%s> ",
1158 dwarf_vmatoa ("x", cu_offset + uvalue));
1159 uvalue = byte_get (data++, 1);
1160 display_block (data, uvalue);
1163 case DW_OP_GNU_regval_type:
1164 uvalue = read_leb128 (data, &bytes_read, 0);
1166 printf ("DW_OP_GNU_regval_type: %s (%s)",
1167 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1168 uvalue = read_leb128 (data, &bytes_read, 0);
1170 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1172 case DW_OP_GNU_deref_type:
1173 printf ("DW_OP_GNU_deref_type: %ld", (long) byte_get (data++, 1));
1174 uvalue = read_leb128 (data, &bytes_read, 0);
1176 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1178 case DW_OP_GNU_convert:
1179 uvalue = read_leb128 (data, &bytes_read, 0);
1181 printf ("DW_OP_GNU_convert <0x%s>",
1182 dwarf_vmatoa ("x", cu_offset + uvalue));
1184 case DW_OP_GNU_reinterpret:
1185 uvalue = read_leb128 (data, &bytes_read, 0);
1187 printf ("DW_OP_GNU_reinterpret <0x%s>",
1188 dwarf_vmatoa ("x", cu_offset + uvalue));
1191 /* HP extensions. */
1192 case DW_OP_HP_is_value:
1193 printf ("DW_OP_HP_is_value");
1194 /* FIXME: Is there data associated with this OP ? */
1196 case DW_OP_HP_fltconst4:
1197 printf ("DW_OP_HP_fltconst4");
1198 /* FIXME: Is there data associated with this OP ? */
1200 case DW_OP_HP_fltconst8:
1201 printf ("DW_OP_HP_fltconst8");
1202 /* FIXME: Is there data associated with this OP ? */
1204 case DW_OP_HP_mod_range:
1205 printf ("DW_OP_HP_mod_range");
1206 /* FIXME: Is there data associated with this OP ? */
1208 case DW_OP_HP_unmod_range:
1209 printf ("DW_OP_HP_unmod_range");
1210 /* FIXME: Is there data associated with this OP ? */
1213 printf ("DW_OP_HP_tls");
1214 /* FIXME: Is there data associated with this OP ? */
1217 /* PGI (STMicroelectronics) extensions. */
1218 case DW_OP_PGI_omp_thread_num:
1219 /* Pushes the thread number for the current thread as it would be
1220 returned by the standard OpenMP library function:
1221 omp_get_thread_num(). The "current thread" is the thread for
1222 which the expression is being evaluated. */
1223 printf ("DW_OP_PGI_omp_thread_num");
1227 if (op >= DW_OP_lo_user
1228 && op <= DW_OP_hi_user)
1229 printf (_("(User defined location op)"));
1231 printf (_("(Unknown location op)"));
1232 /* No way to tell where the next op is, so just bail. */
1233 return need_frame_base;
1236 /* Separate the ops. */
1241 return need_frame_base;
1244 static unsigned char *
1245 read_and_display_attr_value (unsigned long attribute,
1247 unsigned char * data,
1248 dwarf_vma cu_offset,
1249 dwarf_vma pointer_size,
1250 dwarf_vma offset_size,
1252 debug_info * debug_info_p,
1254 struct dwarf_section * section)
1256 dwarf_vma uvalue = 0;
1257 unsigned char *block_start = NULL;
1258 unsigned char * orig_data = data;
1259 unsigned int bytes_read;
1266 case DW_FORM_ref_addr:
1267 if (dwarf_version == 2)
1269 uvalue = byte_get (data, pointer_size);
1270 data += pointer_size;
1272 else if (dwarf_version == 3 || dwarf_version == 4)
1274 uvalue = byte_get (data, offset_size);
1275 data += offset_size;
1278 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1283 uvalue = byte_get (data, pointer_size);
1284 data += pointer_size;
1288 case DW_FORM_sec_offset:
1289 uvalue = byte_get (data, offset_size);
1290 data += offset_size;
1293 case DW_FORM_flag_present:
1300 uvalue = byte_get (data++, 1);
1305 uvalue = byte_get (data, 2);
1311 uvalue = byte_get (data, 4);
1316 uvalue = read_leb128 (data, & bytes_read, 1);
1320 case DW_FORM_ref_udata:
1322 uvalue = read_leb128 (data, & bytes_read, 0);
1326 case DW_FORM_indirect:
1327 form = read_leb128 (data, & bytes_read, 0);
1330 printf (" %s", get_FORM_name (form));
1331 return read_and_display_attr_value (attribute, form, data,
1332 cu_offset, pointer_size,
1333 offset_size, dwarf_version,
1334 debug_info_p, do_loc,
1340 case DW_FORM_ref_addr:
1342 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1348 case DW_FORM_ref_udata:
1350 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1355 case DW_FORM_sec_offset:
1357 printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1360 case DW_FORM_flag_present:
1367 printf (" %s", dwarf_vmatoa ("d", uvalue));
1374 uvalue = byte_get (data, 4);
1375 printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1376 printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1378 if ((do_loc || do_debug_loc || do_debug_ranges)
1379 && num_debug_info_entries == 0)
1381 if (sizeof (uvalue) == 8)
1382 uvalue = byte_get (data, 8);
1384 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1389 case DW_FORM_string:
1391 printf (" %s", data);
1392 data += strlen ((char *) data) + 1;
1396 case DW_FORM_exprloc:
1397 uvalue = read_leb128 (data, & bytes_read, 0);
1398 block_start = data + bytes_read;
1400 data = block_start + uvalue;
1402 data = display_block (block_start, uvalue);
1405 case DW_FORM_block1:
1406 uvalue = byte_get (data, 1);
1407 block_start = data + 1;
1409 data = block_start + uvalue;
1411 data = display_block (block_start, uvalue);
1414 case DW_FORM_block2:
1415 uvalue = byte_get (data, 2);
1416 block_start = data + 2;
1418 data = block_start + uvalue;
1420 data = display_block (block_start, uvalue);
1423 case DW_FORM_block4:
1424 uvalue = byte_get (data, 4);
1425 block_start = data + 4;
1427 data = block_start + uvalue;
1429 data = display_block (block_start, uvalue);
1434 printf (_(" (indirect string, offset: 0x%s): %s"),
1435 dwarf_vmatoa ("x", uvalue),
1436 fetch_indirect_string (uvalue));
1439 case DW_FORM_indirect:
1440 /* Handled above. */
1443 case DW_FORM_ref_sig8:
1447 printf (" signature: ");
1448 for (i = 0; i < 8; i++)
1450 printf ("%02x", (unsigned) byte_get (data, 1));
1459 warn (_("Unrecognized form: %lu\n"), form);
1463 if ((do_loc || do_debug_loc || do_debug_ranges)
1464 && num_debug_info_entries == 0
1465 && debug_info_p != NULL)
1469 case DW_AT_frame_base:
1470 have_frame_base = 1;
1471 case DW_AT_location:
1472 case DW_AT_string_length:
1473 case DW_AT_return_addr:
1474 case DW_AT_data_member_location:
1475 case DW_AT_vtable_elem_location:
1477 case DW_AT_static_link:
1478 case DW_AT_use_location:
1479 case DW_AT_GNU_call_site_value:
1480 case DW_AT_GNU_call_site_data_value:
1481 case DW_AT_GNU_call_site_target:
1482 case DW_AT_GNU_call_site_target_clobbered:
1483 if (form == DW_FORM_data4
1484 || form == DW_FORM_data8
1485 || form == DW_FORM_sec_offset)
1487 /* Process location list. */
1488 unsigned int lmax = debug_info_p->max_loc_offsets;
1489 unsigned int num = debug_info_p->num_loc_offsets;
1491 if (lmax == 0 || num >= lmax)
1494 debug_info_p->loc_offsets = (dwarf_vma *)
1495 xcrealloc (debug_info_p->loc_offsets,
1496 lmax, sizeof (*debug_info_p->loc_offsets));
1497 debug_info_p->have_frame_base = (int *)
1498 xcrealloc (debug_info_p->have_frame_base,
1499 lmax, sizeof (*debug_info_p->have_frame_base));
1500 debug_info_p->max_loc_offsets = lmax;
1502 debug_info_p->loc_offsets [num] = uvalue;
1503 debug_info_p->have_frame_base [num] = have_frame_base;
1504 debug_info_p->num_loc_offsets++;
1509 if (need_base_address)
1510 debug_info_p->base_address = uvalue;
1514 if (form == DW_FORM_data4
1515 || form == DW_FORM_data8
1516 || form == DW_FORM_sec_offset)
1518 /* Process range list. */
1519 unsigned int lmax = debug_info_p->max_range_lists;
1520 unsigned int num = debug_info_p->num_range_lists;
1522 if (lmax == 0 || num >= lmax)
1525 debug_info_p->range_lists = (dwarf_vma *)
1526 xcrealloc (debug_info_p->range_lists,
1527 lmax, sizeof (*debug_info_p->range_lists));
1528 debug_info_p->max_range_lists = lmax;
1530 debug_info_p->range_lists [num] = uvalue;
1531 debug_info_p->num_range_lists++;
1543 /* For some attributes we can display further information. */
1551 case DW_INL_not_inlined:
1552 printf (_("(not inlined)"));
1554 case DW_INL_inlined:
1555 printf (_("(inlined)"));
1557 case DW_INL_declared_not_inlined:
1558 printf (_("(declared as inline but ignored)"));
1560 case DW_INL_declared_inlined:
1561 printf (_("(declared as inline and inlined)"));
1564 printf (_(" (Unknown inline attribute value: %s)"),
1565 dwarf_vmatoa ("x", uvalue));
1570 case DW_AT_language:
1573 /* Ordered by the numeric value of these constants. */
1574 case DW_LANG_C89: printf ("(ANSI C)"); break;
1575 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1576 case DW_LANG_Ada83: printf ("(Ada)"); break;
1577 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1578 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1579 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1580 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1581 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1582 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1583 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1584 /* DWARF 2.1 values. */
1585 case DW_LANG_Java: printf ("(Java)"); break;
1586 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1587 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1588 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1589 /* DWARF 3 values. */
1590 case DW_LANG_PLI: printf ("(PLI)"); break;
1591 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1592 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1593 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1594 case DW_LANG_D: printf ("(D)"); break;
1595 /* DWARF 4 values. */
1596 case DW_LANG_Python: printf ("(Python)"); break;
1597 /* MIPS extension. */
1598 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1599 /* UPC extension. */
1600 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1602 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1603 printf ("(implementation defined: %s)",
1604 dwarf_vmatoa ("x", uvalue));
1606 printf ("(Unknown: %s)", dwarf_vmatoa ("x", uvalue));
1611 case DW_AT_encoding:
1614 case DW_ATE_void: printf ("(void)"); break;
1615 case DW_ATE_address: printf ("(machine address)"); break;
1616 case DW_ATE_boolean: printf ("(boolean)"); break;
1617 case DW_ATE_complex_float: printf ("(complex float)"); break;
1618 case DW_ATE_float: printf ("(float)"); break;
1619 case DW_ATE_signed: printf ("(signed)"); break;
1620 case DW_ATE_signed_char: printf ("(signed char)"); break;
1621 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1622 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1623 /* DWARF 2.1 values: */
1624 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1625 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1626 /* DWARF 3 values: */
1627 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1628 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1629 case DW_ATE_edited: printf ("(edited)"); break;
1630 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1631 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1632 /* HP extensions: */
1633 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1634 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1635 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1636 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1637 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1638 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1639 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1642 if (uvalue >= DW_ATE_lo_user
1643 && uvalue <= DW_ATE_hi_user)
1644 printf ("(user defined type)");
1646 printf ("(unknown type)");
1651 case DW_AT_accessibility:
1654 case DW_ACCESS_public: printf ("(public)"); break;
1655 case DW_ACCESS_protected: printf ("(protected)"); break;
1656 case DW_ACCESS_private: printf ("(private)"); break;
1658 printf ("(unknown accessibility)");
1663 case DW_AT_visibility:
1666 case DW_VIS_local: printf ("(local)"); break;
1667 case DW_VIS_exported: printf ("(exported)"); break;
1668 case DW_VIS_qualified: printf ("(qualified)"); break;
1669 default: printf ("(unknown visibility)"); break;
1673 case DW_AT_virtuality:
1676 case DW_VIRTUALITY_none: printf ("(none)"); break;
1677 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1678 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1679 default: printf ("(unknown virtuality)"); break;
1683 case DW_AT_identifier_case:
1686 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1687 case DW_ID_up_case: printf ("(up_case)"); break;
1688 case DW_ID_down_case: printf ("(down_case)"); break;
1689 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1690 default: printf ("(unknown case)"); break;
1694 case DW_AT_calling_convention:
1697 case DW_CC_normal: printf ("(normal)"); break;
1698 case DW_CC_program: printf ("(program)"); break;
1699 case DW_CC_nocall: printf ("(nocall)"); break;
1701 if (uvalue >= DW_CC_lo_user
1702 && uvalue <= DW_CC_hi_user)
1703 printf ("(user defined)");
1705 printf ("(unknown convention)");
1709 case DW_AT_ordering:
1712 case -1: printf ("(undefined)"); break;
1713 case 0: printf ("(row major)"); break;
1714 case 1: printf ("(column major)"); break;
1718 case DW_AT_frame_base:
1719 have_frame_base = 1;
1720 case DW_AT_location:
1721 case DW_AT_string_length:
1722 case DW_AT_return_addr:
1723 case DW_AT_data_member_location:
1724 case DW_AT_vtable_elem_location:
1726 case DW_AT_static_link:
1727 case DW_AT_use_location:
1728 case DW_AT_GNU_call_site_value:
1729 case DW_AT_GNU_call_site_data_value:
1730 case DW_AT_GNU_call_site_target:
1731 case DW_AT_GNU_call_site_target_clobbered:
1732 if (form == DW_FORM_data4
1733 || form == DW_FORM_data8
1734 || form == DW_FORM_sec_offset)
1735 printf (_("(location list)"));
1737 case DW_AT_allocated:
1738 case DW_AT_associated:
1739 case DW_AT_data_location:
1741 case DW_AT_upper_bound:
1742 case DW_AT_lower_bound:
1745 int need_frame_base;
1748 need_frame_base = decode_location_expression (block_start,
1753 cu_offset, section);
1755 if (need_frame_base && !have_frame_base)
1756 printf (_(" [without DW_AT_frame_base]"));
1762 if (form == DW_FORM_ref_sig8)
1765 if (form == DW_FORM_ref1
1766 || form == DW_FORM_ref2
1767 || form == DW_FORM_ref4)
1768 uvalue += cu_offset;
1770 if (uvalue >= section->size)
1771 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1772 dwarf_vmatoa ("x", uvalue),
1773 (unsigned long) (orig_data - section->start));
1776 unsigned long abbrev_number;
1777 abbrev_entry * entry;
1779 abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1781 printf ("[Abbrev Number: %ld", abbrev_number);
1782 for (entry = first_abbrev; entry != NULL; entry = entry->next)
1783 if (entry->entry == abbrev_number)
1786 printf (" (%s)", get_TAG_name (entry->tag));
1800 get_AT_name (unsigned long attribute)
1804 case DW_AT_sibling: return "DW_AT_sibling";
1805 case DW_AT_location: return "DW_AT_location";
1806 case DW_AT_name: return "DW_AT_name";
1807 case DW_AT_ordering: return "DW_AT_ordering";
1808 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1809 case DW_AT_byte_size: return "DW_AT_byte_size";
1810 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1811 case DW_AT_bit_size: return "DW_AT_bit_size";
1812 case DW_AT_element_list: return "DW_AT_element_list";
1813 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1814 case DW_AT_low_pc: return "DW_AT_low_pc";
1815 case DW_AT_high_pc: return "DW_AT_high_pc";
1816 case DW_AT_language: return "DW_AT_language";
1817 case DW_AT_member: return "DW_AT_member";
1818 case DW_AT_discr: return "DW_AT_discr";
1819 case DW_AT_discr_value: return "DW_AT_discr_value";
1820 case DW_AT_visibility: return "DW_AT_visibility";
1821 case DW_AT_import: return "DW_AT_import";
1822 case DW_AT_string_length: return "DW_AT_string_length";
1823 case DW_AT_common_reference: return "DW_AT_common_reference";
1824 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1825 case DW_AT_const_value: return "DW_AT_const_value";
1826 case DW_AT_containing_type: return "DW_AT_containing_type";
1827 case DW_AT_default_value: return "DW_AT_default_value";
1828 case DW_AT_inline: return "DW_AT_inline";
1829 case DW_AT_is_optional: return "DW_AT_is_optional";
1830 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1831 case DW_AT_producer: return "DW_AT_producer";
1832 case DW_AT_prototyped: return "DW_AT_prototyped";
1833 case DW_AT_return_addr: return "DW_AT_return_addr";
1834 case DW_AT_start_scope: return "DW_AT_start_scope";
1835 case DW_AT_stride_size: return "DW_AT_stride_size";
1836 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1837 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1838 case DW_AT_accessibility: return "DW_AT_accessibility";
1839 case DW_AT_address_class: return "DW_AT_address_class";
1840 case DW_AT_artificial: return "DW_AT_artificial";
1841 case DW_AT_base_types: return "DW_AT_base_types";
1842 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1843 case DW_AT_count: return "DW_AT_count";
1844 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1845 case DW_AT_decl_column: return "DW_AT_decl_column";
1846 case DW_AT_decl_file: return "DW_AT_decl_file";
1847 case DW_AT_decl_line: return "DW_AT_decl_line";
1848 case DW_AT_declaration: return "DW_AT_declaration";
1849 case DW_AT_discr_list: return "DW_AT_discr_list";
1850 case DW_AT_encoding: return "DW_AT_encoding";
1851 case DW_AT_external: return "DW_AT_external";
1852 case DW_AT_frame_base: return "DW_AT_frame_base";
1853 case DW_AT_friend: return "DW_AT_friend";
1854 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1855 case DW_AT_macro_info: return "DW_AT_macro_info";
1856 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1857 case DW_AT_priority: return "DW_AT_priority";
1858 case DW_AT_segment: return "DW_AT_segment";
1859 case DW_AT_specification: return "DW_AT_specification";
1860 case DW_AT_static_link: return "DW_AT_static_link";
1861 case DW_AT_type: return "DW_AT_type";
1862 case DW_AT_use_location: return "DW_AT_use_location";
1863 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1864 case DW_AT_virtuality: return "DW_AT_virtuality";
1865 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1866 /* DWARF 2.1 values. */
1867 case DW_AT_allocated: return "DW_AT_allocated";
1868 case DW_AT_associated: return "DW_AT_associated";
1869 case DW_AT_data_location: return "DW_AT_data_location";
1870 case DW_AT_stride: return "DW_AT_stride";
1871 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1872 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1873 case DW_AT_extension: return "DW_AT_extension";
1874 case DW_AT_ranges: return "DW_AT_ranges";
1875 case DW_AT_trampoline: return "DW_AT_trampoline";
1876 case DW_AT_call_column: return "DW_AT_call_column";
1877 case DW_AT_call_file: return "DW_AT_call_file";
1878 case DW_AT_call_line: return "DW_AT_call_line";
1879 case DW_AT_description: return "DW_AT_description";
1880 case DW_AT_binary_scale: return "DW_AT_binary_scale";
1881 case DW_AT_decimal_scale: return "DW_AT_decimal_scale";
1882 case DW_AT_small: return "DW_AT_small";
1883 case DW_AT_decimal_sign: return "DW_AT_decimal_sign";
1884 case DW_AT_digit_count: return "DW_AT_digit_count";
1885 case DW_AT_picture_string: return "DW_AT_picture_string";
1886 case DW_AT_mutable: return "DW_AT_mutable";
1887 case DW_AT_threads_scaled: return "DW_AT_threads_scaled";
1888 case DW_AT_explicit: return "DW_AT_explicit";
1889 case DW_AT_object_pointer: return "DW_AT_object_pointer";
1890 case DW_AT_endianity: return "DW_AT_endianity";
1891 case DW_AT_elemental: return "DW_AT_elemental";
1892 case DW_AT_pure: return "DW_AT_pure";
1893 case DW_AT_recursive: return "DW_AT_recursive";
1894 /* DWARF 4 values. */
1895 case DW_AT_signature: return "DW_AT_signature";
1896 case DW_AT_main_subprogram: return "DW_AT_main_subprogram";
1897 case DW_AT_data_bit_offset: return "DW_AT_data_bit_offset";
1898 case DW_AT_const_expr: return "DW_AT_const_expr";
1899 case DW_AT_enum_class: return "DW_AT_enum_class";
1900 case DW_AT_linkage_name: return "DW_AT_linkage_name";
1902 /* HP and SGI/MIPS extensions. */
1903 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1904 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1905 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1906 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1907 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
1908 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1909 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1910 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1911 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1912 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1914 /* HP Extensions. */
1915 case DW_AT_HP_block_index: return "DW_AT_HP_block_index";
1916 case DW_AT_HP_actuals_stmt_list: return "DW_AT_HP_actuals_stmt_list";
1917 case DW_AT_HP_proc_per_section: return "DW_AT_HP_proc_per_section";
1918 case DW_AT_HP_raw_data_ptr: return "DW_AT_HP_raw_data_ptr";
1919 case DW_AT_HP_pass_by_reference: return "DW_AT_HP_pass_by_reference";
1920 case DW_AT_HP_opt_level: return "DW_AT_HP_opt_level";
1921 case DW_AT_HP_prof_version_id: return "DW_AT_HP_prof_version_id";
1922 case DW_AT_HP_opt_flags: return "DW_AT_HP_opt_flags";
1923 case DW_AT_HP_cold_region_low_pc: return "DW_AT_HP_cold_region_low_pc";
1924 case DW_AT_HP_cold_region_high_pc: return "DW_AT_HP_cold_region_high_pc";
1925 case DW_AT_HP_all_variables_modifiable: return "DW_AT_HP_all_variables_modifiable";
1926 case DW_AT_HP_linkage_name: return "DW_AT_HP_linkage_name";
1927 case DW_AT_HP_prof_flags: return "DW_AT_HP_prof_flags";
1929 /* One value is shared by the MIPS and HP extensions: */
1930 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1932 /* GNU extensions. */
1933 case DW_AT_sf_names: return "DW_AT_sf_names";
1934 case DW_AT_src_info: return "DW_AT_src_info";
1935 case DW_AT_mac_info: return "DW_AT_mac_info";
1936 case DW_AT_src_coords: return "DW_AT_src_coords";
1937 case DW_AT_body_begin: return "DW_AT_body_begin";
1938 case DW_AT_body_end: return "DW_AT_body_end";
1939 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
1940 case DW_AT_GNU_guarded_by: return "DW_AT_GNU_guarded_by";
1941 case DW_AT_GNU_pt_guarded_by: return "DW_AT_GNU_pt_guarded_by";
1942 case DW_AT_GNU_guarded: return "DW_AT_GNU_guarded";
1943 case DW_AT_GNU_pt_guarded: return "DW_AT_GNU_pt_guarded";
1944 case DW_AT_GNU_locks_excluded: return "DW_AT_GNU_locks_excluded";
1945 case DW_AT_GNU_exclusive_locks_required: return "DW_AT_GNU_exclusive_locks_required";
1946 case DW_AT_GNU_shared_locks_required: return "DW_AT_GNU_shared_locks_required";
1947 case DW_AT_GNU_odr_signature: return "DW_AT_GNU_odr_signature";
1948 case DW_AT_use_GNAT_descriptive_type: return "DW_AT_use_GNAT_descriptive_type";
1949 case DW_AT_GNAT_descriptive_type: return "DW_AT_GNAT_descriptive_type";
1950 case DW_AT_GNU_call_site_value: return "DW_AT_GNU_call_site_value";
1951 case DW_AT_GNU_call_site_data_value: return "DW_AT_GNU_call_site_data_value";
1952 case DW_AT_GNU_call_site_target: return "DW_AT_GNU_call_site_target";
1953 case DW_AT_GNU_call_site_target_clobbered: return "DW_AT_GNU_call_site_target_clobbered";
1954 case DW_AT_GNU_tail_call: return "DW_AT_GNU_tail_call";
1955 case DW_AT_GNU_all_tail_call_sites: return "DW_AT_GNU_all_tail_call_sites";
1956 case DW_AT_GNU_all_call_sites: return "DW_AT_GNU_all_call_sites";
1957 case DW_AT_GNU_all_source_call_sites: return "DW_AT_GNU_all_source_call_sites";
1959 /* UPC extension. */
1960 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
1962 /* PGI (STMicroelectronics) extensions. */
1963 case DW_AT_PGI_lbase: return "DW_AT_PGI_lbase";
1964 case DW_AT_PGI_soffset: return "DW_AT_PGI_soffset";
1965 case DW_AT_PGI_lstride: return "DW_AT_PGI_lstride";
1969 static char buffer[100];
1971 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1978 static unsigned char *
1979 read_and_display_attr (unsigned long attribute,
1981 unsigned char * data,
1982 dwarf_vma cu_offset,
1983 dwarf_vma pointer_size,
1984 dwarf_vma offset_size,
1986 debug_info * debug_info_p,
1988 struct dwarf_section * section)
1991 printf (" %-18s:", get_AT_name (attribute));
1992 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1993 pointer_size, offset_size,
1994 dwarf_version, debug_info_p,
2002 /* Process the contents of a .debug_info section. If do_loc is non-zero
2003 then we are scanning for location lists and we do not want to display
2004 anything to the user. If do_types is non-zero, we are processing
2005 a .debug_types section instead of a .debug_info section. */
2008 process_debug_info (struct dwarf_section *section,
2010 enum dwarf_section_display_enum abbrev_sec,
2014 unsigned char *start = section->start;
2015 unsigned char *end = start + section->size;
2016 unsigned char *section_begin;
2018 unsigned int num_units = 0;
2020 if ((do_loc || do_debug_loc || do_debug_ranges)
2021 && num_debug_info_entries == 0
2026 /* First scan the section to get the number of comp units. */
2027 for (section_begin = start, num_units = 0; section_begin < end;
2030 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2031 will be the length. For a 64-bit DWARF section, it'll be
2032 the escape code 0xffffffff followed by an 8 byte length. */
2033 length = byte_get (section_begin, 4);
2035 if (length == 0xffffffff)
2037 length = byte_get (section_begin + 4, 8);
2038 section_begin += length + 12;
2040 else if (length >= 0xfffffff0 && length < 0xffffffff)
2042 warn (_("Reserved length value (0x%s) found in section %s\n"),
2043 dwarf_vmatoa ("x", length), section->name);
2047 section_begin += length + 4;
2049 /* Negative values are illegal, they may even cause infinite
2050 looping. This can happen if we can't accurately apply
2051 relocations to an object file. */
2052 if ((signed long) length <= 0)
2054 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2055 dwarf_vmatoa ("x", length), section->name);
2062 error (_("No comp units in %s section ?"), section->name);
2066 /* Then allocate an array to hold the information. */
2067 debug_information = (debug_info *) cmalloc (num_units,
2068 sizeof (* debug_information));
2069 if (debug_information == NULL)
2071 error (_("Not enough memory for a debug info array of %u entries"),
2079 if (dwarf_start_die == 0)
2080 printf (_("Contents of the %s section:\n\n"), section->name);
2082 load_debug_section (str, file);
2085 load_debug_section (abbrev_sec, file);
2086 if (debug_displays [abbrev_sec].section.start == NULL)
2088 warn (_("Unable to locate %s section!\n"),
2089 debug_displays [abbrev_sec].section.name);
2093 for (section_begin = start, unit = 0; start < end; unit++)
2095 DWARF2_Internal_CompUnit compunit;
2096 unsigned char *hdrptr;
2097 unsigned char *tags;
2098 int level, last_level, saved_level;
2099 dwarf_vma cu_offset;
2101 int initial_length_size;
2102 unsigned char signature[8] = { 0 };
2103 dwarf_vma type_offset = 0;
2107 compunit.cu_length = byte_get (hdrptr, 4);
2110 if (compunit.cu_length == 0xffffffff)
2112 compunit.cu_length = byte_get (hdrptr, 8);
2115 initial_length_size = 12;
2120 initial_length_size = 4;
2123 compunit.cu_version = byte_get (hdrptr, 2);
2126 cu_offset = start - section_begin;
2128 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
2129 hdrptr += offset_size;
2131 compunit.cu_pointer_size = byte_get (hdrptr, 1);
2138 for (i = 0; i < 8; i++)
2140 signature[i] = byte_get (hdrptr, 1);
2144 type_offset = byte_get (hdrptr, offset_size);
2145 hdrptr += offset_size;
2148 if ((do_loc || do_debug_loc || do_debug_ranges)
2149 && num_debug_info_entries == 0
2152 debug_information [unit].cu_offset = cu_offset;
2153 debug_information [unit].pointer_size
2154 = compunit.cu_pointer_size;
2155 debug_information [unit].offset_size = offset_size;
2156 debug_information [unit].dwarf_version = compunit.cu_version;
2157 debug_information [unit].base_address = 0;
2158 debug_information [unit].loc_offsets = NULL;
2159 debug_information [unit].have_frame_base = NULL;
2160 debug_information [unit].max_loc_offsets = 0;
2161 debug_information [unit].num_loc_offsets = 0;
2162 debug_information [unit].range_lists = NULL;
2163 debug_information [unit].max_range_lists= 0;
2164 debug_information [unit].num_range_lists = 0;
2167 if (!do_loc && dwarf_start_die == 0)
2169 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2170 dwarf_vmatoa ("x", cu_offset));
2171 printf (_(" Length: 0x%s (%s)\n"),
2172 dwarf_vmatoa ("x", compunit.cu_length),
2173 offset_size == 8 ? "64-bit" : "32-bit");
2174 printf (_(" Version: %d\n"), compunit.cu_version);
2175 printf (_(" Abbrev Offset: %s\n"),
2176 dwarf_vmatoa ("d", compunit.cu_abbrev_offset));
2177 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2181 printf (_(" Signature: "));
2182 for (i = 0; i < 8; i++)
2183 printf ("%02x", signature[i]);
2185 printf (_(" Type Offset: 0x%s\n"),
2186 dwarf_vmatoa ("x", type_offset));
2190 if (cu_offset + compunit.cu_length + initial_length_size
2193 warn (_("Debug info is corrupted, length of CU at %s"
2194 " extends beyond end of section (length = %s)\n"),
2195 dwarf_vmatoa ("x", cu_offset),
2196 dwarf_vmatoa ("x", compunit.cu_length));
2200 start += compunit.cu_length + initial_length_size;
2202 if (compunit.cu_version != 2
2203 && compunit.cu_version != 3
2204 && compunit.cu_version != 4)
2206 warn (_("CU at offset %s contains corrupt or "
2207 "unsupported version number: %d.\n"),
2208 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2214 /* Process the abbrevs used by this compilation unit. DWARF
2215 sections under Mach-O have non-zero addresses. */
2216 if (compunit.cu_abbrev_offset >= debug_displays [abbrev_sec].section.size)
2217 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2218 (unsigned long) compunit.cu_abbrev_offset,
2219 (unsigned long) debug_displays [abbrev_sec].section.size);
2221 process_abbrev_section
2222 ((unsigned char *) debug_displays [abbrev_sec].section.start
2223 + compunit.cu_abbrev_offset,
2224 (unsigned char *) debug_displays [abbrev_sec].section.start
2225 + debug_displays [abbrev_sec].section.size);
2230 while (tags < start)
2232 unsigned int bytes_read;
2233 unsigned long abbrev_number;
2234 unsigned long die_offset;
2235 abbrev_entry *entry;
2237 int do_printing = 1;
2239 die_offset = tags - section_begin;
2241 abbrev_number = read_leb128 (tags, & bytes_read, 0);
2244 /* A null DIE marks the end of a list of siblings or it may also be
2245 a section padding. */
2246 if (abbrev_number == 0)
2248 /* Check if it can be a section padding for the last CU. */
2249 if (level == 0 && start == end)
2253 for (chk = tags; chk < start; chk++)
2263 static unsigned num_bogus_warns = 0;
2265 if (num_bogus_warns < 3)
2267 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2270 if (num_bogus_warns == 3)
2271 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2274 if (dwarf_start_die != 0 && level < saved_level)
2281 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2285 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2286 saved_level = level;
2287 do_printing = (dwarf_cutoff_level == -1
2288 || level < dwarf_cutoff_level);
2290 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2291 level, die_offset, abbrev_number);
2292 else if (dwarf_cutoff_level == -1
2293 || last_level < dwarf_cutoff_level)
2294 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2299 /* Scan through the abbreviation list until we reach the
2301 for (entry = first_abbrev;
2302 entry && entry->entry != abbrev_number;
2303 entry = entry->next)
2308 if (!do_loc && do_printing)
2313 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2314 die_offset, abbrev_number);
2318 if (!do_loc && do_printing)
2319 printf (" (%s)\n", get_TAG_name (entry->tag));
2324 need_base_address = 0;
2326 case DW_TAG_compile_unit:
2327 need_base_address = 1;
2329 case DW_TAG_entry_point:
2330 case DW_TAG_subprogram:
2331 need_base_address = 0;
2332 /* Assuming that there is no DW_AT_frame_base. */
2333 have_frame_base = 0;
2337 for (attr = entry->first_attr; attr; attr = attr->next)
2341 if (! do_loc && do_printing)
2342 /* Show the offset from where the tag was extracted. */
2343 printf (" <%lx>", (unsigned long)(tags - section_begin));
2345 arg = debug_information;
2346 if (debug_information)
2349 tags = read_and_display_attr (attr->attribute,
2352 compunit.cu_pointer_size,
2354 compunit.cu_version,
2356 do_loc || ! do_printing, section);
2359 if (entry->children)
2364 /* Set num_debug_info_entries here so that it can be used to check if
2365 we need to process .debug_loc and .debug_ranges sections. */
2366 if ((do_loc || do_debug_loc || do_debug_ranges)
2367 && num_debug_info_entries == 0
2369 num_debug_info_entries = num_units;
2377 /* Locate and scan the .debug_info section in the file and record the pointer
2378 sizes and offsets for the compilation units in it. Usually an executable
2379 will have just one pointer size, but this is not guaranteed, and so we try
2380 not to make any assumptions. Returns zero upon failure, or the number of
2381 compilation units upon success. */
2384 load_debug_info (void * file)
2386 /* Reset the last pointer size so that we can issue correct error
2387 messages if we are displaying the contents of more than one section. */
2388 last_pointer_size = 0;
2389 warned_about_missing_comp_units = FALSE;
2391 /* If we have already tried and failed to load the .debug_info
2392 section then do not bother to repear the task. */
2393 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2396 /* If we already have the information there is nothing else to do. */
2397 if (num_debug_info_entries > 0)
2398 return num_debug_info_entries;
2400 if (load_debug_section (info, file)
2401 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2402 return num_debug_info_entries;
2404 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2409 display_debug_lines_raw (struct dwarf_section *section,
2410 unsigned char *data,
2413 unsigned char *start = section->start;
2415 printf (_("Raw dump of debug contents of section %s:\n\n"),
2420 DWARF2_Internal_LineInfo linfo;
2421 unsigned char *standard_opcodes;
2422 unsigned char *end_of_sequence;
2423 unsigned char *hdrptr;
2424 unsigned long hdroff;
2425 int initial_length_size;
2430 hdroff = hdrptr - start;
2432 /* Check the length of the block. */
2433 linfo.li_length = byte_get (hdrptr, 4);
2436 if (linfo.li_length == 0xffffffff)
2438 /* This section is 64-bit DWARF 3. */
2439 linfo.li_length = byte_get (hdrptr, 8);
2442 initial_length_size = 12;
2447 initial_length_size = 4;
2450 if (linfo.li_length + initial_length_size > section->size)
2453 (_("The information in section %s appears to be corrupt - the section is too small\n"),
2458 /* Check its version number. */
2459 linfo.li_version = byte_get (hdrptr, 2);
2461 if (linfo.li_version != 2
2462 && linfo.li_version != 3
2463 && linfo.li_version != 4)
2465 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2469 linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2470 hdrptr += offset_size;
2471 linfo.li_min_insn_length = byte_get (hdrptr, 1);
2473 if (linfo.li_version >= 4)
2475 linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2477 if (linfo.li_max_ops_per_insn == 0)
2479 warn (_("Invalid maximum operations per insn.\n"));
2484 linfo.li_max_ops_per_insn = 1;
2485 linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2487 linfo.li_line_base = byte_get (hdrptr, 1);
2489 linfo.li_line_range = byte_get (hdrptr, 1);
2491 linfo.li_opcode_base = byte_get (hdrptr, 1);
2494 /* Sign extend the line base field. */
2495 linfo.li_line_base <<= 24;
2496 linfo.li_line_base >>= 24;
2498 printf (_(" Offset: 0x%lx\n"), hdroff);
2499 printf (_(" Length: %ld\n"), (long) linfo.li_length);
2500 printf (_(" DWARF Version: %d\n"), linfo.li_version);
2501 printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length);
2502 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
2503 if (linfo.li_version >= 4)
2504 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2505 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2506 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2507 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2508 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
2510 end_of_sequence = data + linfo.li_length + initial_length_size;
2512 reset_state_machine (linfo.li_default_is_stmt);
2514 /* Display the contents of the Opcodes table. */
2515 standard_opcodes = hdrptr;
2517 printf (_("\n Opcodes:\n"));
2519 for (i = 1; i < linfo.li_opcode_base; i++)
2520 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2522 /* Display the contents of the Directory table. */
2523 data = standard_opcodes + linfo.li_opcode_base - 1;
2526 printf (_("\n The Directory Table is empty.\n"));
2529 printf (_("\n The Directory Table:\n"));
2533 printf (" %s\n", data);
2535 data += strlen ((char *) data) + 1;
2539 /* Skip the NUL at the end of the table. */
2542 /* Display the contents of the File Name table. */
2544 printf (_("\n The File Name Table is empty.\n"));
2547 printf (_("\n The File Name Table:\n"));
2548 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2552 unsigned char *name;
2553 unsigned int bytes_read;
2555 printf (" %d\t", ++state_machine_regs.last_file_entry);
2558 data += strlen ((char *) data) + 1;
2561 dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2564 dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2567 dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2569 printf ("%s\n", name);
2573 /* Skip the NUL at the end of the table. */
2576 /* Now display the statements. */
2577 printf (_("\n Line Number Statements:\n"));
2579 while (data < end_of_sequence)
2581 unsigned char op_code;
2582 dwarf_signed_vma adv;
2584 unsigned int bytes_read;
2588 if (op_code >= linfo.li_opcode_base)
2590 op_code -= linfo.li_opcode_base;
2591 uladv = (op_code / linfo.li_line_range);
2592 if (linfo.li_max_ops_per_insn == 1)
2594 uladv *= linfo.li_min_insn_length;
2595 state_machine_regs.address += uladv;
2596 printf (_(" Special opcode %d: "
2597 "advance Address by %s to 0x%s"),
2598 op_code, dwarf_vmatoa ("u", uladv),
2599 dwarf_vmatoa ("x", state_machine_regs.address));
2603 state_machine_regs.address
2604 += ((state_machine_regs.op_index + uladv)
2605 / linfo.li_max_ops_per_insn)
2606 * linfo.li_min_insn_length;
2607 state_machine_regs.op_index
2608 = (state_machine_regs.op_index + uladv)
2609 % linfo.li_max_ops_per_insn;
2610 printf (_(" Special opcode %d: "
2611 "advance Address by %s to 0x%s[%d]"),
2612 op_code, dwarf_vmatoa ("u", uladv),
2613 dwarf_vmatoa ("x", state_machine_regs.address),
2614 state_machine_regs.op_index);
2616 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2617 state_machine_regs.line += adv;
2618 printf (_(" and Line by %s to %d\n"),
2619 dwarf_vmatoa ("d", adv), state_machine_regs.line);
2621 else switch (op_code)
2623 case DW_LNS_extended_op:
2624 data += process_extended_line_op (data, linfo.li_default_is_stmt);
2628 printf (_(" Copy\n"));
2631 case DW_LNS_advance_pc:
2632 uladv = read_leb128 (data, & bytes_read, 0);
2634 if (linfo.li_max_ops_per_insn == 1)
2636 uladv *= linfo.li_min_insn_length;
2637 state_machine_regs.address += uladv;
2638 printf (_(" Advance PC by %s to 0x%s\n"),
2639 dwarf_vmatoa ("u", uladv),
2640 dwarf_vmatoa ("x", state_machine_regs.address));
2644 state_machine_regs.address
2645 += ((state_machine_regs.op_index + uladv)
2646 / linfo.li_max_ops_per_insn)
2647 * linfo.li_min_insn_length;
2648 state_machine_regs.op_index
2649 = (state_machine_regs.op_index + uladv)
2650 % linfo.li_max_ops_per_insn;
2651 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
2652 dwarf_vmatoa ("u", uladv),
2653 dwarf_vmatoa ("x", state_machine_regs.address),
2654 state_machine_regs.op_index);
2658 case DW_LNS_advance_line:
2659 adv = read_sleb128 (data, & bytes_read);
2661 state_machine_regs.line += adv;
2662 printf (_(" Advance Line by %s to %d\n"),
2663 dwarf_vmatoa ("d", adv),
2664 state_machine_regs.line);
2667 case DW_LNS_set_file:
2668 adv = read_leb128 (data, & bytes_read, 0);
2670 printf (_(" Set File Name to entry %s in the File Name Table\n"),
2671 dwarf_vmatoa ("d", adv));
2672 state_machine_regs.file = adv;
2675 case DW_LNS_set_column:
2676 uladv = read_leb128 (data, & bytes_read, 0);
2678 printf (_(" Set column to %s\n"),
2679 dwarf_vmatoa ("u", uladv));
2680 state_machine_regs.column = uladv;
2683 case DW_LNS_negate_stmt:
2684 adv = state_machine_regs.is_stmt;
2686 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
2687 state_machine_regs.is_stmt = adv;
2690 case DW_LNS_set_basic_block:
2691 printf (_(" Set basic block\n"));
2692 state_machine_regs.basic_block = 1;
2695 case DW_LNS_const_add_pc:
2696 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2697 if (linfo.li_max_ops_per_insn)
2699 uladv *= linfo.li_min_insn_length;
2700 state_machine_regs.address += uladv;
2701 printf (_(" Advance PC by constant %s to 0x%s\n"),
2702 dwarf_vmatoa ("u", uladv),
2703 dwarf_vmatoa ("x", state_machine_regs.address));
2707 state_machine_regs.address
2708 += ((state_machine_regs.op_index + uladv)
2709 / linfo.li_max_ops_per_insn)
2710 * linfo.li_min_insn_length;
2711 state_machine_regs.op_index
2712 = (state_machine_regs.op_index + uladv)
2713 % linfo.li_max_ops_per_insn;
2714 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
2715 dwarf_vmatoa ("u", uladv),
2716 dwarf_vmatoa ("x", state_machine_regs.address),
2717 state_machine_regs.op_index);
2721 case DW_LNS_fixed_advance_pc:
2722 uladv = byte_get (data, 2);
2724 state_machine_regs.address += uladv;
2725 state_machine_regs.op_index = 0;
2726 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
2727 dwarf_vmatoa ("u", uladv),
2728 dwarf_vmatoa ("x", state_machine_regs.address));
2731 case DW_LNS_set_prologue_end:
2732 printf (_(" Set prologue_end to true\n"));
2735 case DW_LNS_set_epilogue_begin:
2736 printf (_(" Set epilogue_begin to true\n"));
2739 case DW_LNS_set_isa:
2740 uladv = read_leb128 (data, & bytes_read, 0);
2742 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
2746 printf (_(" Unknown opcode %d with operands: "), op_code);
2748 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2750 printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
2752 i == 1 ? "" : ", ");
2767 unsigned char *name;
2768 unsigned int directory_index;
2769 unsigned int modification_date;
2770 unsigned int length;
2773 /* Output a decoded representation of the .debug_line section. */
2776 display_debug_lines_decoded (struct dwarf_section *section,
2777 unsigned char *data,
2780 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2785 /* This loop amounts to one iteration per compilation unit. */
2786 DWARF2_Internal_LineInfo linfo;
2787 unsigned char *standard_opcodes;
2788 unsigned char *end_of_sequence;
2789 unsigned char *hdrptr;
2790 int initial_length_size;
2793 File_Entry *file_table = NULL;
2794 unsigned char **directory_table = NULL;
2798 /* Extract information from the Line Number Program Header.
2799 (section 6.2.4 in the Dwarf3 doc). */
2801 /* Get the length of this CU's line number information block. */
2802 linfo.li_length = byte_get (hdrptr, 4);
2805 if (linfo.li_length == 0xffffffff)
2807 /* This section is 64-bit DWARF 3. */
2808 linfo.li_length = byte_get (hdrptr, 8);
2811 initial_length_size = 12;
2816 initial_length_size = 4;
2819 if (linfo.li_length + initial_length_size > section->size)
2821 warn (_("The line info appears to be corrupt - "
2822 "the section is too small\n"));
2826 /* Get this CU's Line Number Block version number. */
2827 linfo.li_version = byte_get (hdrptr, 2);
2829 if (linfo.li_version != 2
2830 && linfo.li_version != 3
2831 && linfo.li_version != 4)
2833 warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2838 linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2839 hdrptr += offset_size;
2840 linfo.li_min_insn_length = byte_get (hdrptr, 1);
2842 if (linfo.li_version >= 4)
2844 linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2846 if (linfo.li_max_ops_per_insn == 0)
2848 warn (_("Invalid maximum operations per insn.\n"));
2853 linfo.li_max_ops_per_insn = 1;
2854 linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2856 linfo.li_line_base = byte_get (hdrptr, 1);
2858 linfo.li_line_range = byte_get (hdrptr, 1);
2860 linfo.li_opcode_base = byte_get (hdrptr, 1);
2863 /* Sign extend the line base field. */
2864 linfo.li_line_base <<= 24;
2865 linfo.li_line_base >>= 24;
2867 /* Find the end of this CU's Line Number Information Block. */
2868 end_of_sequence = data + linfo.li_length + initial_length_size;
2870 reset_state_machine (linfo.li_default_is_stmt);
2872 /* Save a pointer to the contents of the Opcodes table. */
2873 standard_opcodes = hdrptr;
2875 /* Traverse the Directory table just to count entries. */
2876 data = standard_opcodes + linfo.li_opcode_base - 1;
2879 unsigned int n_directories = 0;
2880 unsigned char *ptr_directory_table = data;
2884 data += strlen ((char *) data) + 1;
2888 /* Go through the directory table again to save the directories. */
2889 directory_table = (unsigned char **)
2890 xmalloc (n_directories * sizeof (unsigned char *));
2893 while (*ptr_directory_table != 0)
2895 directory_table[i] = ptr_directory_table;
2896 ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2900 /* Skip the NUL at the end of the table. */
2903 /* Traverse the File Name table just to count the entries. */
2906 unsigned int n_files = 0;
2907 unsigned char *ptr_file_name_table = data;
2911 unsigned int bytes_read;
2913 /* Skip Name, directory index, last modification time and length
2915 data += strlen ((char *) data) + 1;
2916 read_leb128 (data, & bytes_read, 0);
2918 read_leb128 (data, & bytes_read, 0);
2920 read_leb128 (data, & bytes_read, 0);
2926 /* Go through the file table again to save the strings. */
2927 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
2930 while (*ptr_file_name_table != 0)
2932 unsigned int bytes_read;
2934 file_table[i].name = ptr_file_name_table;
2935 ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2937 /* We are not interested in directory, time or size. */
2938 file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2940 ptr_file_name_table += bytes_read;
2941 file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2943 ptr_file_name_table += bytes_read;
2944 file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2945 ptr_file_name_table += bytes_read;
2950 /* Print the Compilation Unit's name and a header. */
2951 if (directory_table == NULL)
2953 printf (_("CU: %s:\n"), file_table[0].name);
2954 printf (_("File name Line number Starting address\n"));
2958 if (do_wide || strlen ((char *) directory_table[0]) < 76)
2959 printf (_("CU: %s/%s:\n"), directory_table[0],
2960 file_table[0].name);
2962 printf ("%s:\n", file_table[0].name);
2964 printf (_("File name Line number Starting address\n"));
2968 /* Skip the NUL at the end of the table. */
2971 /* This loop iterates through the Dwarf Line Number Program. */
2972 while (data < end_of_sequence)
2974 unsigned char op_code;
2976 unsigned long int uladv;
2977 unsigned int bytes_read;
2978 int is_special_opcode = 0;
2982 if (op_code >= linfo.li_opcode_base)
2984 op_code -= linfo.li_opcode_base;
2985 uladv = (op_code / linfo.li_line_range);
2986 if (linfo.li_max_ops_per_insn == 1)
2988 uladv *= linfo.li_min_insn_length;
2989 state_machine_regs.address += uladv;
2993 state_machine_regs.address
2994 += ((state_machine_regs.op_index + uladv)
2995 / linfo.li_max_ops_per_insn)
2996 * linfo.li_min_insn_length;
2997 state_machine_regs.op_index
2998 = (state_machine_regs.op_index + uladv)
2999 % linfo.li_max_ops_per_insn;
3002 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3003 state_machine_regs.line += adv;
3004 is_special_opcode = 1;
3006 else switch (op_code)
3008 case DW_LNS_extended_op:
3010 unsigned int ext_op_code_len;
3011 unsigned char ext_op_code;
3012 unsigned char *op_code_data = data;
3014 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
3015 op_code_data += bytes_read;
3017 if (ext_op_code_len == 0)
3019 warn (_("badly formed extended line op encountered!\n"));
3022 ext_op_code_len += bytes_read;
3023 ext_op_code = *op_code_data++;
3025 switch (ext_op_code)
3027 case DW_LNE_end_sequence:
3028 reset_state_machine (linfo.li_default_is_stmt);
3030 case DW_LNE_set_address:
3031 state_machine_regs.address =
3032 byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
3033 state_machine_regs.op_index = 0;
3035 case DW_LNE_define_file:
3037 unsigned int dir_index = 0;
3039 ++state_machine_regs.last_file_entry;
3040 op_code_data += strlen ((char *) op_code_data) + 1;
3041 dir_index = read_leb128 (op_code_data, & bytes_read, 0);
3042 op_code_data += bytes_read;
3043 read_leb128 (op_code_data, & bytes_read, 0);
3044 op_code_data += bytes_read;
3045 read_leb128 (op_code_data, & bytes_read, 0);
3047 printf ("%s:\n", directory_table[dir_index]);
3051 printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
3054 data += ext_op_code_len;
3060 case DW_LNS_advance_pc:
3061 uladv = read_leb128 (data, & bytes_read, 0);
3063 if (linfo.li_max_ops_per_insn == 1)
3065 uladv *= linfo.li_min_insn_length;
3066 state_machine_regs.address += uladv;
3070 state_machine_regs.address
3071 += ((state_machine_regs.op_index + uladv)
3072 / linfo.li_max_ops_per_insn)
3073 * linfo.li_min_insn_length;
3074 state_machine_regs.op_index
3075 = (state_machine_regs.op_index + uladv)
3076 % linfo.li_max_ops_per_insn;
3080 case DW_LNS_advance_line:
3081 adv = read_sleb128 (data, & bytes_read);
3083 state_machine_regs.line += adv;
3086 case DW_LNS_set_file:
3087 adv = read_leb128 (data, & bytes_read, 0);
3089 state_machine_regs.file = adv;
3090 if (file_table[state_machine_regs.file - 1].directory_index == 0)
3092 /* If directory index is 0, that means current directory. */
3093 printf ("\n./%s:[++]\n",
3094 file_table[state_machine_regs.file - 1].name);
3098 /* The directory index starts counting at 1. */
3099 printf ("\n%s/%s:\n",
3100 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3101 file_table[state_machine_regs.file - 1].name);
3105 case DW_LNS_set_column:
3106 uladv = read_leb128 (data, & bytes_read, 0);
3108 state_machine_regs.column = uladv;
3111 case DW_LNS_negate_stmt:
3112 adv = state_machine_regs.is_stmt;
3114 state_machine_regs.is_stmt = adv;
3117 case DW_LNS_set_basic_block:
3118 state_machine_regs.basic_block = 1;
3121 case DW_LNS_const_add_pc:
3122 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3123 if (linfo.li_max_ops_per_insn == 1)
3125 uladv *= linfo.li_min_insn_length;
3126 state_machine_regs.address += uladv;
3130 state_machine_regs.address
3131 += ((state_machine_regs.op_index + uladv)
3132 / linfo.li_max_ops_per_insn)
3133 * linfo.li_min_insn_length;
3134 state_machine_regs.op_index
3135 = (state_machine_regs.op_index + uladv)
3136 % linfo.li_max_ops_per_insn;
3140 case DW_LNS_fixed_advance_pc:
3141 uladv = byte_get (data, 2);
3143 state_machine_regs.address += uladv;
3144 state_machine_regs.op_index = 0;
3147 case DW_LNS_set_prologue_end:
3150 case DW_LNS_set_epilogue_begin:
3153 case DW_LNS_set_isa:
3154 uladv = read_leb128 (data, & bytes_read, 0);
3156 printf (_(" Set ISA to %lu\n"), uladv);
3160 printf (_(" Unknown opcode %d with operands: "), op_code);
3162 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3164 printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
3166 i == 1 ? "" : ", ");
3173 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3174 to the DWARF address/line matrix. */
3175 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3176 || (op_code == DW_LNS_copy))
3178 const unsigned int MAX_FILENAME_LENGTH = 35;
3179 char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
3180 char *newFileName = NULL;
3181 size_t fileNameLength = strlen (fileName);
3183 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3185 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3186 /* Truncate file name */
3187 strncpy (newFileName,
3188 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3189 MAX_FILENAME_LENGTH + 1);
3193 newFileName = (char *) xmalloc (fileNameLength + 1);
3194 strncpy (newFileName, fileName, fileNameLength + 1);
3197 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3199 if (linfo.li_max_ops_per_insn == 1)
3200 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n",
3201 newFileName, state_machine_regs.line,
3202 state_machine_regs.address);
3204 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3205 newFileName, state_machine_regs.line,
3206 state_machine_regs.address,
3207 state_machine_regs.op_index);
3211 if (linfo.li_max_ops_per_insn == 1)
3212 printf ("%s %11d %#18" DWARF_VMA_FMT "x\n",
3213 newFileName, state_machine_regs.line,
3214 state_machine_regs.address);
3216 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3217 newFileName, state_machine_regs.line,
3218 state_machine_regs.address,
3219 state_machine_regs.op_index);
3222 if (op_code == DW_LNE_end_sequence)
3230 free (directory_table);
3231 directory_table = NULL;
3239 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3241 unsigned char *data = section->start;
3242 unsigned char *end = data + section->size;
3244 int retValDecoded = 1;
3246 if (do_debug_lines == 0)
3247 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3249 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3250 retValRaw = display_debug_lines_raw (section, data, end);
3252 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3253 retValDecoded = display_debug_lines_decoded (section, data, end);
3255 if (!retValRaw || !retValDecoded)
3262 find_debug_info_for_offset (unsigned long offset)
3266 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3269 for (i = 0; i < num_debug_info_entries; i++)
3270 if (debug_information[i].cu_offset == offset)
3271 return debug_information + i;
3277 display_debug_pubnames (struct dwarf_section *section,
3278 void *file ATTRIBUTE_UNUSED)
3280 DWARF2_Internal_PubNames names;
3281 unsigned char *start = section->start;
3282 unsigned char *end = start + section->size;
3284 /* It does not matter if this load fails,
3285 we test for that later on. */
3286 load_debug_info (file);
3288 printf (_("Contents of the %s section:\n\n"), section->name);
3292 unsigned char *data;
3293 unsigned long offset;
3294 int offset_size, initial_length_size;
3298 names.pn_length = byte_get (data, 4);
3300 if (names.pn_length == 0xffffffff)
3302 names.pn_length = byte_get (data, 8);
3305 initial_length_size = 12;
3310 initial_length_size = 4;
3313 names.pn_version = byte_get (data, 2);
3316 names.pn_offset = byte_get (data, offset_size);
3317 data += offset_size;
3319 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3320 && num_debug_info_entries > 0
3321 && find_debug_info_for_offset (names.pn_offset) == NULL)
3322 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3323 (unsigned long) names.pn_offset, section->name);
3325 names.pn_size = byte_get (data, offset_size);
3326 data += offset_size;
3328 start += names.pn_length + initial_length_size;
3330 if (names.pn_version != 2 && names.pn_version != 3)
3332 static int warned = 0;
3336 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3343 printf (_(" Length: %ld\n"),
3344 (long) names.pn_length);
3345 printf (_(" Version: %d\n"),
3347 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3348 (unsigned long) names.pn_offset);
3349 printf (_(" Size of area in .debug_info section: %ld\n"),
3350 (long) names.pn_size);
3352 printf (_("\n Offset\tName\n"));
3356 offset = byte_get (data, offset_size);
3360 data += offset_size;
3361 printf (" %-6lx\t%s\n", offset, data);
3362 data += strlen ((char *) data) + 1;
3365 while (offset != 0);
3373 display_debug_macinfo (struct dwarf_section *section,
3374 void *file ATTRIBUTE_UNUSED)
3376 unsigned char *start = section->start;
3377 unsigned char *end = start + section->size;
3378 unsigned char *curr = start;
3379 unsigned int bytes_read;
3380 enum dwarf_macinfo_record_type op;
3382 printf (_("Contents of the %s section:\n\n"), section->name);
3386 unsigned int lineno;
3389 op = (enum dwarf_macinfo_record_type) *curr;
3394 case DW_MACINFO_start_file:
3396 unsigned int filenum;
3398 lineno = read_leb128 (curr, & bytes_read, 0);
3400 filenum = read_leb128 (curr, & bytes_read, 0);
3403 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3408 case DW_MACINFO_end_file:
3409 printf (_(" DW_MACINFO_end_file\n"));
3412 case DW_MACINFO_define:
3413 lineno = read_leb128 (curr, & bytes_read, 0);
3415 string = (char *) curr;
3416 curr += strlen (string) + 1;
3417 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3421 case DW_MACINFO_undef:
3422 lineno = read_leb128 (curr, & bytes_read, 0);
3424 string = (char *) curr;
3425 curr += strlen (string) + 1;
3426 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3430 case DW_MACINFO_vendor_ext:
3432 unsigned int constant;
3434 constant = read_leb128 (curr, & bytes_read, 0);
3436 string = (char *) curr;
3437 curr += strlen (string) + 1;
3438 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3449 display_debug_abbrev (struct dwarf_section *section,
3450 void *file ATTRIBUTE_UNUSED)
3452 abbrev_entry *entry;
3453 unsigned char *start = section->start;
3454 unsigned char *end = start + section->size;
3456 printf (_("Contents of the %s section:\n\n"), section->name);
3462 start = process_abbrev_section (start, end);
3464 if (first_abbrev == NULL)
3467 printf (_(" Number TAG\n"));
3469 for (entry = first_abbrev; entry; entry = entry->next)
3473 printf (" %ld %s [%s]\n",
3475 get_TAG_name (entry->tag),
3476 entry->children ? _("has children") : _("no children"));
3478 for (attr = entry->first_attr; attr; attr = attr->next)
3479 printf (" %-18s %s\n",
3480 get_AT_name (attr->attribute),
3481 get_FORM_name (attr->form));
3491 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
3493 static dwarf_vma *loc_offsets;
3496 loc_offsets_compar (const void *ap, const void *bp)
3498 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
3499 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
3501 return (a > b) - (b > a);
3505 display_debug_loc (struct dwarf_section *section, void *file)
3507 unsigned char *start = section->start;
3508 unsigned char *section_end;
3509 unsigned long bytes;
3510 unsigned char *section_begin = start;
3511 unsigned int num_loc_list = 0;
3512 unsigned long last_offset = 0;
3513 unsigned int first = 0;
3517 int seen_first_offset = 0;
3518 int locs_sorted = 1;
3519 unsigned char *next;
3520 unsigned int *array = NULL;
3522 bytes = section->size;
3523 section_end = start + bytes;
3527 printf (_("\nThe %s section is empty.\n"), section->name);
3531 if (load_debug_info (file) == 0)
3533 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3538 /* Check the order of location list in .debug_info section. If
3539 offsets of location lists are in the ascending order, we can
3540 use `debug_information' directly. */
3541 for (i = 0; i < num_debug_info_entries; i++)
3545 num = debug_information [i].num_loc_offsets;
3546 if (num > num_loc_list)
3549 /* Check if we can use `debug_information' directly. */
3550 if (locs_sorted && num != 0)
3552 if (!seen_first_offset)
3554 /* This is the first location list. */
3555 last_offset = debug_information [i].loc_offsets [0];
3557 seen_first_offset = 1;
3563 for (; j < num; j++)
3566 debug_information [i].loc_offsets [j])
3571 last_offset = debug_information [i].loc_offsets [j];
3576 if (!seen_first_offset)
3577 error (_("No location lists in .debug_info section!\n"));
3579 /* DWARF sections under Mach-O have non-zero addresses. */
3580 if (debug_information [first].num_loc_offsets > 0
3581 && debug_information [first].loc_offsets [0] != section->address)
3582 warn (_("Location lists in %s section start at 0x%s\n"),
3584 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
3587 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
3588 printf (_("Contents of the %s section:\n\n"), section->name);
3589 printf (_(" Offset Begin End Expression\n"));
3591 seen_first_offset = 0;
3592 for (i = first; i < num_debug_info_entries; i++)
3596 unsigned short length;
3597 unsigned long offset;
3598 unsigned int pointer_size;
3599 unsigned int offset_size;
3601 unsigned long cu_offset;
3602 unsigned long base_address;
3603 int need_frame_base;
3606 pointer_size = debug_information [i].pointer_size;
3607 cu_offset = debug_information [i].cu_offset;
3608 offset_size = debug_information [i].offset_size;
3609 dwarf_version = debug_information [i].dwarf_version;
3612 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
3614 loc_offsets = debug_information [i].loc_offsets;
3615 qsort (array, debug_information [i].num_loc_offsets,
3616 sizeof (*array), loc_offsets_compar);
3619 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
3621 j = locs_sorted ? k : array[k];
3623 && debug_information [i].loc_offsets [locs_sorted
3624 ? k - 1 : array [k - 1]]
3625 == debug_information [i].loc_offsets [j])
3627 has_frame_base = debug_information [i].have_frame_base [j];
3628 /* DWARF sections under Mach-O have non-zero addresses. */
3629 offset = debug_information [i].loc_offsets [j] - section->address;
3630 next = section_begin + offset;
3631 base_address = debug_information [i].base_address;
3633 if (!seen_first_offset)
3634 seen_first_offset = 1;
3638 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3639 (unsigned long) (start - section_begin),
3640 (unsigned long) (next - section_begin));
3641 else if (start > next)
3642 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3643 (unsigned long) (start - section_begin),
3644 (unsigned long) (next - section_begin));
3648 if (offset >= bytes)
3650 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3657 if (start + 2 * pointer_size > section_end)
3659 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3664 /* Note: we use sign extension here in order to be sure that
3665 we can detect the -1 escape value. Sign extension into the
3666 top 32 bits of a 32-bit address will not affect the values
3667 that we display since we always show hex values, and always
3668 the bottom 32-bits. */
3669 begin = byte_get_signed (start, pointer_size);
3670 start += pointer_size;
3671 end = byte_get_signed (start, pointer_size);
3672 start += pointer_size;
3674 printf (" %8.8lx ", offset);
3676 if (begin == 0 && end == 0)
3678 printf (_("<End of list>\n"));
3682 /* Check base address specifiers. */
3683 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3686 print_dwarf_vma (begin, pointer_size);
3687 print_dwarf_vma (end, pointer_size);
3688 printf (_("(base address)\n"));
3692 if (start + 2 > section_end)
3694 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3699 length = byte_get (start, 2);
3702 if (start + length > section_end)
3704 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3709 print_dwarf_vma (begin + base_address, pointer_size);
3710 print_dwarf_vma (end + base_address, pointer_size);
3713 need_frame_base = decode_location_expression (start,
3718 cu_offset, section);
3721 if (need_frame_base && !has_frame_base)
3722 printf (_(" [without DW_AT_frame_base]"));
3725 fputs (_(" (start == end)"), stdout);
3726 else if (begin > end)
3727 fputs (_(" (start > end)"), stdout);
3736 if (start < section_end)
3737 warn (_("There are %ld unused bytes at the end of section %s\n"),
3738 (long) (section_end - start), section->name);
3745 display_debug_str (struct dwarf_section *section,
3746 void *file ATTRIBUTE_UNUSED)
3748 unsigned char *start = section->start;
3749 unsigned long bytes = section->size;
3750 dwarf_vma addr = section->address;
3754 printf (_("\nThe %s section is empty.\n"), section->name);
3758 printf (_("Contents of the %s section:\n\n"), section->name);
3766 lbytes = (bytes > 16 ? 16 : bytes);
3768 printf (" 0x%8.8lx ", (unsigned long) addr);
3770 for (j = 0; j < 16; j++)
3773 printf ("%2.2x", start[j]);
3781 for (j = 0; j < lbytes; j++)
3784 if (k >= ' ' && k < 0x80)
3803 display_debug_info (struct dwarf_section *section, void *file)
3805 return process_debug_info (section, file, abbrev, 0, 0);
3809 display_debug_types (struct dwarf_section *section, void *file)
3811 return process_debug_info (section, file, abbrev, 0, 1);
3815 display_trace_info (struct dwarf_section *section, void *file)
3817 return process_debug_info (section, file, trace_abbrev, 0, 0);
3821 display_debug_aranges (struct dwarf_section *section,
3822 void *file ATTRIBUTE_UNUSED)
3824 unsigned char *start = section->start;
3825 unsigned char *end = start + section->size;
3827 printf (_("Contents of the %s section:\n\n"), section->name);
3829 /* It does not matter if this load fails,
3830 we test for that later on. */
3831 load_debug_info (file);
3835 unsigned char *hdrptr;
3836 DWARF2_Internal_ARange arange;
3837 unsigned char *addr_ranges;
3840 unsigned char address_size;
3843 int initial_length_size;
3847 arange.ar_length = byte_get (hdrptr, 4);
3850 if (arange.ar_length == 0xffffffff)
3852 arange.ar_length = byte_get (hdrptr, 8);
3855 initial_length_size = 12;
3860 initial_length_size = 4;
3863 arange.ar_version = byte_get (hdrptr, 2);
3866 arange.ar_info_offset = byte_get (hdrptr, offset_size);
3867 hdrptr += offset_size;
3869 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3870 && num_debug_info_entries > 0
3871 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
3872 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3873 (unsigned long) arange.ar_info_offset, section->name);
3875 arange.ar_pointer_size = byte_get (hdrptr, 1);
3878 arange.ar_segment_size = byte_get (hdrptr, 1);
3881 if (arange.ar_version != 2 && arange.ar_version != 3)
3883 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3887 printf (_(" Length: %ld\n"),
3888 (long) arange.ar_length);
3889 printf (_(" Version: %d\n"), arange.ar_version);
3890 printf (_(" Offset into .debug_info: 0x%lx\n"),
3891 (unsigned long) arange.ar_info_offset);
3892 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
3893 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
3895 address_size = arange.ar_pointer_size + arange.ar_segment_size;
3897 /* The DWARF spec does not require that the address size be a power
3898 of two, but we do. This will have to change if we ever encounter
3899 an uneven architecture. */
3900 if ((address_size & (address_size - 1)) != 0)
3902 warn (_("Pointer size + Segment size is not a power of two.\n"));
3906 if (address_size > 4)
3907 printf (_("\n Address Length\n"));
3909 printf (_("\n Address Length\n"));
3911 addr_ranges = hdrptr;
3913 /* Must pad to an alignment boundary that is twice the address size. */
3914 excess = (hdrptr - start) % (2 * address_size);
3916 addr_ranges += (2 * address_size) - excess;
3918 start += arange.ar_length + initial_length_size;
3920 while (addr_ranges + 2 * address_size <= start)
3922 address = byte_get (addr_ranges, address_size);
3924 addr_ranges += address_size;
3926 length = byte_get (addr_ranges, address_size);
3928 addr_ranges += address_size;
3931 print_dwarf_vma (address, address_size);
3932 print_dwarf_vma (length, address_size);
3942 /* Each debug_information[x].range_lists[y] gets this representation for
3943 sorting purposes. */
3947 /* The debug_information[x].range_lists[y] value. */
3948 unsigned long ranges_offset;
3950 /* Original debug_information to find parameters of the data. */
3951 debug_info *debug_info_p;
3954 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
3957 range_entry_compar (const void *ap, const void *bp)
3959 const struct range_entry *a_re = (const struct range_entry *) ap;
3960 const struct range_entry *b_re = (const struct range_entry *) bp;
3961 const unsigned long a = a_re->ranges_offset;
3962 const unsigned long b = b_re->ranges_offset;
3964 return (a > b) - (b > a);
3968 display_debug_ranges (struct dwarf_section *section,
3969 void *file ATTRIBUTE_UNUSED)
3971 unsigned char *start = section->start;
3972 unsigned long bytes;
3973 unsigned char *section_begin = start;
3974 unsigned int num_range_list, i;
3975 struct range_entry *range_entries, *range_entry_fill;
3977 bytes = section->size;
3981 printf (_("\nThe %s section is empty.\n"), section->name);
3985 if (load_debug_info (file) == 0)
3987 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3993 for (i = 0; i < num_debug_info_entries; i++)
3994 num_range_list += debug_information [i].num_range_lists;
3996 if (num_range_list == 0)
3997 error (_("No range lists in .debug_info section!\n"));
3999 range_entries = (struct range_entry *)
4000 xmalloc (sizeof (*range_entries) * num_range_list);
4001 range_entry_fill = range_entries;
4003 for (i = 0; i < num_debug_info_entries; i++)
4005 debug_info *debug_info_p = &debug_information[i];
4008 for (j = 0; j < debug_info_p->num_range_lists; j++)
4010 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
4011 range_entry_fill->debug_info_p = debug_info_p;
4016 qsort (range_entries, num_range_list, sizeof (*range_entries),
4017 range_entry_compar);
4019 /* DWARF sections under Mach-O have non-zero addresses. */
4020 if (range_entries[0].ranges_offset != section->address)
4021 warn (_("Range lists in %s section start at 0x%lx\n"),
4022 section->name, range_entries[0].ranges_offset);
4024 printf (_("Contents of the %s section:\n\n"), section->name);
4025 printf (_(" Offset Begin End\n"));
4027 for (i = 0; i < num_range_list; i++)
4029 struct range_entry *range_entry = &range_entries[i];
4030 debug_info *debug_info_p = range_entry->debug_info_p;
4031 unsigned int pointer_size;
4032 unsigned long offset;
4033 unsigned char *next;
4034 unsigned long base_address;
4036 pointer_size = debug_info_p->pointer_size;
4038 /* DWARF sections under Mach-O have non-zero addresses. */
4039 offset = range_entry->ranges_offset - section->address;
4040 next = section_begin + offset;
4041 base_address = debug_info_p->base_address;
4046 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4047 (unsigned long) (start - section_begin),
4048 (unsigned long) (next - section_begin), section->name);
4049 else if (start > next)
4050 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4051 (unsigned long) (start - section_begin),
4052 (unsigned long) (next - section_begin), section->name);
4061 /* Note: we use sign extension here in order to be sure that
4062 we can detect the -1 escape value. Sign extension into the
4063 top 32 bits of a 32-bit address will not affect the values
4064 that we display since we always show hex values, and always
4065 the bottom 32-bits. */
4066 begin = byte_get_signed (start, pointer_size);
4067 start += pointer_size;
4068 end = byte_get_signed (start, pointer_size);
4069 start += pointer_size;
4071 printf (" %8.8lx ", offset);
4073 if (begin == 0 && end == 0)
4075 printf (_("<End of list>\n"));
4079 /* Check base address specifiers. */
4080 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4083 print_dwarf_vma (begin, pointer_size);
4084 print_dwarf_vma (end, pointer_size);
4085 printf ("(base address)\n");
4089 print_dwarf_vma (begin + base_address, pointer_size);
4090 print_dwarf_vma (end + base_address, pointer_size);
4093 fputs (_("(start == end)"), stdout);
4094 else if (begin > end)
4095 fputs (_("(start > end)"), stdout);
4102 free (range_entries);
4107 typedef struct Frame_Chunk
4109 struct Frame_Chunk *next;
4110 unsigned char *chunk_start;
4112 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
4113 short int *col_type;
4116 unsigned int code_factor;
4118 unsigned long pc_begin;
4119 unsigned long pc_range;
4123 unsigned char fde_encoding;
4124 unsigned char cfa_exp;
4125 unsigned char ptr_size;
4126 unsigned char segment_size;
4130 static const char *const *dwarf_regnames;
4131 static unsigned int dwarf_regnames_count;
4133 /* A marker for a col_type that means this column was never referenced
4134 in the frame info. */
4135 #define DW_CFA_unreferenced (-1)
4137 /* Return 0 if not more space is needed, 1 if more space is needed,
4138 -1 for invalid reg. */
4141 frame_need_space (Frame_Chunk *fc, unsigned int reg)
4143 int prev = fc->ncols;
4145 if (reg < (unsigned int) fc->ncols)
4148 if (dwarf_regnames_count
4149 && reg > dwarf_regnames_count)
4152 fc->ncols = reg + 1;
4153 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
4154 sizeof (short int));
4155 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
4157 while (prev < fc->ncols)
4159 fc->col_type[prev] = DW_CFA_unreferenced;
4160 fc->col_offset[prev] = 0;
4166 static const char *const dwarf_regnames_i386[] =
4168 "eax", "ecx", "edx", "ebx",
4169 "esp", "ebp", "esi", "edi",
4170 "eip", "eflags", NULL,
4171 "st0", "st1", "st2", "st3",
4172 "st4", "st5", "st6", "st7",
4174 "xmm0", "xmm1", "xmm2", "xmm3",
4175 "xmm4", "xmm5", "xmm6", "xmm7",
4176 "mm0", "mm1", "mm2", "mm3",
4177 "mm4", "mm5", "mm6", "mm7",
4178 "fcw", "fsw", "mxcsr",
4179 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4184 init_dwarf_regnames_i386 (void)
4186 dwarf_regnames = dwarf_regnames_i386;
4187 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
4190 static const char *const dwarf_regnames_x86_64[] =
4192 "rax", "rdx", "rcx", "rbx",
4193 "rsi", "rdi", "rbp", "rsp",
4194 "r8", "r9", "r10", "r11",
4195 "r12", "r13", "r14", "r15",
4197 "xmm0", "xmm1", "xmm2", "xmm3",
4198 "xmm4", "xmm5", "xmm6", "xmm7",
4199 "xmm8", "xmm9", "xmm10", "xmm11",
4200 "xmm12", "xmm13", "xmm14", "xmm15",
4201 "st0", "st1", "st2", "st3",
4202 "st4", "st5", "st6", "st7",
4203 "mm0", "mm1", "mm2", "mm3",
4204 "mm4", "mm5", "mm6", "mm7",
4206 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4207 "fs.base", "gs.base", NULL, NULL,
4209 "mxcsr", "fcw", "fsw"
4213 init_dwarf_regnames_x86_64 (void)
4215 dwarf_regnames = dwarf_regnames_x86_64;
4216 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
4220 init_dwarf_regnames (unsigned int e_machine)
4226 init_dwarf_regnames_i386 ();
4231 init_dwarf_regnames_x86_64 ();
4240 regname (unsigned int regno, int row)
4242 static char reg[64];
4244 && regno < dwarf_regnames_count
4245 && dwarf_regnames [regno] != NULL)
4248 return dwarf_regnames [regno];
4249 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
4250 dwarf_regnames [regno]);
4253 snprintf (reg, sizeof (reg), "r%d", regno);
4258 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
4263 if (*max_regs < fc->ncols)
4264 *max_regs = fc->ncols;
4266 if (*need_col_headers)
4268 static const char *sloc = " LOC";
4270 *need_col_headers = 0;
4272 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
4274 for (r = 0; r < *max_regs; r++)
4275 if (fc->col_type[r] != DW_CFA_unreferenced)
4280 printf ("%-5s ", regname (r, 1));
4286 printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
4288 strcpy (tmp, "exp");
4290 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
4291 printf ("%-8s ", tmp);
4293 for (r = 0; r < fc->ncols; r++)
4295 if (fc->col_type[r] != DW_CFA_unreferenced)
4297 switch (fc->col_type[r])
4299 case DW_CFA_undefined:
4302 case DW_CFA_same_value:
4306 sprintf (tmp, "c%+d", fc->col_offset[r]);
4308 case DW_CFA_val_offset:
4309 sprintf (tmp, "v%+d", fc->col_offset[r]);
4311 case DW_CFA_register:
4312 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
4314 case DW_CFA_expression:
4315 strcpy (tmp, "exp");
4317 case DW_CFA_val_expression:
4318 strcpy (tmp, "vexp");
4321 strcpy (tmp, "n/a");
4324 printf ("%-5s ", tmp);
4330 #define GET(N) byte_get (start, N); start += N
4331 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
4332 #define SLEB() read_sleb128 (start, & length_return); start += length_return
4335 display_debug_frames (struct dwarf_section *section,
4336 void *file ATTRIBUTE_UNUSED)
4338 unsigned char *start = section->start;
4339 unsigned char *end = start + section->size;
4340 unsigned char *section_start = start;
4341 Frame_Chunk *chunks = 0;
4342 Frame_Chunk *remembered_state = 0;
4344 int is_eh = strcmp (section->name, ".eh_frame") == 0;
4345 unsigned int length_return;
4347 const char *bad_reg = _("bad register: ");
4348 int saved_eh_addr_size = eh_addr_size;
4350 printf (_("Contents of the %s section:\n"), section->name);
4354 unsigned char *saved_start;
4355 unsigned char *block_end;
4356 unsigned long length;
4357 unsigned long cie_id;
4360 int need_col_headers = 1;
4361 unsigned char *augmentation_data = NULL;
4362 unsigned long augmentation_data_len = 0;
4363 int encoded_ptr_size = saved_eh_addr_size;
4365 int initial_length_size;
4367 saved_start = start;
4368 length = byte_get (start, 4); start += 4;
4372 printf ("\n%08lx ZERO terminator\n\n",
4373 (unsigned long)(saved_start - section_start));
4377 if (length == 0xffffffff)
4379 length = byte_get (start, 8);
4382 initial_length_size = 12;
4387 initial_length_size = 4;
4390 block_end = saved_start + length + initial_length_size;
4391 if (block_end > end)
4393 warn ("Invalid length %#08lx in FDE at %#08lx\n",
4394 length, (unsigned long)(saved_start - section_start));
4397 cie_id = byte_get (start, offset_size); start += offset_size;
4399 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
4403 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4404 memset (fc, 0, sizeof (Frame_Chunk));
4408 fc->chunk_start = saved_start;
4410 fc->col_type = (short int *) xmalloc (sizeof (short int));
4411 fc->col_offset = (int *) xmalloc (sizeof (int));
4412 frame_need_space (fc, max_regs - 1);
4416 fc->augmentation = (char *) start;
4417 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
4419 if (strcmp (fc->augmentation, "eh") == 0)
4420 start += eh_addr_size;
4424 fc->ptr_size = GET (1);
4425 fc->segment_size = GET (1);
4426 eh_addr_size = fc->ptr_size;
4430 fc->ptr_size = eh_addr_size;
4431 fc->segment_size = 0;
4433 fc->code_factor = LEB ();
4434 fc->data_factor = SLEB ();
4444 if (fc->augmentation[0] == 'z')
4446 augmentation_data_len = LEB ();
4447 augmentation_data = start;
4448 start += augmentation_data_len;
4452 if (do_debug_frames_interp)
4453 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4454 (unsigned long)(saved_start - section_start), length, cie_id,
4455 fc->augmentation, fc->code_factor, fc->data_factor,
4459 printf ("\n%08lx %08lx %08lx CIE\n",
4460 (unsigned long)(saved_start - section_start), length, cie_id);
4461 printf (" Version: %d\n", version);
4462 printf (" Augmentation: \"%s\"\n", fc->augmentation);
4465 printf (" Pointer Size: %u\n", fc->ptr_size);
4466 printf (" Segment Size: %u\n", fc->segment_size);
4468 printf (" Code alignment factor: %u\n", fc->code_factor);
4469 printf (" Data alignment factor: %d\n", fc->data_factor);
4470 printf (" Return address column: %d\n", fc->ra);
4472 if (augmentation_data_len)
4475 printf (" Augmentation data: ");
4476 for (i = 0; i < augmentation_data_len; ++i)
4477 printf (" %02x", augmentation_data[i]);
4483 if (augmentation_data_len)
4485 unsigned char *p, *q;
4486 p = (unsigned char *) fc->augmentation + 1;
4487 q = augmentation_data;
4494 q += 1 + size_of_encoded_value (*q);
4496 fc->fde_encoding = *q++;
4504 if (fc->fde_encoding)
4505 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4508 frame_need_space (fc, fc->ra);
4512 unsigned char *look_for;
4513 static Frame_Chunk fde_fc;
4514 unsigned long segment_selector;
4517 memset (fc, 0, sizeof (Frame_Chunk));
4519 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4521 for (cie = chunks; cie ; cie = cie->next)
4522 if (cie->chunk_start == look_for)
4527 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4528 cie_id, (unsigned long)(saved_start - section_start));
4530 fc->col_type = (short int *) xmalloc (sizeof (short int));
4531 fc->col_offset = (int *) xmalloc (sizeof (int));
4532 frame_need_space (fc, max_regs - 1);
4534 fc->augmentation = "";
4535 fc->fde_encoding = 0;
4536 fc->ptr_size = eh_addr_size;
4537 fc->segment_size = 0;
4541 fc->ncols = cie->ncols;
4542 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
4543 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
4544 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4545 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4546 fc->augmentation = cie->augmentation;
4547 fc->ptr_size = cie->ptr_size;
4548 eh_addr_size = cie->ptr_size;
4549 fc->segment_size = cie->segment_size;
4550 fc->code_factor = cie->code_factor;
4551 fc->data_factor = cie->data_factor;
4552 fc->cfa_reg = cie->cfa_reg;
4553 fc->cfa_offset = cie->cfa_offset;
4555 frame_need_space (fc, max_regs - 1);
4556 fc->fde_encoding = cie->fde_encoding;
4559 if (fc->fde_encoding)
4560 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4562 segment_selector = 0;
4563 if (fc->segment_size)
4565 segment_selector = byte_get (start, fc->segment_size);
4566 start += fc->segment_size;
4568 fc->pc_begin = get_encoded_value (start, fc->fde_encoding, section);
4569 start += encoded_ptr_size;
4570 fc->pc_range = byte_get (start, encoded_ptr_size);
4571 start += encoded_ptr_size;
4573 if (cie->augmentation[0] == 'z')
4575 augmentation_data_len = LEB ();
4576 augmentation_data = start;
4577 start += augmentation_data_len;
4580 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
4581 (unsigned long)(saved_start - section_start), length, cie_id,
4582 (unsigned long)(cie->chunk_start - section_start));
4583 if (fc->segment_size)
4584 printf ("%04lx:", segment_selector);
4585 printf ("%08lx..%08lx\n", fc->pc_begin, fc->pc_begin + fc->pc_range);
4586 if (! do_debug_frames_interp && augmentation_data_len)
4590 printf (" Augmentation data: ");
4591 for (i = 0; i < augmentation_data_len; ++i)
4592 printf (" %02x", augmentation_data[i]);
4598 /* At this point, fc is the current chunk, cie (if any) is set, and
4599 we're about to interpret instructions for the chunk. */
4600 /* ??? At present we need to do this always, since this sizes the
4601 fc->col_type and fc->col_offset arrays, which we write into always.
4602 We should probably split the interpreted and non-interpreted bits
4603 into two different routines, since there's so much that doesn't
4604 really overlap between them. */
4605 if (1 || do_debug_frames_interp)
4607 /* Start by making a pass over the chunk, allocating storage
4608 and taking note of what registers are used. */
4609 unsigned char *tmp = start;
4611 while (start < block_end)
4614 unsigned long reg, temp;
4621 /* Warning: if you add any more cases to this switch, be
4622 sure to add them to the corresponding switch below. */
4625 case DW_CFA_advance_loc:
4629 if (frame_need_space (fc, opa) >= 0)
4630 fc->col_type[opa] = DW_CFA_undefined;
4632 case DW_CFA_restore:
4633 if (frame_need_space (fc, opa) >= 0)
4634 fc->col_type[opa] = DW_CFA_undefined;
4636 case DW_CFA_set_loc:
4637 start += encoded_ptr_size;
4639 case DW_CFA_advance_loc1:
4642 case DW_CFA_advance_loc2:
4645 case DW_CFA_advance_loc4:
4648 case DW_CFA_offset_extended:
4649 case DW_CFA_val_offset:
4650 reg = LEB (); LEB ();
4651 if (frame_need_space (fc, reg) >= 0)
4652 fc->col_type[reg] = DW_CFA_undefined;
4654 case DW_CFA_restore_extended:
4656 frame_need_space (fc, reg);
4657 if (frame_need_space (fc, reg) >= 0)
4658 fc->col_type[reg] = DW_CFA_undefined;
4660 case DW_CFA_undefined:
4662 if (frame_need_space (fc, reg) >= 0)
4663 fc->col_type[reg] = DW_CFA_undefined;
4665 case DW_CFA_same_value:
4667 if (frame_need_space (fc, reg) >= 0)
4668 fc->col_type[reg] = DW_CFA_undefined;
4670 case DW_CFA_register:
4671 reg = LEB (); LEB ();
4672 if (frame_need_space (fc, reg) >= 0)
4673 fc->col_type[reg] = DW_CFA_undefined;
4675 case DW_CFA_def_cfa:
4678 case DW_CFA_def_cfa_register:
4681 case DW_CFA_def_cfa_offset:
4684 case DW_CFA_def_cfa_expression:
4688 case DW_CFA_expression:
4689 case DW_CFA_val_expression:
4693 if (frame_need_space (fc, reg) >= 0)
4694 fc->col_type[reg] = DW_CFA_undefined;
4696 case DW_CFA_offset_extended_sf:
4697 case DW_CFA_val_offset_sf:
4698 reg = LEB (); SLEB ();
4699 if (frame_need_space (fc, reg) >= 0)
4700 fc->col_type[reg] = DW_CFA_undefined;
4702 case DW_CFA_def_cfa_sf:
4705 case DW_CFA_def_cfa_offset_sf:
4708 case DW_CFA_MIPS_advance_loc8:
4711 case DW_CFA_GNU_args_size:
4714 case DW_CFA_GNU_negative_offset_extended:
4715 reg = LEB (); LEB ();
4716 if (frame_need_space (fc, reg) >= 0)
4717 fc->col_type[reg] = DW_CFA_undefined;
4726 /* Now we know what registers are used, make a second pass over
4727 the chunk, this time actually printing out the info. */
4729 while (start < block_end)
4732 unsigned long ul, reg, roffs;
4735 const char *reg_prefix = "";
4742 /* Warning: if you add any more cases to this switch, be
4743 sure to add them to the corresponding switch above. */
4746 case DW_CFA_advance_loc:
4747 if (do_debug_frames_interp)
4748 frame_display_row (fc, &need_col_headers, &max_regs);
4750 printf (" DW_CFA_advance_loc: %d to %08lx\n",
4751 opa * fc->code_factor,
4752 fc->pc_begin + opa * fc->code_factor);
4753 fc->pc_begin += opa * fc->code_factor;
4758 if (opa >= (unsigned int) fc->ncols)
4759 reg_prefix = bad_reg;
4760 if (! do_debug_frames_interp || *reg_prefix != '\0')
4761 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
4762 reg_prefix, regname (opa, 0),
4763 roffs * fc->data_factor);
4764 if (*reg_prefix == '\0')
4766 fc->col_type[opa] = DW_CFA_offset;
4767 fc->col_offset[opa] = roffs * fc->data_factor;
4771 case DW_CFA_restore:
4772 if (opa >= (unsigned int) cie->ncols
4773 || opa >= (unsigned int) fc->ncols)
4774 reg_prefix = bad_reg;
4775 if (! do_debug_frames_interp || *reg_prefix != '\0')
4776 printf (" DW_CFA_restore: %s%s\n",
4777 reg_prefix, regname (opa, 0));
4778 if (*reg_prefix == '\0')
4780 fc->col_type[opa] = cie->col_type[opa];
4781 fc->col_offset[opa] = cie->col_offset[opa];
4785 case DW_CFA_set_loc:
4786 vma = get_encoded_value (start, fc->fde_encoding, section);
4787 start += encoded_ptr_size;
4788 if (do_debug_frames_interp)
4789 frame_display_row (fc, &need_col_headers, &max_regs);
4791 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
4795 case DW_CFA_advance_loc1:
4796 ofs = byte_get (start, 1); start += 1;
4797 if (do_debug_frames_interp)
4798 frame_display_row (fc, &need_col_headers, &max_regs);
4800 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
4801 ofs * fc->code_factor,
4802 fc->pc_begin + ofs * fc->code_factor);
4803 fc->pc_begin += ofs * fc->code_factor;
4806 case DW_CFA_advance_loc2:
4807 ofs = byte_get (start, 2); start += 2;
4808 if (do_debug_frames_interp)
4809 frame_display_row (fc, &need_col_headers, &max_regs);
4811 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
4812 ofs * fc->code_factor,
4813 fc->pc_begin + ofs * fc->code_factor);
4814 fc->pc_begin += ofs * fc->code_factor;
4817 case DW_CFA_advance_loc4:
4818 ofs = byte_get (start, 4); start += 4;
4819 if (do_debug_frames_interp)
4820 frame_display_row (fc, &need_col_headers, &max_regs);
4822 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
4823 ofs * fc->code_factor,
4824 fc->pc_begin + ofs * fc->code_factor);
4825 fc->pc_begin += ofs * fc->code_factor;
4828 case DW_CFA_offset_extended:
4831 if (reg >= (unsigned int) fc->ncols)
4832 reg_prefix = bad_reg;
4833 if (! do_debug_frames_interp || *reg_prefix != '\0')
4834 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4835 reg_prefix, regname (reg, 0),
4836 roffs * fc->data_factor);
4837 if (*reg_prefix == '\0')
4839 fc->col_type[reg] = DW_CFA_offset;
4840 fc->col_offset[reg] = roffs * fc->data_factor;
4844 case DW_CFA_val_offset:
4847 if (reg >= (unsigned int) fc->ncols)
4848 reg_prefix = bad_reg;
4849 if (! do_debug_frames_interp || *reg_prefix != '\0')
4850 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
4851 reg_prefix, regname (reg, 0),
4852 roffs * fc->data_factor);
4853 if (*reg_prefix == '\0')
4855 fc->col_type[reg] = DW_CFA_val_offset;
4856 fc->col_offset[reg] = roffs * fc->data_factor;
4860 case DW_CFA_restore_extended:
4862 if (reg >= (unsigned int) cie->ncols
4863 || reg >= (unsigned int) fc->ncols)
4864 reg_prefix = bad_reg;
4865 if (! do_debug_frames_interp || *reg_prefix != '\0')
4866 printf (" DW_CFA_restore_extended: %s%s\n",
4867 reg_prefix, regname (reg, 0));
4868 if (*reg_prefix == '\0')
4870 fc->col_type[reg] = cie->col_type[reg];
4871 fc->col_offset[reg] = cie->col_offset[reg];
4875 case DW_CFA_undefined:
4877 if (reg >= (unsigned int) fc->ncols)
4878 reg_prefix = bad_reg;
4879 if (! do_debug_frames_interp || *reg_prefix != '\0')
4880 printf (" DW_CFA_undefined: %s%s\n",
4881 reg_prefix, regname (reg, 0));
4882 if (*reg_prefix == '\0')
4884 fc->col_type[reg] = DW_CFA_undefined;
4885 fc->col_offset[reg] = 0;
4889 case DW_CFA_same_value:
4891 if (reg >= (unsigned int) fc->ncols)
4892 reg_prefix = bad_reg;
4893 if (! do_debug_frames_interp || *reg_prefix != '\0')
4894 printf (" DW_CFA_same_value: %s%s\n",
4895 reg_prefix, regname (reg, 0));
4896 if (*reg_prefix == '\0')
4898 fc->col_type[reg] = DW_CFA_same_value;
4899 fc->col_offset[reg] = 0;
4903 case DW_CFA_register:
4906 if (reg >= (unsigned int) fc->ncols)
4907 reg_prefix = bad_reg;
4908 if (! do_debug_frames_interp || *reg_prefix != '\0')
4910 printf (" DW_CFA_register: %s%s in ",
4911 reg_prefix, regname (reg, 0));
4912 puts (regname (roffs, 0));
4914 if (*reg_prefix == '\0')
4916 fc->col_type[reg] = DW_CFA_register;
4917 fc->col_offset[reg] = roffs;
4921 case DW_CFA_remember_state:
4922 if (! do_debug_frames_interp)
4923 printf (" DW_CFA_remember_state\n");
4924 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4925 rs->ncols = fc->ncols;
4926 rs->col_type = (short int *) xcmalloc (rs->ncols,
4927 sizeof (short int));
4928 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
4929 memcpy (rs->col_type, fc->col_type, rs->ncols);
4930 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
4931 rs->next = remembered_state;
4932 remembered_state = rs;
4935 case DW_CFA_restore_state:
4936 if (! do_debug_frames_interp)
4937 printf (" DW_CFA_restore_state\n");
4938 rs = remembered_state;
4941 remembered_state = rs->next;
4942 frame_need_space (fc, rs->ncols - 1);
4943 memcpy (fc->col_type, rs->col_type, rs->ncols);
4944 memcpy (fc->col_offset, rs->col_offset,
4945 rs->ncols * sizeof (int));
4946 free (rs->col_type);
4947 free (rs->col_offset);
4950 else if (do_debug_frames_interp)
4951 printf ("Mismatched DW_CFA_restore_state\n");
4954 case DW_CFA_def_cfa:
4955 fc->cfa_reg = LEB ();
4956 fc->cfa_offset = LEB ();
4958 if (! do_debug_frames_interp)
4959 printf (" DW_CFA_def_cfa: %s ofs %d\n",
4960 regname (fc->cfa_reg, 0), fc->cfa_offset);
4963 case DW_CFA_def_cfa_register:
4964 fc->cfa_reg = LEB ();
4966 if (! do_debug_frames_interp)
4967 printf (" DW_CFA_def_cfa_register: %s\n",
4968 regname (fc->cfa_reg, 0));
4971 case DW_CFA_def_cfa_offset:
4972 fc->cfa_offset = LEB ();
4973 if (! do_debug_frames_interp)
4974 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
4978 if (! do_debug_frames_interp)
4979 printf (" DW_CFA_nop\n");
4982 case DW_CFA_def_cfa_expression:
4984 if (! do_debug_frames_interp)
4986 printf (" DW_CFA_def_cfa_expression (");
4987 decode_location_expression (start, eh_addr_size, 0, -1,
4995 case DW_CFA_expression:
4998 if (reg >= (unsigned int) fc->ncols)
4999 reg_prefix = bad_reg;
5000 if (! do_debug_frames_interp || *reg_prefix != '\0')
5002 printf (" DW_CFA_expression: %s%s (",
5003 reg_prefix, regname (reg, 0));
5004 decode_location_expression (start, eh_addr_size, 0, -1,
5008 if (*reg_prefix == '\0')
5009 fc->col_type[reg] = DW_CFA_expression;
5013 case DW_CFA_val_expression:
5016 if (reg >= (unsigned int) fc->ncols)
5017 reg_prefix = bad_reg;
5018 if (! do_debug_frames_interp || *reg_prefix != '\0')
5020 printf (" DW_CFA_val_expression: %s%s (",
5021 reg_prefix, regname (reg, 0));
5022 decode_location_expression (start, eh_addr_size, 0, -1,
5026 if (*reg_prefix == '\0')
5027 fc->col_type[reg] = DW_CFA_val_expression;
5031 case DW_CFA_offset_extended_sf:
5034 if (frame_need_space (fc, reg) < 0)
5035 reg_prefix = bad_reg;
5036 if (! do_debug_frames_interp || *reg_prefix != '\0')
5037 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5038 reg_prefix, regname (reg, 0),
5039 l * fc->data_factor);
5040 if (*reg_prefix == '\0')
5042 fc->col_type[reg] = DW_CFA_offset;
5043 fc->col_offset[reg] = l * fc->data_factor;
5047 case DW_CFA_val_offset_sf:
5050 if (frame_need_space (fc, reg) < 0)
5051 reg_prefix = bad_reg;
5052 if (! do_debug_frames_interp || *reg_prefix != '\0')
5053 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5054 reg_prefix, regname (reg, 0),
5055 l * fc->data_factor);
5056 if (*reg_prefix == '\0')
5058 fc->col_type[reg] = DW_CFA_val_offset;
5059 fc->col_offset[reg] = l * fc->data_factor;
5063 case DW_CFA_def_cfa_sf:
5064 fc->cfa_reg = LEB ();
5065 fc->cfa_offset = SLEB ();
5066 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5068 if (! do_debug_frames_interp)
5069 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
5070 regname (fc->cfa_reg, 0), fc->cfa_offset);
5073 case DW_CFA_def_cfa_offset_sf:
5074 fc->cfa_offset = SLEB ();
5075 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5076 if (! do_debug_frames_interp)
5077 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
5080 case DW_CFA_MIPS_advance_loc8:
5081 ofs = byte_get (start, 8); start += 8;
5082 if (do_debug_frames_interp)
5083 frame_display_row (fc, &need_col_headers, &max_regs);
5085 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
5086 ofs * fc->code_factor,
5087 fc->pc_begin + ofs * fc->code_factor);
5088 fc->pc_begin += ofs * fc->code_factor;
5091 case DW_CFA_GNU_window_save:
5092 if (! do_debug_frames_interp)
5093 printf (" DW_CFA_GNU_window_save\n");
5096 case DW_CFA_GNU_args_size:
5098 if (! do_debug_frames_interp)
5099 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
5102 case DW_CFA_GNU_negative_offset_extended:
5105 if (frame_need_space (fc, reg) < 0)
5106 reg_prefix = bad_reg;
5107 if (! do_debug_frames_interp || *reg_prefix != '\0')
5108 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
5109 reg_prefix, regname (reg, 0),
5110 l * fc->data_factor);
5111 if (*reg_prefix == '\0')
5113 fc->col_type[reg] = DW_CFA_offset;
5114 fc->col_offset[reg] = l * fc->data_factor;
5119 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
5120 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
5122 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
5127 if (do_debug_frames_interp)
5128 frame_display_row (fc, &need_col_headers, &max_regs);
5131 eh_addr_size = saved_eh_addr_size;
5144 display_gdb_index (struct dwarf_section *section,
5145 void *file ATTRIBUTE_UNUSED)
5147 unsigned char *start = section->start;
5149 uint32_t cu_list_offset, tu_list_offset;
5150 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
5151 unsigned int cu_list_elements, tu_list_elements;
5152 unsigned int address_table_size, symbol_table_slots;
5153 unsigned char *cu_list, *tu_list;
5154 unsigned char *address_table, *symbol_table, *constant_pool;
5157 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
5159 printf (_("Contents of the %s section:\n"), section->name);
5161 if (section->size < 6 * sizeof (uint32_t))
5163 warn (_("Truncated header in the %s section.\n"), section->name);
5167 version = byte_get_little_endian (start, 4);
5168 printf (_("Version %ld\n"), (long) version);
5170 /* Prior versions are obsolete, and future versions may not be
5171 backwards compatible. */
5175 warn (_("The address table data in version 3 may be wrong.\n"));
5178 warn (_("Version 4 does not support case insensitive lookups.\n"));
5183 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
5187 cu_list_offset = byte_get_little_endian (start + 4, 4);
5188 tu_list_offset = byte_get_little_endian (start + 8, 4);
5189 address_table_offset = byte_get_little_endian (start + 12, 4);
5190 symbol_table_offset = byte_get_little_endian (start + 16, 4);
5191 constant_pool_offset = byte_get_little_endian (start + 20, 4);
5193 if (cu_list_offset > section->size
5194 || tu_list_offset > section->size
5195 || address_table_offset > section->size
5196 || symbol_table_offset > section->size
5197 || constant_pool_offset > section->size)
5199 warn (_("Corrupt header in the %s section.\n"), section->name);
5203 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
5204 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
5205 address_table_size = symbol_table_offset - address_table_offset;
5206 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
5208 cu_list = start + cu_list_offset;
5209 tu_list = start + tu_list_offset;
5210 address_table = start + address_table_offset;
5211 symbol_table = start + symbol_table_offset;
5212 constant_pool = start + constant_pool_offset;
5214 printf (_("\nCU table:\n"));
5215 for (i = 0; i < cu_list_elements; i += 2)
5217 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
5218 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
5220 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
5221 (unsigned long) cu_offset,
5222 (unsigned long) (cu_offset + cu_length - 1));
5225 printf (_("\nTU table:\n"));
5226 for (i = 0; i < tu_list_elements; i += 3)
5228 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
5229 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
5230 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
5232 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
5233 (unsigned long) tu_offset,
5234 (unsigned long) type_offset);
5235 print_dwarf_vma (signature, 8);
5239 printf (_("\nAddress table:\n"));
5240 for (i = 0; i < address_table_size; i += 2 * 8 + 4)
5242 uint64_t low = byte_get_little_endian (address_table + i, 8);
5243 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
5244 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
5246 print_dwarf_vma (low, 8);
5247 print_dwarf_vma (high, 8);
5248 printf (_("%lu\n"), (unsigned long) cu_index);
5251 printf (_("\nSymbol table:\n"));
5252 for (i = 0; i < symbol_table_slots; ++i)
5254 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
5255 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
5256 uint32_t num_cus, cu;
5258 if (name_offset != 0
5259 || cu_vector_offset != 0)
5263 printf ("[%3u] %s:", i, constant_pool + name_offset);
5264 num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
5265 for (j = 0; j < num_cus; ++j)
5267 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
5268 /* Convert to TU number if it's for a type unit. */
5269 if (cu >= cu_list_elements)
5270 printf (" T%lu", (unsigned long) (cu - cu_list_elements));
5272 printf (" %lu", (unsigned long) cu);
5282 display_debug_not_supported (struct dwarf_section *section,
5283 void *file ATTRIBUTE_UNUSED)
5285 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
5292 cmalloc (size_t nmemb, size_t size)
5294 /* Check for overflow. */
5295 if (nmemb >= ~(size_t) 0 / size)
5298 return malloc (nmemb * size);
5302 xcmalloc (size_t nmemb, size_t size)
5304 /* Check for overflow. */
5305 if (nmemb >= ~(size_t) 0 / size)
5308 return xmalloc (nmemb * size);
5312 xcrealloc (void *ptr, size_t nmemb, size_t size)
5314 /* Check for overflow. */
5315 if (nmemb >= ~(size_t) 0 / size)
5318 return xrealloc (ptr, nmemb * size);
5322 free_debug_memory (void)
5328 for (i = 0; i < max; i++)
5329 free_debug_section ((enum dwarf_section_display_enum) i);
5331 if (debug_information != NULL)
5333 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
5335 for (i = 0; i < num_debug_info_entries; i++)
5337 if (!debug_information [i].max_loc_offsets)
5339 free (debug_information [i].loc_offsets);
5340 free (debug_information [i].have_frame_base);
5342 if (!debug_information [i].max_range_lists)
5343 free (debug_information [i].range_lists);
5347 free (debug_information);
5348 debug_information = NULL;
5349 num_debug_info_entries = 0;
5354 dwarf_select_sections_by_names (const char *names)
5358 const char * option;
5362 debug_dump_long_opts;
5364 static const debug_dump_long_opts opts_table [] =
5366 /* Please keep this table alpha- sorted. */
5367 { "Ranges", & do_debug_ranges, 1 },
5368 { "abbrev", & do_debug_abbrevs, 1 },
5369 { "aranges", & do_debug_aranges, 1 },
5370 { "frames", & do_debug_frames, 1 },
5371 { "frames-interp", & do_debug_frames_interp, 1 },
5372 { "info", & do_debug_info, 1 },
5373 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
5374 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
5375 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
5376 { "loc", & do_debug_loc, 1 },
5377 { "macro", & do_debug_macinfo, 1 },
5378 { "pubnames", & do_debug_pubnames, 1 },
5379 { "pubtypes", & do_debug_pubtypes, 1 },
5380 /* This entry is for compatability
5381 with earlier versions of readelf. */
5382 { "ranges", & do_debug_aranges, 1 },
5383 { "str", & do_debug_str, 1 },
5384 /* The special .gdb_index section. */
5385 { "gdb_index", & do_gdb_index, 1 },
5386 /* These trace_* sections are used by Itanium VMS. */
5387 { "trace_abbrev", & do_trace_abbrevs, 1 },
5388 { "trace_aranges", & do_trace_aranges, 1 },
5389 { "trace_info", & do_trace_info, 1 },
5398 const debug_dump_long_opts * entry;
5400 for (entry = opts_table; entry->option; entry++)
5402 size_t len = strlen (entry->option);
5404 if (strncmp (p, entry->option, len) == 0
5405 && (p[len] == ',' || p[len] == '\0'))
5407 * entry->variable |= entry->val;
5409 /* The --debug-dump=frames-interp option also
5410 enables the --debug-dump=frames option. */
5411 if (do_debug_frames_interp)
5412 do_debug_frames = 1;
5419 if (entry->option == NULL)
5421 warn (_("Unrecognized debug option '%s'\n"), p);
5422 p = strchr (p, ',');
5433 dwarf_select_sections_by_letters (const char *letters)
5435 unsigned int lindex = 0;
5437 while (letters[lindex])
5438 switch (letters[lindex++])
5445 do_debug_abbrevs = 1;
5449 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
5453 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
5457 do_debug_pubnames = 1;
5461 do_debug_pubtypes = 1;
5465 do_debug_aranges = 1;
5469 do_debug_ranges = 1;
5473 do_debug_frames_interp = 1;
5475 do_debug_frames = 1;
5479 do_debug_macinfo = 1;
5491 warn (_("Unrecognized debug option '%s'\n"), optarg);
5497 dwarf_select_sections_all (void)
5500 do_debug_abbrevs = 1;
5501 do_debug_lines = FLAG_DEBUG_LINES_RAW;
5502 do_debug_pubnames = 1;
5503 do_debug_pubtypes = 1;
5504 do_debug_aranges = 1;
5505 do_debug_ranges = 1;
5506 do_debug_frames = 1;
5507 do_debug_macinfo = 1;
5512 do_trace_abbrevs = 1;
5513 do_trace_aranges = 1;
5516 struct dwarf_section_display debug_displays[] =
5518 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0 },
5519 display_debug_abbrev, &do_debug_abbrevs, 0 },
5520 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0 },
5521 display_debug_aranges, &do_debug_aranges, 1 },
5522 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0 },
5523 display_debug_frames, &do_debug_frames, 1 },
5524 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0 },
5525 display_debug_info, &do_debug_info, 1 },
5526 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0 },
5527 display_debug_lines, &do_debug_lines, 1 },
5528 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0 },
5529 display_debug_pubnames, &do_debug_pubnames, 0 },
5530 { { ".eh_frame", "", NULL, NULL, 0, 0 },
5531 display_debug_frames, &do_debug_frames, 1 },
5532 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0 },
5533 display_debug_macinfo, &do_debug_macinfo, 0 },
5534 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0 },
5535 display_debug_str, &do_debug_str, 0 },
5536 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0 },
5537 display_debug_loc, &do_debug_loc, 1 },
5538 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0 },
5539 display_debug_pubnames, &do_debug_pubtypes, 0 },
5540 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0 },
5541 display_debug_ranges, &do_debug_ranges, 1 },
5542 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0 },
5543 display_debug_not_supported, NULL, 0 },
5544 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0 },
5545 display_debug_not_supported, NULL, 0 },
5546 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0 },
5547 display_debug_types, &do_debug_info, 1 },
5548 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0 },
5549 display_debug_not_supported, NULL, 0 },
5550 { { ".gdb_index", "", NULL, NULL, 0, 0 },
5551 display_gdb_index, &do_gdb_index, 0 },
5552 { { ".trace_info", "", NULL, NULL, 0, 0 },
5553 display_trace_info, &do_trace_info, 1 },
5554 { { ".trace_abbrev", "", NULL, NULL, 0, 0 },
5555 display_debug_abbrev, &do_trace_abbrevs, 0 },
5556 { { ".trace_aranges", "", NULL, NULL, 0, 0 },
5557 display_debug_aranges, &do_trace_aranges, 0 }