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", uvalue ? cu_offset + uvalue : 0));
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", uvalue ? cu_offset + uvalue : 0));
1190 case DW_OP_GNU_parameter_ref:
1191 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1192 dwarf_vmatoa ("x", cu_offset + byte_get (data, 4)));
1196 /* HP extensions. */
1197 case DW_OP_HP_is_value:
1198 printf ("DW_OP_HP_is_value");
1199 /* FIXME: Is there data associated with this OP ? */
1201 case DW_OP_HP_fltconst4:
1202 printf ("DW_OP_HP_fltconst4");
1203 /* FIXME: Is there data associated with this OP ? */
1205 case DW_OP_HP_fltconst8:
1206 printf ("DW_OP_HP_fltconst8");
1207 /* FIXME: Is there data associated with this OP ? */
1209 case DW_OP_HP_mod_range:
1210 printf ("DW_OP_HP_mod_range");
1211 /* FIXME: Is there data associated with this OP ? */
1213 case DW_OP_HP_unmod_range:
1214 printf ("DW_OP_HP_unmod_range");
1215 /* FIXME: Is there data associated with this OP ? */
1218 printf ("DW_OP_HP_tls");
1219 /* FIXME: Is there data associated with this OP ? */
1222 /* PGI (STMicroelectronics) extensions. */
1223 case DW_OP_PGI_omp_thread_num:
1224 /* Pushes the thread number for the current thread as it would be
1225 returned by the standard OpenMP library function:
1226 omp_get_thread_num(). The "current thread" is the thread for
1227 which the expression is being evaluated. */
1228 printf ("DW_OP_PGI_omp_thread_num");
1232 if (op >= DW_OP_lo_user
1233 && op <= DW_OP_hi_user)
1234 printf (_("(User defined location op)"));
1236 printf (_("(Unknown location op)"));
1237 /* No way to tell where the next op is, so just bail. */
1238 return need_frame_base;
1241 /* Separate the ops. */
1246 return need_frame_base;
1249 static unsigned char *
1250 read_and_display_attr_value (unsigned long attribute,
1252 unsigned char * data,
1253 dwarf_vma cu_offset,
1254 dwarf_vma pointer_size,
1255 dwarf_vma offset_size,
1257 debug_info * debug_info_p,
1259 struct dwarf_section * section)
1261 dwarf_vma uvalue = 0;
1262 unsigned char *block_start = NULL;
1263 unsigned char * orig_data = data;
1264 unsigned int bytes_read;
1271 case DW_FORM_ref_addr:
1272 if (dwarf_version == 2)
1274 uvalue = byte_get (data, pointer_size);
1275 data += pointer_size;
1277 else if (dwarf_version == 3 || dwarf_version == 4)
1279 uvalue = byte_get (data, offset_size);
1280 data += offset_size;
1283 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1288 uvalue = byte_get (data, pointer_size);
1289 data += pointer_size;
1293 case DW_FORM_sec_offset:
1294 uvalue = byte_get (data, offset_size);
1295 data += offset_size;
1298 case DW_FORM_flag_present:
1305 uvalue = byte_get (data++, 1);
1310 uvalue = byte_get (data, 2);
1316 uvalue = byte_get (data, 4);
1321 uvalue = read_leb128 (data, & bytes_read, 1);
1325 case DW_FORM_ref_udata:
1327 uvalue = read_leb128 (data, & bytes_read, 0);
1331 case DW_FORM_indirect:
1332 form = read_leb128 (data, & bytes_read, 0);
1335 printf (" %s", get_FORM_name (form));
1336 return read_and_display_attr_value (attribute, form, data,
1337 cu_offset, pointer_size,
1338 offset_size, dwarf_version,
1339 debug_info_p, do_loc,
1345 case DW_FORM_ref_addr:
1347 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1353 case DW_FORM_ref_udata:
1355 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1360 case DW_FORM_sec_offset:
1362 printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1365 case DW_FORM_flag_present:
1372 printf (" %s", dwarf_vmatoa ("d", uvalue));
1379 uvalue = byte_get (data, 4);
1380 printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1381 printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1383 if ((do_loc || do_debug_loc || do_debug_ranges)
1384 && num_debug_info_entries == 0)
1386 if (sizeof (uvalue) == 8)
1387 uvalue = byte_get (data, 8);
1389 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1394 case DW_FORM_string:
1396 printf (" %s", data);
1397 data += strlen ((char *) data) + 1;
1401 case DW_FORM_exprloc:
1402 uvalue = read_leb128 (data, & bytes_read, 0);
1403 block_start = data + bytes_read;
1405 data = block_start + uvalue;
1407 data = display_block (block_start, uvalue);
1410 case DW_FORM_block1:
1411 uvalue = byte_get (data, 1);
1412 block_start = data + 1;
1414 data = block_start + uvalue;
1416 data = display_block (block_start, uvalue);
1419 case DW_FORM_block2:
1420 uvalue = byte_get (data, 2);
1421 block_start = data + 2;
1423 data = block_start + uvalue;
1425 data = display_block (block_start, uvalue);
1428 case DW_FORM_block4:
1429 uvalue = byte_get (data, 4);
1430 block_start = data + 4;
1432 data = block_start + uvalue;
1434 data = display_block (block_start, uvalue);
1439 printf (_(" (indirect string, offset: 0x%s): %s"),
1440 dwarf_vmatoa ("x", uvalue),
1441 fetch_indirect_string (uvalue));
1444 case DW_FORM_indirect:
1445 /* Handled above. */
1448 case DW_FORM_ref_sig8:
1452 printf (" signature: ");
1453 for (i = 0; i < 8; i++)
1455 printf ("%02x", (unsigned) byte_get (data, 1));
1464 warn (_("Unrecognized form: %lu\n"), form);
1468 if ((do_loc || do_debug_loc || do_debug_ranges)
1469 && num_debug_info_entries == 0
1470 && debug_info_p != NULL)
1474 case DW_AT_frame_base:
1475 have_frame_base = 1;
1476 case DW_AT_location:
1477 case DW_AT_string_length:
1478 case DW_AT_return_addr:
1479 case DW_AT_data_member_location:
1480 case DW_AT_vtable_elem_location:
1482 case DW_AT_static_link:
1483 case DW_AT_use_location:
1484 case DW_AT_GNU_call_site_value:
1485 case DW_AT_GNU_call_site_data_value:
1486 case DW_AT_GNU_call_site_target:
1487 case DW_AT_GNU_call_site_target_clobbered:
1488 if (form == DW_FORM_data4
1489 || form == DW_FORM_data8
1490 || form == DW_FORM_sec_offset)
1492 /* Process location list. */
1493 unsigned int lmax = debug_info_p->max_loc_offsets;
1494 unsigned int num = debug_info_p->num_loc_offsets;
1496 if (lmax == 0 || num >= lmax)
1499 debug_info_p->loc_offsets = (dwarf_vma *)
1500 xcrealloc (debug_info_p->loc_offsets,
1501 lmax, sizeof (*debug_info_p->loc_offsets));
1502 debug_info_p->have_frame_base = (int *)
1503 xcrealloc (debug_info_p->have_frame_base,
1504 lmax, sizeof (*debug_info_p->have_frame_base));
1505 debug_info_p->max_loc_offsets = lmax;
1507 debug_info_p->loc_offsets [num] = uvalue;
1508 debug_info_p->have_frame_base [num] = have_frame_base;
1509 debug_info_p->num_loc_offsets++;
1514 if (need_base_address)
1515 debug_info_p->base_address = uvalue;
1519 if (form == DW_FORM_data4
1520 || form == DW_FORM_data8
1521 || form == DW_FORM_sec_offset)
1523 /* Process range list. */
1524 unsigned int lmax = debug_info_p->max_range_lists;
1525 unsigned int num = debug_info_p->num_range_lists;
1527 if (lmax == 0 || num >= lmax)
1530 debug_info_p->range_lists = (dwarf_vma *)
1531 xcrealloc (debug_info_p->range_lists,
1532 lmax, sizeof (*debug_info_p->range_lists));
1533 debug_info_p->max_range_lists = lmax;
1535 debug_info_p->range_lists [num] = uvalue;
1536 debug_info_p->num_range_lists++;
1545 if (do_loc || attribute == 0)
1548 /* For some attributes we can display further information. */
1556 case DW_INL_not_inlined:
1557 printf (_("(not inlined)"));
1559 case DW_INL_inlined:
1560 printf (_("(inlined)"));
1562 case DW_INL_declared_not_inlined:
1563 printf (_("(declared as inline but ignored)"));
1565 case DW_INL_declared_inlined:
1566 printf (_("(declared as inline and inlined)"));
1569 printf (_(" (Unknown inline attribute value: %s)"),
1570 dwarf_vmatoa ("x", uvalue));
1575 case DW_AT_language:
1578 /* Ordered by the numeric value of these constants. */
1579 case DW_LANG_C89: printf ("(ANSI C)"); break;
1580 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1581 case DW_LANG_Ada83: printf ("(Ada)"); break;
1582 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1583 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1584 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1585 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1586 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1587 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1588 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1589 /* DWARF 2.1 values. */
1590 case DW_LANG_Java: printf ("(Java)"); break;
1591 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1592 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1593 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1594 /* DWARF 3 values. */
1595 case DW_LANG_PLI: printf ("(PLI)"); break;
1596 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1597 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1598 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1599 case DW_LANG_D: printf ("(D)"); break;
1600 /* DWARF 4 values. */
1601 case DW_LANG_Python: printf ("(Python)"); break;
1602 /* MIPS extension. */
1603 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1604 /* UPC extension. */
1605 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1607 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1608 printf ("(implementation defined: %s)",
1609 dwarf_vmatoa ("x", uvalue));
1611 printf ("(Unknown: %s)", dwarf_vmatoa ("x", uvalue));
1616 case DW_AT_encoding:
1619 case DW_ATE_void: printf ("(void)"); break;
1620 case DW_ATE_address: printf ("(machine address)"); break;
1621 case DW_ATE_boolean: printf ("(boolean)"); break;
1622 case DW_ATE_complex_float: printf ("(complex float)"); break;
1623 case DW_ATE_float: printf ("(float)"); break;
1624 case DW_ATE_signed: printf ("(signed)"); break;
1625 case DW_ATE_signed_char: printf ("(signed char)"); break;
1626 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1627 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1628 /* DWARF 2.1 values: */
1629 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1630 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1631 /* DWARF 3 values: */
1632 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1633 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1634 case DW_ATE_edited: printf ("(edited)"); break;
1635 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1636 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1637 /* HP extensions: */
1638 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1639 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1640 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1641 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1642 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1643 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1644 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1647 if (uvalue >= DW_ATE_lo_user
1648 && uvalue <= DW_ATE_hi_user)
1649 printf ("(user defined type)");
1651 printf ("(unknown type)");
1656 case DW_AT_accessibility:
1659 case DW_ACCESS_public: printf ("(public)"); break;
1660 case DW_ACCESS_protected: printf ("(protected)"); break;
1661 case DW_ACCESS_private: printf ("(private)"); break;
1663 printf ("(unknown accessibility)");
1668 case DW_AT_visibility:
1671 case DW_VIS_local: printf ("(local)"); break;
1672 case DW_VIS_exported: printf ("(exported)"); break;
1673 case DW_VIS_qualified: printf ("(qualified)"); break;
1674 default: printf ("(unknown visibility)"); break;
1678 case DW_AT_virtuality:
1681 case DW_VIRTUALITY_none: printf ("(none)"); break;
1682 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1683 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1684 default: printf ("(unknown virtuality)"); break;
1688 case DW_AT_identifier_case:
1691 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1692 case DW_ID_up_case: printf ("(up_case)"); break;
1693 case DW_ID_down_case: printf ("(down_case)"); break;
1694 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1695 default: printf ("(unknown case)"); break;
1699 case DW_AT_calling_convention:
1702 case DW_CC_normal: printf ("(normal)"); break;
1703 case DW_CC_program: printf ("(program)"); break;
1704 case DW_CC_nocall: printf ("(nocall)"); break;
1706 if (uvalue >= DW_CC_lo_user
1707 && uvalue <= DW_CC_hi_user)
1708 printf ("(user defined)");
1710 printf ("(unknown convention)");
1714 case DW_AT_ordering:
1717 case -1: printf ("(undefined)"); break;
1718 case 0: printf ("(row major)"); break;
1719 case 1: printf ("(column major)"); break;
1723 case DW_AT_frame_base:
1724 have_frame_base = 1;
1725 case DW_AT_location:
1726 case DW_AT_string_length:
1727 case DW_AT_return_addr:
1728 case DW_AT_data_member_location:
1729 case DW_AT_vtable_elem_location:
1731 case DW_AT_static_link:
1732 case DW_AT_use_location:
1733 case DW_AT_GNU_call_site_value:
1734 case DW_AT_GNU_call_site_data_value:
1735 case DW_AT_GNU_call_site_target:
1736 case DW_AT_GNU_call_site_target_clobbered:
1737 if (form == DW_FORM_data4
1738 || form == DW_FORM_data8
1739 || form == DW_FORM_sec_offset)
1740 printf (_("(location list)"));
1742 case DW_AT_allocated:
1743 case DW_AT_associated:
1744 case DW_AT_data_location:
1746 case DW_AT_upper_bound:
1747 case DW_AT_lower_bound:
1750 int need_frame_base;
1753 need_frame_base = decode_location_expression (block_start,
1758 cu_offset, section);
1760 if (need_frame_base && !have_frame_base)
1761 printf (_(" [without DW_AT_frame_base]"));
1767 if (form == DW_FORM_ref_sig8)
1770 if (form == DW_FORM_ref1
1771 || form == DW_FORM_ref2
1772 || form == DW_FORM_ref4)
1773 uvalue += cu_offset;
1775 if (uvalue >= section->size)
1776 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1777 dwarf_vmatoa ("x", uvalue),
1778 (unsigned long) (orig_data - section->start));
1781 unsigned long abbrev_number;
1782 abbrev_entry * entry;
1784 abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1786 printf ("[Abbrev Number: %ld", abbrev_number);
1787 for (entry = first_abbrev; entry != NULL; entry = entry->next)
1788 if (entry->entry == abbrev_number)
1791 printf (" (%s)", get_TAG_name (entry->tag));
1805 get_AT_name (unsigned long attribute)
1809 case DW_AT_sibling: return "DW_AT_sibling";
1810 case DW_AT_location: return "DW_AT_location";
1811 case DW_AT_name: return "DW_AT_name";
1812 case DW_AT_ordering: return "DW_AT_ordering";
1813 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1814 case DW_AT_byte_size: return "DW_AT_byte_size";
1815 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1816 case DW_AT_bit_size: return "DW_AT_bit_size";
1817 case DW_AT_element_list: return "DW_AT_element_list";
1818 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1819 case DW_AT_low_pc: return "DW_AT_low_pc";
1820 case DW_AT_high_pc: return "DW_AT_high_pc";
1821 case DW_AT_language: return "DW_AT_language";
1822 case DW_AT_member: return "DW_AT_member";
1823 case DW_AT_discr: return "DW_AT_discr";
1824 case DW_AT_discr_value: return "DW_AT_discr_value";
1825 case DW_AT_visibility: return "DW_AT_visibility";
1826 case DW_AT_import: return "DW_AT_import";
1827 case DW_AT_string_length: return "DW_AT_string_length";
1828 case DW_AT_common_reference: return "DW_AT_common_reference";
1829 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1830 case DW_AT_const_value: return "DW_AT_const_value";
1831 case DW_AT_containing_type: return "DW_AT_containing_type";
1832 case DW_AT_default_value: return "DW_AT_default_value";
1833 case DW_AT_inline: return "DW_AT_inline";
1834 case DW_AT_is_optional: return "DW_AT_is_optional";
1835 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1836 case DW_AT_producer: return "DW_AT_producer";
1837 case DW_AT_prototyped: return "DW_AT_prototyped";
1838 case DW_AT_return_addr: return "DW_AT_return_addr";
1839 case DW_AT_start_scope: return "DW_AT_start_scope";
1840 case DW_AT_stride_size: return "DW_AT_stride_size";
1841 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1842 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1843 case DW_AT_accessibility: return "DW_AT_accessibility";
1844 case DW_AT_address_class: return "DW_AT_address_class";
1845 case DW_AT_artificial: return "DW_AT_artificial";
1846 case DW_AT_base_types: return "DW_AT_base_types";
1847 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1848 case DW_AT_count: return "DW_AT_count";
1849 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1850 case DW_AT_decl_column: return "DW_AT_decl_column";
1851 case DW_AT_decl_file: return "DW_AT_decl_file";
1852 case DW_AT_decl_line: return "DW_AT_decl_line";
1853 case DW_AT_declaration: return "DW_AT_declaration";
1854 case DW_AT_discr_list: return "DW_AT_discr_list";
1855 case DW_AT_encoding: return "DW_AT_encoding";
1856 case DW_AT_external: return "DW_AT_external";
1857 case DW_AT_frame_base: return "DW_AT_frame_base";
1858 case DW_AT_friend: return "DW_AT_friend";
1859 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1860 case DW_AT_macro_info: return "DW_AT_macro_info";
1861 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1862 case DW_AT_priority: return "DW_AT_priority";
1863 case DW_AT_segment: return "DW_AT_segment";
1864 case DW_AT_specification: return "DW_AT_specification";
1865 case DW_AT_static_link: return "DW_AT_static_link";
1866 case DW_AT_type: return "DW_AT_type";
1867 case DW_AT_use_location: return "DW_AT_use_location";
1868 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1869 case DW_AT_virtuality: return "DW_AT_virtuality";
1870 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1871 /* DWARF 2.1 values. */
1872 case DW_AT_allocated: return "DW_AT_allocated";
1873 case DW_AT_associated: return "DW_AT_associated";
1874 case DW_AT_data_location: return "DW_AT_data_location";
1875 case DW_AT_stride: return "DW_AT_stride";
1876 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1877 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1878 case DW_AT_extension: return "DW_AT_extension";
1879 case DW_AT_ranges: return "DW_AT_ranges";
1880 case DW_AT_trampoline: return "DW_AT_trampoline";
1881 case DW_AT_call_column: return "DW_AT_call_column";
1882 case DW_AT_call_file: return "DW_AT_call_file";
1883 case DW_AT_call_line: return "DW_AT_call_line";
1884 case DW_AT_description: return "DW_AT_description";
1885 case DW_AT_binary_scale: return "DW_AT_binary_scale";
1886 case DW_AT_decimal_scale: return "DW_AT_decimal_scale";
1887 case DW_AT_small: return "DW_AT_small";
1888 case DW_AT_decimal_sign: return "DW_AT_decimal_sign";
1889 case DW_AT_digit_count: return "DW_AT_digit_count";
1890 case DW_AT_picture_string: return "DW_AT_picture_string";
1891 case DW_AT_mutable: return "DW_AT_mutable";
1892 case DW_AT_threads_scaled: return "DW_AT_threads_scaled";
1893 case DW_AT_explicit: return "DW_AT_explicit";
1894 case DW_AT_object_pointer: return "DW_AT_object_pointer";
1895 case DW_AT_endianity: return "DW_AT_endianity";
1896 case DW_AT_elemental: return "DW_AT_elemental";
1897 case DW_AT_pure: return "DW_AT_pure";
1898 case DW_AT_recursive: return "DW_AT_recursive";
1899 /* DWARF 4 values. */
1900 case DW_AT_signature: return "DW_AT_signature";
1901 case DW_AT_main_subprogram: return "DW_AT_main_subprogram";
1902 case DW_AT_data_bit_offset: return "DW_AT_data_bit_offset";
1903 case DW_AT_const_expr: return "DW_AT_const_expr";
1904 case DW_AT_enum_class: return "DW_AT_enum_class";
1905 case DW_AT_linkage_name: return "DW_AT_linkage_name";
1907 /* HP and SGI/MIPS extensions. */
1908 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1909 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1910 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1911 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1912 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
1913 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1914 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1915 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1916 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1917 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1919 /* HP Extensions. */
1920 case DW_AT_HP_block_index: return "DW_AT_HP_block_index";
1921 case DW_AT_HP_actuals_stmt_list: return "DW_AT_HP_actuals_stmt_list";
1922 case DW_AT_HP_proc_per_section: return "DW_AT_HP_proc_per_section";
1923 case DW_AT_HP_raw_data_ptr: return "DW_AT_HP_raw_data_ptr";
1924 case DW_AT_HP_pass_by_reference: return "DW_AT_HP_pass_by_reference";
1925 case DW_AT_HP_opt_level: return "DW_AT_HP_opt_level";
1926 case DW_AT_HP_prof_version_id: return "DW_AT_HP_prof_version_id";
1927 case DW_AT_HP_opt_flags: return "DW_AT_HP_opt_flags";
1928 case DW_AT_HP_cold_region_low_pc: return "DW_AT_HP_cold_region_low_pc";
1929 case DW_AT_HP_cold_region_high_pc: return "DW_AT_HP_cold_region_high_pc";
1930 case DW_AT_HP_all_variables_modifiable: return "DW_AT_HP_all_variables_modifiable";
1931 case DW_AT_HP_linkage_name: return "DW_AT_HP_linkage_name";
1932 case DW_AT_HP_prof_flags: return "DW_AT_HP_prof_flags";
1934 /* One value is shared by the MIPS and HP extensions: */
1935 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1937 /* GNU extensions. */
1938 case DW_AT_sf_names: return "DW_AT_sf_names";
1939 case DW_AT_src_info: return "DW_AT_src_info";
1940 case DW_AT_mac_info: return "DW_AT_mac_info";
1941 case DW_AT_src_coords: return "DW_AT_src_coords";
1942 case DW_AT_body_begin: return "DW_AT_body_begin";
1943 case DW_AT_body_end: return "DW_AT_body_end";
1944 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
1945 case DW_AT_GNU_guarded_by: return "DW_AT_GNU_guarded_by";
1946 case DW_AT_GNU_pt_guarded_by: return "DW_AT_GNU_pt_guarded_by";
1947 case DW_AT_GNU_guarded: return "DW_AT_GNU_guarded";
1948 case DW_AT_GNU_pt_guarded: return "DW_AT_GNU_pt_guarded";
1949 case DW_AT_GNU_locks_excluded: return "DW_AT_GNU_locks_excluded";
1950 case DW_AT_GNU_exclusive_locks_required: return "DW_AT_GNU_exclusive_locks_required";
1951 case DW_AT_GNU_shared_locks_required: return "DW_AT_GNU_shared_locks_required";
1952 case DW_AT_GNU_odr_signature: return "DW_AT_GNU_odr_signature";
1953 case DW_AT_use_GNAT_descriptive_type: return "DW_AT_use_GNAT_descriptive_type";
1954 case DW_AT_GNAT_descriptive_type: return "DW_AT_GNAT_descriptive_type";
1955 case DW_AT_GNU_call_site_value: return "DW_AT_GNU_call_site_value";
1956 case DW_AT_GNU_call_site_data_value: return "DW_AT_GNU_call_site_data_value";
1957 case DW_AT_GNU_call_site_target: return "DW_AT_GNU_call_site_target";
1958 case DW_AT_GNU_call_site_target_clobbered: return "DW_AT_GNU_call_site_target_clobbered";
1959 case DW_AT_GNU_tail_call: return "DW_AT_GNU_tail_call";
1960 case DW_AT_GNU_all_tail_call_sites: return "DW_AT_GNU_all_tail_call_sites";
1961 case DW_AT_GNU_all_call_sites: return "DW_AT_GNU_all_call_sites";
1962 case DW_AT_GNU_all_source_call_sites: return "DW_AT_GNU_all_source_call_sites";
1963 case DW_AT_GNU_macros: return "DW_AT_GNU_macros";
1965 /* UPC extension. */
1966 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
1968 /* PGI (STMicroelectronics) extensions. */
1969 case DW_AT_PGI_lbase: return "DW_AT_PGI_lbase";
1970 case DW_AT_PGI_soffset: return "DW_AT_PGI_soffset";
1971 case DW_AT_PGI_lstride: return "DW_AT_PGI_lstride";
1975 static char buffer[100];
1977 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1984 static unsigned char *
1985 read_and_display_attr (unsigned long attribute,
1987 unsigned char * data,
1988 dwarf_vma cu_offset,
1989 dwarf_vma pointer_size,
1990 dwarf_vma offset_size,
1992 debug_info * debug_info_p,
1994 struct dwarf_section * section)
1997 printf (" %-18s:", get_AT_name (attribute));
1998 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1999 pointer_size, offset_size,
2000 dwarf_version, debug_info_p,
2008 /* Process the contents of a .debug_info section. If do_loc is non-zero
2009 then we are scanning for location lists and we do not want to display
2010 anything to the user. If do_types is non-zero, we are processing
2011 a .debug_types section instead of a .debug_info section. */
2014 process_debug_info (struct dwarf_section *section,
2016 enum dwarf_section_display_enum abbrev_sec,
2020 unsigned char *start = section->start;
2021 unsigned char *end = start + section->size;
2022 unsigned char *section_begin;
2024 unsigned int num_units = 0;
2026 if ((do_loc || do_debug_loc || do_debug_ranges)
2027 && num_debug_info_entries == 0
2032 /* First scan the section to get the number of comp units. */
2033 for (section_begin = start, num_units = 0; section_begin < end;
2036 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2037 will be the length. For a 64-bit DWARF section, it'll be
2038 the escape code 0xffffffff followed by an 8 byte length. */
2039 length = byte_get (section_begin, 4);
2041 if (length == 0xffffffff)
2043 length = byte_get (section_begin + 4, 8);
2044 section_begin += length + 12;
2046 else if (length >= 0xfffffff0 && length < 0xffffffff)
2048 warn (_("Reserved length value (0x%s) found in section %s\n"),
2049 dwarf_vmatoa ("x", length), section->name);
2053 section_begin += length + 4;
2055 /* Negative values are illegal, they may even cause infinite
2056 looping. This can happen if we can't accurately apply
2057 relocations to an object file. */
2058 if ((signed long) length <= 0)
2060 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2061 dwarf_vmatoa ("x", length), section->name);
2068 error (_("No comp units in %s section ?"), section->name);
2072 /* Then allocate an array to hold the information. */
2073 debug_information = (debug_info *) cmalloc (num_units,
2074 sizeof (* debug_information));
2075 if (debug_information == NULL)
2077 error (_("Not enough memory for a debug info array of %u entries"),
2085 if (dwarf_start_die == 0)
2086 printf (_("Contents of the %s section:\n\n"), section->name);
2088 load_debug_section (str, file);
2091 load_debug_section (abbrev_sec, file);
2092 if (debug_displays [abbrev_sec].section.start == NULL)
2094 warn (_("Unable to locate %s section!\n"),
2095 debug_displays [abbrev_sec].section.name);
2099 for (section_begin = start, unit = 0; start < end; unit++)
2101 DWARF2_Internal_CompUnit compunit;
2102 unsigned char *hdrptr;
2103 unsigned char *tags;
2104 int level, last_level, saved_level;
2105 dwarf_vma cu_offset;
2107 int initial_length_size;
2108 unsigned char signature[8] = { 0 };
2109 dwarf_vma type_offset = 0;
2113 compunit.cu_length = byte_get (hdrptr, 4);
2116 if (compunit.cu_length == 0xffffffff)
2118 compunit.cu_length = byte_get (hdrptr, 8);
2121 initial_length_size = 12;
2126 initial_length_size = 4;
2129 compunit.cu_version = byte_get (hdrptr, 2);
2132 cu_offset = start - section_begin;
2134 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
2135 hdrptr += offset_size;
2137 compunit.cu_pointer_size = byte_get (hdrptr, 1);
2144 for (i = 0; i < 8; i++)
2146 signature[i] = byte_get (hdrptr, 1);
2150 type_offset = byte_get (hdrptr, offset_size);
2151 hdrptr += offset_size;
2154 if ((do_loc || do_debug_loc || do_debug_ranges)
2155 && num_debug_info_entries == 0
2158 debug_information [unit].cu_offset = cu_offset;
2159 debug_information [unit].pointer_size
2160 = compunit.cu_pointer_size;
2161 debug_information [unit].offset_size = offset_size;
2162 debug_information [unit].dwarf_version = compunit.cu_version;
2163 debug_information [unit].base_address = 0;
2164 debug_information [unit].loc_offsets = NULL;
2165 debug_information [unit].have_frame_base = NULL;
2166 debug_information [unit].max_loc_offsets = 0;
2167 debug_information [unit].num_loc_offsets = 0;
2168 debug_information [unit].range_lists = NULL;
2169 debug_information [unit].max_range_lists= 0;
2170 debug_information [unit].num_range_lists = 0;
2173 if (!do_loc && dwarf_start_die == 0)
2175 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2176 dwarf_vmatoa ("x", cu_offset));
2177 printf (_(" Length: 0x%s (%s)\n"),
2178 dwarf_vmatoa ("x", compunit.cu_length),
2179 offset_size == 8 ? "64-bit" : "32-bit");
2180 printf (_(" Version: %d\n"), compunit.cu_version);
2181 printf (_(" Abbrev Offset: %s\n"),
2182 dwarf_vmatoa ("d", compunit.cu_abbrev_offset));
2183 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2187 printf (_(" Signature: "));
2188 for (i = 0; i < 8; i++)
2189 printf ("%02x", signature[i]);
2191 printf (_(" Type Offset: 0x%s\n"),
2192 dwarf_vmatoa ("x", type_offset));
2196 if (cu_offset + compunit.cu_length + initial_length_size
2199 warn (_("Debug info is corrupted, length of CU at %s"
2200 " extends beyond end of section (length = %s)\n"),
2201 dwarf_vmatoa ("x", cu_offset),
2202 dwarf_vmatoa ("x", compunit.cu_length));
2206 start += compunit.cu_length + initial_length_size;
2208 if (compunit.cu_version != 2
2209 && compunit.cu_version != 3
2210 && compunit.cu_version != 4)
2212 warn (_("CU at offset %s contains corrupt or "
2213 "unsupported version number: %d.\n"),
2214 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2220 /* Process the abbrevs used by this compilation unit. DWARF
2221 sections under Mach-O have non-zero addresses. */
2222 if (compunit.cu_abbrev_offset >= debug_displays [abbrev_sec].section.size)
2223 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2224 (unsigned long) compunit.cu_abbrev_offset,
2225 (unsigned long) debug_displays [abbrev_sec].section.size);
2227 process_abbrev_section
2228 ((unsigned char *) debug_displays [abbrev_sec].section.start
2229 + compunit.cu_abbrev_offset,
2230 (unsigned char *) debug_displays [abbrev_sec].section.start
2231 + debug_displays [abbrev_sec].section.size);
2236 while (tags < start)
2238 unsigned int bytes_read;
2239 unsigned long abbrev_number;
2240 unsigned long die_offset;
2241 abbrev_entry *entry;
2243 int do_printing = 1;
2245 die_offset = tags - section_begin;
2247 abbrev_number = read_leb128 (tags, & bytes_read, 0);
2250 /* A null DIE marks the end of a list of siblings or it may also be
2251 a section padding. */
2252 if (abbrev_number == 0)
2254 /* Check if it can be a section padding for the last CU. */
2255 if (level == 0 && start == end)
2259 for (chk = tags; chk < start; chk++)
2269 static unsigned num_bogus_warns = 0;
2271 if (num_bogus_warns < 3)
2273 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2276 if (num_bogus_warns == 3)
2277 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2280 if (dwarf_start_die != 0 && level < saved_level)
2287 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2291 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2292 saved_level = level;
2293 do_printing = (dwarf_cutoff_level == -1
2294 || level < dwarf_cutoff_level);
2296 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2297 level, die_offset, abbrev_number);
2298 else if (dwarf_cutoff_level == -1
2299 || last_level < dwarf_cutoff_level)
2300 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2305 /* Scan through the abbreviation list until we reach the
2307 for (entry = first_abbrev;
2308 entry && entry->entry != abbrev_number;
2309 entry = entry->next)
2314 if (!do_loc && do_printing)
2319 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2320 die_offset, abbrev_number);
2324 if (!do_loc && do_printing)
2325 printf (" (%s)\n", get_TAG_name (entry->tag));
2330 need_base_address = 0;
2332 case DW_TAG_compile_unit:
2333 need_base_address = 1;
2335 case DW_TAG_entry_point:
2336 case DW_TAG_subprogram:
2337 need_base_address = 0;
2338 /* Assuming that there is no DW_AT_frame_base. */
2339 have_frame_base = 0;
2343 for (attr = entry->first_attr; attr; attr = attr->next)
2347 if (! do_loc && do_printing)
2348 /* Show the offset from where the tag was extracted. */
2349 printf (" <%lx>", (unsigned long)(tags - section_begin));
2351 arg = debug_information;
2352 if (debug_information)
2355 tags = read_and_display_attr (attr->attribute,
2358 compunit.cu_pointer_size,
2360 compunit.cu_version,
2362 do_loc || ! do_printing, section);
2365 if (entry->children)
2370 /* Set num_debug_info_entries here so that it can be used to check if
2371 we need to process .debug_loc and .debug_ranges sections. */
2372 if ((do_loc || do_debug_loc || do_debug_ranges)
2373 && num_debug_info_entries == 0
2375 num_debug_info_entries = num_units;
2383 /* Locate and scan the .debug_info section in the file and record the pointer
2384 sizes and offsets for the compilation units in it. Usually an executable
2385 will have just one pointer size, but this is not guaranteed, and so we try
2386 not to make any assumptions. Returns zero upon failure, or the number of
2387 compilation units upon success. */
2390 load_debug_info (void * file)
2392 /* Reset the last pointer size so that we can issue correct error
2393 messages if we are displaying the contents of more than one section. */
2394 last_pointer_size = 0;
2395 warned_about_missing_comp_units = FALSE;
2397 /* If we have already tried and failed to load the .debug_info
2398 section then do not bother to repear the task. */
2399 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2402 /* If we already have the information there is nothing else to do. */
2403 if (num_debug_info_entries > 0)
2404 return num_debug_info_entries;
2406 if (load_debug_section (info, file)
2407 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2408 return num_debug_info_entries;
2410 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2415 display_debug_lines_raw (struct dwarf_section *section,
2416 unsigned char *data,
2419 unsigned char *start = section->start;
2421 printf (_("Raw dump of debug contents of section %s:\n\n"),
2426 DWARF2_Internal_LineInfo linfo;
2427 unsigned char *standard_opcodes;
2428 unsigned char *end_of_sequence;
2429 unsigned char *hdrptr;
2430 unsigned long hdroff;
2431 int initial_length_size;
2436 hdroff = hdrptr - start;
2438 /* Check the length of the block. */
2439 linfo.li_length = byte_get (hdrptr, 4);
2442 if (linfo.li_length == 0xffffffff)
2444 /* This section is 64-bit DWARF 3. */
2445 linfo.li_length = byte_get (hdrptr, 8);
2448 initial_length_size = 12;
2453 initial_length_size = 4;
2456 if (linfo.li_length + initial_length_size > section->size)
2459 (_("The information in section %s appears to be corrupt - the section is too small\n"),
2464 /* Check its version number. */
2465 linfo.li_version = byte_get (hdrptr, 2);
2467 if (linfo.li_version != 2
2468 && linfo.li_version != 3
2469 && linfo.li_version != 4)
2471 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2475 linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2476 hdrptr += offset_size;
2477 linfo.li_min_insn_length = byte_get (hdrptr, 1);
2479 if (linfo.li_version >= 4)
2481 linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2483 if (linfo.li_max_ops_per_insn == 0)
2485 warn (_("Invalid maximum operations per insn.\n"));
2490 linfo.li_max_ops_per_insn = 1;
2491 linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2493 linfo.li_line_base = byte_get (hdrptr, 1);
2495 linfo.li_line_range = byte_get (hdrptr, 1);
2497 linfo.li_opcode_base = byte_get (hdrptr, 1);
2500 /* Sign extend the line base field. */
2501 linfo.li_line_base <<= 24;
2502 linfo.li_line_base >>= 24;
2504 printf (_(" Offset: 0x%lx\n"), hdroff);
2505 printf (_(" Length: %ld\n"), (long) linfo.li_length);
2506 printf (_(" DWARF Version: %d\n"), linfo.li_version);
2507 printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length);
2508 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
2509 if (linfo.li_version >= 4)
2510 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2511 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2512 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2513 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2514 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
2516 end_of_sequence = data + linfo.li_length + initial_length_size;
2518 reset_state_machine (linfo.li_default_is_stmt);
2520 /* Display the contents of the Opcodes table. */
2521 standard_opcodes = hdrptr;
2523 printf (_("\n Opcodes:\n"));
2525 for (i = 1; i < linfo.li_opcode_base; i++)
2526 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2528 /* Display the contents of the Directory table. */
2529 data = standard_opcodes + linfo.li_opcode_base - 1;
2532 printf (_("\n The Directory Table is empty.\n"));
2535 printf (_("\n The Directory Table:\n"));
2539 printf (" %s\n", data);
2541 data += strlen ((char *) data) + 1;
2545 /* Skip the NUL at the end of the table. */
2548 /* Display the contents of the File Name table. */
2550 printf (_("\n The File Name Table is empty.\n"));
2553 printf (_("\n The File Name Table:\n"));
2554 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2558 unsigned char *name;
2559 unsigned int bytes_read;
2561 printf (" %d\t", ++state_machine_regs.last_file_entry);
2564 data += strlen ((char *) data) + 1;
2567 dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2570 dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2573 dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2575 printf ("%s\n", name);
2579 /* Skip the NUL at the end of the table. */
2582 /* Now display the statements. */
2583 printf (_("\n Line Number Statements:\n"));
2585 while (data < end_of_sequence)
2587 unsigned char op_code;
2588 dwarf_signed_vma adv;
2590 unsigned int bytes_read;
2594 if (op_code >= linfo.li_opcode_base)
2596 op_code -= linfo.li_opcode_base;
2597 uladv = (op_code / linfo.li_line_range);
2598 if (linfo.li_max_ops_per_insn == 1)
2600 uladv *= linfo.li_min_insn_length;
2601 state_machine_regs.address += uladv;
2602 printf (_(" Special opcode %d: "
2603 "advance Address by %s to 0x%s"),
2604 op_code, dwarf_vmatoa ("u", uladv),
2605 dwarf_vmatoa ("x", state_machine_regs.address));
2609 state_machine_regs.address
2610 += ((state_machine_regs.op_index + uladv)
2611 / linfo.li_max_ops_per_insn)
2612 * linfo.li_min_insn_length;
2613 state_machine_regs.op_index
2614 = (state_machine_regs.op_index + uladv)
2615 % linfo.li_max_ops_per_insn;
2616 printf (_(" Special opcode %d: "
2617 "advance Address by %s to 0x%s[%d]"),
2618 op_code, dwarf_vmatoa ("u", uladv),
2619 dwarf_vmatoa ("x", state_machine_regs.address),
2620 state_machine_regs.op_index);
2622 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2623 state_machine_regs.line += adv;
2624 printf (_(" and Line by %s to %d\n"),
2625 dwarf_vmatoa ("d", adv), state_machine_regs.line);
2627 else switch (op_code)
2629 case DW_LNS_extended_op:
2630 data += process_extended_line_op (data, linfo.li_default_is_stmt);
2634 printf (_(" Copy\n"));
2637 case DW_LNS_advance_pc:
2638 uladv = read_leb128 (data, & bytes_read, 0);
2640 if (linfo.li_max_ops_per_insn == 1)
2642 uladv *= linfo.li_min_insn_length;
2643 state_machine_regs.address += uladv;
2644 printf (_(" Advance PC by %s to 0x%s\n"),
2645 dwarf_vmatoa ("u", uladv),
2646 dwarf_vmatoa ("x", state_machine_regs.address));
2650 state_machine_regs.address
2651 += ((state_machine_regs.op_index + uladv)
2652 / linfo.li_max_ops_per_insn)
2653 * linfo.li_min_insn_length;
2654 state_machine_regs.op_index
2655 = (state_machine_regs.op_index + uladv)
2656 % linfo.li_max_ops_per_insn;
2657 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
2658 dwarf_vmatoa ("u", uladv),
2659 dwarf_vmatoa ("x", state_machine_regs.address),
2660 state_machine_regs.op_index);
2664 case DW_LNS_advance_line:
2665 adv = read_sleb128 (data, & bytes_read);
2667 state_machine_regs.line += adv;
2668 printf (_(" Advance Line by %s to %d\n"),
2669 dwarf_vmatoa ("d", adv),
2670 state_machine_regs.line);
2673 case DW_LNS_set_file:
2674 adv = read_leb128 (data, & bytes_read, 0);
2676 printf (_(" Set File Name to entry %s in the File Name Table\n"),
2677 dwarf_vmatoa ("d", adv));
2678 state_machine_regs.file = adv;
2681 case DW_LNS_set_column:
2682 uladv = read_leb128 (data, & bytes_read, 0);
2684 printf (_(" Set column to %s\n"),
2685 dwarf_vmatoa ("u", uladv));
2686 state_machine_regs.column = uladv;
2689 case DW_LNS_negate_stmt:
2690 adv = state_machine_regs.is_stmt;
2692 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
2693 state_machine_regs.is_stmt = adv;
2696 case DW_LNS_set_basic_block:
2697 printf (_(" Set basic block\n"));
2698 state_machine_regs.basic_block = 1;
2701 case DW_LNS_const_add_pc:
2702 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2703 if (linfo.li_max_ops_per_insn)
2705 uladv *= linfo.li_min_insn_length;
2706 state_machine_regs.address += uladv;
2707 printf (_(" Advance PC by constant %s to 0x%s\n"),
2708 dwarf_vmatoa ("u", uladv),
2709 dwarf_vmatoa ("x", state_machine_regs.address));
2713 state_machine_regs.address
2714 += ((state_machine_regs.op_index + uladv)
2715 / linfo.li_max_ops_per_insn)
2716 * linfo.li_min_insn_length;
2717 state_machine_regs.op_index
2718 = (state_machine_regs.op_index + uladv)
2719 % linfo.li_max_ops_per_insn;
2720 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
2721 dwarf_vmatoa ("u", uladv),
2722 dwarf_vmatoa ("x", state_machine_regs.address),
2723 state_machine_regs.op_index);
2727 case DW_LNS_fixed_advance_pc:
2728 uladv = byte_get (data, 2);
2730 state_machine_regs.address += uladv;
2731 state_machine_regs.op_index = 0;
2732 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
2733 dwarf_vmatoa ("u", uladv),
2734 dwarf_vmatoa ("x", state_machine_regs.address));
2737 case DW_LNS_set_prologue_end:
2738 printf (_(" Set prologue_end to true\n"));
2741 case DW_LNS_set_epilogue_begin:
2742 printf (_(" Set epilogue_begin to true\n"));
2745 case DW_LNS_set_isa:
2746 uladv = read_leb128 (data, & bytes_read, 0);
2748 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
2752 printf (_(" Unknown opcode %d with operands: "), op_code);
2754 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2756 printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
2758 i == 1 ? "" : ", ");
2773 unsigned char *name;
2774 unsigned int directory_index;
2775 unsigned int modification_date;
2776 unsigned int length;
2779 /* Output a decoded representation of the .debug_line section. */
2782 display_debug_lines_decoded (struct dwarf_section *section,
2783 unsigned char *data,
2786 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2791 /* This loop amounts to one iteration per compilation unit. */
2792 DWARF2_Internal_LineInfo linfo;
2793 unsigned char *standard_opcodes;
2794 unsigned char *end_of_sequence;
2795 unsigned char *hdrptr;
2796 int initial_length_size;
2799 File_Entry *file_table = NULL;
2800 unsigned char **directory_table = NULL;
2804 /* Extract information from the Line Number Program Header.
2805 (section 6.2.4 in the Dwarf3 doc). */
2807 /* Get the length of this CU's line number information block. */
2808 linfo.li_length = byte_get (hdrptr, 4);
2811 if (linfo.li_length == 0xffffffff)
2813 /* This section is 64-bit DWARF 3. */
2814 linfo.li_length = byte_get (hdrptr, 8);
2817 initial_length_size = 12;
2822 initial_length_size = 4;
2825 if (linfo.li_length + initial_length_size > section->size)
2827 warn (_("The line info appears to be corrupt - "
2828 "the section is too small\n"));
2832 /* Get this CU's Line Number Block version number. */
2833 linfo.li_version = byte_get (hdrptr, 2);
2835 if (linfo.li_version != 2
2836 && linfo.li_version != 3
2837 && linfo.li_version != 4)
2839 warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2844 linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2845 hdrptr += offset_size;
2846 linfo.li_min_insn_length = byte_get (hdrptr, 1);
2848 if (linfo.li_version >= 4)
2850 linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2852 if (linfo.li_max_ops_per_insn == 0)
2854 warn (_("Invalid maximum operations per insn.\n"));
2859 linfo.li_max_ops_per_insn = 1;
2860 linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2862 linfo.li_line_base = byte_get (hdrptr, 1);
2864 linfo.li_line_range = byte_get (hdrptr, 1);
2866 linfo.li_opcode_base = byte_get (hdrptr, 1);
2869 /* Sign extend the line base field. */
2870 linfo.li_line_base <<= 24;
2871 linfo.li_line_base >>= 24;
2873 /* Find the end of this CU's Line Number Information Block. */
2874 end_of_sequence = data + linfo.li_length + initial_length_size;
2876 reset_state_machine (linfo.li_default_is_stmt);
2878 /* Save a pointer to the contents of the Opcodes table. */
2879 standard_opcodes = hdrptr;
2881 /* Traverse the Directory table just to count entries. */
2882 data = standard_opcodes + linfo.li_opcode_base - 1;
2885 unsigned int n_directories = 0;
2886 unsigned char *ptr_directory_table = data;
2890 data += strlen ((char *) data) + 1;
2894 /* Go through the directory table again to save the directories. */
2895 directory_table = (unsigned char **)
2896 xmalloc (n_directories * sizeof (unsigned char *));
2899 while (*ptr_directory_table != 0)
2901 directory_table[i] = ptr_directory_table;
2902 ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2906 /* Skip the NUL at the end of the table. */
2909 /* Traverse the File Name table just to count the entries. */
2912 unsigned int n_files = 0;
2913 unsigned char *ptr_file_name_table = data;
2917 unsigned int bytes_read;
2919 /* Skip Name, directory index, last modification time and length
2921 data += strlen ((char *) data) + 1;
2922 read_leb128 (data, & bytes_read, 0);
2924 read_leb128 (data, & bytes_read, 0);
2926 read_leb128 (data, & bytes_read, 0);
2932 /* Go through the file table again to save the strings. */
2933 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
2936 while (*ptr_file_name_table != 0)
2938 unsigned int bytes_read;
2940 file_table[i].name = ptr_file_name_table;
2941 ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2943 /* We are not interested in directory, time or size. */
2944 file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2946 ptr_file_name_table += bytes_read;
2947 file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2949 ptr_file_name_table += bytes_read;
2950 file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2951 ptr_file_name_table += bytes_read;
2956 /* Print the Compilation Unit's name and a header. */
2957 if (directory_table == NULL)
2959 printf (_("CU: %s:\n"), file_table[0].name);
2960 printf (_("File name Line number Starting address\n"));
2964 if (do_wide || strlen ((char *) directory_table[0]) < 76)
2965 printf (_("CU: %s/%s:\n"), directory_table[0],
2966 file_table[0].name);
2968 printf ("%s:\n", file_table[0].name);
2970 printf (_("File name Line number Starting address\n"));
2974 /* Skip the NUL at the end of the table. */
2977 /* This loop iterates through the Dwarf Line Number Program. */
2978 while (data < end_of_sequence)
2980 unsigned char op_code;
2982 unsigned long int uladv;
2983 unsigned int bytes_read;
2984 int is_special_opcode = 0;
2988 if (op_code >= linfo.li_opcode_base)
2990 op_code -= linfo.li_opcode_base;
2991 uladv = (op_code / linfo.li_line_range);
2992 if (linfo.li_max_ops_per_insn == 1)
2994 uladv *= linfo.li_min_insn_length;
2995 state_machine_regs.address += uladv;
2999 state_machine_regs.address
3000 += ((state_machine_regs.op_index + uladv)
3001 / linfo.li_max_ops_per_insn)
3002 * linfo.li_min_insn_length;
3003 state_machine_regs.op_index
3004 = (state_machine_regs.op_index + uladv)
3005 % linfo.li_max_ops_per_insn;
3008 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3009 state_machine_regs.line += adv;
3010 is_special_opcode = 1;
3012 else switch (op_code)
3014 case DW_LNS_extended_op:
3016 unsigned int ext_op_code_len;
3017 unsigned char ext_op_code;
3018 unsigned char *op_code_data = data;
3020 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
3021 op_code_data += bytes_read;
3023 if (ext_op_code_len == 0)
3025 warn (_("badly formed extended line op encountered!\n"));
3028 ext_op_code_len += bytes_read;
3029 ext_op_code = *op_code_data++;
3031 switch (ext_op_code)
3033 case DW_LNE_end_sequence:
3034 reset_state_machine (linfo.li_default_is_stmt);
3036 case DW_LNE_set_address:
3037 state_machine_regs.address =
3038 byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
3039 state_machine_regs.op_index = 0;
3041 case DW_LNE_define_file:
3043 unsigned int dir_index = 0;
3045 ++state_machine_regs.last_file_entry;
3046 op_code_data += strlen ((char *) op_code_data) + 1;
3047 dir_index = read_leb128 (op_code_data, & bytes_read, 0);
3048 op_code_data += bytes_read;
3049 read_leb128 (op_code_data, & bytes_read, 0);
3050 op_code_data += bytes_read;
3051 read_leb128 (op_code_data, & bytes_read, 0);
3053 printf ("%s:\n", directory_table[dir_index]);
3057 printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
3060 data += ext_op_code_len;
3066 case DW_LNS_advance_pc:
3067 uladv = read_leb128 (data, & bytes_read, 0);
3069 if (linfo.li_max_ops_per_insn == 1)
3071 uladv *= linfo.li_min_insn_length;
3072 state_machine_regs.address += uladv;
3076 state_machine_regs.address
3077 += ((state_machine_regs.op_index + uladv)
3078 / linfo.li_max_ops_per_insn)
3079 * linfo.li_min_insn_length;
3080 state_machine_regs.op_index
3081 = (state_machine_regs.op_index + uladv)
3082 % linfo.li_max_ops_per_insn;
3086 case DW_LNS_advance_line:
3087 adv = read_sleb128 (data, & bytes_read);
3089 state_machine_regs.line += adv;
3092 case DW_LNS_set_file:
3093 adv = read_leb128 (data, & bytes_read, 0);
3095 state_machine_regs.file = adv;
3096 if (file_table[state_machine_regs.file - 1].directory_index == 0)
3098 /* If directory index is 0, that means current directory. */
3099 printf ("\n./%s:[++]\n",
3100 file_table[state_machine_regs.file - 1].name);
3104 /* The directory index starts counting at 1. */
3105 printf ("\n%s/%s:\n",
3106 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3107 file_table[state_machine_regs.file - 1].name);
3111 case DW_LNS_set_column:
3112 uladv = read_leb128 (data, & bytes_read, 0);
3114 state_machine_regs.column = uladv;
3117 case DW_LNS_negate_stmt:
3118 adv = state_machine_regs.is_stmt;
3120 state_machine_regs.is_stmt = adv;
3123 case DW_LNS_set_basic_block:
3124 state_machine_regs.basic_block = 1;
3127 case DW_LNS_const_add_pc:
3128 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3129 if (linfo.li_max_ops_per_insn == 1)
3131 uladv *= linfo.li_min_insn_length;
3132 state_machine_regs.address += uladv;
3136 state_machine_regs.address
3137 += ((state_machine_regs.op_index + uladv)
3138 / linfo.li_max_ops_per_insn)
3139 * linfo.li_min_insn_length;
3140 state_machine_regs.op_index
3141 = (state_machine_regs.op_index + uladv)
3142 % linfo.li_max_ops_per_insn;
3146 case DW_LNS_fixed_advance_pc:
3147 uladv = byte_get (data, 2);
3149 state_machine_regs.address += uladv;
3150 state_machine_regs.op_index = 0;
3153 case DW_LNS_set_prologue_end:
3156 case DW_LNS_set_epilogue_begin:
3159 case DW_LNS_set_isa:
3160 uladv = read_leb128 (data, & bytes_read, 0);
3162 printf (_(" Set ISA to %lu\n"), uladv);
3166 printf (_(" Unknown opcode %d with operands: "), op_code);
3168 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3170 printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
3172 i == 1 ? "" : ", ");
3179 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3180 to the DWARF address/line matrix. */
3181 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3182 || (op_code == DW_LNS_copy))
3184 const unsigned int MAX_FILENAME_LENGTH = 35;
3185 char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
3186 char *newFileName = NULL;
3187 size_t fileNameLength = strlen (fileName);
3189 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3191 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3192 /* Truncate file name */
3193 strncpy (newFileName,
3194 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3195 MAX_FILENAME_LENGTH + 1);
3199 newFileName = (char *) xmalloc (fileNameLength + 1);
3200 strncpy (newFileName, fileName, fileNameLength + 1);
3203 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3205 if (linfo.li_max_ops_per_insn == 1)
3206 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n",
3207 newFileName, state_machine_regs.line,
3208 state_machine_regs.address);
3210 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3211 newFileName, state_machine_regs.line,
3212 state_machine_regs.address,
3213 state_machine_regs.op_index);
3217 if (linfo.li_max_ops_per_insn == 1)
3218 printf ("%s %11d %#18" DWARF_VMA_FMT "x\n",
3219 newFileName, state_machine_regs.line,
3220 state_machine_regs.address);
3222 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3223 newFileName, state_machine_regs.line,
3224 state_machine_regs.address,
3225 state_machine_regs.op_index);
3228 if (op_code == DW_LNE_end_sequence)
3236 free (directory_table);
3237 directory_table = NULL;
3245 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3247 unsigned char *data = section->start;
3248 unsigned char *end = data + section->size;
3250 int retValDecoded = 1;
3252 if (do_debug_lines == 0)
3253 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3255 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3256 retValRaw = display_debug_lines_raw (section, data, end);
3258 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3259 retValDecoded = display_debug_lines_decoded (section, data, end);
3261 if (!retValRaw || !retValDecoded)
3268 find_debug_info_for_offset (unsigned long offset)
3272 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3275 for (i = 0; i < num_debug_info_entries; i++)
3276 if (debug_information[i].cu_offset == offset)
3277 return debug_information + i;
3283 display_debug_pubnames (struct dwarf_section *section,
3284 void *file ATTRIBUTE_UNUSED)
3286 DWARF2_Internal_PubNames names;
3287 unsigned char *start = section->start;
3288 unsigned char *end = start + section->size;
3290 /* It does not matter if this load fails,
3291 we test for that later on. */
3292 load_debug_info (file);
3294 printf (_("Contents of the %s section:\n\n"), section->name);
3298 unsigned char *data;
3299 unsigned long offset;
3300 int offset_size, initial_length_size;
3304 names.pn_length = byte_get (data, 4);
3306 if (names.pn_length == 0xffffffff)
3308 names.pn_length = byte_get (data, 8);
3311 initial_length_size = 12;
3316 initial_length_size = 4;
3319 names.pn_version = byte_get (data, 2);
3322 names.pn_offset = byte_get (data, offset_size);
3323 data += offset_size;
3325 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3326 && num_debug_info_entries > 0
3327 && find_debug_info_for_offset (names.pn_offset) == NULL)
3328 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3329 (unsigned long) names.pn_offset, section->name);
3331 names.pn_size = byte_get (data, offset_size);
3332 data += offset_size;
3334 start += names.pn_length + initial_length_size;
3336 if (names.pn_version != 2 && names.pn_version != 3)
3338 static int warned = 0;
3342 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3349 printf (_(" Length: %ld\n"),
3350 (long) names.pn_length);
3351 printf (_(" Version: %d\n"),
3353 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3354 (unsigned long) names.pn_offset);
3355 printf (_(" Size of area in .debug_info section: %ld\n"),
3356 (long) names.pn_size);
3358 printf (_("\n Offset\tName\n"));
3362 offset = byte_get (data, offset_size);
3366 data += offset_size;
3367 printf (" %-6lx\t%s\n", offset, data);
3368 data += strlen ((char *) data) + 1;
3371 while (offset != 0);
3379 display_debug_macinfo (struct dwarf_section *section,
3380 void *file ATTRIBUTE_UNUSED)
3382 unsigned char *start = section->start;
3383 unsigned char *end = start + section->size;
3384 unsigned char *curr = start;
3385 unsigned int bytes_read;
3386 enum dwarf_macinfo_record_type op;
3388 printf (_("Contents of the %s section:\n\n"), section->name);
3392 unsigned int lineno;
3395 op = (enum dwarf_macinfo_record_type) *curr;
3400 case DW_MACINFO_start_file:
3402 unsigned int filenum;
3404 lineno = read_leb128 (curr, & bytes_read, 0);
3406 filenum = read_leb128 (curr, & bytes_read, 0);
3409 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3414 case DW_MACINFO_end_file:
3415 printf (_(" DW_MACINFO_end_file\n"));
3418 case DW_MACINFO_define:
3419 lineno = read_leb128 (curr, & bytes_read, 0);
3421 string = (char *) curr;
3422 curr += strlen (string) + 1;
3423 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3427 case DW_MACINFO_undef:
3428 lineno = read_leb128 (curr, & bytes_read, 0);
3430 string = (char *) curr;
3431 curr += strlen (string) + 1;
3432 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3436 case DW_MACINFO_vendor_ext:
3438 unsigned int constant;
3440 constant = read_leb128 (curr, & bytes_read, 0);
3442 string = (char *) curr;
3443 curr += strlen (string) + 1;
3444 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3454 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3455 filename and dirname corresponding to file name table entry with index
3456 FILEIDX. Return NULL on failure. */
3458 static unsigned char *
3459 get_line_filename_and_dirname (dwarf_vma line_offset, dwarf_vma fileidx,
3460 unsigned char **dir_name)
3462 struct dwarf_section *section = &debug_displays [line].section;
3463 unsigned char *hdrptr, *dirtable, *file_name;
3464 unsigned int offset_size, initial_length_size;
3465 unsigned int version, opcode_base, bytes_read;
3466 dwarf_vma length, diridx;
3469 if (section->start == NULL
3470 || line_offset >= section->size
3474 hdrptr = section->start + line_offset;
3475 length = byte_get (hdrptr, 4);
3477 if (length == 0xffffffff)
3479 /* This section is 64-bit DWARF 3. */
3480 length = byte_get (hdrptr, 8);
3483 initial_length_size = 12;
3488 initial_length_size = 4;
3490 if (length + initial_length_size > section->size)
3492 version = byte_get (hdrptr, 2);
3494 if (version != 2 && version != 3 && version != 4)
3496 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
3498 hdrptr++; /* Skip max_ops_per_insn. */
3499 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
3500 opcode_base = byte_get (hdrptr, 1);
3501 if (opcode_base == 0)
3504 hdrptr += opcode_base - 1;
3506 /* Skip over dirname table. */
3507 while (*hdrptr != '\0')
3508 hdrptr += strlen ((char *) hdrptr) + 1;
3509 hdrptr++; /* Skip the NUL at the end of the table. */
3510 /* Now skip over preceding filename table entries. */
3511 for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3513 hdrptr += strlen ((char *) hdrptr) + 1;
3514 read_leb128 (hdrptr, &bytes_read, 0);
3515 hdrptr += bytes_read;
3516 read_leb128 (hdrptr, &bytes_read, 0);
3517 hdrptr += bytes_read;
3518 read_leb128 (hdrptr, &bytes_read, 0);
3519 hdrptr += bytes_read;
3521 if (*hdrptr == '\0')
3524 hdrptr += strlen ((char *) hdrptr) + 1;
3525 diridx = read_leb128 (hdrptr, &bytes_read, 0);
3528 for (; *dirtable != '\0' && diridx > 1; diridx--)
3529 dirtable += strlen ((char *) dirtable) + 1;
3530 if (*dirtable == '\0')
3532 *dir_name = dirtable;
3537 display_debug_macro (struct dwarf_section *section,
3540 unsigned char *start = section->start;
3541 unsigned char *end = start + section->size;
3542 unsigned char *curr = start;
3543 unsigned char *extended_op_buf[256];
3544 unsigned int bytes_read;
3546 load_debug_section (str, file);
3547 load_debug_section (line, file);
3549 printf (_("Contents of the %s section:\n\n"), section->name);
3553 unsigned int lineno, version, flags;
3554 unsigned int offset_size = 4;
3556 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
3557 unsigned char **extended_ops = NULL;
3559 version = byte_get (curr, 2);
3564 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3569 flags = byte_get (curr++, 1);
3572 printf (_(" Offset: 0x%lx\n"),
3573 (unsigned long) sec_offset);
3574 printf (_(" Version: %d\n"), version);
3575 printf (_(" Offset size: %d\n"), offset_size);
3578 line_offset = byte_get (curr, offset_size);
3579 curr += offset_size;
3580 printf (_(" Offset into .debug_line: 0x%lx\n"),
3581 (unsigned long) line_offset);
3585 unsigned int i, count = byte_get (curr++, 1), op;
3587 memset (extended_op_buf, 0, sizeof (extended_op_buf));
3588 extended_ops = extended_op_buf;
3591 printf (_(" Extension opcode arguments:\n"));
3592 for (i = 0; i < count; i++)
3594 op = byte_get (curr++, 1);
3595 extended_ops[op] = curr;
3596 nargs = read_leb128 (curr, &bytes_read, 0);
3599 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op);
3602 printf (_(" DW_MACRO_GNU_%02x arguments: "), op);
3603 for (n = 0; n < nargs; n++)
3605 unsigned int form = byte_get (curr++, 1);
3606 printf ("%s%s", get_FORM_name (form),
3607 n == nargs - 1 ? "\n" : ", ");
3617 case DW_FORM_block1:
3618 case DW_FORM_block2:
3619 case DW_FORM_block4:
3621 case DW_FORM_string:
3623 case DW_FORM_sec_offset:
3626 error (_("Invalid extension opcode form %s\n"),
3627 get_FORM_name (form));
3643 error (_(".debug_macro section not zero terminated\n"));
3647 op = byte_get (curr++, 1);
3653 case DW_MACRO_GNU_start_file:
3655 unsigned int filenum;
3656 unsigned char *file_name = NULL, *dir_name = NULL;
3658 lineno = read_leb128 (curr, &bytes_read, 0);
3660 filenum = read_leb128 (curr, &bytes_read, 0);
3663 if ((flags & 2) == 0)
3664 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
3667 = get_line_filename_and_dirname (line_offset, filenum,
3669 if (file_name == NULL)
3670 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
3673 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
3675 dir_name != NULL ? (const char *) dir_name : "",
3676 dir_name != NULL ? "/" : "", file_name);
3680 case DW_MACRO_GNU_end_file:
3681 printf (_(" DW_MACRO_GNU_end_file\n"));
3684 case DW_MACRO_GNU_define:
3685 lineno = read_leb128 (curr, &bytes_read, 0);
3687 string = (char *) curr;
3688 curr += strlen (string) + 1;
3689 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
3693 case DW_MACRO_GNU_undef:
3694 lineno = read_leb128 (curr, &bytes_read, 0);
3696 string = (char *) curr;
3697 curr += strlen (string) + 1;
3698 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
3702 case DW_MACRO_GNU_define_indirect:
3703 lineno = read_leb128 (curr, &bytes_read, 0);
3705 offset = byte_get (curr, offset_size);
3706 curr += offset_size;
3707 string = fetch_indirect_string (offset);
3708 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
3712 case DW_MACRO_GNU_undef_indirect:
3713 lineno = read_leb128 (curr, &bytes_read, 0);
3715 offset = byte_get (curr, offset_size);
3716 curr += offset_size;
3717 string = fetch_indirect_string (offset);
3718 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
3722 case DW_MACRO_GNU_transparent_include:
3723 offset = byte_get (curr, offset_size);
3724 curr += offset_size;
3725 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
3726 (unsigned long) offset);
3730 if (extended_ops == NULL || extended_ops[op] == NULL)
3732 error (_(" Unknown macro opcode %02x seen\n"), op);
3737 /* Skip over unhandled opcodes. */
3739 unsigned char *desc = extended_ops[op];
3740 nargs = read_leb128 (desc, &bytes_read, 0);
3744 printf (_(" DW_MACRO_GNU_%02x\n"), op);
3747 printf (_(" DW_MACRO_GNU_%02x -"), op);
3748 for (n = 0; n < nargs; n++)
3751 = read_and_display_attr_value (0, byte_get (desc++, 1),
3752 curr, 0, 0, offset_size,
3753 version, NULL, 0, NULL);
3770 display_debug_abbrev (struct dwarf_section *section,
3771 void *file ATTRIBUTE_UNUSED)
3773 abbrev_entry *entry;
3774 unsigned char *start = section->start;
3775 unsigned char *end = start + section->size;
3777 printf (_("Contents of the %s section:\n\n"), section->name);
3783 start = process_abbrev_section (start, end);
3785 if (first_abbrev == NULL)
3788 printf (_(" Number TAG\n"));
3790 for (entry = first_abbrev; entry; entry = entry->next)
3794 printf (" %ld %s [%s]\n",
3796 get_TAG_name (entry->tag),
3797 entry->children ? _("has children") : _("no children"));
3799 for (attr = entry->first_attr; attr; attr = attr->next)
3800 printf (" %-18s %s\n",
3801 get_AT_name (attr->attribute),
3802 get_FORM_name (attr->form));
3812 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
3814 static dwarf_vma *loc_offsets;
3817 loc_offsets_compar (const void *ap, const void *bp)
3819 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
3820 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
3822 return (a > b) - (b > a);
3826 display_debug_loc (struct dwarf_section *section, void *file)
3828 unsigned char *start = section->start;
3829 unsigned char *section_end;
3830 unsigned long bytes;
3831 unsigned char *section_begin = start;
3832 unsigned int num_loc_list = 0;
3833 unsigned long last_offset = 0;
3834 unsigned int first = 0;
3838 int seen_first_offset = 0;
3839 int locs_sorted = 1;
3840 unsigned char *next;
3841 unsigned int *array = NULL;
3843 bytes = section->size;
3844 section_end = start + bytes;
3848 printf (_("\nThe %s section is empty.\n"), section->name);
3852 if (load_debug_info (file) == 0)
3854 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3859 /* Check the order of location list in .debug_info section. If
3860 offsets of location lists are in the ascending order, we can
3861 use `debug_information' directly. */
3862 for (i = 0; i < num_debug_info_entries; i++)
3866 num = debug_information [i].num_loc_offsets;
3867 if (num > num_loc_list)
3870 /* Check if we can use `debug_information' directly. */
3871 if (locs_sorted && num != 0)
3873 if (!seen_first_offset)
3875 /* This is the first location list. */
3876 last_offset = debug_information [i].loc_offsets [0];
3878 seen_first_offset = 1;
3884 for (; j < num; j++)
3887 debug_information [i].loc_offsets [j])
3892 last_offset = debug_information [i].loc_offsets [j];
3897 if (!seen_first_offset)
3898 error (_("No location lists in .debug_info section!\n"));
3900 /* DWARF sections under Mach-O have non-zero addresses. */
3901 if (debug_information [first].num_loc_offsets > 0
3902 && debug_information [first].loc_offsets [0] != section->address)
3903 warn (_("Location lists in %s section start at 0x%s\n"),
3905 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
3908 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
3909 printf (_("Contents of the %s section:\n\n"), section->name);
3910 printf (_(" Offset Begin End Expression\n"));
3912 seen_first_offset = 0;
3913 for (i = first; i < num_debug_info_entries; i++)
3917 unsigned short length;
3918 unsigned long offset;
3919 unsigned int pointer_size;
3920 unsigned int offset_size;
3922 unsigned long cu_offset;
3923 unsigned long base_address;
3924 int need_frame_base;
3927 pointer_size = debug_information [i].pointer_size;
3928 cu_offset = debug_information [i].cu_offset;
3929 offset_size = debug_information [i].offset_size;
3930 dwarf_version = debug_information [i].dwarf_version;
3933 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
3935 loc_offsets = debug_information [i].loc_offsets;
3936 qsort (array, debug_information [i].num_loc_offsets,
3937 sizeof (*array), loc_offsets_compar);
3940 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
3942 j = locs_sorted ? k : array[k];
3944 && debug_information [i].loc_offsets [locs_sorted
3945 ? k - 1 : array [k - 1]]
3946 == debug_information [i].loc_offsets [j])
3948 has_frame_base = debug_information [i].have_frame_base [j];
3949 /* DWARF sections under Mach-O have non-zero addresses. */
3950 offset = debug_information [i].loc_offsets [j] - section->address;
3951 next = section_begin + offset;
3952 base_address = debug_information [i].base_address;
3954 if (!seen_first_offset)
3955 seen_first_offset = 1;
3959 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3960 (unsigned long) (start - section_begin),
3961 (unsigned long) (next - section_begin));
3962 else if (start > next)
3963 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3964 (unsigned long) (start - section_begin),
3965 (unsigned long) (next - section_begin));
3969 if (offset >= bytes)
3971 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3978 if (start + 2 * pointer_size > section_end)
3980 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3985 /* Note: we use sign extension here in order to be sure that
3986 we can detect the -1 escape value. Sign extension into the
3987 top 32 bits of a 32-bit address will not affect the values
3988 that we display since we always show hex values, and always
3989 the bottom 32-bits. */
3990 begin = byte_get_signed (start, pointer_size);
3991 start += pointer_size;
3992 end = byte_get_signed (start, pointer_size);
3993 start += pointer_size;
3995 printf (" %8.8lx ", offset);
3997 if (begin == 0 && end == 0)
3999 printf (_("<End of list>\n"));
4003 /* Check base address specifiers. */
4004 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4007 print_dwarf_vma (begin, pointer_size);
4008 print_dwarf_vma (end, pointer_size);
4009 printf (_("(base address)\n"));
4013 if (start + 2 > section_end)
4015 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4020 length = byte_get (start, 2);
4023 if (start + length > section_end)
4025 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4030 print_dwarf_vma (begin + base_address, pointer_size);
4031 print_dwarf_vma (end + base_address, pointer_size);
4034 need_frame_base = decode_location_expression (start,
4039 cu_offset, section);
4042 if (need_frame_base && !has_frame_base)
4043 printf (_(" [without DW_AT_frame_base]"));
4046 fputs (_(" (start == end)"), stdout);
4047 else if (begin > end)
4048 fputs (_(" (start > end)"), stdout);
4057 if (start < section_end)
4058 warn (_("There are %ld unused bytes at the end of section %s\n"),
4059 (long) (section_end - start), section->name);
4066 display_debug_str (struct dwarf_section *section,
4067 void *file ATTRIBUTE_UNUSED)
4069 unsigned char *start = section->start;
4070 unsigned long bytes = section->size;
4071 dwarf_vma addr = section->address;
4075 printf (_("\nThe %s section is empty.\n"), section->name);
4079 printf (_("Contents of the %s section:\n\n"), section->name);
4087 lbytes = (bytes > 16 ? 16 : bytes);
4089 printf (" 0x%8.8lx ", (unsigned long) addr);
4091 for (j = 0; j < 16; j++)
4094 printf ("%2.2x", start[j]);
4102 for (j = 0; j < lbytes; j++)
4105 if (k >= ' ' && k < 0x80)
4124 display_debug_info (struct dwarf_section *section, void *file)
4126 return process_debug_info (section, file, abbrev, 0, 0);
4130 display_debug_types (struct dwarf_section *section, void *file)
4132 return process_debug_info (section, file, abbrev, 0, 1);
4136 display_trace_info (struct dwarf_section *section, void *file)
4138 return process_debug_info (section, file, trace_abbrev, 0, 0);
4142 display_debug_aranges (struct dwarf_section *section,
4143 void *file ATTRIBUTE_UNUSED)
4145 unsigned char *start = section->start;
4146 unsigned char *end = start + section->size;
4148 printf (_("Contents of the %s section:\n\n"), section->name);
4150 /* It does not matter if this load fails,
4151 we test for that later on. */
4152 load_debug_info (file);
4156 unsigned char *hdrptr;
4157 DWARF2_Internal_ARange arange;
4158 unsigned char *addr_ranges;
4161 unsigned char address_size;
4164 int initial_length_size;
4168 arange.ar_length = byte_get (hdrptr, 4);
4171 if (arange.ar_length == 0xffffffff)
4173 arange.ar_length = byte_get (hdrptr, 8);
4176 initial_length_size = 12;
4181 initial_length_size = 4;
4184 arange.ar_version = byte_get (hdrptr, 2);
4187 arange.ar_info_offset = byte_get (hdrptr, offset_size);
4188 hdrptr += offset_size;
4190 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4191 && num_debug_info_entries > 0
4192 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4193 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4194 (unsigned long) arange.ar_info_offset, section->name);
4196 arange.ar_pointer_size = byte_get (hdrptr, 1);
4199 arange.ar_segment_size = byte_get (hdrptr, 1);
4202 if (arange.ar_version != 2 && arange.ar_version != 3)
4204 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4208 printf (_(" Length: %ld\n"),
4209 (long) arange.ar_length);
4210 printf (_(" Version: %d\n"), arange.ar_version);
4211 printf (_(" Offset into .debug_info: 0x%lx\n"),
4212 (unsigned long) arange.ar_info_offset);
4213 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
4214 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
4216 address_size = arange.ar_pointer_size + arange.ar_segment_size;
4218 /* The DWARF spec does not require that the address size be a power
4219 of two, but we do. This will have to change if we ever encounter
4220 an uneven architecture. */
4221 if ((address_size & (address_size - 1)) != 0)
4223 warn (_("Pointer size + Segment size is not a power of two.\n"));
4227 if (address_size > 4)
4228 printf (_("\n Address Length\n"));
4230 printf (_("\n Address Length\n"));
4232 addr_ranges = hdrptr;
4234 /* Must pad to an alignment boundary that is twice the address size. */
4235 excess = (hdrptr - start) % (2 * address_size);
4237 addr_ranges += (2 * address_size) - excess;
4239 start += arange.ar_length + initial_length_size;
4241 while (addr_ranges + 2 * address_size <= start)
4243 address = byte_get (addr_ranges, address_size);
4245 addr_ranges += address_size;
4247 length = byte_get (addr_ranges, address_size);
4249 addr_ranges += address_size;
4252 print_dwarf_vma (address, address_size);
4253 print_dwarf_vma (length, address_size);
4263 /* Each debug_information[x].range_lists[y] gets this representation for
4264 sorting purposes. */
4268 /* The debug_information[x].range_lists[y] value. */
4269 unsigned long ranges_offset;
4271 /* Original debug_information to find parameters of the data. */
4272 debug_info *debug_info_p;
4275 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
4278 range_entry_compar (const void *ap, const void *bp)
4280 const struct range_entry *a_re = (const struct range_entry *) ap;
4281 const struct range_entry *b_re = (const struct range_entry *) bp;
4282 const unsigned long a = a_re->ranges_offset;
4283 const unsigned long b = b_re->ranges_offset;
4285 return (a > b) - (b > a);
4289 display_debug_ranges (struct dwarf_section *section,
4290 void *file ATTRIBUTE_UNUSED)
4292 unsigned char *start = section->start;
4293 unsigned long bytes;
4294 unsigned char *section_begin = start;
4295 unsigned int num_range_list, i;
4296 struct range_entry *range_entries, *range_entry_fill;
4298 bytes = section->size;
4302 printf (_("\nThe %s section is empty.\n"), section->name);
4306 if (load_debug_info (file) == 0)
4308 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4314 for (i = 0; i < num_debug_info_entries; i++)
4315 num_range_list += debug_information [i].num_range_lists;
4317 if (num_range_list == 0)
4318 error (_("No range lists in .debug_info section!\n"));
4320 range_entries = (struct range_entry *)
4321 xmalloc (sizeof (*range_entries) * num_range_list);
4322 range_entry_fill = range_entries;
4324 for (i = 0; i < num_debug_info_entries; i++)
4326 debug_info *debug_info_p = &debug_information[i];
4329 for (j = 0; j < debug_info_p->num_range_lists; j++)
4331 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
4332 range_entry_fill->debug_info_p = debug_info_p;
4337 qsort (range_entries, num_range_list, sizeof (*range_entries),
4338 range_entry_compar);
4340 /* DWARF sections under Mach-O have non-zero addresses. */
4341 if (range_entries[0].ranges_offset != section->address)
4342 warn (_("Range lists in %s section start at 0x%lx\n"),
4343 section->name, range_entries[0].ranges_offset);
4345 printf (_("Contents of the %s section:\n\n"), section->name);
4346 printf (_(" Offset Begin End\n"));
4348 for (i = 0; i < num_range_list; i++)
4350 struct range_entry *range_entry = &range_entries[i];
4351 debug_info *debug_info_p = range_entry->debug_info_p;
4352 unsigned int pointer_size;
4353 unsigned long offset;
4354 unsigned char *next;
4355 unsigned long base_address;
4357 pointer_size = debug_info_p->pointer_size;
4359 /* DWARF sections under Mach-O have non-zero addresses. */
4360 offset = range_entry->ranges_offset - section->address;
4361 next = section_begin + offset;
4362 base_address = debug_info_p->base_address;
4367 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4368 (unsigned long) (start - section_begin),
4369 (unsigned long) (next - section_begin), section->name);
4370 else if (start > next)
4371 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4372 (unsigned long) (start - section_begin),
4373 (unsigned long) (next - section_begin), section->name);
4382 /* Note: we use sign extension here in order to be sure that
4383 we can detect the -1 escape value. Sign extension into the
4384 top 32 bits of a 32-bit address will not affect the values
4385 that we display since we always show hex values, and always
4386 the bottom 32-bits. */
4387 begin = byte_get_signed (start, pointer_size);
4388 start += pointer_size;
4389 end = byte_get_signed (start, pointer_size);
4390 start += pointer_size;
4392 printf (" %8.8lx ", offset);
4394 if (begin == 0 && end == 0)
4396 printf (_("<End of list>\n"));
4400 /* Check base address specifiers. */
4401 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4404 print_dwarf_vma (begin, pointer_size);
4405 print_dwarf_vma (end, pointer_size);
4406 printf ("(base address)\n");
4410 print_dwarf_vma (begin + base_address, pointer_size);
4411 print_dwarf_vma (end + base_address, pointer_size);
4414 fputs (_("(start == end)"), stdout);
4415 else if (begin > end)
4416 fputs (_("(start > end)"), stdout);
4423 free (range_entries);
4428 typedef struct Frame_Chunk
4430 struct Frame_Chunk *next;
4431 unsigned char *chunk_start;
4433 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
4434 short int *col_type;
4437 unsigned int code_factor;
4439 unsigned long pc_begin;
4440 unsigned long pc_range;
4444 unsigned char fde_encoding;
4445 unsigned char cfa_exp;
4446 unsigned char ptr_size;
4447 unsigned char segment_size;
4451 static const char *const *dwarf_regnames;
4452 static unsigned int dwarf_regnames_count;
4454 /* A marker for a col_type that means this column was never referenced
4455 in the frame info. */
4456 #define DW_CFA_unreferenced (-1)
4458 /* Return 0 if not more space is needed, 1 if more space is needed,
4459 -1 for invalid reg. */
4462 frame_need_space (Frame_Chunk *fc, unsigned int reg)
4464 int prev = fc->ncols;
4466 if (reg < (unsigned int) fc->ncols)
4469 if (dwarf_regnames_count
4470 && reg > dwarf_regnames_count)
4473 fc->ncols = reg + 1;
4474 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
4475 sizeof (short int));
4476 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
4478 while (prev < fc->ncols)
4480 fc->col_type[prev] = DW_CFA_unreferenced;
4481 fc->col_offset[prev] = 0;
4487 static const char *const dwarf_regnames_i386[] =
4489 "eax", "ecx", "edx", "ebx",
4490 "esp", "ebp", "esi", "edi",
4491 "eip", "eflags", NULL,
4492 "st0", "st1", "st2", "st3",
4493 "st4", "st5", "st6", "st7",
4495 "xmm0", "xmm1", "xmm2", "xmm3",
4496 "xmm4", "xmm5", "xmm6", "xmm7",
4497 "mm0", "mm1", "mm2", "mm3",
4498 "mm4", "mm5", "mm6", "mm7",
4499 "fcw", "fsw", "mxcsr",
4500 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4505 init_dwarf_regnames_i386 (void)
4507 dwarf_regnames = dwarf_regnames_i386;
4508 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
4511 static const char *const dwarf_regnames_x86_64[] =
4513 "rax", "rdx", "rcx", "rbx",
4514 "rsi", "rdi", "rbp", "rsp",
4515 "r8", "r9", "r10", "r11",
4516 "r12", "r13", "r14", "r15",
4518 "xmm0", "xmm1", "xmm2", "xmm3",
4519 "xmm4", "xmm5", "xmm6", "xmm7",
4520 "xmm8", "xmm9", "xmm10", "xmm11",
4521 "xmm12", "xmm13", "xmm14", "xmm15",
4522 "st0", "st1", "st2", "st3",
4523 "st4", "st5", "st6", "st7",
4524 "mm0", "mm1", "mm2", "mm3",
4525 "mm4", "mm5", "mm6", "mm7",
4527 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4528 "fs.base", "gs.base", NULL, NULL,
4530 "mxcsr", "fcw", "fsw"
4534 init_dwarf_regnames_x86_64 (void)
4536 dwarf_regnames = dwarf_regnames_x86_64;
4537 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
4541 init_dwarf_regnames (unsigned int e_machine)
4547 init_dwarf_regnames_i386 ();
4553 init_dwarf_regnames_x86_64 ();
4562 regname (unsigned int regno, int row)
4564 static char reg[64];
4566 && regno < dwarf_regnames_count
4567 && dwarf_regnames [regno] != NULL)
4570 return dwarf_regnames [regno];
4571 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
4572 dwarf_regnames [regno]);
4575 snprintf (reg, sizeof (reg), "r%d", regno);
4580 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
4585 if (*max_regs < fc->ncols)
4586 *max_regs = fc->ncols;
4588 if (*need_col_headers)
4590 static const char *sloc = " LOC";
4592 *need_col_headers = 0;
4594 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
4596 for (r = 0; r < *max_regs; r++)
4597 if (fc->col_type[r] != DW_CFA_unreferenced)
4602 printf ("%-5s ", regname (r, 1));
4608 printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
4610 strcpy (tmp, "exp");
4612 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
4613 printf ("%-8s ", tmp);
4615 for (r = 0; r < fc->ncols; r++)
4617 if (fc->col_type[r] != DW_CFA_unreferenced)
4619 switch (fc->col_type[r])
4621 case DW_CFA_undefined:
4624 case DW_CFA_same_value:
4628 sprintf (tmp, "c%+d", fc->col_offset[r]);
4630 case DW_CFA_val_offset:
4631 sprintf (tmp, "v%+d", fc->col_offset[r]);
4633 case DW_CFA_register:
4634 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
4636 case DW_CFA_expression:
4637 strcpy (tmp, "exp");
4639 case DW_CFA_val_expression:
4640 strcpy (tmp, "vexp");
4643 strcpy (tmp, "n/a");
4646 printf ("%-5s ", tmp);
4652 #define GET(N) byte_get (start, N); start += N
4653 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
4654 #define SLEB() read_sleb128 (start, & length_return); start += length_return
4657 display_debug_frames (struct dwarf_section *section,
4658 void *file ATTRIBUTE_UNUSED)
4660 unsigned char *start = section->start;
4661 unsigned char *end = start + section->size;
4662 unsigned char *section_start = start;
4663 Frame_Chunk *chunks = 0;
4664 Frame_Chunk *remembered_state = 0;
4666 int is_eh = strcmp (section->name, ".eh_frame") == 0;
4667 unsigned int length_return;
4669 const char *bad_reg = _("bad register: ");
4670 int saved_eh_addr_size = eh_addr_size;
4672 printf (_("Contents of the %s section:\n"), section->name);
4676 unsigned char *saved_start;
4677 unsigned char *block_end;
4678 unsigned long length;
4679 unsigned long cie_id;
4682 int need_col_headers = 1;
4683 unsigned char *augmentation_data = NULL;
4684 unsigned long augmentation_data_len = 0;
4685 int encoded_ptr_size = saved_eh_addr_size;
4687 int initial_length_size;
4689 saved_start = start;
4690 length = byte_get (start, 4); start += 4;
4694 printf ("\n%08lx ZERO terminator\n\n",
4695 (unsigned long)(saved_start - section_start));
4699 if (length == 0xffffffff)
4701 length = byte_get (start, 8);
4704 initial_length_size = 12;
4709 initial_length_size = 4;
4712 block_end = saved_start + length + initial_length_size;
4713 if (block_end > end)
4715 warn ("Invalid length %#08lx in FDE at %#08lx\n",
4716 length, (unsigned long)(saved_start - section_start));
4719 cie_id = byte_get (start, offset_size); start += offset_size;
4721 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
4725 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4726 memset (fc, 0, sizeof (Frame_Chunk));
4730 fc->chunk_start = saved_start;
4732 fc->col_type = (short int *) xmalloc (sizeof (short int));
4733 fc->col_offset = (int *) xmalloc (sizeof (int));
4734 frame_need_space (fc, max_regs - 1);
4738 fc->augmentation = (char *) start;
4739 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
4741 if (strcmp (fc->augmentation, "eh") == 0)
4742 start += eh_addr_size;
4746 fc->ptr_size = GET (1);
4747 fc->segment_size = GET (1);
4748 eh_addr_size = fc->ptr_size;
4752 fc->ptr_size = eh_addr_size;
4753 fc->segment_size = 0;
4755 fc->code_factor = LEB ();
4756 fc->data_factor = SLEB ();
4766 if (fc->augmentation[0] == 'z')
4768 augmentation_data_len = LEB ();
4769 augmentation_data = start;
4770 start += augmentation_data_len;
4774 if (do_debug_frames_interp)
4775 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4776 (unsigned long)(saved_start - section_start), length, cie_id,
4777 fc->augmentation, fc->code_factor, fc->data_factor,
4781 printf ("\n%08lx %08lx %08lx CIE\n",
4782 (unsigned long)(saved_start - section_start), length, cie_id);
4783 printf (" Version: %d\n", version);
4784 printf (" Augmentation: \"%s\"\n", fc->augmentation);
4787 printf (" Pointer Size: %u\n", fc->ptr_size);
4788 printf (" Segment Size: %u\n", fc->segment_size);
4790 printf (" Code alignment factor: %u\n", fc->code_factor);
4791 printf (" Data alignment factor: %d\n", fc->data_factor);
4792 printf (" Return address column: %d\n", fc->ra);
4794 if (augmentation_data_len)
4797 printf (" Augmentation data: ");
4798 for (i = 0; i < augmentation_data_len; ++i)
4799 printf (" %02x", augmentation_data[i]);
4805 if (augmentation_data_len)
4807 unsigned char *p, *q;
4808 p = (unsigned char *) fc->augmentation + 1;
4809 q = augmentation_data;
4816 q += 1 + size_of_encoded_value (*q);
4818 fc->fde_encoding = *q++;
4826 if (fc->fde_encoding)
4827 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4830 frame_need_space (fc, fc->ra);
4834 unsigned char *look_for;
4835 static Frame_Chunk fde_fc;
4836 unsigned long segment_selector;
4839 memset (fc, 0, sizeof (Frame_Chunk));
4841 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4843 for (cie = chunks; cie ; cie = cie->next)
4844 if (cie->chunk_start == look_for)
4849 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4850 cie_id, (unsigned long)(saved_start - section_start));
4852 fc->col_type = (short int *) xmalloc (sizeof (short int));
4853 fc->col_offset = (int *) xmalloc (sizeof (int));
4854 frame_need_space (fc, max_regs - 1);
4856 fc->augmentation = "";
4857 fc->fde_encoding = 0;
4858 fc->ptr_size = eh_addr_size;
4859 fc->segment_size = 0;
4863 fc->ncols = cie->ncols;
4864 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
4865 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
4866 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4867 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4868 fc->augmentation = cie->augmentation;
4869 fc->ptr_size = cie->ptr_size;
4870 eh_addr_size = cie->ptr_size;
4871 fc->segment_size = cie->segment_size;
4872 fc->code_factor = cie->code_factor;
4873 fc->data_factor = cie->data_factor;
4874 fc->cfa_reg = cie->cfa_reg;
4875 fc->cfa_offset = cie->cfa_offset;
4877 frame_need_space (fc, max_regs - 1);
4878 fc->fde_encoding = cie->fde_encoding;
4881 if (fc->fde_encoding)
4882 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4884 segment_selector = 0;
4885 if (fc->segment_size)
4887 segment_selector = byte_get (start, fc->segment_size);
4888 start += fc->segment_size;
4890 fc->pc_begin = get_encoded_value (start, fc->fde_encoding, section);
4891 start += encoded_ptr_size;
4892 fc->pc_range = byte_get (start, encoded_ptr_size);
4893 start += encoded_ptr_size;
4895 if (cie->augmentation[0] == 'z')
4897 augmentation_data_len = LEB ();
4898 augmentation_data = start;
4899 start += augmentation_data_len;
4902 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
4903 (unsigned long)(saved_start - section_start), length, cie_id,
4904 (unsigned long)(cie->chunk_start - section_start));
4905 if (fc->segment_size)
4906 printf ("%04lx:", segment_selector);
4907 printf ("%08lx..%08lx\n", fc->pc_begin, fc->pc_begin + fc->pc_range);
4908 if (! do_debug_frames_interp && augmentation_data_len)
4912 printf (" Augmentation data: ");
4913 for (i = 0; i < augmentation_data_len; ++i)
4914 printf (" %02x", augmentation_data[i]);
4920 /* At this point, fc is the current chunk, cie (if any) is set, and
4921 we're about to interpret instructions for the chunk. */
4922 /* ??? At present we need to do this always, since this sizes the
4923 fc->col_type and fc->col_offset arrays, which we write into always.
4924 We should probably split the interpreted and non-interpreted bits
4925 into two different routines, since there's so much that doesn't
4926 really overlap between them. */
4927 if (1 || do_debug_frames_interp)
4929 /* Start by making a pass over the chunk, allocating storage
4930 and taking note of what registers are used. */
4931 unsigned char *tmp = start;
4933 while (start < block_end)
4936 unsigned long reg, temp;
4943 /* Warning: if you add any more cases to this switch, be
4944 sure to add them to the corresponding switch below. */
4947 case DW_CFA_advance_loc:
4951 if (frame_need_space (fc, opa) >= 0)
4952 fc->col_type[opa] = DW_CFA_undefined;
4954 case DW_CFA_restore:
4955 if (frame_need_space (fc, opa) >= 0)
4956 fc->col_type[opa] = DW_CFA_undefined;
4958 case DW_CFA_set_loc:
4959 start += encoded_ptr_size;
4961 case DW_CFA_advance_loc1:
4964 case DW_CFA_advance_loc2:
4967 case DW_CFA_advance_loc4:
4970 case DW_CFA_offset_extended:
4971 case DW_CFA_val_offset:
4972 reg = LEB (); LEB ();
4973 if (frame_need_space (fc, reg) >= 0)
4974 fc->col_type[reg] = DW_CFA_undefined;
4976 case DW_CFA_restore_extended:
4978 frame_need_space (fc, reg);
4979 if (frame_need_space (fc, reg) >= 0)
4980 fc->col_type[reg] = DW_CFA_undefined;
4982 case DW_CFA_undefined:
4984 if (frame_need_space (fc, reg) >= 0)
4985 fc->col_type[reg] = DW_CFA_undefined;
4987 case DW_CFA_same_value:
4989 if (frame_need_space (fc, reg) >= 0)
4990 fc->col_type[reg] = DW_CFA_undefined;
4992 case DW_CFA_register:
4993 reg = LEB (); LEB ();
4994 if (frame_need_space (fc, reg) >= 0)
4995 fc->col_type[reg] = DW_CFA_undefined;
4997 case DW_CFA_def_cfa:
5000 case DW_CFA_def_cfa_register:
5003 case DW_CFA_def_cfa_offset:
5006 case DW_CFA_def_cfa_expression:
5010 case DW_CFA_expression:
5011 case DW_CFA_val_expression:
5015 if (frame_need_space (fc, reg) >= 0)
5016 fc->col_type[reg] = DW_CFA_undefined;
5018 case DW_CFA_offset_extended_sf:
5019 case DW_CFA_val_offset_sf:
5020 reg = LEB (); SLEB ();
5021 if (frame_need_space (fc, reg) >= 0)
5022 fc->col_type[reg] = DW_CFA_undefined;
5024 case DW_CFA_def_cfa_sf:
5027 case DW_CFA_def_cfa_offset_sf:
5030 case DW_CFA_MIPS_advance_loc8:
5033 case DW_CFA_GNU_args_size:
5036 case DW_CFA_GNU_negative_offset_extended:
5037 reg = LEB (); LEB ();
5038 if (frame_need_space (fc, reg) >= 0)
5039 fc->col_type[reg] = DW_CFA_undefined;
5048 /* Now we know what registers are used, make a second pass over
5049 the chunk, this time actually printing out the info. */
5051 while (start < block_end)
5054 unsigned long ul, reg, roffs;
5057 const char *reg_prefix = "";
5064 /* Warning: if you add any more cases to this switch, be
5065 sure to add them to the corresponding switch above. */
5068 case DW_CFA_advance_loc:
5069 if (do_debug_frames_interp)
5070 frame_display_row (fc, &need_col_headers, &max_regs);
5072 printf (" DW_CFA_advance_loc: %d to %08lx\n",
5073 opa * fc->code_factor,
5074 fc->pc_begin + opa * fc->code_factor);
5075 fc->pc_begin += opa * fc->code_factor;
5080 if (opa >= (unsigned int) fc->ncols)
5081 reg_prefix = bad_reg;
5082 if (! do_debug_frames_interp || *reg_prefix != '\0')
5083 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
5084 reg_prefix, regname (opa, 0),
5085 roffs * fc->data_factor);
5086 if (*reg_prefix == '\0')
5088 fc->col_type[opa] = DW_CFA_offset;
5089 fc->col_offset[opa] = roffs * fc->data_factor;
5093 case DW_CFA_restore:
5094 if (opa >= (unsigned int) cie->ncols
5095 || opa >= (unsigned int) fc->ncols)
5096 reg_prefix = bad_reg;
5097 if (! do_debug_frames_interp || *reg_prefix != '\0')
5098 printf (" DW_CFA_restore: %s%s\n",
5099 reg_prefix, regname (opa, 0));
5100 if (*reg_prefix == '\0')
5102 fc->col_type[opa] = cie->col_type[opa];
5103 fc->col_offset[opa] = cie->col_offset[opa];
5107 case DW_CFA_set_loc:
5108 vma = get_encoded_value (start, fc->fde_encoding, section);
5109 start += encoded_ptr_size;
5110 if (do_debug_frames_interp)
5111 frame_display_row (fc, &need_col_headers, &max_regs);
5113 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
5117 case DW_CFA_advance_loc1:
5118 ofs = byte_get (start, 1); start += 1;
5119 if (do_debug_frames_interp)
5120 frame_display_row (fc, &need_col_headers, &max_regs);
5122 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
5123 ofs * fc->code_factor,
5124 fc->pc_begin + ofs * fc->code_factor);
5125 fc->pc_begin += ofs * fc->code_factor;
5128 case DW_CFA_advance_loc2:
5129 ofs = byte_get (start, 2); start += 2;
5130 if (do_debug_frames_interp)
5131 frame_display_row (fc, &need_col_headers, &max_regs);
5133 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
5134 ofs * fc->code_factor,
5135 fc->pc_begin + ofs * fc->code_factor);
5136 fc->pc_begin += ofs * fc->code_factor;
5139 case DW_CFA_advance_loc4:
5140 ofs = byte_get (start, 4); start += 4;
5141 if (do_debug_frames_interp)
5142 frame_display_row (fc, &need_col_headers, &max_regs);
5144 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
5145 ofs * fc->code_factor,
5146 fc->pc_begin + ofs * fc->code_factor);
5147 fc->pc_begin += ofs * fc->code_factor;
5150 case DW_CFA_offset_extended:
5153 if (reg >= (unsigned int) fc->ncols)
5154 reg_prefix = bad_reg;
5155 if (! do_debug_frames_interp || *reg_prefix != '\0')
5156 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5157 reg_prefix, regname (reg, 0),
5158 roffs * fc->data_factor);
5159 if (*reg_prefix == '\0')
5161 fc->col_type[reg] = DW_CFA_offset;
5162 fc->col_offset[reg] = roffs * fc->data_factor;
5166 case DW_CFA_val_offset:
5169 if (reg >= (unsigned int) fc->ncols)
5170 reg_prefix = bad_reg;
5171 if (! do_debug_frames_interp || *reg_prefix != '\0')
5172 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
5173 reg_prefix, regname (reg, 0),
5174 roffs * fc->data_factor);
5175 if (*reg_prefix == '\0')
5177 fc->col_type[reg] = DW_CFA_val_offset;
5178 fc->col_offset[reg] = roffs * fc->data_factor;
5182 case DW_CFA_restore_extended:
5184 if (reg >= (unsigned int) cie->ncols
5185 || reg >= (unsigned int) fc->ncols)
5186 reg_prefix = bad_reg;
5187 if (! do_debug_frames_interp || *reg_prefix != '\0')
5188 printf (" DW_CFA_restore_extended: %s%s\n",
5189 reg_prefix, regname (reg, 0));
5190 if (*reg_prefix == '\0')
5192 fc->col_type[reg] = cie->col_type[reg];
5193 fc->col_offset[reg] = cie->col_offset[reg];
5197 case DW_CFA_undefined:
5199 if (reg >= (unsigned int) fc->ncols)
5200 reg_prefix = bad_reg;
5201 if (! do_debug_frames_interp || *reg_prefix != '\0')
5202 printf (" DW_CFA_undefined: %s%s\n",
5203 reg_prefix, regname (reg, 0));
5204 if (*reg_prefix == '\0')
5206 fc->col_type[reg] = DW_CFA_undefined;
5207 fc->col_offset[reg] = 0;
5211 case DW_CFA_same_value:
5213 if (reg >= (unsigned int) fc->ncols)
5214 reg_prefix = bad_reg;
5215 if (! do_debug_frames_interp || *reg_prefix != '\0')
5216 printf (" DW_CFA_same_value: %s%s\n",
5217 reg_prefix, regname (reg, 0));
5218 if (*reg_prefix == '\0')
5220 fc->col_type[reg] = DW_CFA_same_value;
5221 fc->col_offset[reg] = 0;
5225 case DW_CFA_register:
5228 if (reg >= (unsigned int) fc->ncols)
5229 reg_prefix = bad_reg;
5230 if (! do_debug_frames_interp || *reg_prefix != '\0')
5232 printf (" DW_CFA_register: %s%s in ",
5233 reg_prefix, regname (reg, 0));
5234 puts (regname (roffs, 0));
5236 if (*reg_prefix == '\0')
5238 fc->col_type[reg] = DW_CFA_register;
5239 fc->col_offset[reg] = roffs;
5243 case DW_CFA_remember_state:
5244 if (! do_debug_frames_interp)
5245 printf (" DW_CFA_remember_state\n");
5246 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5247 rs->ncols = fc->ncols;
5248 rs->col_type = (short int *) xcmalloc (rs->ncols,
5249 sizeof (short int));
5250 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
5251 memcpy (rs->col_type, fc->col_type, rs->ncols);
5252 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
5253 rs->next = remembered_state;
5254 remembered_state = rs;
5257 case DW_CFA_restore_state:
5258 if (! do_debug_frames_interp)
5259 printf (" DW_CFA_restore_state\n");
5260 rs = remembered_state;
5263 remembered_state = rs->next;
5264 frame_need_space (fc, rs->ncols - 1);
5265 memcpy (fc->col_type, rs->col_type, rs->ncols);
5266 memcpy (fc->col_offset, rs->col_offset,
5267 rs->ncols * sizeof (int));
5268 free (rs->col_type);
5269 free (rs->col_offset);
5272 else if (do_debug_frames_interp)
5273 printf ("Mismatched DW_CFA_restore_state\n");
5276 case DW_CFA_def_cfa:
5277 fc->cfa_reg = LEB ();
5278 fc->cfa_offset = LEB ();
5280 if (! do_debug_frames_interp)
5281 printf (" DW_CFA_def_cfa: %s ofs %d\n",
5282 regname (fc->cfa_reg, 0), fc->cfa_offset);
5285 case DW_CFA_def_cfa_register:
5286 fc->cfa_reg = LEB ();
5288 if (! do_debug_frames_interp)
5289 printf (" DW_CFA_def_cfa_register: %s\n",
5290 regname (fc->cfa_reg, 0));
5293 case DW_CFA_def_cfa_offset:
5294 fc->cfa_offset = LEB ();
5295 if (! do_debug_frames_interp)
5296 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
5300 if (! do_debug_frames_interp)
5301 printf (" DW_CFA_nop\n");
5304 case DW_CFA_def_cfa_expression:
5306 if (! do_debug_frames_interp)
5308 printf (" DW_CFA_def_cfa_expression (");
5309 decode_location_expression (start, eh_addr_size, 0, -1,
5317 case DW_CFA_expression:
5320 if (reg >= (unsigned int) fc->ncols)
5321 reg_prefix = bad_reg;
5322 if (! do_debug_frames_interp || *reg_prefix != '\0')
5324 printf (" DW_CFA_expression: %s%s (",
5325 reg_prefix, regname (reg, 0));
5326 decode_location_expression (start, eh_addr_size, 0, -1,
5330 if (*reg_prefix == '\0')
5331 fc->col_type[reg] = DW_CFA_expression;
5335 case DW_CFA_val_expression:
5338 if (reg >= (unsigned int) fc->ncols)
5339 reg_prefix = bad_reg;
5340 if (! do_debug_frames_interp || *reg_prefix != '\0')
5342 printf (" DW_CFA_val_expression: %s%s (",
5343 reg_prefix, regname (reg, 0));
5344 decode_location_expression (start, eh_addr_size, 0, -1,
5348 if (*reg_prefix == '\0')
5349 fc->col_type[reg] = DW_CFA_val_expression;
5353 case DW_CFA_offset_extended_sf:
5356 if (frame_need_space (fc, reg) < 0)
5357 reg_prefix = bad_reg;
5358 if (! do_debug_frames_interp || *reg_prefix != '\0')
5359 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5360 reg_prefix, regname (reg, 0),
5361 l * fc->data_factor);
5362 if (*reg_prefix == '\0')
5364 fc->col_type[reg] = DW_CFA_offset;
5365 fc->col_offset[reg] = l * fc->data_factor;
5369 case DW_CFA_val_offset_sf:
5372 if (frame_need_space (fc, reg) < 0)
5373 reg_prefix = bad_reg;
5374 if (! do_debug_frames_interp || *reg_prefix != '\0')
5375 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5376 reg_prefix, regname (reg, 0),
5377 l * fc->data_factor);
5378 if (*reg_prefix == '\0')
5380 fc->col_type[reg] = DW_CFA_val_offset;
5381 fc->col_offset[reg] = l * fc->data_factor;
5385 case DW_CFA_def_cfa_sf:
5386 fc->cfa_reg = LEB ();
5387 fc->cfa_offset = SLEB ();
5388 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5390 if (! do_debug_frames_interp)
5391 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
5392 regname (fc->cfa_reg, 0), fc->cfa_offset);
5395 case DW_CFA_def_cfa_offset_sf:
5396 fc->cfa_offset = SLEB ();
5397 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5398 if (! do_debug_frames_interp)
5399 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
5402 case DW_CFA_MIPS_advance_loc8:
5403 ofs = byte_get (start, 8); start += 8;
5404 if (do_debug_frames_interp)
5405 frame_display_row (fc, &need_col_headers, &max_regs);
5407 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
5408 ofs * fc->code_factor,
5409 fc->pc_begin + ofs * fc->code_factor);
5410 fc->pc_begin += ofs * fc->code_factor;
5413 case DW_CFA_GNU_window_save:
5414 if (! do_debug_frames_interp)
5415 printf (" DW_CFA_GNU_window_save\n");
5418 case DW_CFA_GNU_args_size:
5420 if (! do_debug_frames_interp)
5421 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
5424 case DW_CFA_GNU_negative_offset_extended:
5427 if (frame_need_space (fc, reg) < 0)
5428 reg_prefix = bad_reg;
5429 if (! do_debug_frames_interp || *reg_prefix != '\0')
5430 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
5431 reg_prefix, regname (reg, 0),
5432 l * fc->data_factor);
5433 if (*reg_prefix == '\0')
5435 fc->col_type[reg] = DW_CFA_offset;
5436 fc->col_offset[reg] = l * fc->data_factor;
5441 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
5442 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
5444 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
5449 if (do_debug_frames_interp)
5450 frame_display_row (fc, &need_col_headers, &max_regs);
5453 eh_addr_size = saved_eh_addr_size;
5466 display_gdb_index (struct dwarf_section *section,
5467 void *file ATTRIBUTE_UNUSED)
5469 unsigned char *start = section->start;
5471 uint32_t cu_list_offset, tu_list_offset;
5472 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
5473 unsigned int cu_list_elements, tu_list_elements;
5474 unsigned int address_table_size, symbol_table_slots;
5475 unsigned char *cu_list, *tu_list;
5476 unsigned char *address_table, *symbol_table, *constant_pool;
5479 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
5481 printf (_("Contents of the %s section:\n"), section->name);
5483 if (section->size < 6 * sizeof (uint32_t))
5485 warn (_("Truncated header in the %s section.\n"), section->name);
5489 version = byte_get_little_endian (start, 4);
5490 printf (_("Version %ld\n"), (long) version);
5492 /* Prior versions are obsolete, and future versions may not be
5493 backwards compatible. */
5497 warn (_("The address table data in version 3 may be wrong.\n"));
5500 warn (_("Version 4 does not support case insensitive lookups.\n"));
5505 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
5509 cu_list_offset = byte_get_little_endian (start + 4, 4);
5510 tu_list_offset = byte_get_little_endian (start + 8, 4);
5511 address_table_offset = byte_get_little_endian (start + 12, 4);
5512 symbol_table_offset = byte_get_little_endian (start + 16, 4);
5513 constant_pool_offset = byte_get_little_endian (start + 20, 4);
5515 if (cu_list_offset > section->size
5516 || tu_list_offset > section->size
5517 || address_table_offset > section->size
5518 || symbol_table_offset > section->size
5519 || constant_pool_offset > section->size)
5521 warn (_("Corrupt header in the %s section.\n"), section->name);
5525 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
5526 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
5527 address_table_size = symbol_table_offset - address_table_offset;
5528 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
5530 cu_list = start + cu_list_offset;
5531 tu_list = start + tu_list_offset;
5532 address_table = start + address_table_offset;
5533 symbol_table = start + symbol_table_offset;
5534 constant_pool = start + constant_pool_offset;
5536 printf (_("\nCU table:\n"));
5537 for (i = 0; i < cu_list_elements; i += 2)
5539 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
5540 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
5542 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
5543 (unsigned long) cu_offset,
5544 (unsigned long) (cu_offset + cu_length - 1));
5547 printf (_("\nTU table:\n"));
5548 for (i = 0; i < tu_list_elements; i += 3)
5550 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
5551 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
5552 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
5554 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
5555 (unsigned long) tu_offset,
5556 (unsigned long) type_offset);
5557 print_dwarf_vma (signature, 8);
5561 printf (_("\nAddress table:\n"));
5562 for (i = 0; i < address_table_size; i += 2 * 8 + 4)
5564 uint64_t low = byte_get_little_endian (address_table + i, 8);
5565 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
5566 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
5568 print_dwarf_vma (low, 8);
5569 print_dwarf_vma (high, 8);
5570 printf (_("%lu\n"), (unsigned long) cu_index);
5573 printf (_("\nSymbol table:\n"));
5574 for (i = 0; i < symbol_table_slots; ++i)
5576 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
5577 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
5578 uint32_t num_cus, cu;
5580 if (name_offset != 0
5581 || cu_vector_offset != 0)
5585 printf ("[%3u] %s:", i, constant_pool + name_offset);
5586 num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
5587 for (j = 0; j < num_cus; ++j)
5589 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
5590 /* Convert to TU number if it's for a type unit. */
5591 if (cu >= cu_list_elements / 2)
5592 printf (" T%lu", (unsigned long) (cu - cu_list_elements / 2));
5594 printf (" %lu", (unsigned long) cu);
5604 display_debug_not_supported (struct dwarf_section *section,
5605 void *file ATTRIBUTE_UNUSED)
5607 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
5614 cmalloc (size_t nmemb, size_t size)
5616 /* Check for overflow. */
5617 if (nmemb >= ~(size_t) 0 / size)
5620 return malloc (nmemb * size);
5624 xcmalloc (size_t nmemb, size_t size)
5626 /* Check for overflow. */
5627 if (nmemb >= ~(size_t) 0 / size)
5630 return xmalloc (nmemb * size);
5634 xcrealloc (void *ptr, size_t nmemb, size_t size)
5636 /* Check for overflow. */
5637 if (nmemb >= ~(size_t) 0 / size)
5640 return xrealloc (ptr, nmemb * size);
5644 free_debug_memory (void)
5650 for (i = 0; i < max; i++)
5651 free_debug_section ((enum dwarf_section_display_enum) i);
5653 if (debug_information != NULL)
5655 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
5657 for (i = 0; i < num_debug_info_entries; i++)
5659 if (!debug_information [i].max_loc_offsets)
5661 free (debug_information [i].loc_offsets);
5662 free (debug_information [i].have_frame_base);
5664 if (!debug_information [i].max_range_lists)
5665 free (debug_information [i].range_lists);
5669 free (debug_information);
5670 debug_information = NULL;
5671 num_debug_info_entries = 0;
5676 dwarf_select_sections_by_names (const char *names)
5680 const char * option;
5684 debug_dump_long_opts;
5686 static const debug_dump_long_opts opts_table [] =
5688 /* Please keep this table alpha- sorted. */
5689 { "Ranges", & do_debug_ranges, 1 },
5690 { "abbrev", & do_debug_abbrevs, 1 },
5691 { "aranges", & do_debug_aranges, 1 },
5692 { "frames", & do_debug_frames, 1 },
5693 { "frames-interp", & do_debug_frames_interp, 1 },
5694 { "info", & do_debug_info, 1 },
5695 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
5696 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
5697 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
5698 { "loc", & do_debug_loc, 1 },
5699 { "macro", & do_debug_macinfo, 1 },
5700 { "pubnames", & do_debug_pubnames, 1 },
5701 { "pubtypes", & do_debug_pubtypes, 1 },
5702 /* This entry is for compatability
5703 with earlier versions of readelf. */
5704 { "ranges", & do_debug_aranges, 1 },
5705 { "str", & do_debug_str, 1 },
5706 /* The special .gdb_index section. */
5707 { "gdb_index", & do_gdb_index, 1 },
5708 /* These trace_* sections are used by Itanium VMS. */
5709 { "trace_abbrev", & do_trace_abbrevs, 1 },
5710 { "trace_aranges", & do_trace_aranges, 1 },
5711 { "trace_info", & do_trace_info, 1 },
5720 const debug_dump_long_opts * entry;
5722 for (entry = opts_table; entry->option; entry++)
5724 size_t len = strlen (entry->option);
5726 if (strncmp (p, entry->option, len) == 0
5727 && (p[len] == ',' || p[len] == '\0'))
5729 * entry->variable |= entry->val;
5731 /* The --debug-dump=frames-interp option also
5732 enables the --debug-dump=frames option. */
5733 if (do_debug_frames_interp)
5734 do_debug_frames = 1;
5741 if (entry->option == NULL)
5743 warn (_("Unrecognized debug option '%s'\n"), p);
5744 p = strchr (p, ',');
5755 dwarf_select_sections_by_letters (const char *letters)
5757 unsigned int lindex = 0;
5759 while (letters[lindex])
5760 switch (letters[lindex++])
5767 do_debug_abbrevs = 1;
5771 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
5775 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
5779 do_debug_pubnames = 1;
5783 do_debug_pubtypes = 1;
5787 do_debug_aranges = 1;
5791 do_debug_ranges = 1;
5795 do_debug_frames_interp = 1;
5797 do_debug_frames = 1;
5801 do_debug_macinfo = 1;
5813 warn (_("Unrecognized debug option '%s'\n"), optarg);
5819 dwarf_select_sections_all (void)
5822 do_debug_abbrevs = 1;
5823 do_debug_lines = FLAG_DEBUG_LINES_RAW;
5824 do_debug_pubnames = 1;
5825 do_debug_pubtypes = 1;
5826 do_debug_aranges = 1;
5827 do_debug_ranges = 1;
5828 do_debug_frames = 1;
5829 do_debug_macinfo = 1;
5834 do_trace_abbrevs = 1;
5835 do_trace_aranges = 1;
5838 struct dwarf_section_display debug_displays[] =
5840 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0 },
5841 display_debug_abbrev, &do_debug_abbrevs, 0 },
5842 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0 },
5843 display_debug_aranges, &do_debug_aranges, 1 },
5844 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0 },
5845 display_debug_frames, &do_debug_frames, 1 },
5846 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0 },
5847 display_debug_info, &do_debug_info, 1 },
5848 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0 },
5849 display_debug_lines, &do_debug_lines, 1 },
5850 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0 },
5851 display_debug_pubnames, &do_debug_pubnames, 0 },
5852 { { ".eh_frame", "", NULL, NULL, 0, 0 },
5853 display_debug_frames, &do_debug_frames, 1 },
5854 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0 },
5855 display_debug_macinfo, &do_debug_macinfo, 0 },
5856 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0 },
5857 display_debug_macro, &do_debug_macinfo, 1 },
5858 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0 },
5859 display_debug_str, &do_debug_str, 0 },
5860 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0 },
5861 display_debug_loc, &do_debug_loc, 1 },
5862 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0 },
5863 display_debug_pubnames, &do_debug_pubtypes, 0 },
5864 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0 },
5865 display_debug_ranges, &do_debug_ranges, 1 },
5866 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0 },
5867 display_debug_not_supported, NULL, 0 },
5868 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0 },
5869 display_debug_not_supported, NULL, 0 },
5870 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0 },
5871 display_debug_types, &do_debug_info, 1 },
5872 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0 },
5873 display_debug_not_supported, NULL, 0 },
5874 { { ".gdb_index", "", NULL, NULL, 0, 0 },
5875 display_gdb_index, &do_gdb_index, 0 },
5876 { { ".trace_info", "", NULL, NULL, 0, 0 },
5877 display_trace_info, &do_trace_info, 1 },
5878 { { ".trace_abbrev", "", NULL, NULL, 0, 0 },
5879 display_debug_abbrev, &do_trace_abbrevs, 0 },
5880 { { ".trace_aranges", "", NULL, NULL, 0, 0 },
5881 display_debug_aranges, &do_trace_aranges, 0 }