1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007, 2008, 2009, 2010
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"
26 #include "elf/common.h"
30 static const char *regname (unsigned int regno, int row);
32 static int have_frame_base;
33 static int need_base_address;
35 static unsigned int last_pointer_size = 0;
36 static int warned_about_missing_comp_units = FALSE;
38 static unsigned int num_debug_info_entries = 0;
39 static debug_info *debug_information = NULL;
40 /* Special value for num_debug_info_entries to indicate
41 that the .debug_info section could not be loaded/parsed. */
42 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
49 int do_debug_pubnames;
50 int do_debug_pubtypes;
54 int do_debug_frames_interp;
63 /* Values for do_debug_lines. */
64 #define FLAG_DEBUG_LINES_RAW 1
65 #define FLAG_DEBUG_LINES_DECODED 2
67 dwarf_vma (*byte_get) (unsigned char *, int);
70 byte_get_little_endian (unsigned char *field, int size)
78 return ((unsigned int) (field[0]))
79 | (((unsigned int) (field[1])) << 8);
82 return ((unsigned long) (field[0]))
83 | (((unsigned long) (field[1])) << 8)
84 | (((unsigned long) (field[2])) << 16);
87 return ((unsigned long) (field[0]))
88 | (((unsigned long) (field[1])) << 8)
89 | (((unsigned long) (field[2])) << 16)
90 | (((unsigned long) (field[3])) << 24);
93 if (sizeof (dwarf_vma) == 8)
94 return ((dwarf_vma) (field[0]))
95 | (((dwarf_vma) (field[1])) << 8)
96 | (((dwarf_vma) (field[2])) << 16)
97 | (((dwarf_vma) (field[3])) << 24)
98 | (((dwarf_vma) (field[4])) << 32)
99 | (((dwarf_vma) (field[5])) << 40)
100 | (((dwarf_vma) (field[6])) << 48)
101 | (((dwarf_vma) (field[7])) << 56);
102 else if (sizeof (dwarf_vma) == 4)
103 /* We want to extract data from an 8 byte wide field and
104 place it into a 4 byte wide field. Since this is a little
105 endian source we can just use the 4 byte extraction code. */
106 return ((unsigned long) (field[0]))
107 | (((unsigned long) (field[1])) << 8)
108 | (((unsigned long) (field[2])) << 16)
109 | (((unsigned long) (field[3])) << 24);
112 error (_("Unhandled data length: %d\n"), size);
118 byte_get_big_endian (unsigned char *field, int size)
126 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
129 return ((unsigned long) (field[2]))
130 | (((unsigned long) (field[1])) << 8)
131 | (((unsigned long) (field[0])) << 16);
134 return ((unsigned long) (field[3]))
135 | (((unsigned long) (field[2])) << 8)
136 | (((unsigned long) (field[1])) << 16)
137 | (((unsigned long) (field[0])) << 24);
140 if (sizeof (dwarf_vma) == 8)
141 return ((dwarf_vma) (field[7]))
142 | (((dwarf_vma) (field[6])) << 8)
143 | (((dwarf_vma) (field[5])) << 16)
144 | (((dwarf_vma) (field[4])) << 24)
145 | (((dwarf_vma) (field[3])) << 32)
146 | (((dwarf_vma) (field[2])) << 40)
147 | (((dwarf_vma) (field[1])) << 48)
148 | (((dwarf_vma) (field[0])) << 56);
149 else if (sizeof (dwarf_vma) == 4)
151 /* Although we are extracing data from an 8 byte wide field,
152 we are returning only 4 bytes of data. */
154 return ((unsigned long) (field[3]))
155 | (((unsigned long) (field[2])) << 8)
156 | (((unsigned long) (field[1])) << 16)
157 | (((unsigned long) (field[0])) << 24);
161 error (_("Unhandled data length: %d\n"), size);
167 byte_get_signed (unsigned char *field, int size)
169 dwarf_vma x = byte_get (field, size);
174 return (x ^ 0x80) - 0x80;
176 return (x ^ 0x8000) - 0x8000;
178 return (x ^ 0x80000000) - 0x80000000;
187 size_of_encoded_value (int encoding)
189 switch (encoding & 0x7)
192 case 0: return eh_addr_size;
200 get_encoded_value (unsigned char *data, int encoding)
202 int size = size_of_encoded_value (encoding);
204 if (encoding & DW_EH_PE_signed)
205 return byte_get_signed (data, size);
207 return byte_get (data, size);
210 /* Print a dwarf_vma value (typically an address, offset or length) in
211 hexadecimal format, followed by a space. The length of the value (and
212 hence the precision displayed) is determined by the byte_size parameter. */
215 print_dwarf_vma (dwarf_vma val, unsigned byte_size)
217 static char buff[18];
219 /* Printf does not have a way of specifiying a maximum field width for an
220 integer value, so we print the full value into a buffer and then select
221 the precision we need. */
222 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
224 snprintf (buff, sizeof (buff), "%16.16llx ", val);
226 snprintf (buff, sizeof (buff), "%016I64x ", val);
229 snprintf (buff, sizeof (buff), "%16.16lx ", val);
232 fputs (buff + (byte_size == 4 ? 8 : 0), stdout);
236 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
238 unsigned long int result = 0;
239 unsigned int num_read = 0;
240 unsigned int shift = 0;
248 result |= ((unsigned long int) (byte & 0x7f)) << shift;
255 if (length_return != NULL)
256 *length_return = num_read;
258 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
259 result |= -1L << shift;
264 typedef struct State_Machine_Registers
266 unsigned long address;
272 unsigned char op_index;
273 unsigned char end_sequence;
274 /* This variable hold the number of the last entry seen
275 in the File Table. */
276 unsigned int last_file_entry;
279 static SMR state_machine_regs;
282 reset_state_machine (int is_stmt)
284 state_machine_regs.address = 0;
285 state_machine_regs.op_index = 0;
286 state_machine_regs.file = 1;
287 state_machine_regs.line = 1;
288 state_machine_regs.column = 0;
289 state_machine_regs.is_stmt = is_stmt;
290 state_machine_regs.basic_block = 0;
291 state_machine_regs.end_sequence = 0;
292 state_machine_regs.last_file_entry = 0;
295 /* Handled an extend line op.
296 Returns the number of bytes read. */
299 process_extended_line_op (unsigned char *data, int is_stmt)
301 unsigned char op_code;
302 unsigned int bytes_read;
307 len = read_leb128 (data, & bytes_read, 0);
312 warn (_("badly formed extended line op encountered!\n"));
319 printf (_(" Extended opcode %d: "), op_code);
323 case DW_LNE_end_sequence:
324 printf (_("End of Sequence\n\n"));
325 reset_state_machine (is_stmt);
328 case DW_LNE_set_address:
329 adr = byte_get (data, len - bytes_read - 1);
330 printf (_("set Address to 0x%lx\n"), adr);
331 state_machine_regs.address = adr;
332 state_machine_regs.op_index = 0;
335 case DW_LNE_define_file:
336 printf (_(" define new File Table entry\n"));
337 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
339 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
341 data += strlen ((char *) data) + 1;
342 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
344 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
346 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
347 printf (_("%s\n\n"), name);
350 case DW_LNE_set_discriminator:
351 printf (_("set Discriminator to %lu\n"),
352 read_leb128 (data, & bytes_read, 0));
356 case DW_LNE_HP_negate_is_UV_update:
357 printf ("DW_LNE_HP_negate_is_UV_update\n");
359 case DW_LNE_HP_push_context:
360 printf ("DW_LNE_HP_push_context\n");
362 case DW_LNE_HP_pop_context:
363 printf ("DW_LNE_HP_pop_context\n");
365 case DW_LNE_HP_set_file_line_column:
366 printf ("DW_LNE_HP_set_file_line_column\n");
368 case DW_LNE_HP_set_routine_name:
369 printf ("DW_LNE_HP_set_routine_name\n");
371 case DW_LNE_HP_set_sequence:
372 printf ("DW_LNE_HP_set_sequence\n");
374 case DW_LNE_HP_negate_post_semantics:
375 printf ("DW_LNE_HP_negate_post_semantics\n");
377 case DW_LNE_HP_negate_function_exit:
378 printf ("DW_LNE_HP_negate_function_exit\n");
380 case DW_LNE_HP_negate_front_end_logical:
381 printf ("DW_LNE_HP_negate_front_end_logical\n");
383 case DW_LNE_HP_define_proc:
384 printf ("DW_LNE_HP_define_proc\n");
388 if (op_code >= DW_LNE_lo_user
389 /* The test against DW_LNW_hi_user is redundant due to
390 the limited range of the unsigned char data type used
392 /*&& op_code <= DW_LNE_hi_user*/)
393 printf (_("user defined: length %d\n"), len - bytes_read);
395 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
403 fetch_indirect_string (unsigned long offset)
405 struct dwarf_section *section = &debug_displays [str].section;
407 if (section->start == NULL)
408 return _("<no .debug_str section>");
410 /* DWARF sections under Mach-O have non-zero addresses. */
411 offset -= section->address;
412 if (offset > section->size)
414 warn (_("DW_FORM_strp offset too big: %lx\n"), 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));
482 entry->entry = number;
484 entry->children = children;
485 entry->first_attr = NULL;
486 entry->last_attr = NULL;
489 if (first_abbrev == NULL)
490 first_abbrev = entry;
492 last_abbrev->next = entry;
498 add_abbrev_attr (unsigned long attribute, unsigned long form)
502 attr = (abbrev_attr *) malloc (sizeof (*attr));
508 attr->attribute = attribute;
512 if (last_abbrev->first_attr == NULL)
513 last_abbrev->first_attr = attr;
515 last_abbrev->last_attr->next = attr;
517 last_abbrev->last_attr = attr;
520 /* Processes the (partial) contents of a .debug_abbrev section.
521 Returns NULL if the end of the section was encountered.
522 Returns the address after the last byte read if the end of
523 an abbreviation set was found. */
525 static unsigned char *
526 process_abbrev_section (unsigned char *start, unsigned char *end)
528 if (first_abbrev != NULL)
533 unsigned int bytes_read;
536 unsigned long attribute;
539 entry = read_leb128 (start, & bytes_read, 0);
542 /* A single zero is supposed to end the section according
543 to the standard. If there's more, then signal that to
546 return start == end ? NULL : start;
548 tag = read_leb128 (start, & bytes_read, 0);
553 add_abbrev (entry, tag, children);
559 attribute = read_leb128 (start, & bytes_read, 0);
562 form = read_leb128 (start, & bytes_read, 0);
566 add_abbrev_attr (attribute, form);
568 while (attribute != 0);
575 get_TAG_name (unsigned long tag)
579 case DW_TAG_padding: return "DW_TAG_padding";
580 case DW_TAG_array_type: return "DW_TAG_array_type";
581 case DW_TAG_class_type: return "DW_TAG_class_type";
582 case DW_TAG_entry_point: return "DW_TAG_entry_point";
583 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
584 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
585 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
586 case DW_TAG_label: return "DW_TAG_label";
587 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
588 case DW_TAG_member: return "DW_TAG_member";
589 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
590 case DW_TAG_reference_type: return "DW_TAG_reference_type";
591 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
592 case DW_TAG_string_type: return "DW_TAG_string_type";
593 case DW_TAG_structure_type: return "DW_TAG_structure_type";
594 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
595 case DW_TAG_typedef: return "DW_TAG_typedef";
596 case DW_TAG_union_type: return "DW_TAG_union_type";
597 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
598 case DW_TAG_variant: return "DW_TAG_variant";
599 case DW_TAG_common_block: return "DW_TAG_common_block";
600 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
601 case DW_TAG_inheritance: return "DW_TAG_inheritance";
602 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
603 case DW_TAG_module: return "DW_TAG_module";
604 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
605 case DW_TAG_set_type: return "DW_TAG_set_type";
606 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
607 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
608 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
609 case DW_TAG_base_type: return "DW_TAG_base_type";
610 case DW_TAG_catch_block: return "DW_TAG_catch_block";
611 case DW_TAG_const_type: return "DW_TAG_const_type";
612 case DW_TAG_constant: return "DW_TAG_constant";
613 case DW_TAG_enumerator: return "DW_TAG_enumerator";
614 case DW_TAG_file_type: return "DW_TAG_file_type";
615 case DW_TAG_friend: return "DW_TAG_friend";
616 case DW_TAG_namelist: return "DW_TAG_namelist";
617 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
618 case DW_TAG_packed_type: return "DW_TAG_packed_type";
619 case DW_TAG_subprogram: return "DW_TAG_subprogram";
620 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
621 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
622 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
623 case DW_TAG_try_block: return "DW_TAG_try_block";
624 case DW_TAG_variant_part: return "DW_TAG_variant_part";
625 case DW_TAG_variable: return "DW_TAG_variable";
626 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
627 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
628 case DW_TAG_format_label: return "DW_TAG_format_label";
629 case DW_TAG_function_template: return "DW_TAG_function_template";
630 case DW_TAG_class_template: return "DW_TAG_class_template";
631 /* DWARF 2.1 values. */
632 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
633 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
634 case DW_TAG_interface_type: return "DW_TAG_interface_type";
635 case DW_TAG_namespace: return "DW_TAG_namespace";
636 case DW_TAG_imported_module: return "DW_TAG_imported_module";
637 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
638 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
639 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
640 case DW_TAG_condition: return "DW_TAG_condition";
641 case DW_TAG_shared_type: return "DW_TAG_shared_type";
642 /* DWARF 4 values. */
643 case DW_TAG_type_unit: return "DW_TAG_type_unit";
644 case DW_TAG_rvalue_reference_type: return "DW_TAG_rvalue_reference_type";
645 case DW_TAG_template_alias: return "DW_TAG_template_alias";
647 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
648 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
649 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
652 static char buffer[100];
654 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
661 get_FORM_name (unsigned long form)
665 case DW_FORM_addr: return "DW_FORM_addr";
666 case DW_FORM_block2: return "DW_FORM_block2";
667 case DW_FORM_block4: return "DW_FORM_block4";
668 case DW_FORM_data2: return "DW_FORM_data2";
669 case DW_FORM_data4: return "DW_FORM_data4";
670 case DW_FORM_data8: return "DW_FORM_data8";
671 case DW_FORM_string: return "DW_FORM_string";
672 case DW_FORM_block: return "DW_FORM_block";
673 case DW_FORM_block1: return "DW_FORM_block1";
674 case DW_FORM_data1: return "DW_FORM_data1";
675 case DW_FORM_flag: return "DW_FORM_flag";
676 case DW_FORM_sdata: return "DW_FORM_sdata";
677 case DW_FORM_strp: return "DW_FORM_strp";
678 case DW_FORM_udata: return "DW_FORM_udata";
679 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
680 case DW_FORM_ref1: return "DW_FORM_ref1";
681 case DW_FORM_ref2: return "DW_FORM_ref2";
682 case DW_FORM_ref4: return "DW_FORM_ref4";
683 case DW_FORM_ref8: return "DW_FORM_ref8";
684 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
685 case DW_FORM_indirect: return "DW_FORM_indirect";
686 /* DWARF 4 values. */
687 case DW_FORM_sec_offset: return "DW_FORM_sec_offset";
688 case DW_FORM_exprloc: return "DW_FORM_exprloc";
689 case DW_FORM_flag_present: return "DW_FORM_flag_present";
690 case DW_FORM_ref_sig8: return "DW_FORM_ref_sig8";
693 static char buffer[100];
695 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
701 static unsigned char *
702 display_block (unsigned char *data, unsigned long length)
704 printf (_(" %lu byte block: "), length);
707 printf ("%lx ", (unsigned long) byte_get (data++, 1));
713 decode_location_expression (unsigned char * data,
714 unsigned int pointer_size,
715 unsigned int offset_size,
717 unsigned long length,
718 unsigned long cu_offset,
719 struct dwarf_section * section)
722 unsigned int bytes_read;
723 unsigned long uvalue;
724 unsigned char *end = data + length;
725 int need_frame_base = 0;
734 printf ("DW_OP_addr: %lx",
735 (unsigned long) byte_get (data, pointer_size));
736 data += pointer_size;
739 printf ("DW_OP_deref");
742 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
745 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
748 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
752 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
756 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
760 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
764 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
765 (unsigned long) byte_get (data + 4, 4));
769 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
770 (long) byte_get (data + 4, 4));
774 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
778 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
782 printf ("DW_OP_dup");
785 printf ("DW_OP_drop");
788 printf ("DW_OP_over");
791 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
794 printf ("DW_OP_swap");
797 printf ("DW_OP_rot");
800 printf ("DW_OP_xderef");
803 printf ("DW_OP_abs");
806 printf ("DW_OP_and");
809 printf ("DW_OP_div");
812 printf ("DW_OP_minus");
815 printf ("DW_OP_mod");
818 printf ("DW_OP_mul");
821 printf ("DW_OP_neg");
824 printf ("DW_OP_not");
830 printf ("DW_OP_plus");
832 case DW_OP_plus_uconst:
833 printf ("DW_OP_plus_uconst: %lu",
834 read_leb128 (data, &bytes_read, 0));
838 printf ("DW_OP_shl");
841 printf ("DW_OP_shr");
844 printf ("DW_OP_shra");
847 printf ("DW_OP_xor");
850 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
872 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
908 printf ("DW_OP_lit%d", op - DW_OP_lit0);
943 printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
944 regname (op - DW_OP_reg0, 1));
979 printf ("DW_OP_breg%d (%s): %ld", op - DW_OP_breg0,
980 regname (op - DW_OP_breg0, 1),
981 read_leb128 (data, &bytes_read, 1));
986 uvalue = read_leb128 (data, &bytes_read, 0);
988 printf ("DW_OP_regx: %lu (%s)", uvalue, regname (uvalue, 1));
992 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
996 uvalue = read_leb128 (data, &bytes_read, 0);
998 printf ("DW_OP_bregx: %lu (%s) %ld", uvalue, regname (uvalue, 1),
999 read_leb128 (data, &bytes_read, 1));
1003 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
1006 case DW_OP_deref_size:
1007 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
1009 case DW_OP_xderef_size:
1010 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
1013 printf ("DW_OP_nop");
1016 /* DWARF 3 extensions. */
1017 case DW_OP_push_object_address:
1018 printf ("DW_OP_push_object_address");
1021 /* XXX: Strictly speaking for 64-bit DWARF3 files
1022 this ought to be an 8-byte wide computation. */
1023 printf ("DW_OP_call2: <0x%lx>", (long) byte_get (data, 2) + cu_offset);
1027 /* XXX: Strictly speaking for 64-bit DWARF3 files
1028 this ought to be an 8-byte wide computation. */
1029 printf ("DW_OP_call4: <0x%lx>", (long) byte_get (data, 4) + cu_offset);
1032 case DW_OP_call_ref:
1033 /* XXX: Strictly speaking for 64-bit DWARF3 files
1034 this ought to be an 8-byte wide computation. */
1035 if (dwarf_version == -1)
1037 printf (_("(DW_OP_call_ref in frame info)"));
1038 /* No way to tell where the next op is, so just bail. */
1039 return need_frame_base;
1041 if (dwarf_version == 2)
1043 printf ("DW_OP_call_ref: <0x%lx>",
1044 (long) byte_get (data, pointer_size));
1045 data += pointer_size;
1049 printf ("DW_OP_call_ref: <0x%lx>",
1050 (long) byte_get (data, offset_size));
1051 data += offset_size;
1054 case DW_OP_form_tls_address:
1055 printf ("DW_OP_form_tls_address");
1057 case DW_OP_call_frame_cfa:
1058 printf ("DW_OP_call_frame_cfa");
1060 case DW_OP_bit_piece:
1061 printf ("DW_OP_bit_piece: ");
1062 printf ("size: %lu ", read_leb128 (data, &bytes_read, 0));
1064 printf ("offset: %lu ", read_leb128 (data, &bytes_read, 0));
1068 /* DWARF 4 extensions. */
1069 case DW_OP_stack_value:
1070 printf ("DW_OP_stack_value");
1073 case DW_OP_implicit_value:
1074 printf ("DW_OP_implicit_value");
1075 uvalue = read_leb128 (data, &bytes_read, 0);
1077 display_block (data, uvalue);
1081 /* GNU extensions. */
1082 case DW_OP_GNU_push_tls_address:
1083 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1085 case DW_OP_GNU_uninit:
1086 printf ("DW_OP_GNU_uninit");
1087 /* FIXME: Is there data associated with this OP ? */
1089 case DW_OP_GNU_encoded_addr:
1095 addr = get_encoded_value (data, encoding);
1096 if ((encoding & 0x70) == DW_EH_PE_pcrel)
1097 addr += section->address + (data - section->start);
1098 data += size_of_encoded_value (encoding);
1100 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1101 print_dwarf_vma (addr, pointer_size);
1104 case DW_OP_GNU_implicit_pointer:
1105 /* XXX: Strictly speaking for 64-bit DWARF3 files
1106 this ought to be an 8-byte wide computation. */
1107 if (dwarf_version == -1)
1109 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1110 /* No way to tell where the next op is, so just bail. */
1111 return need_frame_base;
1113 if (dwarf_version == 2)
1115 printf ("DW_OP_GNU_implicit_pointer: <0x%lx> %ld",
1116 (long) byte_get (data, pointer_size),
1117 read_leb128 (data + pointer_size, &bytes_read, 1));
1118 data += pointer_size + bytes_read;
1122 printf ("DW_OP_GNU_implicit_pointer: <0x%lx> %ld",
1123 (long) byte_get (data, offset_size),
1124 read_leb128 (data + offset_size, &bytes_read, 1));
1125 data += offset_size;
1129 /* HP extensions. */
1130 case DW_OP_HP_is_value:
1131 printf ("DW_OP_HP_is_value");
1132 /* FIXME: Is there data associated with this OP ? */
1134 case DW_OP_HP_fltconst4:
1135 printf ("DW_OP_HP_fltconst4");
1136 /* FIXME: Is there data associated with this OP ? */
1138 case DW_OP_HP_fltconst8:
1139 printf ("DW_OP_HP_fltconst8");
1140 /* FIXME: Is there data associated with this OP ? */
1142 case DW_OP_HP_mod_range:
1143 printf ("DW_OP_HP_mod_range");
1144 /* FIXME: Is there data associated with this OP ? */
1146 case DW_OP_HP_unmod_range:
1147 printf ("DW_OP_HP_unmod_range");
1148 /* FIXME: Is there data associated with this OP ? */
1151 printf ("DW_OP_HP_tls");
1152 /* FIXME: Is there data associated with this OP ? */
1155 /* PGI (STMicroelectronics) extensions. */
1156 case DW_OP_PGI_omp_thread_num:
1157 /* Pushes the thread number for the current thread as it would be
1158 returned by the standard OpenMP library function:
1159 omp_get_thread_num(). The "current thread" is the thread for
1160 which the expression is being evaluated. */
1161 printf ("DW_OP_PGI_omp_thread_num");
1165 if (op >= DW_OP_lo_user
1166 && op <= DW_OP_hi_user)
1167 printf (_("(User defined location op)"));
1169 printf (_("(Unknown location op)"));
1170 /* No way to tell where the next op is, so just bail. */
1171 return need_frame_base;
1174 /* Separate the ops. */
1179 return need_frame_base;
1182 static unsigned char *
1183 read_and_display_attr_value (unsigned long attribute,
1185 unsigned char * data,
1186 unsigned long cu_offset,
1187 unsigned long pointer_size,
1188 unsigned long offset_size,
1190 debug_info * debug_info_p,
1192 struct dwarf_section * section)
1194 unsigned long uvalue = 0;
1195 unsigned char *block_start = NULL;
1196 unsigned char * orig_data = data;
1197 unsigned int bytes_read;
1204 case DW_FORM_ref_addr:
1205 if (dwarf_version == 2)
1207 uvalue = byte_get (data, pointer_size);
1208 data += pointer_size;
1210 else if (dwarf_version == 3 || dwarf_version == 4)
1212 uvalue = byte_get (data, offset_size);
1213 data += offset_size;
1217 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1222 uvalue = byte_get (data, pointer_size);
1223 data += pointer_size;
1227 case DW_FORM_sec_offset:
1228 uvalue = byte_get (data, offset_size);
1229 data += offset_size;
1232 case DW_FORM_flag_present:
1239 uvalue = byte_get (data++, 1);
1244 uvalue = byte_get (data, 2);
1250 uvalue = byte_get (data, 4);
1255 uvalue = read_leb128 (data, & bytes_read, 1);
1259 case DW_FORM_ref_udata:
1261 uvalue = read_leb128 (data, & bytes_read, 0);
1265 case DW_FORM_indirect:
1266 form = read_leb128 (data, & bytes_read, 0);
1269 printf (" %s", get_FORM_name (form));
1270 return read_and_display_attr_value (attribute, form, data,
1271 cu_offset, pointer_size,
1272 offset_size, dwarf_version,
1273 debug_info_p, do_loc,
1279 case DW_FORM_ref_addr:
1281 printf (" <0x%lx>", uvalue);
1287 case DW_FORM_ref_udata:
1289 printf (" <0x%lx>", uvalue + cu_offset);
1294 case DW_FORM_sec_offset:
1296 printf (" 0x%lx", uvalue);
1299 case DW_FORM_flag_present:
1306 printf (" %ld", uvalue);
1313 uvalue = byte_get (data, 4);
1314 printf (" 0x%lx", uvalue);
1315 printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1317 if ((do_loc || do_debug_loc || do_debug_ranges)
1318 && num_debug_info_entries == 0)
1320 if (sizeof (uvalue) == 8)
1321 uvalue = byte_get (data, 8);
1323 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1328 case DW_FORM_string:
1330 printf (" %s", data);
1331 data += strlen ((char *) data) + 1;
1335 case DW_FORM_exprloc:
1336 uvalue = read_leb128 (data, & bytes_read, 0);
1337 block_start = data + bytes_read;
1339 data = block_start + uvalue;
1341 data = display_block (block_start, uvalue);
1344 case DW_FORM_block1:
1345 uvalue = byte_get (data, 1);
1346 block_start = data + 1;
1348 data = block_start + uvalue;
1350 data = display_block (block_start, uvalue);
1353 case DW_FORM_block2:
1354 uvalue = byte_get (data, 2);
1355 block_start = data + 2;
1357 data = block_start + uvalue;
1359 data = display_block (block_start, uvalue);
1362 case DW_FORM_block4:
1363 uvalue = byte_get (data, 4);
1364 block_start = data + 4;
1366 data = block_start + uvalue;
1368 data = display_block (block_start, uvalue);
1373 printf (_(" (indirect string, offset: 0x%lx): %s"),
1374 uvalue, fetch_indirect_string (uvalue));
1377 case DW_FORM_indirect:
1378 /* Handled above. */
1381 case DW_FORM_ref_sig8:
1385 printf (" signature: ");
1386 for (i = 0; i < 8; i++)
1388 printf ("%02x", (unsigned) byte_get (data, 1));
1397 warn (_("Unrecognized form: %lu\n"), form);
1401 if ((do_loc || do_debug_loc || do_debug_ranges)
1402 && num_debug_info_entries == 0)
1406 case DW_AT_frame_base:
1407 have_frame_base = 1;
1408 case DW_AT_location:
1409 case DW_AT_string_length:
1410 case DW_AT_return_addr:
1411 case DW_AT_data_member_location:
1412 case DW_AT_vtable_elem_location:
1414 case DW_AT_static_link:
1415 case DW_AT_use_location:
1416 if (form == DW_FORM_data4
1417 || form == DW_FORM_data8
1418 || form == DW_FORM_sec_offset)
1420 /* Process location list. */
1421 unsigned int lmax = debug_info_p->max_loc_offsets;
1422 unsigned int num = debug_info_p->num_loc_offsets;
1424 if (lmax == 0 || num >= lmax)
1427 debug_info_p->loc_offsets = (long unsigned int *)
1428 xcrealloc (debug_info_p->loc_offsets,
1429 lmax, sizeof (*debug_info_p->loc_offsets));
1430 debug_info_p->have_frame_base = (int *)
1431 xcrealloc (debug_info_p->have_frame_base,
1432 lmax, sizeof (*debug_info_p->have_frame_base));
1433 debug_info_p->max_loc_offsets = lmax;
1435 debug_info_p->loc_offsets [num] = uvalue;
1436 debug_info_p->have_frame_base [num] = have_frame_base;
1437 debug_info_p->num_loc_offsets++;
1442 if (need_base_address)
1443 debug_info_p->base_address = uvalue;
1447 if (form == DW_FORM_data4
1448 || form == DW_FORM_data8
1449 || form == DW_FORM_sec_offset)
1451 /* Process range list. */
1452 unsigned int lmax = debug_info_p->max_range_lists;
1453 unsigned int num = debug_info_p->num_range_lists;
1455 if (lmax == 0 || num >= lmax)
1458 debug_info_p->range_lists = (long unsigned int *)
1459 xcrealloc (debug_info_p->range_lists,
1460 lmax, sizeof (*debug_info_p->range_lists));
1461 debug_info_p->max_range_lists = lmax;
1463 debug_info_p->range_lists [num] = uvalue;
1464 debug_info_p->num_range_lists++;
1476 /* For some attributes we can display further information. */
1484 case DW_INL_not_inlined:
1485 printf (_("(not inlined)"));
1487 case DW_INL_inlined:
1488 printf (_("(inlined)"));
1490 case DW_INL_declared_not_inlined:
1491 printf (_("(declared as inline but ignored)"));
1493 case DW_INL_declared_inlined:
1494 printf (_("(declared as inline and inlined)"));
1497 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
1502 case DW_AT_language:
1505 /* Ordered by the numeric value of these constants. */
1506 case DW_LANG_C89: printf ("(ANSI C)"); break;
1507 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1508 case DW_LANG_Ada83: printf ("(Ada)"); break;
1509 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1510 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1511 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1512 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1513 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1514 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1515 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1516 /* DWARF 2.1 values. */
1517 case DW_LANG_Java: printf ("(Java)"); break;
1518 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1519 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1520 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1521 /* DWARF 3 values. */
1522 case DW_LANG_PLI: printf ("(PLI)"); break;
1523 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1524 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1525 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1526 case DW_LANG_D: printf ("(D)"); break;
1527 /* DWARF 4 values. */
1528 case DW_LANG_Python: printf ("(Python)"); break;
1529 /* MIPS extension. */
1530 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1531 /* UPC extension. */
1532 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1534 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1535 printf ("(implementation defined: %lx)", uvalue);
1537 printf ("(Unknown: %lx)", uvalue);
1542 case DW_AT_encoding:
1545 case DW_ATE_void: printf ("(void)"); break;
1546 case DW_ATE_address: printf ("(machine address)"); break;
1547 case DW_ATE_boolean: printf ("(boolean)"); break;
1548 case DW_ATE_complex_float: printf ("(complex float)"); break;
1549 case DW_ATE_float: printf ("(float)"); break;
1550 case DW_ATE_signed: printf ("(signed)"); break;
1551 case DW_ATE_signed_char: printf ("(signed char)"); break;
1552 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1553 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1554 /* DWARF 2.1 values: */
1555 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1556 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1557 /* DWARF 3 values: */
1558 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1559 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1560 case DW_ATE_edited: printf ("(edited)"); break;
1561 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1562 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1563 /* HP extensions: */
1564 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1565 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1566 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1567 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1568 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1569 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1570 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1573 if (uvalue >= DW_ATE_lo_user
1574 && uvalue <= DW_ATE_hi_user)
1575 printf ("(user defined type)");
1577 printf ("(unknown type)");
1582 case DW_AT_accessibility:
1585 case DW_ACCESS_public: printf ("(public)"); break;
1586 case DW_ACCESS_protected: printf ("(protected)"); break;
1587 case DW_ACCESS_private: printf ("(private)"); break;
1589 printf ("(unknown accessibility)");
1594 case DW_AT_visibility:
1597 case DW_VIS_local: printf ("(local)"); break;
1598 case DW_VIS_exported: printf ("(exported)"); break;
1599 case DW_VIS_qualified: printf ("(qualified)"); break;
1600 default: printf ("(unknown visibility)"); break;
1604 case DW_AT_virtuality:
1607 case DW_VIRTUALITY_none: printf ("(none)"); break;
1608 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1609 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1610 default: printf ("(unknown virtuality)"); break;
1614 case DW_AT_identifier_case:
1617 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1618 case DW_ID_up_case: printf ("(up_case)"); break;
1619 case DW_ID_down_case: printf ("(down_case)"); break;
1620 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1621 default: printf ("(unknown case)"); break;
1625 case DW_AT_calling_convention:
1628 case DW_CC_normal: printf ("(normal)"); break;
1629 case DW_CC_program: printf ("(program)"); break;
1630 case DW_CC_nocall: printf ("(nocall)"); break;
1632 if (uvalue >= DW_CC_lo_user
1633 && uvalue <= DW_CC_hi_user)
1634 printf ("(user defined)");
1636 printf ("(unknown convention)");
1640 case DW_AT_ordering:
1643 case -1: printf ("(undefined)"); break;
1644 case 0: printf ("(row major)"); break;
1645 case 1: printf ("(column major)"); break;
1649 case DW_AT_frame_base:
1650 have_frame_base = 1;
1651 case DW_AT_location:
1652 case DW_AT_string_length:
1653 case DW_AT_return_addr:
1654 case DW_AT_data_member_location:
1655 case DW_AT_vtable_elem_location:
1657 case DW_AT_static_link:
1658 case DW_AT_use_location:
1659 if (form == DW_FORM_data4
1660 || form == DW_FORM_data8
1661 || form == DW_FORM_sec_offset)
1662 printf (_("(location list)"));
1664 case DW_AT_allocated:
1665 case DW_AT_associated:
1666 case DW_AT_data_location:
1668 case DW_AT_upper_bound:
1669 case DW_AT_lower_bound:
1672 int need_frame_base;
1675 need_frame_base = decode_location_expression (block_start,
1680 cu_offset, section);
1682 if (need_frame_base && !have_frame_base)
1683 printf (_(" [without DW_AT_frame_base]"));
1689 if (form == DW_FORM_ref_sig8)
1692 if (form == DW_FORM_ref1
1693 || form == DW_FORM_ref2
1694 || form == DW_FORM_ref4)
1695 uvalue += cu_offset;
1697 if (uvalue >= section->size)
1698 warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1699 uvalue, (unsigned long) (orig_data - section->start));
1702 unsigned long abbrev_number;
1703 abbrev_entry * entry;
1705 abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1707 printf ("[Abbrev Number: %ld", abbrev_number);
1708 for (entry = first_abbrev; entry != NULL; entry = entry->next)
1709 if (entry->entry == abbrev_number)
1712 printf (" (%s)", get_TAG_name (entry->tag));
1726 get_AT_name (unsigned long attribute)
1730 case DW_AT_sibling: return "DW_AT_sibling";
1731 case DW_AT_location: return "DW_AT_location";
1732 case DW_AT_name: return "DW_AT_name";
1733 case DW_AT_ordering: return "DW_AT_ordering";
1734 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1735 case DW_AT_byte_size: return "DW_AT_byte_size";
1736 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1737 case DW_AT_bit_size: return "DW_AT_bit_size";
1738 case DW_AT_element_list: return "DW_AT_element_list";
1739 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1740 case DW_AT_low_pc: return "DW_AT_low_pc";
1741 case DW_AT_high_pc: return "DW_AT_high_pc";
1742 case DW_AT_language: return "DW_AT_language";
1743 case DW_AT_member: return "DW_AT_member";
1744 case DW_AT_discr: return "DW_AT_discr";
1745 case DW_AT_discr_value: return "DW_AT_discr_value";
1746 case DW_AT_visibility: return "DW_AT_visibility";
1747 case DW_AT_import: return "DW_AT_import";
1748 case DW_AT_string_length: return "DW_AT_string_length";
1749 case DW_AT_common_reference: return "DW_AT_common_reference";
1750 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1751 case DW_AT_const_value: return "DW_AT_const_value";
1752 case DW_AT_containing_type: return "DW_AT_containing_type";
1753 case DW_AT_default_value: return "DW_AT_default_value";
1754 case DW_AT_inline: return "DW_AT_inline";
1755 case DW_AT_is_optional: return "DW_AT_is_optional";
1756 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1757 case DW_AT_producer: return "DW_AT_producer";
1758 case DW_AT_prototyped: return "DW_AT_prototyped";
1759 case DW_AT_return_addr: return "DW_AT_return_addr";
1760 case DW_AT_start_scope: return "DW_AT_start_scope";
1761 case DW_AT_stride_size: return "DW_AT_stride_size";
1762 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1763 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1764 case DW_AT_accessibility: return "DW_AT_accessibility";
1765 case DW_AT_address_class: return "DW_AT_address_class";
1766 case DW_AT_artificial: return "DW_AT_artificial";
1767 case DW_AT_base_types: return "DW_AT_base_types";
1768 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1769 case DW_AT_count: return "DW_AT_count";
1770 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1771 case DW_AT_decl_column: return "DW_AT_decl_column";
1772 case DW_AT_decl_file: return "DW_AT_decl_file";
1773 case DW_AT_decl_line: return "DW_AT_decl_line";
1774 case DW_AT_declaration: return "DW_AT_declaration";
1775 case DW_AT_discr_list: return "DW_AT_discr_list";
1776 case DW_AT_encoding: return "DW_AT_encoding";
1777 case DW_AT_external: return "DW_AT_external";
1778 case DW_AT_frame_base: return "DW_AT_frame_base";
1779 case DW_AT_friend: return "DW_AT_friend";
1780 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1781 case DW_AT_macro_info: return "DW_AT_macro_info";
1782 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1783 case DW_AT_priority: return "DW_AT_priority";
1784 case DW_AT_segment: return "DW_AT_segment";
1785 case DW_AT_specification: return "DW_AT_specification";
1786 case DW_AT_static_link: return "DW_AT_static_link";
1787 case DW_AT_type: return "DW_AT_type";
1788 case DW_AT_use_location: return "DW_AT_use_location";
1789 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1790 case DW_AT_virtuality: return "DW_AT_virtuality";
1791 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1792 /* DWARF 2.1 values. */
1793 case DW_AT_allocated: return "DW_AT_allocated";
1794 case DW_AT_associated: return "DW_AT_associated";
1795 case DW_AT_data_location: return "DW_AT_data_location";
1796 case DW_AT_stride: return "DW_AT_stride";
1797 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1798 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1799 case DW_AT_extension: return "DW_AT_extension";
1800 case DW_AT_ranges: return "DW_AT_ranges";
1801 case DW_AT_trampoline: return "DW_AT_trampoline";
1802 case DW_AT_call_column: return "DW_AT_call_column";
1803 case DW_AT_call_file: return "DW_AT_call_file";
1804 case DW_AT_call_line: return "DW_AT_call_line";
1805 case DW_AT_description: return "DW_AT_description";
1806 case DW_AT_binary_scale: return "DW_AT_binary_scale";
1807 case DW_AT_decimal_scale: return "DW_AT_decimal_scale";
1808 case DW_AT_small: return "DW_AT_small";
1809 case DW_AT_decimal_sign: return "DW_AT_decimal_sign";
1810 case DW_AT_digit_count: return "DW_AT_digit_count";
1811 case DW_AT_picture_string: return "DW_AT_picture_string";
1812 case DW_AT_mutable: return "DW_AT_mutable";
1813 case DW_AT_threads_scaled: return "DW_AT_threads_scaled";
1814 case DW_AT_explicit: return "DW_AT_explicit";
1815 case DW_AT_object_pointer: return "DW_AT_object_pointer";
1816 case DW_AT_endianity: return "DW_AT_endianity";
1817 case DW_AT_elemental: return "DW_AT_elemental";
1818 case DW_AT_pure: return "DW_AT_pure";
1819 case DW_AT_recursive: return "DW_AT_recursive";
1820 /* DWARF 4 values. */
1821 case DW_AT_signature: return "DW_AT_signature";
1822 case DW_AT_main_subprogram: return "DW_AT_main_subprogram";
1823 case DW_AT_data_bit_offset: return "DW_AT_data_bit_offset";
1824 case DW_AT_const_expr: return "DW_AT_const_expr";
1825 case DW_AT_enum_class: return "DW_AT_enum_class";
1826 case DW_AT_linkage_name: return "DW_AT_linkage_name";
1828 /* HP and SGI/MIPS extensions. */
1829 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1830 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1831 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1832 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1833 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
1834 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1835 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1836 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1837 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1838 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1840 /* HP Extensions. */
1841 case DW_AT_HP_block_index: return "DW_AT_HP_block_index";
1842 case DW_AT_HP_actuals_stmt_list: return "DW_AT_HP_actuals_stmt_list";
1843 case DW_AT_HP_proc_per_section: return "DW_AT_HP_proc_per_section";
1844 case DW_AT_HP_raw_data_ptr: return "DW_AT_HP_raw_data_ptr";
1845 case DW_AT_HP_pass_by_reference: return "DW_AT_HP_pass_by_reference";
1846 case DW_AT_HP_opt_level: return "DW_AT_HP_opt_level";
1847 case DW_AT_HP_prof_version_id: return "DW_AT_HP_prof_version_id";
1848 case DW_AT_HP_opt_flags: return "DW_AT_HP_opt_flags";
1849 case DW_AT_HP_cold_region_low_pc: return "DW_AT_HP_cold_region_low_pc";
1850 case DW_AT_HP_cold_region_high_pc: return "DW_AT_HP_cold_region_high_pc";
1851 case DW_AT_HP_all_variables_modifiable: return "DW_AT_HP_all_variables_modifiable";
1852 case DW_AT_HP_linkage_name: return "DW_AT_HP_linkage_name";
1853 case DW_AT_HP_prof_flags: return "DW_AT_HP_prof_flags";
1855 /* One value is shared by the MIPS and HP extensions: */
1856 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1858 /* GNU extensions. */
1859 case DW_AT_sf_names: return "DW_AT_sf_names";
1860 case DW_AT_src_info: return "DW_AT_src_info";
1861 case DW_AT_mac_info: return "DW_AT_mac_info";
1862 case DW_AT_src_coords: return "DW_AT_src_coords";
1863 case DW_AT_body_begin: return "DW_AT_body_begin";
1864 case DW_AT_body_end: return "DW_AT_body_end";
1865 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
1866 case DW_AT_GNU_guarded_by: return "DW_AT_GNU_guarded_by";
1867 case DW_AT_GNU_pt_guarded_by: return "DW_AT_GNU_pt_guarded_by";
1868 case DW_AT_GNU_guarded: return "DW_AT_GNU_guarded";
1869 case DW_AT_GNU_pt_guarded: return "DW_AT_GNU_pt_guarded";
1870 case DW_AT_GNU_locks_excluded: return "DW_AT_GNU_locks_excluded";
1871 case DW_AT_GNU_exclusive_locks_required: return "DW_AT_GNU_exclusive_locks_required";
1872 case DW_AT_GNU_shared_locks_required: return "DW_AT_GNU_shared_locks_required";
1873 case DW_AT_GNU_odr_signature: return "DW_AT_GNU_odr_signature";
1874 case DW_AT_use_GNAT_descriptive_type: return "DW_AT_use_GNAT_descriptive_type";
1875 case DW_AT_GNAT_descriptive_type: return "DW_AT_GNAT_descriptive_type";
1877 /* UPC extension. */
1878 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
1880 /* PGI (STMicroelectronics) extensions. */
1881 case DW_AT_PGI_lbase: return "DW_AT_PGI_lbase";
1882 case DW_AT_PGI_soffset: return "DW_AT_PGI_soffset";
1883 case DW_AT_PGI_lstride: return "DW_AT_PGI_lstride";
1887 static char buffer[100];
1889 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1896 static unsigned char *
1897 read_and_display_attr (unsigned long attribute,
1899 unsigned char * data,
1900 unsigned long cu_offset,
1901 unsigned long pointer_size,
1902 unsigned long offset_size,
1904 debug_info * debug_info_p,
1906 struct dwarf_section * section)
1909 printf (" %-18s:", get_AT_name (attribute));
1910 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1911 pointer_size, offset_size,
1912 dwarf_version, debug_info_p,
1920 /* Process the contents of a .debug_info section. If do_loc is non-zero
1921 then we are scanning for location lists and we do not want to display
1922 anything to the user. If do_types is non-zero, we are processing
1923 a .debug_types section instead of a .debug_info section. */
1926 process_debug_info (struct dwarf_section *section,
1928 enum dwarf_section_display_enum abbrev_sec,
1932 unsigned char *start = section->start;
1933 unsigned char *end = start + section->size;
1934 unsigned char *section_begin;
1936 unsigned int num_units = 0;
1938 if ((do_loc || do_debug_loc || do_debug_ranges)
1939 && num_debug_info_entries == 0
1942 unsigned long length;
1944 /* First scan the section to get the number of comp units. */
1945 for (section_begin = start, num_units = 0; section_begin < end;
1948 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1949 will be the length. For a 64-bit DWARF section, it'll be
1950 the escape code 0xffffffff followed by an 8 byte length. */
1951 length = byte_get (section_begin, 4);
1953 if (length == 0xffffffff)
1955 length = byte_get (section_begin + 4, 8);
1956 section_begin += length + 12;
1958 else if (length >= 0xfffffff0 && length < 0xffffffff)
1960 warn (_("Reserved length value (%lx) found in section %s\n"), length, section->name);
1964 section_begin += length + 4;
1966 /* Negative values are illegal, they may even cause infinite
1967 looping. This can happen if we can't accurately apply
1968 relocations to an object file. */
1969 if ((signed long) length <= 0)
1971 warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
1978 error (_("No comp units in %s section ?"), section->name);
1982 /* Then allocate an array to hold the information. */
1983 debug_information = (debug_info *) cmalloc (num_units,
1984 sizeof (* debug_information));
1985 if (debug_information == NULL)
1987 error (_("Not enough memory for a debug info array of %u entries"),
1995 printf (_("Contents of the %s section:\n\n"), section->name);
1997 load_debug_section (str, file);
2000 load_debug_section (abbrev_sec, file);
2001 if (debug_displays [abbrev_sec].section.start == NULL)
2003 warn (_("Unable to locate %s section!\n"),
2004 debug_displays [abbrev_sec].section.name);
2008 for (section_begin = start, unit = 0; start < end; unit++)
2010 DWARF2_Internal_CompUnit compunit;
2011 unsigned char *hdrptr;
2012 unsigned char *tags;
2014 unsigned long cu_offset;
2016 int initial_length_size;
2017 unsigned char signature[8] = { 0 };
2018 unsigned long type_offset = 0;
2022 compunit.cu_length = byte_get (hdrptr, 4);
2025 if (compunit.cu_length == 0xffffffff)
2027 compunit.cu_length = byte_get (hdrptr, 8);
2030 initial_length_size = 12;
2035 initial_length_size = 4;
2038 compunit.cu_version = byte_get (hdrptr, 2);
2041 cu_offset = start - section_begin;
2043 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
2044 hdrptr += offset_size;
2046 compunit.cu_pointer_size = byte_get (hdrptr, 1);
2053 for (i = 0; i < 8; i++)
2055 signature[i] = byte_get (hdrptr, 1);
2059 type_offset = byte_get (hdrptr, offset_size);
2060 hdrptr += offset_size;
2063 if ((do_loc || do_debug_loc || do_debug_ranges)
2064 && num_debug_info_entries == 0
2067 debug_information [unit].cu_offset = cu_offset;
2068 debug_information [unit].pointer_size
2069 = compunit.cu_pointer_size;
2070 debug_information [unit].offset_size = offset_size;
2071 debug_information [unit].dwarf_version = compunit.cu_version;
2072 debug_information [unit].base_address = 0;
2073 debug_information [unit].loc_offsets = NULL;
2074 debug_information [unit].have_frame_base = NULL;
2075 debug_information [unit].max_loc_offsets = 0;
2076 debug_information [unit].num_loc_offsets = 0;
2077 debug_information [unit].range_lists = NULL;
2078 debug_information [unit].max_range_lists= 0;
2079 debug_information [unit].num_range_lists = 0;
2084 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset);
2085 printf (_(" Length: 0x%lx (%s)\n"), compunit.cu_length,
2086 initial_length_size == 8 ? "64-bit" : "32-bit");
2087 printf (_(" Version: %d\n"), compunit.cu_version);
2088 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
2089 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2093 printf (_(" Signature: "));
2094 for (i = 0; i < 8; i++)
2095 printf ("%02x", signature[i]);
2097 printf (_(" Type Offset: 0x%lx\n"), type_offset);
2101 if (cu_offset + compunit.cu_length + initial_length_size
2104 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
2105 cu_offset, compunit.cu_length);
2109 start += compunit.cu_length + initial_length_size;
2111 if (compunit.cu_version != 2
2112 && compunit.cu_version != 3
2113 && compunit.cu_version != 4)
2115 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
2116 cu_offset, compunit.cu_version);
2122 /* Process the abbrevs used by this compilation unit. DWARF
2123 sections under Mach-O have non-zero addresses. */
2124 if (compunit.cu_abbrev_offset >= debug_displays [abbrev_sec].section.size)
2125 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2126 (unsigned long) compunit.cu_abbrev_offset,
2127 (unsigned long) debug_displays [abbrev_sec].section.size);
2129 process_abbrev_section
2130 ((unsigned char *) debug_displays [abbrev_sec].section.start
2131 + compunit.cu_abbrev_offset,
2132 (unsigned char *) debug_displays [abbrev_sec].section.start
2133 + debug_displays [abbrev_sec].section.size);
2136 while (tags < start)
2138 unsigned int bytes_read;
2139 unsigned long abbrev_number;
2140 unsigned long die_offset;
2141 abbrev_entry *entry;
2144 die_offset = tags - section_begin;
2146 abbrev_number = read_leb128 (tags, & bytes_read, 0);
2149 /* A null DIE marks the end of a list of siblings or it may also be
2150 a section padding. */
2151 if (abbrev_number == 0)
2153 /* Check if it can be a section padding for the last CU. */
2154 if (level == 0 && start == end)
2158 for (chk = tags; chk < start; chk++)
2168 static unsigned num_bogus_warns = 0;
2170 if (num_bogus_warns < 3)
2172 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2175 if (num_bogus_warns == 3)
2176 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2183 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2184 level, die_offset, abbrev_number);
2186 /* Scan through the abbreviation list until we reach the
2188 for (entry = first_abbrev;
2189 entry && entry->entry != abbrev_number;
2190 entry = entry->next)
2200 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2201 die_offset, abbrev_number);
2206 printf (_(" (%s)\n"), get_TAG_name (entry->tag));
2211 need_base_address = 0;
2213 case DW_TAG_compile_unit:
2214 need_base_address = 1;
2216 case DW_TAG_entry_point:
2217 case DW_TAG_subprogram:
2218 need_base_address = 0;
2219 /* Assuming that there is no DW_AT_frame_base. */
2220 have_frame_base = 0;
2224 for (attr = entry->first_attr; attr; attr = attr->next)
2227 /* Show the offset from where the tag was extracted. */
2228 printf (" <%2lx>", (unsigned long)(tags - section_begin));
2230 tags = read_and_display_attr (attr->attribute,
2233 compunit.cu_pointer_size,
2235 compunit.cu_version,
2236 debug_information + unit,
2240 if (entry->children)
2245 /* Set num_debug_info_entries here so that it can be used to check if
2246 we need to process .debug_loc and .debug_ranges sections. */
2247 if ((do_loc || do_debug_loc || do_debug_ranges)
2248 && num_debug_info_entries == 0
2250 num_debug_info_entries = num_units;
2260 /* Locate and scan the .debug_info section in the file and record the pointer
2261 sizes and offsets for the compilation units in it. Usually an executable
2262 will have just one pointer size, but this is not guaranteed, and so we try
2263 not to make any assumptions. Returns zero upon failure, or the number of
2264 compilation units upon success. */
2267 load_debug_info (void * file)
2269 /* Reset the last pointer size so that we can issue correct error
2270 messages if we are displaying the contents of more than one section. */
2271 last_pointer_size = 0;
2272 warned_about_missing_comp_units = FALSE;
2274 /* If we have already tried and failed to load the .debug_info
2275 section then do not bother to repear the task. */
2276 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2279 /* If we already have the information there is nothing else to do. */
2280 if (num_debug_info_entries > 0)
2281 return num_debug_info_entries;
2283 if (load_debug_section (info, file)
2284 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2285 return num_debug_info_entries;
2287 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2292 display_debug_lines_raw (struct dwarf_section *section,
2293 unsigned char *data,
2296 unsigned char *start = section->start;
2298 printf (_("Raw dump of debug contents of section %s:\n\n"),
2303 DWARF2_Internal_LineInfo linfo;
2304 unsigned char *standard_opcodes;
2305 unsigned char *end_of_sequence;
2306 unsigned char *hdrptr;
2307 unsigned long hdroff;
2308 int initial_length_size;
2313 hdroff = hdrptr - start;
2315 /* Check the length of the block. */
2316 linfo.li_length = byte_get (hdrptr, 4);
2319 if (linfo.li_length == 0xffffffff)
2321 /* This section is 64-bit DWARF 3. */
2322 linfo.li_length = byte_get (hdrptr, 8);
2325 initial_length_size = 12;
2330 initial_length_size = 4;
2333 if (linfo.li_length + initial_length_size > section->size)
2336 (_("The information in section %s appears to be corrupt - the section is too small\n"),
2341 /* Check its version number. */
2342 linfo.li_version = byte_get (hdrptr, 2);
2344 if (linfo.li_version != 2
2345 && linfo.li_version != 3
2346 && linfo.li_version != 4)
2348 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2352 linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2353 hdrptr += offset_size;
2354 linfo.li_min_insn_length = byte_get (hdrptr, 1);
2356 if (linfo.li_version >= 4)
2358 linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2360 if (linfo.li_max_ops_per_insn == 0)
2362 warn (_("Invalid maximum operations per insn.\n"));
2367 linfo.li_max_ops_per_insn = 1;
2368 linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2370 linfo.li_line_base = byte_get (hdrptr, 1);
2372 linfo.li_line_range = byte_get (hdrptr, 1);
2374 linfo.li_opcode_base = byte_get (hdrptr, 1);
2377 /* Sign extend the line base field. */
2378 linfo.li_line_base <<= 24;
2379 linfo.li_line_base >>= 24;
2381 printf (_(" Offset: 0x%lx\n"), hdroff);
2382 printf (_(" Length: %ld\n"), linfo.li_length);
2383 printf (_(" DWARF Version: %d\n"), linfo.li_version);
2384 printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length);
2385 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
2386 if (linfo.li_version >= 4)
2387 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2388 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2389 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2390 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2391 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
2393 end_of_sequence = data + linfo.li_length + initial_length_size;
2395 reset_state_machine (linfo.li_default_is_stmt);
2397 /* Display the contents of the Opcodes table. */
2398 standard_opcodes = hdrptr;
2400 printf (_("\n Opcodes:\n"));
2402 for (i = 1; i < linfo.li_opcode_base; i++)
2403 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2405 /* Display the contents of the Directory table. */
2406 data = standard_opcodes + linfo.li_opcode_base - 1;
2409 printf (_("\n The Directory Table is empty.\n"));
2412 printf (_("\n The Directory Table:\n"));
2416 printf (_(" %s\n"), data);
2418 data += strlen ((char *) data) + 1;
2422 /* Skip the NUL at the end of the table. */
2425 /* Display the contents of the File Name table. */
2427 printf (_("\n The File Name Table is empty.\n"));
2430 printf (_("\n The File Name Table:\n"));
2431 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2435 unsigned char *name;
2436 unsigned int bytes_read;
2438 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
2441 data += strlen ((char *) data) + 1;
2443 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2445 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2447 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2449 printf (_("%s\n"), name);
2453 /* Skip the NUL at the end of the table. */
2456 /* Now display the statements. */
2457 printf (_("\n Line Number Statements:\n"));
2459 while (data < end_of_sequence)
2461 unsigned char op_code;
2463 unsigned long int uladv;
2464 unsigned int bytes_read;
2468 if (op_code >= linfo.li_opcode_base)
2470 op_code -= linfo.li_opcode_base;
2471 uladv = (op_code / linfo.li_line_range);
2472 if (linfo.li_max_ops_per_insn == 1)
2474 uladv *= linfo.li_min_insn_length;
2475 state_machine_regs.address += uladv;
2476 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2477 op_code, uladv, state_machine_regs.address);
2481 state_machine_regs.address
2482 += ((state_machine_regs.op_index + uladv)
2483 / linfo.li_max_ops_per_insn)
2484 * linfo.li_min_insn_length;
2485 state_machine_regs.op_index
2486 = (state_machine_regs.op_index + uladv)
2487 % linfo.li_max_ops_per_insn;
2488 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx[%d]"),
2489 op_code, uladv, state_machine_regs.address,
2490 state_machine_regs.op_index);
2492 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2493 state_machine_regs.line += adv;
2494 printf (_(" and Line by %d to %d\n"),
2495 adv, state_machine_regs.line);
2497 else switch (op_code)
2499 case DW_LNS_extended_op:
2500 data += process_extended_line_op (data, linfo.li_default_is_stmt);
2504 printf (_(" Copy\n"));
2507 case DW_LNS_advance_pc:
2508 uladv = read_leb128 (data, & bytes_read, 0);
2510 if (linfo.li_max_ops_per_insn == 1)
2512 uladv *= linfo.li_min_insn_length;
2513 state_machine_regs.address += uladv;
2514 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv,
2515 state_machine_regs.address);
2519 state_machine_regs.address
2520 += ((state_machine_regs.op_index + uladv)
2521 / linfo.li_max_ops_per_insn)
2522 * linfo.li_min_insn_length;
2523 state_machine_regs.op_index
2524 = (state_machine_regs.op_index + uladv)
2525 % linfo.li_max_ops_per_insn;
2526 printf (_(" Advance PC by %lu to 0x%lx[%d]\n"), uladv,
2527 state_machine_regs.address,
2528 state_machine_regs.op_index);
2532 case DW_LNS_advance_line:
2533 adv = read_leb128 (data, & bytes_read, 1);
2535 state_machine_regs.line += adv;
2536 printf (_(" Advance Line by %d to %d\n"), adv,
2537 state_machine_regs.line);
2540 case DW_LNS_set_file:
2541 adv = read_leb128 (data, & bytes_read, 0);
2543 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2545 state_machine_regs.file = adv;
2548 case DW_LNS_set_column:
2549 uladv = read_leb128 (data, & bytes_read, 0);
2551 printf (_(" Set column to %lu\n"), uladv);
2552 state_machine_regs.column = uladv;
2555 case DW_LNS_negate_stmt:
2556 adv = state_machine_regs.is_stmt;
2558 printf (_(" Set is_stmt to %d\n"), adv);
2559 state_machine_regs.is_stmt = adv;
2562 case DW_LNS_set_basic_block:
2563 printf (_(" Set basic block\n"));
2564 state_machine_regs.basic_block = 1;
2567 case DW_LNS_const_add_pc:
2568 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2569 if (linfo.li_max_ops_per_insn)
2571 uladv *= linfo.li_min_insn_length;
2572 state_machine_regs.address += uladv;
2573 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv,
2574 state_machine_regs.address);
2578 state_machine_regs.address
2579 += ((state_machine_regs.op_index + uladv)
2580 / linfo.li_max_ops_per_insn)
2581 * linfo.li_min_insn_length;
2582 state_machine_regs.op_index
2583 = (state_machine_regs.op_index + uladv)
2584 % linfo.li_max_ops_per_insn;
2585 printf (_(" Advance PC by constant %lu to 0x%lx[%d]\n"),
2586 uladv, state_machine_regs.address,
2587 state_machine_regs.op_index);
2591 case DW_LNS_fixed_advance_pc:
2592 uladv = byte_get (data, 2);
2594 state_machine_regs.address += uladv;
2595 state_machine_regs.op_index = 0;
2596 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2597 uladv, state_machine_regs.address);
2600 case DW_LNS_set_prologue_end:
2601 printf (_(" Set prologue_end to true\n"));
2604 case DW_LNS_set_epilogue_begin:
2605 printf (_(" Set epilogue_begin to true\n"));
2608 case DW_LNS_set_isa:
2609 uladv = read_leb128 (data, & bytes_read, 0);
2611 printf (_(" Set ISA to %lu\n"), uladv);
2615 printf (_(" Unknown opcode %d with operands: "), op_code);
2617 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2619 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2620 i == 1 ? "" : ", ");
2635 unsigned char *name;
2636 unsigned int directory_index;
2637 unsigned int modification_date;
2638 unsigned int length;
2641 /* Output a decoded representation of the .debug_line section. */
2644 display_debug_lines_decoded (struct dwarf_section *section,
2645 unsigned char *data,
2648 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2653 /* This loop amounts to one iteration per compilation unit. */
2654 DWARF2_Internal_LineInfo linfo;
2655 unsigned char *standard_opcodes;
2656 unsigned char *end_of_sequence;
2657 unsigned char *hdrptr;
2658 int initial_length_size;
2661 File_Entry *file_table = NULL;
2662 unsigned char **directory_table = NULL;
2666 /* Extract information from the Line Number Program Header.
2667 (section 6.2.4 in the Dwarf3 doc). */
2669 /* Get the length of this CU's line number information block. */
2670 linfo.li_length = byte_get (hdrptr, 4);
2673 if (linfo.li_length == 0xffffffff)
2675 /* This section is 64-bit DWARF 3. */
2676 linfo.li_length = byte_get (hdrptr, 8);
2679 initial_length_size = 12;
2684 initial_length_size = 4;
2687 if (linfo.li_length + initial_length_size > section->size)
2689 warn (_("The line info appears to be corrupt - "
2690 "the section is too small\n"));
2694 /* Get this CU's Line Number Block version number. */
2695 linfo.li_version = byte_get (hdrptr, 2);
2697 if (linfo.li_version != 2
2698 && linfo.li_version != 3
2699 && linfo.li_version != 4)
2701 warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2706 linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2707 hdrptr += offset_size;
2708 linfo.li_min_insn_length = byte_get (hdrptr, 1);
2710 if (linfo.li_version >= 4)
2712 linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2714 if (linfo.li_max_ops_per_insn == 0)
2716 warn (_("Invalid maximum operations per insn.\n"));
2721 linfo.li_max_ops_per_insn = 1;
2722 linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2724 linfo.li_line_base = byte_get (hdrptr, 1);
2726 linfo.li_line_range = byte_get (hdrptr, 1);
2728 linfo.li_opcode_base = byte_get (hdrptr, 1);
2731 /* Sign extend the line base field. */
2732 linfo.li_line_base <<= 24;
2733 linfo.li_line_base >>= 24;
2735 /* Find the end of this CU's Line Number Information Block. */
2736 end_of_sequence = data + linfo.li_length + initial_length_size;
2738 reset_state_machine (linfo.li_default_is_stmt);
2740 /* Save a pointer to the contents of the Opcodes table. */
2741 standard_opcodes = hdrptr;
2743 /* Traverse the Directory table just to count entries. */
2744 data = standard_opcodes + linfo.li_opcode_base - 1;
2747 unsigned int n_directories = 0;
2748 unsigned char *ptr_directory_table = data;
2752 data += strlen ((char *) data) + 1;
2756 /* Go through the directory table again to save the directories. */
2757 directory_table = (unsigned char **)
2758 xmalloc (n_directories * sizeof (unsigned char *));
2761 while (*ptr_directory_table != 0)
2763 directory_table[i] = ptr_directory_table;
2764 ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2768 /* Skip the NUL at the end of the table. */
2771 /* Traverse the File Name table just to count the entries. */
2774 unsigned int n_files = 0;
2775 unsigned char *ptr_file_name_table = data;
2779 unsigned int bytes_read;
2781 /* Skip Name, directory index, last modification time and length
2783 data += strlen ((char *) data) + 1;
2784 read_leb128 (data, & bytes_read, 0);
2786 read_leb128 (data, & bytes_read, 0);
2788 read_leb128 (data, & bytes_read, 0);
2794 /* Go through the file table again to save the strings. */
2795 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
2798 while (*ptr_file_name_table != 0)
2800 unsigned int bytes_read;
2802 file_table[i].name = ptr_file_name_table;
2803 ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2805 /* We are not interested in directory, time or size. */
2806 file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2808 ptr_file_name_table += bytes_read;
2809 file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2811 ptr_file_name_table += bytes_read;
2812 file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2813 ptr_file_name_table += bytes_read;
2818 /* Print the Compilation Unit's name and a header. */
2819 if (directory_table == NULL)
2821 printf (_("CU: %s:\n"), file_table[0].name);
2822 printf (_("File name Line number Starting address\n"));
2826 if (do_wide || strlen ((char *) directory_table[0]) < 76)
2828 printf (_("CU: %s/%s:\n"), directory_table[0],
2829 file_table[0].name);
2833 printf (_("%s:\n"), file_table[0].name);
2835 printf (_("File name Line number Starting address\n"));
2839 /* Skip the NUL at the end of the table. */
2842 /* This loop iterates through the Dwarf Line Number Program. */
2843 while (data < end_of_sequence)
2845 unsigned char op_code;
2847 unsigned long int uladv;
2848 unsigned int bytes_read;
2849 int is_special_opcode = 0;
2853 if (op_code >= linfo.li_opcode_base)
2855 op_code -= linfo.li_opcode_base;
2856 uladv = (op_code / linfo.li_line_range);
2857 if (linfo.li_max_ops_per_insn == 1)
2859 uladv *= linfo.li_min_insn_length;
2860 state_machine_regs.address += uladv;
2864 state_machine_regs.address
2865 += ((state_machine_regs.op_index + uladv)
2866 / linfo.li_max_ops_per_insn)
2867 * linfo.li_min_insn_length;
2868 state_machine_regs.op_index
2869 = (state_machine_regs.op_index + uladv)
2870 % linfo.li_max_ops_per_insn;
2873 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2874 state_machine_regs.line += adv;
2875 is_special_opcode = 1;
2877 else switch (op_code)
2879 case DW_LNS_extended_op:
2881 unsigned int ext_op_code_len;
2882 unsigned char ext_op_code;
2883 unsigned char *op_code_data = data;
2885 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
2886 op_code_data += bytes_read;
2888 if (ext_op_code_len == 0)
2890 warn (_("badly formed extended line op encountered!\n"));
2893 ext_op_code_len += bytes_read;
2894 ext_op_code = *op_code_data++;
2896 switch (ext_op_code)
2898 case DW_LNE_end_sequence:
2899 reset_state_machine (linfo.li_default_is_stmt);
2901 case DW_LNE_set_address:
2902 state_machine_regs.address =
2903 byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
2904 state_machine_regs.op_index = 0;
2906 case DW_LNE_define_file:
2908 unsigned int dir_index = 0;
2910 ++state_machine_regs.last_file_entry;
2911 op_code_data += strlen ((char *) op_code_data) + 1;
2912 dir_index = read_leb128 (op_code_data, & bytes_read, 0);
2913 op_code_data += bytes_read;
2914 read_leb128 (op_code_data, & bytes_read, 0);
2915 op_code_data += bytes_read;
2916 read_leb128 (op_code_data, & bytes_read, 0);
2918 printf (_("%s:\n"), directory_table[dir_index]);
2922 printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
2925 data += ext_op_code_len;
2931 case DW_LNS_advance_pc:
2932 uladv = read_leb128 (data, & bytes_read, 0);
2934 if (linfo.li_max_ops_per_insn == 1)
2936 uladv *= linfo.li_min_insn_length;
2937 state_machine_regs.address += uladv;
2941 state_machine_regs.address
2942 += ((state_machine_regs.op_index + uladv)
2943 / linfo.li_max_ops_per_insn)
2944 * linfo.li_min_insn_length;
2945 state_machine_regs.op_index
2946 = (state_machine_regs.op_index + uladv)
2947 % linfo.li_max_ops_per_insn;
2951 case DW_LNS_advance_line:
2952 adv = read_leb128 (data, & bytes_read, 1);
2954 state_machine_regs.line += adv;
2957 case DW_LNS_set_file:
2958 adv = read_leb128 (data, & bytes_read, 0);
2960 state_machine_regs.file = adv;
2961 if (file_table[state_machine_regs.file - 1].directory_index == 0)
2963 /* If directory index is 0, that means current directory. */
2964 printf (_("\n./%s:[++]\n"),
2965 file_table[state_machine_regs.file - 1].name);
2969 /* The directory index starts counting at 1. */
2970 printf (_("\n%s/%s:\n"),
2971 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
2972 file_table[state_machine_regs.file - 1].name);
2976 case DW_LNS_set_column:
2977 uladv = read_leb128 (data, & bytes_read, 0);
2979 state_machine_regs.column = uladv;
2982 case DW_LNS_negate_stmt:
2983 adv = state_machine_regs.is_stmt;
2985 state_machine_regs.is_stmt = adv;
2988 case DW_LNS_set_basic_block:
2989 state_machine_regs.basic_block = 1;
2992 case DW_LNS_const_add_pc:
2993 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2994 if (linfo.li_max_ops_per_insn == 1)
2996 uladv *= linfo.li_min_insn_length;
2997 state_machine_regs.address += uladv;
3001 state_machine_regs.address
3002 += ((state_machine_regs.op_index + uladv)
3003 / linfo.li_max_ops_per_insn)
3004 * linfo.li_min_insn_length;
3005 state_machine_regs.op_index
3006 = (state_machine_regs.op_index + uladv)
3007 % linfo.li_max_ops_per_insn;
3011 case DW_LNS_fixed_advance_pc:
3012 uladv = byte_get (data, 2);
3014 state_machine_regs.address += uladv;
3015 state_machine_regs.op_index = 0;
3018 case DW_LNS_set_prologue_end:
3021 case DW_LNS_set_epilogue_begin:
3024 case DW_LNS_set_isa:
3025 uladv = read_leb128 (data, & bytes_read, 0);
3027 printf (_(" Set ISA to %lu\n"), uladv);
3031 printf (_(" Unknown opcode %d with operands: "), op_code);
3033 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3035 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
3036 i == 1 ? "" : ", ");
3043 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3044 to the DWARF address/line matrix. */
3045 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3046 || (op_code == DW_LNS_copy))
3048 const unsigned int MAX_FILENAME_LENGTH = 35;
3049 char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
3050 char *newFileName = NULL;
3051 size_t fileNameLength = strlen (fileName);
3053 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3055 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3056 /* Truncate file name */
3057 strncpy (newFileName,
3058 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3059 MAX_FILENAME_LENGTH + 1);
3063 newFileName = (char *) xmalloc (fileNameLength + 1);
3064 strncpy (newFileName, fileName, fileNameLength + 1);
3067 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3069 if (linfo.li_max_ops_per_insn == 1)
3070 printf (_("%-35s %11d %#18lx\n"), newFileName,
3071 state_machine_regs.line,
3072 state_machine_regs.address);
3074 printf (_("%-35s %11d %#18lx[%d]\n"), newFileName,
3075 state_machine_regs.line,
3076 state_machine_regs.address,
3077 state_machine_regs.op_index);
3081 if (linfo.li_max_ops_per_insn == 1)
3082 printf (_("%s %11d %#18lx\n"), newFileName,
3083 state_machine_regs.line,
3084 state_machine_regs.address);
3086 printf (_("%s %11d %#18lx[%d]\n"), newFileName,
3087 state_machine_regs.line,
3088 state_machine_regs.address,
3089 state_machine_regs.op_index);
3092 if (op_code == DW_LNE_end_sequence)
3100 free (directory_table);
3101 directory_table = NULL;
3109 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3111 unsigned char *data = section->start;
3112 unsigned char *end = data + section->size;
3114 int retValDecoded = 1;
3116 if (do_debug_lines == 0)
3117 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3119 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3120 retValRaw = display_debug_lines_raw (section, data, end);
3122 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3123 retValDecoded = display_debug_lines_decoded (section, data, end);
3125 if (!retValRaw || !retValDecoded)
3132 find_debug_info_for_offset (unsigned long offset)
3136 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3139 for (i = 0; i < num_debug_info_entries; i++)
3140 if (debug_information[i].cu_offset == offset)
3141 return debug_information + i;
3147 display_debug_pubnames (struct dwarf_section *section,
3148 void *file ATTRIBUTE_UNUSED)
3150 DWARF2_Internal_PubNames names;
3151 unsigned char *start = section->start;
3152 unsigned char *end = start + section->size;
3154 /* It does not matter if this load fails,
3155 we test for that later on. */
3156 load_debug_info (file);
3158 printf (_("Contents of the %s section:\n\n"), section->name);
3162 unsigned char *data;
3163 unsigned long offset;
3164 int offset_size, initial_length_size;
3168 names.pn_length = byte_get (data, 4);
3170 if (names.pn_length == 0xffffffff)
3172 names.pn_length = byte_get (data, 8);
3175 initial_length_size = 12;
3180 initial_length_size = 4;
3183 names.pn_version = byte_get (data, 2);
3186 names.pn_offset = byte_get (data, offset_size);
3187 data += offset_size;
3189 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3190 && num_debug_info_entries > 0
3191 && find_debug_info_for_offset (names.pn_offset) == NULL)
3192 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3193 names.pn_offset, section->name);
3195 names.pn_size = byte_get (data, offset_size);
3196 data += offset_size;
3198 start += names.pn_length + initial_length_size;
3200 if (names.pn_version != 2 && names.pn_version != 3)
3202 static int warned = 0;
3206 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3213 printf (_(" Length: %ld\n"),
3215 printf (_(" Version: %d\n"),
3217 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3219 printf (_(" Size of area in .debug_info section: %ld\n"),
3222 printf (_("\n Offset\tName\n"));
3226 offset = byte_get (data, offset_size);
3230 data += offset_size;
3231 printf (" %-6lx\t%s\n", offset, data);
3232 data += strlen ((char *) data) + 1;
3235 while (offset != 0);
3243 display_debug_macinfo (struct dwarf_section *section,
3244 void *file ATTRIBUTE_UNUSED)
3246 unsigned char *start = section->start;
3247 unsigned char *end = start + section->size;
3248 unsigned char *curr = start;
3249 unsigned int bytes_read;
3250 enum dwarf_macinfo_record_type op;
3252 printf (_("Contents of the %s section:\n\n"), section->name);
3256 unsigned int lineno;
3259 op = (enum dwarf_macinfo_record_type) *curr;
3264 case DW_MACINFO_start_file:
3266 unsigned int filenum;
3268 lineno = read_leb128 (curr, & bytes_read, 0);
3270 filenum = read_leb128 (curr, & bytes_read, 0);
3273 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3278 case DW_MACINFO_end_file:
3279 printf (_(" DW_MACINFO_end_file\n"));
3282 case DW_MACINFO_define:
3283 lineno = read_leb128 (curr, & bytes_read, 0);
3285 string = (char *) curr;
3286 curr += strlen (string) + 1;
3287 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3291 case DW_MACINFO_undef:
3292 lineno = read_leb128 (curr, & bytes_read, 0);
3294 string = (char *) curr;
3295 curr += strlen (string) + 1;
3296 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3300 case DW_MACINFO_vendor_ext:
3302 unsigned int constant;
3304 constant = read_leb128 (curr, & bytes_read, 0);
3306 string = (char *) curr;
3307 curr += strlen (string) + 1;
3308 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3319 display_debug_abbrev (struct dwarf_section *section,
3320 void *file ATTRIBUTE_UNUSED)
3322 abbrev_entry *entry;
3323 unsigned char *start = section->start;
3324 unsigned char *end = start + section->size;
3326 printf (_("Contents of the %s section:\n\n"), section->name);
3332 start = process_abbrev_section (start, end);
3334 if (first_abbrev == NULL)
3337 printf (_(" Number TAG\n"));
3339 for (entry = first_abbrev; entry; entry = entry->next)
3343 printf (_(" %ld %s [%s]\n"),
3345 get_TAG_name (entry->tag),
3346 entry->children ? _("has children") : _("no children"));
3348 for (attr = entry->first_attr; attr; attr = attr->next)
3349 printf (_(" %-18s %s\n"),
3350 get_AT_name (attr->attribute),
3351 get_FORM_name (attr->form));
3362 display_debug_loc (struct dwarf_section *section, void *file)
3364 unsigned char *start = section->start;
3365 unsigned char *section_end;
3366 unsigned long bytes;
3367 unsigned char *section_begin = start;
3368 unsigned int num_loc_list = 0;
3369 unsigned long last_offset = 0;
3370 unsigned int first = 0;
3373 int seen_first_offset = 0;
3374 int use_debug_info = 1;
3375 unsigned char *next;
3377 bytes = section->size;
3378 section_end = start + bytes;
3382 printf (_("\nThe %s section is empty.\n"), section->name);
3386 if (load_debug_info (file) == 0)
3388 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3393 /* Check the order of location list in .debug_info section. If
3394 offsets of location lists are in the ascending order, we can
3395 use `debug_information' directly. */
3396 for (i = 0; i < num_debug_info_entries; i++)
3400 num = debug_information [i].num_loc_offsets;
3401 num_loc_list += num;
3403 /* Check if we can use `debug_information' directly. */
3404 if (use_debug_info && num != 0)
3406 if (!seen_first_offset)
3408 /* This is the first location list. */
3409 last_offset = debug_information [i].loc_offsets [0];
3411 seen_first_offset = 1;
3417 for (; j < num; j++)
3420 debug_information [i].loc_offsets [j])
3425 last_offset = debug_information [i].loc_offsets [j];
3430 if (!use_debug_info)
3431 /* FIXME: Should we handle this case? */
3432 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3434 if (!seen_first_offset)
3435 error (_("No location lists in .debug_info section!\n"));
3437 /* DWARF sections under Mach-O have non-zero addresses. */
3438 if (debug_information [first].num_loc_offsets > 0
3439 && debug_information [first].loc_offsets [0] != section->address)
3440 warn (_("Location lists in %s section start at 0x%lx\n"),
3441 section->name, debug_information [first].loc_offsets [0]);
3443 printf (_("Contents of the %s section:\n\n"), section->name);
3444 printf (_(" Offset Begin End Expression\n"));
3446 seen_first_offset = 0;
3447 for (i = first; i < num_debug_info_entries; i++)
3451 unsigned short length;
3452 unsigned long offset;
3453 unsigned int pointer_size;
3454 unsigned int offset_size;
3456 unsigned long cu_offset;
3457 unsigned long base_address;
3458 int need_frame_base;
3461 pointer_size = debug_information [i].pointer_size;
3462 cu_offset = debug_information [i].cu_offset;
3463 offset_size = debug_information [i].offset_size;
3464 dwarf_version = debug_information [i].dwarf_version;
3466 for (j = 0; j < debug_information [i].num_loc_offsets; j++)
3468 has_frame_base = debug_information [i].have_frame_base [j];
3469 /* DWARF sections under Mach-O have non-zero addresses. */
3470 offset = debug_information [i].loc_offsets [j] - section->address;
3471 next = section_begin + offset;
3472 base_address = debug_information [i].base_address;
3474 if (!seen_first_offset)
3475 seen_first_offset = 1;
3479 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3480 (unsigned long) (start - section_begin),
3481 (unsigned long) (next - section_begin));
3482 else if (start > next)
3483 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3484 (unsigned long) (start - section_begin),
3485 (unsigned long) (next - section_begin));
3489 if (offset >= bytes)
3491 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3498 if (start + 2 * pointer_size > section_end)
3500 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3505 /* Note: we use sign extension here in order to be sure that
3506 we can detect the -1 escape value. Sign extension into the
3507 top 32 bits of a 32-bit address will not affect the values
3508 that we display since we always show hex values, and always
3509 the bottom 32-bits. */
3510 begin = byte_get_signed (start, pointer_size);
3511 start += pointer_size;
3512 end = byte_get_signed (start, pointer_size);
3513 start += pointer_size;
3515 printf (" %8.8lx ", offset);
3517 if (begin == 0 && end == 0)
3519 printf (_("<End of list>\n"));
3523 /* Check base address specifiers. */
3524 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3527 print_dwarf_vma (begin, pointer_size);
3528 print_dwarf_vma (end, pointer_size);
3529 printf (_("(base address)\n"));
3533 if (start + 2 > section_end)
3535 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3540 length = byte_get (start, 2);
3543 if (start + length > section_end)
3545 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3550 print_dwarf_vma (begin + base_address, pointer_size);
3551 print_dwarf_vma (end + base_address, pointer_size);
3554 need_frame_base = decode_location_expression (start,
3559 cu_offset, section);
3562 if (need_frame_base && !has_frame_base)
3563 printf (_(" [without DW_AT_frame_base]"));
3566 fputs (_(" (start == end)"), stdout);
3567 else if (begin > end)
3568 fputs (_(" (start > end)"), stdout);
3577 if (start < section_end)
3578 warn (_("There are %ld unused bytes at the end of section %s\n"),
3579 (long) (section_end - start), section->name);
3585 display_debug_str (struct dwarf_section *section,
3586 void *file ATTRIBUTE_UNUSED)
3588 unsigned char *start = section->start;
3589 unsigned long bytes = section->size;
3590 dwarf_vma addr = section->address;
3594 printf (_("\nThe %s section is empty.\n"), section->name);
3598 printf (_("Contents of the %s section:\n\n"), section->name);
3606 lbytes = (bytes > 16 ? 16 : bytes);
3608 printf (" 0x%8.8lx ", (unsigned long) addr);
3610 for (j = 0; j < 16; j++)
3613 printf ("%2.2x", start[j]);
3621 for (j = 0; j < lbytes; j++)
3624 if (k >= ' ' && k < 0x80)
3643 display_debug_info (struct dwarf_section *section, void *file)
3645 return process_debug_info (section, file, abbrev, 0, 0);
3649 display_debug_types (struct dwarf_section *section, void *file)
3651 return process_debug_info (section, file, abbrev, 0, 1);
3655 display_trace_info (struct dwarf_section *section, void *file)
3657 return process_debug_info (section, file, trace_abbrev, 0, 0);
3661 display_debug_aranges (struct dwarf_section *section,
3662 void *file ATTRIBUTE_UNUSED)
3664 unsigned char *start = section->start;
3665 unsigned char *end = start + section->size;
3667 printf (_("Contents of the %s section:\n\n"), section->name);
3669 /* It does not matter if this load fails,
3670 we test for that later on. */
3671 load_debug_info (file);
3675 unsigned char *hdrptr;
3676 DWARF2_Internal_ARange arange;
3677 unsigned char *addr_ranges;
3680 unsigned char address_size;
3683 int initial_length_size;
3687 arange.ar_length = byte_get (hdrptr, 4);
3690 if (arange.ar_length == 0xffffffff)
3692 arange.ar_length = byte_get (hdrptr, 8);
3695 initial_length_size = 12;
3700 initial_length_size = 4;
3703 arange.ar_version = byte_get (hdrptr, 2);
3706 arange.ar_info_offset = byte_get (hdrptr, offset_size);
3707 hdrptr += offset_size;
3709 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3710 && num_debug_info_entries > 0
3711 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
3712 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3713 arange.ar_info_offset, section->name);
3715 arange.ar_pointer_size = byte_get (hdrptr, 1);
3718 arange.ar_segment_size = byte_get (hdrptr, 1);
3721 if (arange.ar_version != 2 && arange.ar_version != 3)
3723 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3727 printf (_(" Length: %ld\n"), arange.ar_length);
3728 printf (_(" Version: %d\n"), arange.ar_version);
3729 printf (_(" Offset into .debug_info: 0x%lx\n"), arange.ar_info_offset);
3730 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
3731 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
3733 address_size = arange.ar_pointer_size + arange.ar_segment_size;
3735 /* The DWARF spec does not require that the address size be a power
3736 of two, but we do. This will have to change if we ever encounter
3737 an uneven architecture. */
3738 if ((address_size & (address_size - 1)) != 0)
3740 warn (_("Pointer size + Segment size is not a power of two.\n"));
3744 if (address_size > 4)
3745 printf (_("\n Address Length\n"));
3747 printf (_("\n Address Length\n"));
3749 addr_ranges = hdrptr;
3751 /* Must pad to an alignment boundary that is twice the address size. */
3752 excess = (hdrptr - start) % (2 * address_size);
3754 addr_ranges += (2 * address_size) - excess;
3756 start += arange.ar_length + initial_length_size;
3758 while (addr_ranges + 2 * address_size <= start)
3760 address = byte_get (addr_ranges, address_size);
3762 addr_ranges += address_size;
3764 length = byte_get (addr_ranges, address_size);
3766 addr_ranges += address_size;
3769 print_dwarf_vma (address, address_size);
3770 print_dwarf_vma (length, address_size);
3780 /* Each debug_information[x].range_lists[y] gets this representation for
3781 sorting purposes. */
3785 /* The debug_information[x].range_lists[y] value. */
3786 unsigned long ranges_offset;
3788 /* Original debug_information to find parameters of the data. */
3789 debug_info *debug_info_p;
3792 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
3795 range_entry_compar (const void *ap, const void *bp)
3797 const struct range_entry *a_re = (const struct range_entry *) ap;
3798 const struct range_entry *b_re = (const struct range_entry *) bp;
3799 const unsigned long a = a_re->ranges_offset;
3800 const unsigned long b = b_re->ranges_offset;
3802 return (a > b) - (b > a);
3806 display_debug_ranges (struct dwarf_section *section,
3807 void *file ATTRIBUTE_UNUSED)
3809 unsigned char *start = section->start;
3810 unsigned long bytes;
3811 unsigned char *section_begin = start;
3812 unsigned int num_range_list, i;
3813 struct range_entry *range_entries, *range_entry_fill;
3815 bytes = section->size;
3819 printf (_("\nThe %s section is empty.\n"), section->name);
3823 if (load_debug_info (file) == 0)
3825 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3831 for (i = 0; i < num_debug_info_entries; i++)
3832 num_range_list += debug_information [i].num_range_lists;
3834 if (num_range_list == 0)
3835 error (_("No range lists in .debug_info section!\n"));
3837 range_entries = (struct range_entry *)
3838 xmalloc (sizeof (*range_entries) * num_range_list);
3839 range_entry_fill = range_entries;
3841 for (i = 0; i < num_debug_info_entries; i++)
3843 debug_info *debug_info_p = &debug_information[i];
3846 for (j = 0; j < debug_info_p->num_range_lists; j++)
3848 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
3849 range_entry_fill->debug_info_p = debug_info_p;
3854 qsort (range_entries, num_range_list, sizeof (*range_entries),
3855 range_entry_compar);
3857 /* DWARF sections under Mach-O have non-zero addresses. */
3858 if (range_entries[0].ranges_offset != section->address)
3859 warn (_("Range lists in %s section start at 0x%lx\n"),
3860 section->name, range_entries[0].ranges_offset);
3862 printf (_("Contents of the %s section:\n\n"), section->name);
3863 printf (_(" Offset Begin End\n"));
3865 for (i = 0; i < num_range_list; i++)
3867 struct range_entry *range_entry = &range_entries[i];
3868 debug_info *debug_info_p = range_entry->debug_info_p;
3869 unsigned int pointer_size;
3870 unsigned long offset;
3871 unsigned char *next;
3872 unsigned long base_address;
3874 pointer_size = debug_info_p->pointer_size;
3876 /* DWARF sections under Mach-O have non-zero addresses. */
3877 offset = range_entry->ranges_offset - section->address;
3878 next = section_begin + offset;
3879 base_address = debug_info_p->base_address;
3884 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3885 (unsigned long) (start - section_begin),
3886 (unsigned long) (next - section_begin), section->name);
3887 else if (start > next)
3888 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3889 (unsigned long) (start - section_begin),
3890 (unsigned long) (next - section_begin), section->name);
3899 /* Note: we use sign extension here in order to be sure that
3900 we can detect the -1 escape value. Sign extension into the
3901 top 32 bits of a 32-bit address will not affect the values
3902 that we display since we always show hex values, and always
3903 the bottom 32-bits. */
3904 begin = byte_get_signed (start, pointer_size);
3905 start += pointer_size;
3906 end = byte_get_signed (start, pointer_size);
3907 start += pointer_size;
3909 printf (" %8.8lx ", offset);
3911 if (begin == 0 && end == 0)
3913 printf (_("<End of list>\n"));
3917 /* Check base address specifiers. */
3918 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3921 print_dwarf_vma (begin, pointer_size);
3922 print_dwarf_vma (end, pointer_size);
3923 printf ("(base address)\n");
3927 print_dwarf_vma (begin + base_address, pointer_size);
3928 print_dwarf_vma (end + base_address, pointer_size);
3931 fputs (_("(start == end)"), stdout);
3932 else if (begin > end)
3933 fputs (_("(start > end)"), stdout);
3940 free (range_entries);
3945 typedef struct Frame_Chunk
3947 struct Frame_Chunk *next;
3948 unsigned char *chunk_start;
3950 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3951 short int *col_type;
3954 unsigned int code_factor;
3956 unsigned long pc_begin;
3957 unsigned long pc_range;
3961 unsigned char fde_encoding;
3962 unsigned char cfa_exp;
3963 unsigned char ptr_size;
3964 unsigned char segment_size;
3968 static const char *const *dwarf_regnames;
3969 static unsigned int dwarf_regnames_count;
3971 /* A marker for a col_type that means this column was never referenced
3972 in the frame info. */
3973 #define DW_CFA_unreferenced (-1)
3975 /* Return 0 if not more space is needed, 1 if more space is needed,
3976 -1 for invalid reg. */
3979 frame_need_space (Frame_Chunk *fc, unsigned int reg)
3981 int prev = fc->ncols;
3983 if (reg < (unsigned int) fc->ncols)
3986 if (dwarf_regnames_count
3987 && reg > dwarf_regnames_count)
3990 fc->ncols = reg + 1;
3991 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
3992 sizeof (short int));
3993 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
3995 while (prev < fc->ncols)
3997 fc->col_type[prev] = DW_CFA_unreferenced;
3998 fc->col_offset[prev] = 0;
4004 static const char *const dwarf_regnames_i386[] =
4006 "eax", "ecx", "edx", "ebx",
4007 "esp", "ebp", "esi", "edi",
4008 "eip", "eflags", NULL,
4009 "st0", "st1", "st2", "st3",
4010 "st4", "st5", "st6", "st7",
4012 "xmm0", "xmm1", "xmm2", "xmm3",
4013 "xmm4", "xmm5", "xmm6", "xmm7",
4014 "mm0", "mm1", "mm2", "mm3",
4015 "mm4", "mm5", "mm6", "mm7",
4016 "fcw", "fsw", "mxcsr",
4017 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4022 init_dwarf_regnames_i386 (void)
4024 dwarf_regnames = dwarf_regnames_i386;
4025 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
4028 static const char *const dwarf_regnames_x86_64[] =
4030 "rax", "rdx", "rcx", "rbx",
4031 "rsi", "rdi", "rbp", "rsp",
4032 "r8", "r9", "r10", "r11",
4033 "r12", "r13", "r14", "r15",
4035 "xmm0", "xmm1", "xmm2", "xmm3",
4036 "xmm4", "xmm5", "xmm6", "xmm7",
4037 "xmm8", "xmm9", "xmm10", "xmm11",
4038 "xmm12", "xmm13", "xmm14", "xmm15",
4039 "st0", "st1", "st2", "st3",
4040 "st4", "st5", "st6", "st7",
4041 "mm0", "mm1", "mm2", "mm3",
4042 "mm4", "mm5", "mm6", "mm7",
4044 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4045 "fs.base", "gs.base", NULL, NULL,
4047 "mxcsr", "fcw", "fsw"
4051 init_dwarf_regnames_x86_64 (void)
4053 dwarf_regnames = dwarf_regnames_x86_64;
4054 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
4058 init_dwarf_regnames (unsigned int e_machine)
4064 init_dwarf_regnames_i386 ();
4069 init_dwarf_regnames_x86_64 ();
4078 regname (unsigned int regno, int row)
4080 static char reg[64];
4082 && regno < dwarf_regnames_count
4083 && dwarf_regnames [regno] != NULL)
4086 return dwarf_regnames [regno];
4087 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
4088 dwarf_regnames [regno]);
4091 snprintf (reg, sizeof (reg), "r%d", regno);
4096 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
4101 if (*max_regs < fc->ncols)
4102 *max_regs = fc->ncols;
4104 if (*need_col_headers)
4106 static const char *sloc = " LOC";
4108 *need_col_headers = 0;
4110 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
4112 for (r = 0; r < *max_regs; r++)
4113 if (fc->col_type[r] != DW_CFA_unreferenced)
4118 printf ("%-5s ", regname (r, 1));
4124 printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
4126 strcpy (tmp, "exp");
4128 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
4129 printf ("%-8s ", tmp);
4131 for (r = 0; r < fc->ncols; r++)
4133 if (fc->col_type[r] != DW_CFA_unreferenced)
4135 switch (fc->col_type[r])
4137 case DW_CFA_undefined:
4140 case DW_CFA_same_value:
4144 sprintf (tmp, "c%+d", fc->col_offset[r]);
4146 case DW_CFA_val_offset:
4147 sprintf (tmp, "v%+d", fc->col_offset[r]);
4149 case DW_CFA_register:
4150 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
4152 case DW_CFA_expression:
4153 strcpy (tmp, "exp");
4155 case DW_CFA_val_expression:
4156 strcpy (tmp, "vexp");
4159 strcpy (tmp, "n/a");
4162 printf ("%-5s ", tmp);
4168 #define GET(N) byte_get (start, N); start += N
4169 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
4170 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
4173 display_debug_frames (struct dwarf_section *section,
4174 void *file ATTRIBUTE_UNUSED)
4176 unsigned char *start = section->start;
4177 unsigned char *end = start + section->size;
4178 unsigned char *section_start = start;
4179 Frame_Chunk *chunks = 0;
4180 Frame_Chunk *remembered_state = 0;
4182 int is_eh = strcmp (section->name, ".eh_frame") == 0;
4183 unsigned int length_return;
4185 const char *bad_reg = _("bad register: ");
4186 int saved_eh_addr_size = eh_addr_size;
4188 printf (_("Contents of the %s section:\n"), section->name);
4192 unsigned char *saved_start;
4193 unsigned char *block_end;
4194 unsigned long length;
4195 unsigned long cie_id;
4198 int need_col_headers = 1;
4199 unsigned char *augmentation_data = NULL;
4200 unsigned long augmentation_data_len = 0;
4201 int encoded_ptr_size = saved_eh_addr_size;
4203 int initial_length_size;
4205 saved_start = start;
4206 length = byte_get (start, 4); start += 4;
4210 printf ("\n%08lx ZERO terminator\n\n",
4211 (unsigned long)(saved_start - section_start));
4215 if (length == 0xffffffff)
4217 length = byte_get (start, 8);
4220 initial_length_size = 12;
4225 initial_length_size = 4;
4228 block_end = saved_start + length + initial_length_size;
4229 if (block_end > end)
4231 warn ("Invalid length %#08lx in FDE at %#08lx\n",
4232 length, (unsigned long)(saved_start - section_start));
4235 cie_id = byte_get (start, offset_size); start += offset_size;
4237 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
4241 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4242 memset (fc, 0, sizeof (Frame_Chunk));
4246 fc->chunk_start = saved_start;
4248 fc->col_type = (short int *) xmalloc (sizeof (short int));
4249 fc->col_offset = (int *) xmalloc (sizeof (int));
4250 frame_need_space (fc, max_regs - 1);
4254 fc->augmentation = (char *) start;
4255 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
4257 if (strcmp (fc->augmentation, "eh") == 0)
4258 start += eh_addr_size;
4262 fc->ptr_size = GET (1);
4263 fc->segment_size = GET (1);
4264 eh_addr_size = fc->ptr_size;
4268 fc->ptr_size = eh_addr_size;
4269 fc->segment_size = 0;
4271 fc->code_factor = LEB ();
4272 fc->data_factor = SLEB ();
4282 if (fc->augmentation[0] == 'z')
4284 augmentation_data_len = LEB ();
4285 augmentation_data = start;
4286 start += augmentation_data_len;
4290 if (do_debug_frames_interp)
4291 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4292 (unsigned long)(saved_start - section_start), length, cie_id,
4293 fc->augmentation, fc->code_factor, fc->data_factor,
4297 printf ("\n%08lx %08lx %08lx CIE\n",
4298 (unsigned long)(saved_start - section_start), length, cie_id);
4299 printf (" Version: %d\n", version);
4300 printf (" Augmentation: \"%s\"\n", fc->augmentation);
4303 printf (" Pointer Size: %u\n", fc->ptr_size);
4304 printf (" Segment Size: %u\n", fc->segment_size);
4306 printf (" Code alignment factor: %u\n", fc->code_factor);
4307 printf (" Data alignment factor: %d\n", fc->data_factor);
4308 printf (" Return address column: %d\n", fc->ra);
4310 if (augmentation_data_len)
4313 printf (" Augmentation data: ");
4314 for (i = 0; i < augmentation_data_len; ++i)
4315 printf (" %02x", augmentation_data[i]);
4321 if (augmentation_data_len)
4323 unsigned char *p, *q;
4324 p = (unsigned char *) fc->augmentation + 1;
4325 q = augmentation_data;
4332 q += 1 + size_of_encoded_value (*q);
4334 fc->fde_encoding = *q++;
4342 if (fc->fde_encoding)
4343 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4346 frame_need_space (fc, fc->ra);
4350 unsigned char *look_for;
4351 static Frame_Chunk fde_fc;
4352 unsigned long segment_selector;
4355 memset (fc, 0, sizeof (Frame_Chunk));
4357 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4359 for (cie = chunks; cie ; cie = cie->next)
4360 if (cie->chunk_start == look_for)
4365 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4366 cie_id, (unsigned long)(saved_start - section_start));
4368 fc->col_type = (short int *) xmalloc (sizeof (short int));
4369 fc->col_offset = (int *) xmalloc (sizeof (int));
4370 frame_need_space (fc, max_regs - 1);
4372 fc->augmentation = "";
4373 fc->fde_encoding = 0;
4374 fc->ptr_size = eh_addr_size;
4375 fc->segment_size = 0;
4379 fc->ncols = cie->ncols;
4380 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
4381 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
4382 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4383 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4384 fc->augmentation = cie->augmentation;
4385 fc->ptr_size = cie->ptr_size;
4386 eh_addr_size = cie->ptr_size;
4387 fc->segment_size = cie->segment_size;
4388 fc->code_factor = cie->code_factor;
4389 fc->data_factor = cie->data_factor;
4390 fc->cfa_reg = cie->cfa_reg;
4391 fc->cfa_offset = cie->cfa_offset;
4393 frame_need_space (fc, max_regs - 1);
4394 fc->fde_encoding = cie->fde_encoding;
4397 if (fc->fde_encoding)
4398 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4400 segment_selector = 0;
4401 if (fc->segment_size)
4403 segment_selector = byte_get (start, fc->segment_size);
4404 start += fc->segment_size;
4406 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
4407 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4408 fc->pc_begin += section->address + (start - section_start);
4409 start += encoded_ptr_size;
4410 fc->pc_range = byte_get (start, encoded_ptr_size);
4411 start += encoded_ptr_size;
4413 if (cie->augmentation[0] == 'z')
4415 augmentation_data_len = LEB ();
4416 augmentation_data = start;
4417 start += augmentation_data_len;
4420 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
4421 (unsigned long)(saved_start - section_start), length, cie_id,
4422 (unsigned long)(cie->chunk_start - section_start));
4423 if (fc->segment_size)
4424 printf ("%04lx:", segment_selector);
4425 printf ("%08lx..%08lx\n", fc->pc_begin, fc->pc_begin + fc->pc_range);
4426 if (! do_debug_frames_interp && augmentation_data_len)
4430 printf (" Augmentation data: ");
4431 for (i = 0; i < augmentation_data_len; ++i)
4432 printf (" %02x", augmentation_data[i]);
4438 /* At this point, fc is the current chunk, cie (if any) is set, and
4439 we're about to interpret instructions for the chunk. */
4440 /* ??? At present we need to do this always, since this sizes the
4441 fc->col_type and fc->col_offset arrays, which we write into always.
4442 We should probably split the interpreted and non-interpreted bits
4443 into two different routines, since there's so much that doesn't
4444 really overlap between them. */
4445 if (1 || do_debug_frames_interp)
4447 /* Start by making a pass over the chunk, allocating storage
4448 and taking note of what registers are used. */
4449 unsigned char *tmp = start;
4451 while (start < block_end)
4454 unsigned long reg, temp;
4461 /* Warning: if you add any more cases to this switch, be
4462 sure to add them to the corresponding switch below. */
4465 case DW_CFA_advance_loc:
4469 if (frame_need_space (fc, opa) >= 0)
4470 fc->col_type[opa] = DW_CFA_undefined;
4472 case DW_CFA_restore:
4473 if (frame_need_space (fc, opa) >= 0)
4474 fc->col_type[opa] = DW_CFA_undefined;
4476 case DW_CFA_set_loc:
4477 start += encoded_ptr_size;
4479 case DW_CFA_advance_loc1:
4482 case DW_CFA_advance_loc2:
4485 case DW_CFA_advance_loc4:
4488 case DW_CFA_offset_extended:
4489 case DW_CFA_val_offset:
4490 reg = LEB (); LEB ();
4491 if (frame_need_space (fc, reg) >= 0)
4492 fc->col_type[reg] = DW_CFA_undefined;
4494 case DW_CFA_restore_extended:
4496 frame_need_space (fc, reg);
4497 if (frame_need_space (fc, reg) >= 0)
4498 fc->col_type[reg] = DW_CFA_undefined;
4500 case DW_CFA_undefined:
4502 if (frame_need_space (fc, reg) >= 0)
4503 fc->col_type[reg] = DW_CFA_undefined;
4505 case DW_CFA_same_value:
4507 if (frame_need_space (fc, reg) >= 0)
4508 fc->col_type[reg] = DW_CFA_undefined;
4510 case DW_CFA_register:
4511 reg = LEB (); LEB ();
4512 if (frame_need_space (fc, reg) >= 0)
4513 fc->col_type[reg] = DW_CFA_undefined;
4515 case DW_CFA_def_cfa:
4518 case DW_CFA_def_cfa_register:
4521 case DW_CFA_def_cfa_offset:
4524 case DW_CFA_def_cfa_expression:
4528 case DW_CFA_expression:
4529 case DW_CFA_val_expression:
4533 if (frame_need_space (fc, reg) >= 0)
4534 fc->col_type[reg] = DW_CFA_undefined;
4536 case DW_CFA_offset_extended_sf:
4537 case DW_CFA_val_offset_sf:
4538 reg = LEB (); SLEB ();
4539 if (frame_need_space (fc, reg) >= 0)
4540 fc->col_type[reg] = DW_CFA_undefined;
4542 case DW_CFA_def_cfa_sf:
4545 case DW_CFA_def_cfa_offset_sf:
4548 case DW_CFA_MIPS_advance_loc8:
4551 case DW_CFA_GNU_args_size:
4554 case DW_CFA_GNU_negative_offset_extended:
4555 reg = LEB (); LEB ();
4556 if (frame_need_space (fc, reg) >= 0)
4557 fc->col_type[reg] = DW_CFA_undefined;
4566 /* Now we know what registers are used, make a second pass over
4567 the chunk, this time actually printing out the info. */
4569 while (start < block_end)
4572 unsigned long ul, reg, roffs;
4575 const char *reg_prefix = "";
4582 /* Warning: if you add any more cases to this switch, be
4583 sure to add them to the corresponding switch above. */
4586 case DW_CFA_advance_loc:
4587 if (do_debug_frames_interp)
4588 frame_display_row (fc, &need_col_headers, &max_regs);
4590 printf (" DW_CFA_advance_loc: %d to %08lx\n",
4591 opa * fc->code_factor,
4592 fc->pc_begin + opa * fc->code_factor);
4593 fc->pc_begin += opa * fc->code_factor;
4598 if (opa >= (unsigned int) fc->ncols)
4599 reg_prefix = bad_reg;
4600 if (! do_debug_frames_interp || *reg_prefix != '\0')
4601 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
4602 reg_prefix, regname (opa, 0),
4603 roffs * fc->data_factor);
4604 if (*reg_prefix == '\0')
4606 fc->col_type[opa] = DW_CFA_offset;
4607 fc->col_offset[opa] = roffs * fc->data_factor;
4611 case DW_CFA_restore:
4612 if (opa >= (unsigned int) cie->ncols
4613 || opa >= (unsigned int) fc->ncols)
4614 reg_prefix = bad_reg;
4615 if (! do_debug_frames_interp || *reg_prefix != '\0')
4616 printf (" DW_CFA_restore: %s%s\n",
4617 reg_prefix, regname (opa, 0));
4618 if (*reg_prefix == '\0')
4620 fc->col_type[opa] = cie->col_type[opa];
4621 fc->col_offset[opa] = cie->col_offset[opa];
4625 case DW_CFA_set_loc:
4626 vma = get_encoded_value (start, fc->fde_encoding);
4627 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4628 vma += section->address + (start - section_start);
4629 start += encoded_ptr_size;
4630 if (do_debug_frames_interp)
4631 frame_display_row (fc, &need_col_headers, &max_regs);
4633 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
4637 case DW_CFA_advance_loc1:
4638 ofs = byte_get (start, 1); start += 1;
4639 if (do_debug_frames_interp)
4640 frame_display_row (fc, &need_col_headers, &max_regs);
4642 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
4643 ofs * fc->code_factor,
4644 fc->pc_begin + ofs * fc->code_factor);
4645 fc->pc_begin += ofs * fc->code_factor;
4648 case DW_CFA_advance_loc2:
4649 ofs = byte_get (start, 2); start += 2;
4650 if (do_debug_frames_interp)
4651 frame_display_row (fc, &need_col_headers, &max_regs);
4653 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
4654 ofs * fc->code_factor,
4655 fc->pc_begin + ofs * fc->code_factor);
4656 fc->pc_begin += ofs * fc->code_factor;
4659 case DW_CFA_advance_loc4:
4660 ofs = byte_get (start, 4); start += 4;
4661 if (do_debug_frames_interp)
4662 frame_display_row (fc, &need_col_headers, &max_regs);
4664 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
4665 ofs * fc->code_factor,
4666 fc->pc_begin + ofs * fc->code_factor);
4667 fc->pc_begin += ofs * fc->code_factor;
4670 case DW_CFA_offset_extended:
4673 if (reg >= (unsigned int) fc->ncols)
4674 reg_prefix = bad_reg;
4675 if (! do_debug_frames_interp || *reg_prefix != '\0')
4676 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4677 reg_prefix, regname (reg, 0),
4678 roffs * fc->data_factor);
4679 if (*reg_prefix == '\0')
4681 fc->col_type[reg] = DW_CFA_offset;
4682 fc->col_offset[reg] = roffs * fc->data_factor;
4686 case DW_CFA_val_offset:
4689 if (reg >= (unsigned int) fc->ncols)
4690 reg_prefix = bad_reg;
4691 if (! do_debug_frames_interp || *reg_prefix != '\0')
4692 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
4693 reg_prefix, regname (reg, 0),
4694 roffs * fc->data_factor);
4695 if (*reg_prefix == '\0')
4697 fc->col_type[reg] = DW_CFA_val_offset;
4698 fc->col_offset[reg] = roffs * fc->data_factor;
4702 case DW_CFA_restore_extended:
4704 if (reg >= (unsigned int) cie->ncols
4705 || reg >= (unsigned int) fc->ncols)
4706 reg_prefix = bad_reg;
4707 if (! do_debug_frames_interp || *reg_prefix != '\0')
4708 printf (" DW_CFA_restore_extended: %s%s\n",
4709 reg_prefix, regname (reg, 0));
4710 if (*reg_prefix == '\0')
4712 fc->col_type[reg] = cie->col_type[reg];
4713 fc->col_offset[reg] = cie->col_offset[reg];
4717 case DW_CFA_undefined:
4719 if (reg >= (unsigned int) fc->ncols)
4720 reg_prefix = bad_reg;
4721 if (! do_debug_frames_interp || *reg_prefix != '\0')
4722 printf (" DW_CFA_undefined: %s%s\n",
4723 reg_prefix, regname (reg, 0));
4724 if (*reg_prefix == '\0')
4726 fc->col_type[reg] = DW_CFA_undefined;
4727 fc->col_offset[reg] = 0;
4731 case DW_CFA_same_value:
4733 if (reg >= (unsigned int) fc->ncols)
4734 reg_prefix = bad_reg;
4735 if (! do_debug_frames_interp || *reg_prefix != '\0')
4736 printf (" DW_CFA_same_value: %s%s\n",
4737 reg_prefix, regname (reg, 0));
4738 if (*reg_prefix == '\0')
4740 fc->col_type[reg] = DW_CFA_same_value;
4741 fc->col_offset[reg] = 0;
4745 case DW_CFA_register:
4748 if (reg >= (unsigned int) fc->ncols)
4749 reg_prefix = bad_reg;
4750 if (! do_debug_frames_interp || *reg_prefix != '\0')
4752 printf (" DW_CFA_register: %s%s in ",
4753 reg_prefix, regname (reg, 0));
4754 puts (regname (roffs, 0));
4756 if (*reg_prefix == '\0')
4758 fc->col_type[reg] = DW_CFA_register;
4759 fc->col_offset[reg] = roffs;
4763 case DW_CFA_remember_state:
4764 if (! do_debug_frames_interp)
4765 printf (" DW_CFA_remember_state\n");
4766 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4767 rs->ncols = fc->ncols;
4768 rs->col_type = (short int *) xcmalloc (rs->ncols,
4769 sizeof (short int));
4770 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
4771 memcpy (rs->col_type, fc->col_type, rs->ncols);
4772 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
4773 rs->next = remembered_state;
4774 remembered_state = rs;
4777 case DW_CFA_restore_state:
4778 if (! do_debug_frames_interp)
4779 printf (" DW_CFA_restore_state\n");
4780 rs = remembered_state;
4783 remembered_state = rs->next;
4784 frame_need_space (fc, rs->ncols - 1);
4785 memcpy (fc->col_type, rs->col_type, rs->ncols);
4786 memcpy (fc->col_offset, rs->col_offset,
4787 rs->ncols * sizeof (int));
4788 free (rs->col_type);
4789 free (rs->col_offset);
4792 else if (do_debug_frames_interp)
4793 printf ("Mismatched DW_CFA_restore_state\n");
4796 case DW_CFA_def_cfa:
4797 fc->cfa_reg = LEB ();
4798 fc->cfa_offset = LEB ();
4800 if (! do_debug_frames_interp)
4801 printf (" DW_CFA_def_cfa: %s ofs %d\n",
4802 regname (fc->cfa_reg, 0), fc->cfa_offset);
4805 case DW_CFA_def_cfa_register:
4806 fc->cfa_reg = LEB ();
4808 if (! do_debug_frames_interp)
4809 printf (" DW_CFA_def_cfa_register: %s\n",
4810 regname (fc->cfa_reg, 0));
4813 case DW_CFA_def_cfa_offset:
4814 fc->cfa_offset = LEB ();
4815 if (! do_debug_frames_interp)
4816 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
4820 if (! do_debug_frames_interp)
4821 printf (" DW_CFA_nop\n");
4824 case DW_CFA_def_cfa_expression:
4826 if (! do_debug_frames_interp)
4828 printf (" DW_CFA_def_cfa_expression (");
4829 decode_location_expression (start, eh_addr_size, 0, -1,
4837 case DW_CFA_expression:
4840 if (reg >= (unsigned int) fc->ncols)
4841 reg_prefix = bad_reg;
4842 if (! do_debug_frames_interp || *reg_prefix != '\0')
4844 printf (" DW_CFA_expression: %s%s (",
4845 reg_prefix, regname (reg, 0));
4846 decode_location_expression (start, eh_addr_size, 0, -1,
4850 if (*reg_prefix == '\0')
4851 fc->col_type[reg] = DW_CFA_expression;
4855 case DW_CFA_val_expression:
4858 if (reg >= (unsigned int) fc->ncols)
4859 reg_prefix = bad_reg;
4860 if (! do_debug_frames_interp || *reg_prefix != '\0')
4862 printf (" DW_CFA_val_expression: %s%s (",
4863 reg_prefix, regname (reg, 0));
4864 decode_location_expression (start, eh_addr_size, 0, -1,
4868 if (*reg_prefix == '\0')
4869 fc->col_type[reg] = DW_CFA_val_expression;
4873 case DW_CFA_offset_extended_sf:
4876 if (frame_need_space (fc, reg) < 0)
4877 reg_prefix = bad_reg;
4878 if (! do_debug_frames_interp || *reg_prefix != '\0')
4879 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
4880 reg_prefix, regname (reg, 0),
4881 l * fc->data_factor);
4882 if (*reg_prefix == '\0')
4884 fc->col_type[reg] = DW_CFA_offset;
4885 fc->col_offset[reg] = l * fc->data_factor;
4889 case DW_CFA_val_offset_sf:
4892 if (frame_need_space (fc, reg) < 0)
4893 reg_prefix = bad_reg;
4894 if (! do_debug_frames_interp || *reg_prefix != '\0')
4895 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
4896 reg_prefix, regname (reg, 0),
4897 l * fc->data_factor);
4898 if (*reg_prefix == '\0')
4900 fc->col_type[reg] = DW_CFA_val_offset;
4901 fc->col_offset[reg] = l * fc->data_factor;
4905 case DW_CFA_def_cfa_sf:
4906 fc->cfa_reg = LEB ();
4907 fc->cfa_offset = SLEB ();
4908 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4910 if (! do_debug_frames_interp)
4911 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
4912 regname (fc->cfa_reg, 0), fc->cfa_offset);
4915 case DW_CFA_def_cfa_offset_sf:
4916 fc->cfa_offset = SLEB ();
4917 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4918 if (! do_debug_frames_interp)
4919 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
4922 case DW_CFA_MIPS_advance_loc8:
4923 ofs = byte_get (start, 8); start += 8;
4924 if (do_debug_frames_interp)
4925 frame_display_row (fc, &need_col_headers, &max_regs);
4927 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4928 ofs * fc->code_factor,
4929 fc->pc_begin + ofs * fc->code_factor);
4930 fc->pc_begin += ofs * fc->code_factor;
4933 case DW_CFA_GNU_window_save:
4934 if (! do_debug_frames_interp)
4935 printf (" DW_CFA_GNU_window_save\n");
4938 case DW_CFA_GNU_args_size:
4940 if (! do_debug_frames_interp)
4941 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
4944 case DW_CFA_GNU_negative_offset_extended:
4947 if (frame_need_space (fc, reg) < 0)
4948 reg_prefix = bad_reg;
4949 if (! do_debug_frames_interp || *reg_prefix != '\0')
4950 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
4951 reg_prefix, regname (reg, 0),
4952 l * fc->data_factor);
4953 if (*reg_prefix == '\0')
4955 fc->col_type[reg] = DW_CFA_offset;
4956 fc->col_offset[reg] = l * fc->data_factor;
4961 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
4962 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
4964 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
4969 if (do_debug_frames_interp)
4970 frame_display_row (fc, &need_col_headers, &max_regs);
4973 eh_addr_size = saved_eh_addr_size;
4986 display_debug_not_supported (struct dwarf_section *section,
4987 void *file ATTRIBUTE_UNUSED)
4989 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4996 cmalloc (size_t nmemb, size_t size)
4998 /* Check for overflow. */
4999 if (nmemb >= ~(size_t) 0 / size)
5002 return malloc (nmemb * size);
5006 xcmalloc (size_t nmemb, size_t size)
5008 /* Check for overflow. */
5009 if (nmemb >= ~(size_t) 0 / size)
5012 return xmalloc (nmemb * size);
5016 xcrealloc (void *ptr, size_t nmemb, size_t size)
5018 /* Check for overflow. */
5019 if (nmemb >= ~(size_t) 0 / size)
5022 return xrealloc (ptr, nmemb * size);
5026 error (const char *message, ...)
5030 va_start (args, message);
5031 fprintf (stderr, _("%s: Error: "), program_name);
5032 vfprintf (stderr, message, args);
5037 warn (const char *message, ...)
5041 va_start (args, message);
5042 fprintf (stderr, _("%s: Warning: "), program_name);
5043 vfprintf (stderr, message, args);
5048 free_debug_memory (void)
5054 for (i = 0; i < max; i++)
5055 free_debug_section ((enum dwarf_section_display_enum) i);
5057 if (debug_information != NULL)
5059 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
5061 for (i = 0; i < num_debug_info_entries; i++)
5063 if (!debug_information [i].max_loc_offsets)
5065 free (debug_information [i].loc_offsets);
5066 free (debug_information [i].have_frame_base);
5068 if (!debug_information [i].max_range_lists)
5069 free (debug_information [i].range_lists);
5073 free (debug_information);
5074 debug_information = NULL;
5075 num_debug_info_entries = 0;
5080 dwarf_select_sections_by_names (const char *names)
5084 const char * option;
5088 debug_dump_long_opts;
5090 static const debug_dump_long_opts opts_table [] =
5092 /* Please keep this table alpha- sorted. */
5093 { "Ranges", & do_debug_ranges, 1 },
5094 { "abbrev", & do_debug_abbrevs, 1 },
5095 { "aranges", & do_debug_aranges, 1 },
5096 { "frames", & do_debug_frames, 1 },
5097 { "frames-interp", & do_debug_frames_interp, 1 },
5098 { "info", & do_debug_info, 1 },
5099 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
5100 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
5101 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
5102 { "loc", & do_debug_loc, 1 },
5103 { "macro", & do_debug_macinfo, 1 },
5104 { "pubnames", & do_debug_pubnames, 1 },
5105 { "pubtypes", & do_debug_pubtypes, 1 },
5106 /* This entry is for compatability
5107 with earlier versions of readelf. */
5108 { "ranges", & do_debug_aranges, 1 },
5109 { "str", & do_debug_str, 1 },
5110 /* These trace_* sections are used by Itanium VMS. */
5111 { "trace_abbrev", & do_trace_abbrevs, 1 },
5112 { "trace_aranges", & do_trace_aranges, 1 },
5113 { "trace_info", & do_trace_info, 1 },
5122 const debug_dump_long_opts * entry;
5124 for (entry = opts_table; entry->option; entry++)
5126 size_t len = strlen (entry->option);
5128 if (strncmp (p, entry->option, len) == 0
5129 && (p[len] == ',' || p[len] == '\0'))
5131 * entry->variable |= entry->val;
5133 /* The --debug-dump=frames-interp option also
5134 enables the --debug-dump=frames option. */
5135 if (do_debug_frames_interp)
5136 do_debug_frames = 1;
5143 if (entry->option == NULL)
5145 warn (_("Unrecognized debug option '%s'\n"), p);
5146 p = strchr (p, ',');
5157 dwarf_select_sections_by_letters (const char *letters)
5159 unsigned int lindex = 0;
5161 while (letters[lindex])
5162 switch (letters[lindex++])
5169 do_debug_abbrevs = 1;
5173 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
5177 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
5181 do_debug_pubnames = 1;
5185 do_debug_pubtypes = 1;
5189 do_debug_aranges = 1;
5193 do_debug_ranges = 1;
5197 do_debug_frames_interp = 1;
5199 do_debug_frames = 1;
5203 do_debug_macinfo = 1;
5215 warn (_("Unrecognized debug option '%s'\n"), optarg);
5221 dwarf_select_sections_all (void)
5224 do_debug_abbrevs = 1;
5225 do_debug_lines = FLAG_DEBUG_LINES_RAW;
5226 do_debug_pubnames = 1;
5227 do_debug_pubtypes = 1;
5228 do_debug_aranges = 1;
5229 do_debug_ranges = 1;
5230 do_debug_frames = 1;
5231 do_debug_macinfo = 1;
5235 do_trace_abbrevs = 1;
5236 do_trace_aranges = 1;
5239 struct dwarf_section_display debug_displays[] =
5241 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0 },
5242 display_debug_abbrev, &do_debug_abbrevs, 0 },
5243 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0 },
5244 display_debug_aranges, &do_debug_aranges, 1 },
5245 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0 },
5246 display_debug_frames, &do_debug_frames, 1 },
5247 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0 },
5248 display_debug_info, &do_debug_info, 1 },
5249 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0 },
5250 display_debug_lines, &do_debug_lines, 1 },
5251 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0 },
5252 display_debug_pubnames, &do_debug_pubnames, 0 },
5253 { { ".eh_frame", "", NULL, NULL, 0, 0 },
5254 display_debug_frames, &do_debug_frames, 1 },
5255 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0 },
5256 display_debug_macinfo, &do_debug_macinfo, 0 },
5257 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0 },
5258 display_debug_str, &do_debug_str, 0 },
5259 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0 },
5260 display_debug_loc, &do_debug_loc, 1 },
5261 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0 },
5262 display_debug_pubnames, &do_debug_pubtypes, 0 },
5263 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0 },
5264 display_debug_ranges, &do_debug_ranges, 1 },
5265 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0 },
5266 display_debug_not_supported, NULL, 0 },
5267 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0 },
5268 display_debug_not_supported, NULL, 0 },
5269 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0 },
5270 display_debug_types, &do_debug_info, 1 },
5271 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0 },
5272 display_debug_not_supported, NULL, 0 },
5273 { { ".trace_info", "", NULL, NULL, 0, 0 },
5274 display_trace_info, &do_trace_info, 1 },
5275 { { ".trace_abbrev", "", NULL, NULL, 0, 0 },
5276 display_debug_abbrev, &do_trace_abbrevs, 0 },
5277 { { ".trace_aranges", "", NULL, NULL, 0, 0 },
5278 display_debug_aranges, &do_trace_aranges, 0 }